Commit 3fc54d37 authored by akpm@osdl.org's avatar akpm@osdl.org Committed by Dave Jones
Browse files

[CPUFREQ] Convert drivers/cpufreq semaphores to mutexes. 



Semaphore to mutex conversion.

The conversion was generated via scripts, and the result was validated
automatically via a script as well.

Signed-off-by: default avatarArjan van de Ven <arjan@infradead.org>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarDave Jones <davej@redhat.com>
parent 7eb9b2f5

drivers/cpufreq/cpufreq.c

+10 −9
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include <linux/slab.h>

#include <linux/cpu.h>

#include <linux/completion.h>

#include <linux/mutex.h>



#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, "cpufreq-core", msg)
@@ -55,7 +56,7 @@ static DECLARE_RWSEM (cpufreq_notifier_rwsem); 




static LIST_HEAD(cpufreq_governor_list);

static DECLARE_MUTEX		(cpufreq_governor_sem);

static DEFINE_MUTEX		(cpufreq_governor_mutex);



struct cpufreq_policy * cpufreq_cpu_get(unsigned int cpu)

{
@@ -297,18 +298,18 @@ static int cpufreq_parse_governor (char *str_governor, unsigned int *policy, 
		return -EINVAL;

	} else {

		struct cpufreq_governor *t;

		down(&cpufreq_governor_sem);

		mutex_lock(&cpufreq_governor_mutex);

		if (!cpufreq_driver || !cpufreq_driver->target)

			goto out;

		list_for_each_entry(t, &cpufreq_governor_list, governor_list) {

			if (!strnicmp(str_governor,t->name,CPUFREQ_NAME_LEN)) {

				*governor = t;

				up(&cpufreq_governor_sem);

				mutex_unlock(&cpufreq_governor_mutex);

				return 0;

			}

		}

	out:

		up(&cpufreq_governor_sem);

		mutex_unlock(&cpufreq_governor_mutex);

	}

	return -EINVAL;

}
@@ -1217,17 +1218,17 @@ int cpufreq_register_governor(struct cpufreq_governor *governor) 
	if (!governor)

		return -EINVAL;



	down(&cpufreq_governor_sem);

	mutex_lock(&cpufreq_governor_mutex);

	

	list_for_each_entry(t, &cpufreq_governor_list, governor_list) {

		if (!strnicmp(governor->name,t->name,CPUFREQ_NAME_LEN)) {

			up(&cpufreq_governor_sem);

			mutex_unlock(&cpufreq_governor_mutex);

			return -EBUSY;

		}

	}

	list_add(&governor->governor_list, &cpufreq_governor_list);



 	up(&cpufreq_governor_sem);

 	mutex_unlock(&cpufreq_governor_mutex);



	return 0;

}
@@ -1239,9 +1240,9 @@ void cpufreq_unregister_governor(struct cpufreq_governor *governor) 
	if (!governor)

		return;



	down(&cpufreq_governor_sem);

	mutex_lock(&cpufreq_governor_mutex);

	list_del(&governor->governor_list);

	up(&cpufreq_governor_sem);

	mutex_unlock(&cpufreq_governor_mutex);

	return;

}

EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);

drivers/cpufreq/cpufreq_conservative.c

+26 −26
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ 
#include <linux/jiffies.h>

#include <linux/kernel_stat.h>

#include <linux/percpu.h>



#include <linux/mutex.h>

/*

 * dbs is used in this file as a shortform for demandbased switching

 * It helps to keep variable names smaller, simpler
@@ -71,7 +71,7 @@ static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info); 


static unsigned int dbs_enable;	/* number of CPUs using this policy */



static DECLARE_MUTEX 	(dbs_sem);

static DEFINE_MUTEX 	(dbs_mutex);

static DECLARE_WORK	(dbs_work, do_dbs_timer, NULL);



struct dbs_tuners {
@@ -139,9 +139,9 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, 
	if (ret != 1 )

