From 1c3d85dd4e21a405e8de54131a5f759f9a0115b7 Mon Sep 17 00:00:00 2001 From: "Rafael J. Wysocki" Date: Mon, 29 Apr 2013 00:08:16 +0200 Subject: [PATCH] cpufreq: Revert incorrect commit 5800043 Commit 5800043 (cpufreq: convert cpufreq_driver to using RCU) causes the following call trace to be spit on boot: BUG: sleeping function called from invalid context at /scratch/rafael/work/linux-pm/mm/slab.c:3179 in_atomic(): 0, irqs_disabled(): 0, pid: 292, name: systemd-udevd 2 locks held by systemd-udevd/292: #0: (subsys mutex){+.+.+.}, at: [] subsys_interface_register+0x4a/0xe0 #1: (rcu_read_lock){.+.+.+}, at: [] cpufreq_add_dev_interface+0x60/0x5e0 Pid: 292, comm: systemd-udevd Not tainted 3.9.0-rc8+ #323 Call Trace: [] __might_sleep+0x140/0x1f0 [] kmem_cache_alloc+0x42/0x2b0 [] sysfs_new_dirent+0x59/0x130 [] sysfs_add_file_mode+0x6b/0x110 [] ? cpufreq_add_dev_interface+0x60/0x5e0 [] ? __lock_is_held+0x54/0x80 [] sysfs_add_file+0xd/0x10 [] sysfs_create_file+0x21/0x30 [] cpufreq_add_dev_interface+0xd0/0x5e0 [] ? cpufreq_add_dev_interface+0x60/0x5e0 [] ? acpi_processor_get_platform_limit+0x32/0xbb [processor] [] ? do_drv_write+0x70/0x70 [acpi_cpufreq] [] ? __lock_is_held+0x54/0x80 [] ? up_read+0x1e/0x40 [] ? __blocking_notifier_call_chain+0x72/0xc0 [] cpufreq_add_dev+0x62d/0xae0 [] ? cpufreq_add_dev+0x228/0xae0 [] subsys_interface_register+0x99/0xe0 [] ? 0xffffffffa014cfff [] cpufreq_register_driver+0x9d/0x200 [] ? 0xffffffffa014cfff [] acpi_cpufreq_init+0xe9/0x1000 [acpi_cpufreq] [] do_one_initcall+0x11a/0x170 [] load_module+0x1cf7/0x2920 [] ? ddebug_proc_open+0xb0/0xb0 [] ? retint_restore_args+0xe/0xe [] sys_init_module+0xd7/0x120 [] system_call_fastpath+0x16/0x1b which is quite obvious, because that commit put (multiple instances of) sysfs_create_file() under rcu_read_lock()/rcu_read_unlock(), although sysfs_create_file() may cause memory to be allocated with GFP_KERNEL and that may sleep, which is not permitted in RCU read critical section. Revert the buggy commit altogether along with some changes on top of it. Signed-off-by: Rafael J. Wysocki --- drivers/cpufreq/cpufreq.c | 289 ++++++++++---------------------------- 1 file changed, 72 insertions(+), 217 deletions(-) diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c index a6f65954b0ab..1b8a48eaf90f 100644 --- a/drivers/cpufreq/cpufreq.c +++ b/drivers/cpufreq/cpufreq.c @@ -39,7 +39,7 @@ * level driver of CPUFreq support, and its spinlock. This lock * also protects the cpufreq_cpu_data array. */ -static struct cpufreq_driver __rcu *cpufreq_driver; +static struct cpufreq_driver *cpufreq_driver; static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data); #ifdef CONFIG_HOTPLUG_CPU /* This one keeps track of the previously set governor of a removed CPU */ @@ -130,35 +130,27 @@ static DEFINE_MUTEX(cpufreq_governor_mutex); bool have_governor_per_policy(void) { - bool have_governor_per_policy; - rcu_read_lock(); - have_governor_per_policy = - rcu_dereference(cpufreq_driver)->have_governor_per_policy; - rcu_read_unlock(); - return have_governor_per_policy; + return cpufreq_driver->have_governor_per_policy; } static struct cpufreq_policy *__cpufreq_cpu_get(unsigned int cpu, bool sysfs) { struct cpufreq_policy *data; - struct cpufreq_driver *driver; unsigned long flags; if (cpu >= nr_cpu_ids) goto err_out; /* get the cpufreq driver */ - rcu_read_lock(); - driver = rcu_dereference(cpufreq_driver); - - if (!driver) - goto err_out_unlock; - - if (!try_module_get(driver->owner)) - goto err_out_unlock; - read_lock_irqsave(&cpufreq_driver_lock, flags); + if (!cpufreq_driver) + goto err_out_unlock; + + if (!try_module_get(cpufreq_driver->owner)) + goto err_out_unlock; + + /* get the CPU */ data = per_cpu(cpufreq_cpu_data, cpu); @@ -169,14 +161,12 @@ static struct cpufreq_policy *__cpufreq_cpu_get(unsigned int cpu, bool sysfs) goto err_out_put_module; read_unlock_irqrestore(&cpufreq_driver_lock, flags); - rcu_read_unlock(); return data; err_out_put_module: - module_put(driver->owner); - read_unlock_irqrestore(&cpufreq_driver_lock, flags); + module_put(cpufreq_driver->owner); err_out_unlock: - rcu_read_unlock(); + read_unlock_irqrestore(&cpufreq_driver_lock, flags); err_out: return NULL; } @@ -199,9 +189,7 @@ static void __cpufreq_cpu_put(struct cpufreq_policy *data, bool sysfs) { if (!sysfs) kobject_put(&data->kobj); - rcu_read_lock(); - module_put(rcu_dereference(cpufreq_driver)->owner); - rcu_read_unlock(); + module_put(cpufreq_driver->owner); } void cpufreq_cpu_put(struct cpufreq_policy *data) @@ -269,9 +257,7 @@ void __cpufreq_notify_transition(struct cpufreq_policy *policy, if (cpufreq_disabled()) return; - rcu_read_lock(); - freqs->flags = rcu_dereference(cpufreq_driver)->flags; - rcu_read_unlock(); + freqs->flags = cpufreq_driver->flags; pr_debug("notification %u of frequency transition to %u kHz\n", state, freqs->new); @@ -282,7 +268,7 @@ void __cpufreq_notify_transition(struct cpufreq_policy *policy, * which is not equal to what the cpufreq core thinks is * "old frequency". */ - if (!(freqs->flags & CPUFREQ_CONST_LOOPS)) { + if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) { if ((policy) && (policy->cpu == freqs->cpu) && (policy->cur) && (policy->cur != freqs->old)) { pr_debug("Warning: CPU frequency is" @@ -348,21 +334,11 @@ static int cpufreq_parse_governor(char *str_governor, unsigned int *policy, struct cpufreq_governor **governor) { int err = -EINVAL; - struct cpufreq_driver *driver; - bool has_setpolicy; - bool has_target; - rcu_read_lock(); - driver = rcu_dereference(cpufreq_driver); - if (!driver) { - rcu_read_unlock(); + if (!cpufreq_driver) goto out; - } - has_setpolicy = driver->setpolicy ? true : false; - has_target = driver->target ? true : false; - rcu_read_unlock(); - if (has_setpolicy) { + if (cpufreq_driver->setpolicy) { if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) { *policy = CPUFREQ_POLICY_PERFORMANCE; err = 0; @@ -371,7 +347,7 @@ static int cpufreq_parse_governor(char *str_governor, unsigned int *policy, *policy = CPUFREQ_POLICY_POWERSAVE; err = 0; } - } else if (has_target) { + } else if (cpufreq_driver->target) { struct cpufreq_governor *t; mutex_lock(&cpufreq_governor_mutex); @@ -522,12 +498,7 @@ static ssize_t store_scaling_governor(struct cpufreq_policy *policy, */ static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf) { - ssize_t size; - rcu_read_lock(); - size = scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", - rcu_dereference(cpufreq_driver)->name); - rcu_read_unlock(); - return size; + return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name); } /** @@ -539,13 +510,10 @@ static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy, ssize_t i = 0; struct cpufreq_governor *t; - rcu_read_lock(); - if (!rcu_dereference(cpufreq_driver)->target) { - rcu_read_unlock(); + if (!cpufreq_driver->target) { i += sprintf(buf, "performance powersave"); goto out; } - rcu_read_unlock(); list_for_each_entry(t, &cpufreq_governor_list, governor_list) { if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char)) @@ -623,15 +591,9 @@ static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf) static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf) { unsigned int limit; - int (*bios_limit)(int cpu, unsigned int *limit); int ret; - - rcu_read_lock(); - bios_limit = rcu_dereference(cpufreq_driver)->bios_limit; - rcu_read_unlock(); - - if (bios_limit) { - ret = bios_limit(policy->cpu, &limit); + if (cpufreq_driver->bios_limit) { + ret = cpufreq_driver->bios_limit(policy->cpu, &limit); if (!ret) return sprintf(buf, "%u\n", limit); } @@ -774,7 +736,6 @@ static int cpufreq_add_dev_interface(unsigned int cpu, { struct cpufreq_policy new_policy; struct freq_attr **drv_attr; - struct cpufreq_driver *driver; unsigned long flags; int ret = 0; unsigned int j; @@ -786,31 +747,28 @@ static int cpufreq_add_dev_interface(unsigned int cpu, return ret; /* set up files for this cpu device */ - rcu_read_lock(); - driver = rcu_dereference(cpufreq_driver); - drv_attr = driver->attr; + drv_attr = cpufreq_driver->attr; while ((drv_attr) && (*drv_attr)) { ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr)); if (ret) - goto err_out_unlock; + goto err_out_kobj_put; drv_attr++; } - if (driver->get) { + if (cpufreq_driver->get) { ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr); if (ret) - goto err_out_unlock; + goto err_out_kobj_put; } - if (driver->target) { + if (cpufreq_driver->target) { ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr); if (ret) - goto err_out_unlock; + goto err_out_kobj_put; } - if (driver->bios_limit) { + if (cpufreq_driver->bios_limit) { ret = sysfs_create_file(&policy->kobj, &bios_limit.attr); if (ret) - goto err_out_unlock; + goto err_out_kobj_put; } - rcu_read_unlock(); write_lock_irqsave(&cpufreq_driver_lock, flags); for_each_cpu(j, policy->cpus) { @@ -833,20 +791,12 @@ static int cpufreq_add_dev_interface(unsigned int cpu, policy->user_policy.governor = policy->governor; if (ret) { - int (*exit)(struct cpufreq_policy *policy); - pr_debug("setting policy failed\n"); - rcu_read_lock(); - exit = rcu_dereference(cpufreq_driver)->exit; - rcu_read_unlock(); - if (exit) - exit(policy); - + if (cpufreq_driver->exit) + cpufreq_driver->exit(policy); } return ret; -err_out_unlock: - rcu_read_unlock(); err_out_kobj_put: kobject_put(&policy->kobj); wait_for_completion(&policy->kobj_unregister); @@ -858,16 +808,12 @@ static int cpufreq_add_policy_cpu(unsigned int cpu, unsigned int sibling, struct device *dev) { struct cpufreq_policy *policy; - int ret = 0, has_target = 0; + int ret = 0, has_target = !!cpufreq_driver->target; unsigned long flags; policy = cpufreq_cpu_get(sibling); WARN_ON(!policy); - rcu_read_lock(); - has_target = !!rcu_dereference(cpufreq_driver)->target; - rcu_read_unlock(); - if (has_target) __cpufreq_governor(policy, CPUFREQ_GOV_STOP); @@ -911,8 +857,6 @@ static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif) unsigned int j, cpu = dev->id; int ret = -ENOMEM; struct cpufreq_policy *policy; - struct cpufreq_driver *driver; - int (*init)(struct cpufreq_policy *policy); unsigned long flags; #ifdef CONFIG_HOTPLUG_CPU struct cpufreq_governor *gov; @@ -947,15 +891,10 @@ static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif) #endif #endif - rcu_read_lock(); - driver = rcu_dereference(cpufreq_driver); - if (!try_module_get(driver->owner)) { - rcu_read_unlock(); + if (!try_module_get(cpufreq_driver->owner)) { ret = -EINVAL; goto module_out; } - init = driver->init; - rcu_read_unlock(); policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL); if (!policy) @@ -980,7 +919,7 @@ static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif) /* call driver. From then on the cpufreq must be able * to accept all calls to ->verify and ->setpolicy for this CPU */ - ret = init(policy); + ret = cpufreq_driver->init(policy); if (ret) { pr_debug("initialization failed\n"); goto err_set_policy_cpu; @@ -1015,9 +954,7 @@ static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif) goto err_out_unregister; kobject_uevent(&policy->kobj, KOBJ_ADD); - rcu_read_lock(); - module_put(rcu_dereference(cpufreq_driver)->owner); - rcu_read_unlock(); + module_put(cpufreq_driver->owner); pr_debug("initialization complete\n"); return 0; @@ -1039,9 +976,7 @@ err_free_cpumask: err_free_policy: kfree(policy); nomem_out: - rcu_read_lock(); - module_put(rcu_dereference(cpufreq_driver)->owner); - rcu_read_unlock(); + module_put(cpufreq_driver->owner); module_out: return ret; } @@ -1075,12 +1010,9 @@ static int __cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif unsigned int cpu = dev->id, ret, cpus; unsigned long flags; struct cpufreq_policy *data; - struct cpufreq_driver *driver; struct kobject *kobj; struct completion *cmp; struct device *cpu_dev; - bool has_target; - int (*exit)(struct cpufreq_policy *policy); pr_debug("%s: unregistering CPU %u\n", __func__, cpu); @@ -1096,19 +1028,14 @@ static int __cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif return -EINVAL; } - rcu_read_lock(); - driver = rcu_dereference(cpufreq_driver); - has_target = driver->target ? true : false; - exit = driver->exit; - if (has_target) + if (cpufreq_driver->target) __cpufreq_governor(data, CPUFREQ_GOV_STOP); #ifdef CONFIG_HOTPLUG_CPU - if (!driver->setpolicy) + if (!cpufreq_driver->setpolicy) strncpy(per_cpu(cpufreq_cpu_governor, cpu), data->governor->name, CPUFREQ_NAME_LEN); #endif - rcu_read_unlock(); WARN_ON(lock_policy_rwsem_write(cpu)); cpus = cpumask_weight(data->cpus); @@ -1153,7 +1080,7 @@ static int __cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif /* If cpu is last user of policy, free policy */ if (cpus == 1) { - if (has_target) + if (cpufreq_driver->target) __cpufreq_governor(data, CPUFREQ_GOV_POLICY_EXIT); lock_policy_rwsem_read(cpu); @@ -1170,13 +1097,13 @@ static int __cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif wait_for_completion(cmp); pr_debug("wait complete\n"); - if (exit) - exit(data); + if (cpufreq_driver->exit) + cpufreq_driver->exit(data); free_cpumask_var(data->related_cpus); free_cpumask_var(data->cpus); kfree(data); - } else if (has_target) { + } else if (cpufreq_driver->target) { __cpufreq_governor(data, CPUFREQ_GOV_START); __cpufreq_governor(data, CPUFREQ_GOV_LIMITS); } @@ -1250,18 +1177,10 @@ static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq, unsigned int cpufreq_quick_get(unsigned int cpu) { struct cpufreq_policy *policy; - struct cpufreq_driver *driver; - unsigned int (*get)(unsigned int cpu); unsigned int ret_freq = 0; - rcu_read_lock(); - driver = rcu_dereference(cpufreq_driver); - if (driver && driver->setpolicy && driver->get) { - get = driver->get; - rcu_read_unlock(); - return get(cpu); - } - rcu_read_unlock(); + if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get) + return cpufreq_driver->get(cpu); policy = cpufreq_cpu_get(cpu); if (policy) { @@ -1297,26 +1216,15 @@ EXPORT_SYMBOL(cpufreq_quick_get_max); static unsigned int __cpufreq_get(unsigned int cpu) { struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); - struct cpufreq_driver *driver; - unsigned int (*get)(unsigned int cpu); unsigned int ret_freq = 0; - u8 flags; - - rcu_read_lock(); - driver = rcu_dereference(cpufreq_driver); - if (!driver->get) { - rcu_read_unlock(); + if (!cpufreq_driver->get) return ret_freq; - } - flags = driver->flags; - get = driver->get; - rcu_read_unlock(); - ret_freq = get(cpu); + ret_freq = cpufreq_driver->get(cpu); if (ret_freq && policy->cur && - !(flags & CPUFREQ_CONST_LOOPS)) { + !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) { /* verify no discrepancy between actual and saved value exists */ if (unlikely(ret_freq != policy->cur)) { @@ -1372,7 +1280,6 @@ static struct subsys_interface cpufreq_interface = { */ static int cpufreq_bp_suspend(void) { - int (*suspend)(struct cpufreq_policy *policy); int ret = 0; int cpu = smp_processor_id(); @@ -1385,11 +1292,8 @@ static int cpufreq_bp_suspend(void) if (!cpu_policy) return 0; - rcu_read_lock(); - suspend = rcu_dereference(cpufreq_driver)->suspend; - rcu_read_unlock(); - if (suspend) { - ret = suspend(cpu_policy); + if (cpufreq_driver->suspend) { + ret = cpufreq_driver->suspend(cpu_policy); if (ret) printk(KERN_ERR "cpufreq: suspend failed in ->suspend " "step on CPU %u\n", cpu_policy->cpu); @@ -1415,7 +1319,6 @@ static int cpufreq_bp_suspend(void) static void cpufreq_bp_resume(void) { int ret = 0; - int (*resume)(struct cpufreq_policy *policy); int cpu = smp_processor_id(); struct cpufreq_policy *cpu_policy; @@ -1427,12 +1330,8 @@ static void cpufreq_bp_resume(void) if (!cpu_policy) return; - rcu_read_lock(); - resume = rcu_dereference(cpufreq_driver)->resume; - rcu_read_unlock(); - - if (resume) { - ret = resume(cpu_policy); + if (cpufreq_driver->resume) { + ret = cpufreq_driver->resume(cpu_policy); if (ret) { printk(KERN_ERR "cpufreq: resume failed in ->resume " "step on CPU %u\n", cpu_policy->cpu); @@ -1459,14 +1358,10 @@ static struct syscore_ops cpufreq_syscore_ops = { */ const char *cpufreq_get_current_driver(void) { - struct cpufreq_driver *driver; - const char *name = NULL; - rcu_read_lock(); - driver = rcu_dereference(cpufreq_driver); - if (driver) - name = driver->name; - rcu_read_unlock(); - return name; + if (cpufreq_driver) + return cpufreq_driver->name; + + return NULL; } EXPORT_SYMBOL_GPL(cpufreq_get_current_driver); @@ -1560,9 +1455,6 @@ int __cpufreq_driver_target(struct cpufreq_policy *policy, { int retval = -EINVAL; unsigned int old_target_freq = target_freq; - int (*target)(struct cpufreq_policy *policy, - unsigned int target_freq, - unsigned int relation); if (cpufreq_disabled()) return -ENODEV; @@ -1579,11 +1471,8 @@ int __cpufreq_driver_target(struct cpufreq_policy *policy, if (target_freq == policy->cur) return 0; - rcu_read_lock(); - target = rcu_dereference(cpufreq_driver)->target; - rcu_read_unlock(); - if (target) - retval = target(policy, target_freq, relation); + if (cpufreq_driver->target) + retval = cpufreq_driver->target(policy, target_freq, relation); return retval; } @@ -1616,24 +1505,18 @@ EXPORT_SYMBOL_GPL(cpufreq_driver_target); int __cpufreq_driver_getavg(struct cpufreq_policy *policy, unsigned int cpu) { int ret = 0; - unsigned int (*getavg)(struct cpufreq_policy *policy, - unsigned int cpu); if (cpufreq_disabled()) return ret; - rcu_read_lock(); - getavg = rcu_dereference(cpufreq_driver)->getavg; - rcu_read_unlock(); - - if (!getavg) + if (!cpufreq_driver->getavg) return 0; policy = cpufreq_cpu_get(policy->cpu); if (!policy) return -EINVAL; - ret = getavg(policy, cpu); + ret = cpufreq_driver->getavg(policy, cpu); cpufreq_cpu_put(policy); return ret; @@ -1791,9 +1674,6 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_policy *policy) { int ret = 0, failed = 1; - struct cpufreq_driver *driver; - int (*verify)(struct cpufreq_policy *policy); - int (*setpolicy)(struct cpufreq_policy *policy); pr_debug("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu, policy->min, policy->max); @@ -1807,13 +1687,7 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, } /* verify the cpu speed can be set within this limit */ - rcu_read_lock(); - driver = rcu_dereference(cpufreq_driver); - verify = driver->verify; - setpolicy = driver->setpolicy; - rcu_read_unlock(); - - ret = verify(policy); + ret = cpufreq_driver->verify(policy); if (ret) goto error_out; @@ -1827,7 +1701,7 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, /* verify the cpu speed can be set within this limit, which might be different to the first one */ - ret = verify(policy); + ret = cpufreq_driver->verify(policy); if (ret) goto error_out; @@ -1841,10 +1715,10 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data, pr_debug("new min and max freqs are %u - %u kHz\n", data->min, data->max); - if (setpolicy) { + if (cpufreq_driver->setpolicy) { data->policy = policy->policy; pr_debug("setting range\n"); - ret = setpolicy(policy); + ret = cpufreq_driver->setpolicy(policy); } else { if (policy->governor != data->governor) { /* save old, working values */ @@ -1904,11 +1778,6 @@ int cpufreq_update_policy(unsigned int cpu) { struct cpufreq_policy *data = cpufreq_cpu_get(cpu); struct cpufreq_policy policy; - struct cpufreq_driver *driver; - unsigned int (*get)(unsigned int cpu); - int (*target)(struct cpufreq_policy *policy, - unsigned int target_freq, - unsigned int relation); int ret; if (!data) { @@ -1930,18 +1799,13 @@ int cpufreq_update_policy(unsigned int cpu) /* BIOS might change freq behind our back -> ask driver for current freq and notify governors about a change */ - rcu_read_lock(); - driver = rcu_access_pointer(cpufreq_driver); - get = driver->get; - target = driver->target; - rcu_read_unlock(); - if (get) { - policy.cur = get(cpu); + if (cpufreq_driver->get) { + policy.cur = cpufreq_driver->get(cpu); if (!data->cur) { pr_debug("Driver did not initialize current freq"); data->cur = policy.cur; } else { - if (data->cur != policy.cur && target) + if (data->cur != policy.cur && cpufreq_driver->target) cpufreq_out_of_sync(cpu, data->cur, policy.cur); } @@ -2020,19 +1884,18 @@ int cpufreq_register_driver(struct cpufreq_driver *driver_data) driver_data->flags |= CPUFREQ_CONST_LOOPS; write_lock_irqsave(&cpufreq_driver_lock, flags); - if (rcu_access_pointer(cpufreq_driver)) { + if (cpufreq_driver) { write_unlock_irqrestore(&cpufreq_driver_lock, flags); return -EBUSY; } - rcu_assign_pointer(cpufreq_driver, driver_data); + cpufreq_driver = driver_data; write_unlock_irqrestore(&cpufreq_driver_lock, flags); - synchronize_rcu(); ret = subsys_interface_register(&cpufreq_interface); if (ret) goto err_null_driver; - if (!(driver_data->flags & CPUFREQ_STICKY)) { + if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) { int i; ret = -ENODEV; @@ -2059,9 +1922,8 @@ err_if_unreg: subsys_interface_unregister(&cpufreq_interface); err_null_driver: write_lock_irqsave(&cpufreq_driver_lock, flags); - rcu_assign_pointer(cpufreq_driver, NULL); + cpufreq_driver = NULL; write_unlock_irqrestore(&cpufreq_driver_lock, flags); - synchronize_rcu(); return ret; } EXPORT_SYMBOL_GPL(cpufreq_register_driver); @@ -2078,15 +1940,9 @@ EXPORT_SYMBOL_GPL(cpufreq_register_driver); int cpufreq_unregister_driver(struct cpufreq_driver *driver) { unsigned long flags; - struct cpufreq_driver *old_driver; - rcu_read_lock(); - old_driver = rcu_access_pointer(cpufreq_driver); - if (!old_driver || (driver != old_driver)) { - rcu_read_unlock(); + if (!cpufreq_driver || (driver != cpufreq_driver)) return -EINVAL; - } - rcu_read_unlock(); pr_debug("unregistering driver %s\n", driver->name); @@ -2094,9 +1950,8 @@ int cpufreq_unregister_driver(struct cpufreq_driver *driver) unregister_hotcpu_notifier(&cpufreq_cpu_notifier); write_lock_irqsave(&cpufreq_driver_lock, flags); - rcu_assign_pointer(cpufreq_driver, NULL); + cpufreq_driver = NULL; write_unlock_irqrestore(&cpufreq_driver_lock, flags); - synchronize_rcu(); return 0; }