\
        return sprintf(buf, _format "\n", edev->_memb);       \
 }                                                        \
-static DEVICE_ATTR(_name, S_IRUGO, eeh_show_##_name, NULL);
+static DEVICE_ATTR(_name, 0444, eeh_show_##_name, NULL);
 
 EEH_SHOW_ATTR(eeh_mode,            mode,            "0x%x");
 EEH_SHOW_ATTR(eeh_pe_config_addr,  pe_config_addr,  "0x%x");
 
 {
        struct proc_dir_entry *pde;
 
-       pde = proc_create_data("powerpc/systemcfg", S_IFREG|S_IRUGO, NULL,
+       pde = proc_create_data("powerpc/systemcfg", S_IFREG | 0444, NULL,
                               &page_map_fops, vdso_data);
        if (!pde)
                return 1;
 
        if (rtas_node == NULL)
                return -ENODEV;
 
-       proc_create("powerpc/rtas/progress", S_IRUGO|S_IWUSR, NULL,
+       proc_create("powerpc/rtas/progress", 0644, NULL,
                    &ppc_rtas_progress_operations);
-       proc_create("powerpc/rtas/clock", S_IRUGO|S_IWUSR, NULL,
+       proc_create("powerpc/rtas/clock", 0644, NULL,
                    &ppc_rtas_clock_operations);
-       proc_create("powerpc/rtas/poweron", S_IWUSR|S_IRUGO, NULL,
+       proc_create("powerpc/rtas/poweron", 0644, NULL,
                    &ppc_rtas_poweron_operations);
-       proc_create("powerpc/rtas/sensors", S_IRUGO, NULL,
+       proc_create("powerpc/rtas/sensors", 0444, NULL,
                    &ppc_rtas_sensors_operations);
-       proc_create("powerpc/rtas/frequency", S_IWUSR|S_IRUGO, NULL,
+       proc_create("powerpc/rtas/frequency", 0644, NULL,
                    &ppc_rtas_tone_freq_operations);
-       proc_create("powerpc/rtas/volume", S_IWUSR|S_IRUGO, NULL,
+       proc_create("powerpc/rtas/volume", 0644, NULL,
                    &ppc_rtas_tone_volume_operations);
-       proc_create("powerpc/rtas/rmo_buffer", S_IRUSR, NULL,
+       proc_create("powerpc/rtas/rmo_buffer", 0400, NULL,
                    &ppc_rtas_rmo_buf_ops);
        return 0;
 }
 
                const struct rtas_flash_file *f = &rtas_flash_files[i];
                int token;
 
-               if (!proc_create(f->filename, S_IRUSR | S_IWUSR, NULL, &f->fops))
+               if (!proc_create(f->filename, 0600, NULL, &f->fops))
                        goto enomem;
 
                /*
 
        if (!rtas_log_buf)
                return -ENODEV;
 
-       entry = proc_create("powerpc/rtas/error_log", S_IRUSR, NULL,
+       entry = proc_create("powerpc/rtas/error_log", 0400, NULL,
                            &proc_rtas_log_operations);
        if (!entry)
                printk(KERN_ERR "Failed to create error_log proc entry\n");
 
        if (!dir)
                return -ENOMEM;
 
-       d = debugfs_create_u32("do_warn", S_IRUGO | S_IWUSR, dir,
+       d = debugfs_create_u32("do_warn", 0644, dir,
                               &ppc_warn_emulated);
        if (!d)
                goto fail;
 
        for (i = 0; i < sizeof(ppc_emulated)/sizeof(*entries); i++) {
-               d = debugfs_create_u32(entries[i].name, S_IRUGO | S_IWUSR, dir,
+               d = debugfs_create_u32(entries[i].name, 0644, dir,
                                       (u32 *)&entries[i].val.counter);
                if (!d)
                        goto fail;
 
 static DECLARE_BITMAP(default_enabled_hcalls, MAX_HCALL_OPCODE/4 + 1);
 
 static int dynamic_mt_modes = 6;
-module_param(dynamic_mt_modes, int, S_IRUGO | S_IWUSR);
+module_param(dynamic_mt_modes, int, 0644);
 MODULE_PARM_DESC(dynamic_mt_modes, "Set of allowed dynamic micro-threading modes: 0 (= none), 2, 4, or 6 (= 2 or 4)");
 static int target_smt_mode;
-module_param(target_smt_mode, int, S_IRUGO | S_IWUSR);
+module_param(target_smt_mode, int, 0644);
 MODULE_PARM_DESC(target_smt_mode, "Target threads per core (0 = max)");
 
 static bool indep_threads_mode = true;
        .get = param_get_int,
 };
 
-module_param_cb(kvm_irq_bypass, &module_param_ops, &kvm_irq_bypass,
-                                                       S_IRUGO | S_IWUSR);
+module_param_cb(kvm_irq_bypass, &module_param_ops, &kvm_irq_bypass, 0644);
 MODULE_PARM_DESC(kvm_irq_bypass, "Bypass passthrough interrupt optimization");
 
-module_param_cb(h_ipi_redirect, &module_param_ops, &h_ipi_redirect,
-                                                       S_IRUGO | S_IWUSR);
+module_param_cb(h_ipi_redirect, &module_param_ops, &h_ipi_redirect, 0644);
 MODULE_PARM_DESC(h_ipi_redirect, "Redirect H_IPI wakeup to a free host core");
 #endif
 
 
                return;
        }
 
-       xics->dentry = debugfs_create_file(name, S_IRUGO, powerpc_debugfs_root,
+       xics->dentry = debugfs_create_file(name, 0444, powerpc_debugfs_root,
                                           xics, &xics_debug_fops);
 
        pr_debug("%s: created %s\n", __func__, name);
 
 
        return sprintf(buf, "%02x\n", ret);
 }
-static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
+static DEVICE_ATTR(status, 0444, show_status, NULL);
 
 static void mcu_power_off(void)
 {
 
                }
        }
 
-       ret = spufs_mkdir(inode, dentry, flags, mode & S_IRWXUGO);
+       ret = spufs_mkdir(inode, dentry, flags, mode & 0777);
        if (ret)
                goto out_aff_unlock;
 
        struct path path = {.mnt = mnt, .dentry = dentry};
        int ret;
 
-       ret = spufs_mkgang(inode, dentry, mode & S_IRWXUGO);
+       ret = spufs_mkgang(inode, dentry, mode & 0777);
        if (!ret) {
                ret = spufs_gang_open(&path);
                if (ret < 0) {
 
  * due to the dynamic size of the dump
  */
 static struct dump_attribute id_attribute =
-       __ATTR(id, S_IRUGO, dump_id_show, NULL);
+       __ATTR(id, 0444, dump_id_show, NULL);
 static struct dump_attribute type_attribute =
-       __ATTR(type, S_IRUGO, dump_type_show, NULL);
+       __ATTR(type, 0444, dump_type_show, NULL);
 static struct dump_attribute ack_attribute =
        __ATTR(acknowledge, 0660, dump_ack_show, dump_ack_store);
 
 
 }
 
 static struct elog_attribute id_attribute =
-       __ATTR(id, S_IRUGO, elog_id_show, NULL);
+       __ATTR(id, 0444, elog_id_show, NULL);
 static struct elog_attribute type_attribute =
-       __ATTR(type, S_IRUGO, elog_type_show, NULL);
+       __ATTR(type, 0444, elog_type_show, NULL);
 static struct elog_attribute ack_attribute =
        __ATTR(acknowledge, 0660, elog_ack_show, elog_ack_store);
 
 
                /* If the parameter is read-only or read-write */
                switch (perm[i] & 3) {
                case OPAL_SYSPARAM_READ:
-                       attr[i].kobj_attr.attr.mode = S_IRUGO;
+                       attr[i].kobj_attr.attr.mode = 0444;
                        break;
                case OPAL_SYSPARAM_WRITE:
-                       attr[i].kobj_attr.attr.mode = S_IWUSR;
+                       attr[i].kobj_attr.attr.mode = 0200;
                        break;
                case OPAL_SYSPARAM_RW:
-                       attr[i].kobj_attr.attr.mode = S_IRUGO | S_IWUSR;
+                       attr[i].kobj_attr.attr.mode = 0644;
                        break;
                default:
                        break;
 
 MODULE_LICENSE("GPL");
 MODULE_VERSION(CMM_DRIVER_VERSION);
 
-module_param_named(delay, delay, uint, S_IRUGO | S_IWUSR);
+module_param_named(delay, delay, uint, 0644);
 MODULE_PARM_DESC(delay, "Delay (in seconds) between polls to query hypervisor paging requests. "
                 "[Default=" __stringify(CMM_DEFAULT_DELAY) "]");
-module_param_named(hotplug_delay, hotplug_delay, uint, S_IRUGO | S_IWUSR);
+module_param_named(hotplug_delay, hotplug_delay, uint, 0644);
 MODULE_PARM_DESC(hotplug_delay, "Delay (in seconds) after memory hotplug remove "
                 "before loaning resumes. "
                 "[Default=" __stringify(CMM_HOTPLUG_DELAY) "]");
-module_param_named(oom_kb, oom_kb, uint, S_IRUGO | S_IWUSR);
+module_param_named(oom_kb, oom_kb, uint, 0644);
 MODULE_PARM_DESC(oom_kb, "Amount of memory in kb to free on OOM. "
                 "[Default=" __stringify(CMM_OOM_KB) "]");
-module_param_named(min_mem_mb, min_mem_mb, ulong, S_IRUGO | S_IWUSR);
+module_param_named(min_mem_mb, min_mem_mb, ulong, 0644);
 MODULE_PARM_DESC(min_mem_mb, "Minimum amount of memory (in MB) to not balloon. "
                 "[Default=" __stringify(CMM_MIN_MEM_MB) "]");
-module_param_named(debug, cmm_debug, uint, S_IRUGO | S_IWUSR);
+module_param_named(debug, cmm_debug, uint, 0644);
 MODULE_PARM_DESC(debug, "Enable module debugging logging. Set to 1 to enable. "
                 "[Default=" __stringify(CMM_DEBUG) "]");
 
        {                                                       \
                return sprintf(buf, format, ##args);            \
        }                                                       \
-       static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
+       static DEVICE_ATTR(name, 0444, show_##name, NULL)
 
 CMM_SHOW(loaned_kb, "%lu\n", PAGES2KB(loaned_pages));
 CMM_SHOW(loaned_target_kb, "%lu\n", PAGES2KB(loaned_pages_target));
        return count;
 }
 
-static DEVICE_ATTR(oom_freed_kb, S_IWUSR | S_IRUGO,
+static DEVICE_ATTR(oom_freed_kb, 0644,
                   show_oom_pages, store_oom_pages);
 
 static struct device_attribute *cmm_attrs[] = {
 }
 
 module_param_call(disable, cmm_set_disable, param_get_uint,
-                 &cmm_disabled, S_IRUGO | S_IWUSR);
+                 &cmm_disabled, 0644);
 MODULE_PARM_DESC(disable, "Disable CMM. Set to 1 to disable. "
                 "[Default=" __stringify(CMM_DISABLE) "]");
 
 
 
        for_each_possible_cpu(cpu) {
                snprintf(cpu_name_buf, CPU_NAME_BUF_SIZE, "cpu%d", cpu);
-               hcall_file = debugfs_create_file(cpu_name_buf, S_IRUGO,
+               hcall_file = debugfs_create_file(cpu_name_buf, 0444,
                                                 hcall_root,
                                                 per_cpu(hcall_stats, cpu),
                                                 &hcall_inst_seq_fops);
 
                return rc;
        return count;
 }
-static BUS_ATTR(probe, S_IWUSR, NULL, ibmebus_store_probe);
+static BUS_ATTR(probe, 0200, NULL, ibmebus_store_probe);
 
 static ssize_t ibmebus_store_remove(struct bus_type *bus,
                                    const char *buf, size_t count)
                return -ENODEV;
        }
 }
-static BUS_ATTR(remove, S_IWUSR, NULL, ibmebus_store_remove);
+static BUS_ATTR(remove, 0200, NULL, ibmebus_store_remove);
 
 static struct attribute *ibmbus_bus_attrs[] = {
        &bus_attr_probe.attr,
 
 
 static int __init lparcfg_init(void)
 {
-       umode_t mode = S_IRUSR | S_IRGRP | S_IROTH;
+       umode_t mode = 0444;
 
        /* Allow writing if we have FW_FEATURE_SPLPAR */
        if (firmware_has_feature(FW_FEATURE_SPLPAR))
-               mode |= S_IWUSR;
+               mode |= 0200;
 
        if (!proc_create("powerpc/lparcfg", mode, NULL, &lparcfg_fops)) {
                printk(KERN_ERR "Failed to create powerpc/lparcfg\n");
 
 #define MIGRATION_API_VERSION  1
 
 static CLASS_ATTR_WO(migration);
-static CLASS_ATTR_STRING(api_version, S_IRUGO, __stringify(MIGRATION_API_VERSION));
+static CLASS_ATTR_STRING(api_version, 0444, __stringify(MIGRATION_API_VERSION));
 
 static int __init mobility_sysfs_init(void)
 {
 
 {
        struct proc_dir_entry *ent;
 
-       ent = proc_create("powerpc/ofdt", S_IWUSR, NULL, &ofdt_fops);
+       ent = proc_create("powerpc/ofdt", 0200, NULL, &ofdt_fops);
        if (ent)
                proc_set_size(ent, 0);
 
 
        if (!scanlog_buffer)
                goto err;
 
-       ent = proc_create("powerpc/rtas/scan-log-dump", S_IRUSR, NULL,
+       ent = proc_create("powerpc/rtas/scan-log-dump", 0400, NULL,
                          &scanlog_fops);
        if (!ent)
                goto err;
 
        return sprintf(buf, "%d\n", KERN_DT_UPDATE);
 }
 
-static DEVICE_ATTR(hibernate, S_IWUSR | S_IRUGO,
-                  show_hibernate, store_hibernate);
+static DEVICE_ATTR(hibernate, 0644, show_hibernate, store_hibernate);
 
 static struct bus_type suspend_subsys = {
        .name = "power",
 
        return sprintf(buf, "%ld\n", bank->ecc_counter);
 }
 
-static DEVICE_ATTR(ecc, S_IRUGO, axon_ram_sysfs_ecc, NULL);
+static DEVICE_ATTR(ecc, 0444, axon_ram_sysfs_ecc, NULL);
 
 /**
  * axon_ram_irq_handler - interrupt handler for Axon RAM ECC
 
 static const struct bin_attribute mv64x60_hs_reg_attr = { /* Hotswap register */
        .attr = {
                .name = "hs_reg",
-               .mode = S_IRUGO | S_IWUSR,
+               .mode = 0644,
        },
        .size  = MV64X60_VAL_LEN_MAX,
        .read  = mv64x60_hs_reg_read,