		return -EINVAL;



	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	dbs_tuners_ins.sampling_down_factor = input;

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -153,14 +153,14 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused, 
	int ret;

	ret = sscanf (buf, "%u", &input);



	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		return -EINVAL;

	}



	dbs_tuners_ins.sampling_rate = input;

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -172,16 +172,16 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused, 
	int ret;

	ret = sscanf (buf, "%u", &input);



	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || 

			input < MIN_FREQUENCY_UP_THRESHOLD ||

			input <= dbs_tuners_ins.down_threshold) {

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		return -EINVAL;

	}



	dbs_tuners_ins.up_threshold = input;

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -193,16 +193,16 @@ static ssize_t store_down_threshold(struct cpufreq_policy *unused, 
	int ret;

	ret = sscanf (buf, "%u", &input);



	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	if (ret != 1 || input > MAX_FREQUENCY_DOWN_THRESHOLD || 

			input < MIN_FREQUENCY_DOWN_THRESHOLD ||

			input >= dbs_tuners_ins.up_threshold) {

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		return -EINVAL;

	}



	dbs_tuners_ins.down_threshold = input;

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -222,9 +222,9 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy, 
	if ( input > 1 )

		input = 1;

	

	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		return count;

	}

	dbs_tuners_ins.ignore_nice = input;
@@ -236,7 +236,7 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy, 
		j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);

		j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;

	}

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -257,9 +257,9 @@ static ssize_t store_freq_step(struct cpufreq_policy *policy, 
	

	/* no need to test here if freq_step is zero as the user might actually

	 * want this, they would be crazy though :) */

	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	dbs_tuners_ins.freq_step = input;

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -444,12 +444,12 @@ static void dbs_check_cpu(int cpu) 
static void do_dbs_timer(void *data)

{ 

	int i;

	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	for_each_online_cpu(i)

		dbs_check_cpu(i);

	schedule_delayed_work(&dbs_work, 

			usecs_to_jiffies(dbs_tuners_ins.sampling_rate));

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);

} 



static inline void dbs_timer_init(void)
@@ -487,7 +487,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
		if (this_dbs_info->enable) /* Already enabled */

			break;

		 

		down(&dbs_sem);

		mutex_lock(&dbs_mutex);

		for_each_cpu_mask(j, policy->cpus) {

			struct cpu_dbs_info_s *j_dbs_info;

			j_dbs_info = &per_cpu(cpu_dbs_info, j);
@@ -521,11 +521,11 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
			dbs_timer_init();

		}

		

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		break;



	case CPUFREQ_GOV_STOP:

		down(&dbs_sem);

		mutex_lock(&dbs_mutex);

		this_dbs_info->enable = 0;

		sysfs_remove_group(&policy->kobj, &dbs_attr_group);

		dbs_enable--;
@@ -536,12 +536,12 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
		if (dbs_enable == 0) 

			dbs_timer_exit();

		

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);



		break;



	case CPUFREQ_GOV_LIMITS:

		down(&dbs_sem);

		mutex_lock(&dbs_mutex);

		if (policy->max < this_dbs_info->cur_policy->cur)

			__cpufreq_driver_target(

					this_dbs_info->cur_policy,
@@ -550,7 +550,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
			__cpufreq_driver_target(

					this_dbs_info->cur_policy,

				       	policy->min, CPUFREQ_RELATION_L);

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		break;

	}

	return 0;

drivers/cpufreq/cpufreq_ondemand.c

+21 −20
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 
#include <linux/jiffies.h>

#include <linux/kernel_stat.h>

#include <linux/percpu.h>

#include <linux/mutex.h>



/*

 * dbs is used in this file as a shortform for demandbased switching
@@ -70,7 +71,7 @@ static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info); 


static unsigned int dbs_enable;	/* number of CPUs using this policy */



static DECLARE_MUTEX 	(dbs_sem);

static DEFINE_MUTEX 	(dbs_mutex);

static DECLARE_WORK	(dbs_work, do_dbs_timer, NULL);



struct dbs_tuners {
@@ -136,9 +137,9 @@ static ssize_t store_sampling_down_factor(struct cpufreq_policy *unused, 
	if (input > MAX_SAMPLING_DOWN_FACTOR || input < 1)

		return -EINVAL;



	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	dbs_tuners_ins.sampling_down_factor = input;

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -150,14 +151,14 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused, 
	int ret;

	ret = sscanf (buf, "%u", &input);



	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	if (ret != 1 || input > MAX_SAMPLING_RATE || input < MIN_SAMPLING_RATE) {

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		return -EINVAL;

	}



	dbs_tuners_ins.sampling_rate = input;

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -169,15 +170,15 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused, 
	int ret;

	ret = sscanf (buf, "%u", &input);



	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || 

			input < MIN_FREQUENCY_UP_THRESHOLD) {

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		return -EINVAL;

	}



	dbs_tuners_ins.up_threshold = input;

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -197,9 +198,9 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy, 
	if ( input > 1 )

		input = 1;

	

	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	if ( input == dbs_tuners_ins.ignore_nice ) { /* nothing to do */

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		return count;

	}

	dbs_tuners_ins.ignore_nice = input;
@@ -211,7 +212,7 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy, 
		j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j);

		j_dbs_info->prev_cpu_idle_down = j_dbs_info->prev_cpu_idle_up;

	}

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);



	return count;

}
@@ -356,12 +357,12 @@ static void dbs_check_cpu(int cpu) 
static void do_dbs_timer(void *data)

{ 

	int i;

	down(&dbs_sem);

	mutex_lock(&dbs_mutex);

	for_each_online_cpu(i)

		dbs_check_cpu(i);

	schedule_delayed_work(&dbs_work, 

			usecs_to_jiffies(dbs_tuners_ins.sampling_rate));

	up(&dbs_sem);

	mutex_unlock(&dbs_mutex);

} 



static inline void dbs_timer_init(void)
@@ -399,7 +400,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
		if (this_dbs_info->enable) /* Already enabled */

			break;

		 

		down(&dbs_sem);

		mutex_lock(&dbs_mutex);

		for_each_cpu_mask(j, policy->cpus) {

			struct cpu_dbs_info_s *j_dbs_info;

			j_dbs_info = &per_cpu(cpu_dbs_info, j);
@@ -435,11 +436,11 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
			dbs_timer_init();

		}

		

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		break;



	case CPUFREQ_GOV_STOP:

		down(&dbs_sem);

		mutex_lock(&dbs_mutex);

		this_dbs_info->enable = 0;

		sysfs_remove_group(&policy->kobj, &dbs_attr_group);

		dbs_enable--;
@@ -450,12 +451,12 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
		if (dbs_enable == 0) 

			dbs_timer_exit();

		

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);



		break;



	case CPUFREQ_GOV_LIMITS:

		down(&dbs_sem);

		mutex_lock(&dbs_mutex);

		if (policy->max < this_dbs_info->cur_policy->cur)

			__cpufreq_driver_target(

					this_dbs_info->cur_policy,
@@ -464,7 +465,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, 
			__cpufreq_driver_target(

					this_dbs_info->cur_policy,

				       	policy->min, CPUFREQ_RELATION_L);

		up(&dbs_sem);

		mutex_unlock(&dbs_mutex);

		break;

	}

	return 0;

drivers/cpufreq/cpufreq_userspace.c

+13 −12
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <linux/types.h>

#include <linux/fs.h>

#include <linux/sysfs.h>

#include <linux/mutex.h>



#include <asm/uaccess.h>
@@ -35,7 +36,7 @@ static unsigned int cpu_set_freq[NR_CPUS]; /* CPU freq desired by userspace */ 
static unsigned int	cpu_is_managed[NR_CPUS];

static struct cpufreq_policy current_policy[NR_CPUS];



static DECLARE_MUTEX	(userspace_sem); 

static DEFINE_MUTEX	(userspace_mutex);



#define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "userspace", msg)
@@ -70,7 +71,7 @@ static int cpufreq_set(unsigned int freq, unsigned int cpu) 


	dprintk("cpufreq_set for cpu %u, freq %u kHz\n", cpu, freq);



	down(&userspace_sem);

	mutex_lock(&userspace_mutex);

	if (!cpu_is_managed[cpu])

		goto err;
@@ -83,16 +84,16 @@ static int cpufreq_set(unsigned int freq, unsigned int cpu) 


	/*

	 * We're safe from concurrent calls to ->target() here

	 * as we hold the userspace_sem lock. If we were calling

	 * as we hold the userspace_mutex lock. If we were calling

	 * cpufreq_driver_target, a deadlock situation might occur:

	 * A: cpufreq_set (lock userspace_sem) -> cpufreq_driver_target(lock policy->lock)

	 * B: cpufreq_set_policy(lock policy->lock) -> __cpufreq_governor -> cpufreq_governor_userspace (lock userspace_sem)

	 * A: cpufreq_set (lock userspace_mutex) -> cpufreq_driver_target(lock policy->lock)

	 * B: cpufreq_set_policy(lock policy->lock) -> __cpufreq_governor -> cpufreq_governor_userspace (lock userspace_mutex)

	 */

	ret = __cpufreq_driver_target(&current_policy[cpu], freq, 

	      CPUFREQ_RELATION_L);



 err:

	up(&userspace_sem);

	mutex_unlock(&userspace_mutex);

	return ret;

}
@@ -134,7 +135,7 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy, 
		if (!cpu_online(cpu))

			return -EINVAL;

		BUG_ON(!policy->cur);

		down(&userspace_sem);

		mutex_lock(&userspace_mutex);

		cpu_is_managed[cpu] = 1;		

		cpu_min_freq[cpu] = policy->min;

		cpu_max_freq[cpu] = policy->max;
@@ -143,20 +144,20 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy, 
		sysfs_create_file (&policy->kobj, &freq_attr_scaling_setspeed.attr);

		memcpy (&current_policy[cpu], policy, sizeof(struct cpufreq_policy));

		dprintk("managing cpu %u started (%u - %u kHz, currently %u kHz)\n", cpu, cpu_min_freq[cpu], cpu_max_freq[cpu], cpu_cur_freq[cpu]);

		up(&userspace_sem);

		mutex_unlock(&userspace_mutex);

		break;

	case CPUFREQ_GOV_STOP:

		down(&userspace_sem);

		mutex_lock(&userspace_mutex);

		cpu_is_managed[cpu] = 0;

		cpu_min_freq[cpu] = 0;

		cpu_max_freq[cpu] = 0;

		cpu_set_freq[cpu] = 0;

		sysfs_remove_file (&policy->kobj, &freq_attr_scaling_setspeed.attr);

		dprintk("managing cpu %u stopped\n", cpu);

		up(&userspace_sem);

		mutex_unlock(&userspace_mutex);

		break;

	case CPUFREQ_GOV_LIMITS:

		down(&userspace_sem);

		mutex_lock(&userspace_mutex);

		cpu_min_freq[cpu] = policy->min;

		cpu_max_freq[cpu] = policy->max;

		dprintk("limit event for cpu %u: %u - %u kHz, currently %u kHz, last set to %u kHz\n", cpu, cpu_min_freq[cpu], cpu_max_freq[cpu], cpu_cur_freq[cpu], cpu_set_freq[cpu]);
@@ -171,7 +172,7 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy, 
			      CPUFREQ_RELATION_L);

		}

		memcpy (&current_policy[cpu], policy, sizeof(struct cpufreq_policy));

		up(&userspace_sem);

		mutex_unlock(&userspace_mutex);

		break;

	}

	return 0;

CRA Git | Maintained and supported by SUSTech CRA and CCSE