kernel/latency.c - maze/linux - Git at Google

 /*
  * latency.c: Explicit system-wide latency-expectation infrastructure
  *
  * The purpose of this infrastructure is to allow device drivers to set
  * latency constraint they have and to collect and summarize these
  * expectations globally. The cummulated result can then be used by
  * power management and similar users to make decisions that have
  * tradoffs with a latency component.
  *
  * An example user of this are the x86 C-states; each higher C state saves
  * more power, but has a higher exit latency. For the idle loop power
  * code to make a good decision which C-state to use, information about
  * acceptable latencies is required.
  *
  * An example announcer of latency is an audio driver that knowns it
  * will get an interrupt when the hardware has 200 usec of samples
  * left in the DMA buffer; in that case the driver can set a latency
  * constraint of, say, 150 usec.
  *
  * Multiple drivers can each announce their maximum accepted latency,
  * to keep these appart, a string based identifier is used.
  *
  *
  * (C) Copyright 2006 Intel Corporation
  * Author: Arjan van de Ven <arjan@linux.intel.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; version 2
  * of the License.
  */

 #include <linux/latency.h>
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/notifier.h>
 #include <linux/jiffies.h>
 #include <asm/atomic.h>

 struct latency_info {
 	struct list_head list;
 	int usecs;
 	char *identifier;
 };

 /*
  * locking rule: all modifications to current_max_latency and
  * latency_list need to be done while holding the latency_lock.
  * latency_lock needs to be taken _irqsave.
  */
 static atomic_t current_max_latency;
 static DEFINE_SPINLOCK(latency_lock);

 static LIST_HEAD(latency_list);
 static BLOCKING_NOTIFIER_HEAD(latency_notifier);

 /*
  * This function returns the maximum latency allowed, which
  * happens to be the minimum of all maximum latencies on the
  * list.
  */
 static int __find_max_latency(void)
 {
 	int min = INFINITE_LATENCY;
 	struct latency_info *info;

 	list_for_each_entry(info, &latency_list, list) {
 		if (info->usecs < min)
 			min = info->usecs;
 	}
 	return min;
 }

 /**
  * set_acceptable_latency - sets the maximum latency acceptable
  * @identifier: string that identifies this driver
  * @usecs: maximum acceptable latency for this driver
  *
  * This function informs the kernel that this device(driver)
  * can accept at most usecs latency. This setting is used for
  * power management and similar tradeoffs.
  *
  * This function sleeps and can only be called from process
  * context.
  * Calling this function with an existing identifier is valid
  * and will cause the existing latency setting to be changed.
  */
 void set_acceptable_latency(char *identifier, int usecs)
 {
 	struct latency_info *info, *iter;
 	unsigned long flags;
 	int found_old = 0;

 	info = kzalloc(sizeof(struct latency_info), GFP_KERNEL);
 	if (!info)
 		return;
 	info->usecs = usecs;
 	info->identifier = kstrdup(identifier, GFP_KERNEL);
 	if (!info->identifier)
 		goto free_info;

 	spin_lock_irqsave(&latency_lock, flags);
 	list_for_each_entry(iter, &latency_list, list) {
 		if (strcmp(iter->identifier, identifier)==0) {
 			found_old = 1;
 			iter->usecs = usecs;
 			break;
 		}
 	}
 	if (!found_old)
 		list_add(&info->list, &latency_list);

 	if (usecs < atomic_read(&current_max_latency))
 		atomic_set(&current_max_latency, usecs);

 	spin_unlock_irqrestore(&latency_lock, flags);

 	blocking_notifier_call_chain(&latency_notifier,
 		atomic_read(&current_max_latency), NULL);

 	/*
 	 * if we inserted the new one, we're done; otherwise there was
 	 * an existing one so we need to free the redundant data
 	 */
 	if (!found_old)
 		return;

 	kfree(info->identifier);
 free_info:
 	kfree(info);
 }
 EXPORT_SYMBOL_GPL(set_acceptable_latency);

 /**
  * modify_acceptable_latency - changes the maximum latency acceptable
  * @identifier: string that identifies this driver
  * @usecs: maximum acceptable latency for this driver
  *
  * This function informs the kernel that this device(driver)
  * can accept at most usecs latency. This setting is used for
  * power management and similar tradeoffs.
  *
  * This function does not sleep and can be called in any context.
  * Trying to use a non-existing identifier silently gets ignored.
  *
  * Due to the atomic nature of this function, the modified latency
  * value will only be used for future decisions; past decisions
  * can still lead to longer latencies in the near future.
  */
 void modify_acceptable_latency(char *identifier, int usecs)
 {
 	struct latency_info *iter;
 	unsigned long flags;

 	spin_lock_irqsave(&latency_lock, flags);
 	list_for_each_entry(iter, &latency_list, list) {
 		if (strcmp(iter->identifier, identifier) == 0) {
 			iter->usecs = usecs;
 			break;
 		}
 	}
 	if (usecs < atomic_read(&current_max_latency))
 		atomic_set(&current_max_latency, usecs);
 	spin_unlock_irqrestore(&latency_lock, flags);
 }
 EXPORT_SYMBOL_GPL(modify_acceptable_latency);

 /**
  * remove_acceptable_latency - removes the maximum latency acceptable
  * @identifier: string that identifies this driver
  *
  * This function removes a previously set maximum latency setting
  * for the driver and frees up any resources associated with the
  * bookkeeping needed for this.
  *
  * This function does not sleep and can be called in any context.
  * Trying to use a non-existing identifier silently gets ignored.
  */
 void remove_acceptable_latency(char *identifier)
 {
 	unsigned long flags;
 	int newmax = 0;
 	struct latency_info *iter, *temp;

 	spin_lock_irqsave(&latency_lock, flags);

 	list_for_each_entry_safe(iter,  temp, &latency_list, list) {
 		if (strcmp(iter->identifier, identifier) == 0) {
 			list_del(&iter->list);
 			newmax = iter->usecs;
 			kfree(iter->identifier);
 			kfree(iter);
 			break;
 		}
 	}

 	/* If we just deleted the system wide value, we need to
 	 * recalculate with a full search
 	 */
 	if (newmax == atomic_read(&current_max_latency)) {
 		newmax = __find_max_latency();
 		atomic_set(&current_max_latency, newmax);
 	}
 	spin_unlock_irqrestore(&latency_lock, flags);
 }
 EXPORT_SYMBOL_GPL(remove_acceptable_latency);

 /**
  * system_latency_constraint - queries the system wide latency maximum
  *
  * This function returns the system wide maximum latency in
  * microseconds.
  *
  * This function does not sleep and can be called in any context.
  */
 int system_latency_constraint(void)
 {
 	return atomic_read(&current_max_latency);
 }
 EXPORT_SYMBOL_GPL(system_latency_constraint);

 /**
  * synchronize_acceptable_latency - recalculates all latency decisions
  *
  * This function will cause a callback to various kernel pieces that
  * will make those pieces rethink their latency decisions. This implies
  * that if there are overlong latencies in hardware state already, those
  * latencies get taken right now. When this call completes no overlong
  * latency decisions should be active anymore.
  *
  * Typical usecase of this is after a modify_acceptable_latency() call,
  * which in itself is non-blocking and non-synchronizing.
  *
  * This function blocks and should not be called with locks held.
  */

 void synchronize_acceptable_latency(void)
 {
 	blocking_notifier_call_chain(&latency_notifier,
 		atomic_read(&current_max_latency), NULL);
 }
 EXPORT_SYMBOL_GPL(synchronize_acceptable_latency);

 /*
  * Latency notifier: this notifier gets called when a non-atomic new
  * latency value gets set. The expectation nof the caller of the
  * non-atomic set is that when the call returns, future latencies
  * are within bounds, so the functions on the notifier list are
  * expected to take the overlong latencies immediately, inside the
  * callback, and not make a overlong latency decision anymore.
  *
  * The callback gets called when the new latency value is made
  * active so system_latency_constraint() returns the new latency.
  */
 int register_latency_notifier(struct notifier_block * nb)
 {
 	return blocking_notifier_chain_register(&latency_notifier, nb);
 }
 EXPORT_SYMBOL_GPL(register_latency_notifier);

 int unregister_latency_notifier(struct notifier_block * nb)
 {
 	return blocking_notifier_chain_unregister(&latency_notifier, nb);
 }
 EXPORT_SYMBOL_GPL(unregister_latency_notifier);

 static __init int latency_init(void)
 {
 	atomic_set(&current_max_latency, INFINITE_LATENCY);
 	/*
 	 * we don't want by default to have longer latencies than 2 ticks,
 	 * since that would cause lost ticks
 	 */
 	set_acceptable_latency("kernel", 2*1000000/HZ);
 	return 0;
 }

 module_init(latency_init);
	/*
	* latency.c: Explicit system-wide latency-expectation infrastructure
	*
	* The purpose of this infrastructure is to allow device drivers to set
	* latency constraint they have and to collect and summarize these
	* expectations globally. The cummulated result can then be used by
	* power management and similar users to make decisions that have
	* tradoffs with a latency component.
	*
	* An example user of this are the x86 C-states; each higher C state saves
	* more power, but has a higher exit latency. For the idle loop power
	* code to make a good decision which C-state to use, information about
	* acceptable latencies is required.
	*
	* An example announcer of latency is an audio driver that knowns it
	* will get an interrupt when the hardware has 200 usec of samples
	* left in the DMA buffer; in that case the driver can set a latency
	* constraint of, say, 150 usec.
	*
	* Multiple drivers can each announce their maximum accepted latency,
	* to keep these appart, a string based identifier is used.
	*
	*
	* (C) Copyright 2006 Intel Corporation
	* Author: Arjan van de Ven <arjan@linux.intel.com>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* as published by the Free Software Foundation; version 2
	* of the License.
	*/

	#include <linux/latency.h>
	#include <linux/list.h>
	#include <linux/spinlock.h>
	#include <linux/slab.h>
	#include <linux/module.h>
	#include <linux/notifier.h>
	#include <linux/jiffies.h>
	#include <asm/atomic.h>

	struct latency_info {
	struct list_head list;
	int usecs;
	char *identifier;
	};

	/*
	* locking rule: all modifications to current_max_latency and
	* latency_list need to be done while holding the latency_lock.
	* latency_lock needs to be taken _irqsave.
	*/
	static atomic_t current_max_latency;
	static DEFINE_SPINLOCK(latency_lock);

	static LIST_HEAD(latency_list);
	static BLOCKING_NOTIFIER_HEAD(latency_notifier);

	/*
	* This function returns the maximum latency allowed, which
	* happens to be the minimum of all maximum latencies on the
	* list.
	*/
	static int __find_max_latency(void)
	{
	int min = INFINITE_LATENCY;
	struct latency_info *info;

	list_for_each_entry(info, &latency_list, list) {
	if (info->usecs < min)
	min = info->usecs;
	}
	return min;
	}

	/**
	* set_acceptable_latency - sets the maximum latency acceptable
	* @identifier: string that identifies this driver
	* @usecs: maximum acceptable latency for this driver
	*
	* This function informs the kernel that this device(driver)
	* can accept at most usecs latency. This setting is used for
	* power management and similar tradeoffs.
	*
	* This function sleeps and can only be called from process
	* context.
	* Calling this function with an existing identifier is valid
	* and will cause the existing latency setting to be changed.
	*/
	void set_acceptable_latency(char *identifier, int usecs)
	{
	struct latency_info info, iter;
	unsigned long flags;
	int found_old = 0;

	info = kzalloc(sizeof(struct latency_info), GFP_KERNEL);
	if (!info)
	return;
	info->usecs = usecs;
	info->identifier = kstrdup(identifier, GFP_KERNEL);
	if (!info->identifier)
	goto free_info;

	spin_lock_irqsave(&latency_lock, flags);
	list_for_each_entry(iter, &latency_list, list) {
	if (strcmp(iter->identifier, identifier)==0) {
	found_old = 1;
	iter->usecs = usecs;
	break;
	}
	}
	if (!found_old)
	list_add(&info->list, &latency_list);

	if (usecs < atomic_read(&current_max_latency))
	atomic_set(&current_max_latency, usecs);

	spin_unlock_irqrestore(&latency_lock, flags);

	blocking_notifier_call_chain(&latency_notifier,
	atomic_read(&current_max_latency), NULL);

	/*
	* if we inserted the new one, we're done; otherwise there was
	* an existing one so we need to free the redundant data
	*/
	if (!found_old)
	return;

	kfree(info->identifier);
	free_info:
	kfree(info);
	}
	EXPORT_SYMBOL_GPL(set_acceptable_latency);

	/**
	* modify_acceptable_latency - changes the maximum latency acceptable
	* @identifier: string that identifies this driver
	* @usecs: maximum acceptable latency for this driver
	*
	* This function informs the kernel that this device(driver)
	* can accept at most usecs latency. This setting is used for
	* power management and similar tradeoffs.
	*
	* This function does not sleep and can be called in any context.
	* Trying to use a non-existing identifier silently gets ignored.
	*
	* Due to the atomic nature of this function, the modified latency
	* value will only be used for future decisions; past decisions
	* can still lead to longer latencies in the near future.
	*/
	void modify_acceptable_latency(char *identifier, int usecs)
	{
	struct latency_info *iter;
	unsigned long flags;

	spin_lock_irqsave(&latency_lock, flags);
	list_for_each_entry(iter, &latency_list, list) {
	if (strcmp(iter->identifier, identifier) == 0) {
	iter->usecs = usecs;
	break;
	}
	}
	if (usecs < atomic_read(&current_max_latency))
	atomic_set(&current_max_latency, usecs);
	spin_unlock_irqrestore(&latency_lock, flags);
	}
	EXPORT_SYMBOL_GPL(modify_acceptable_latency);

	/**
	* remove_acceptable_latency - removes the maximum latency acceptable
	* @identifier: string that identifies this driver
	*
	* This function removes a previously set maximum latency setting
	* for the driver and frees up any resources associated with the
	* bookkeeping needed for this.
	*
	* This function does not sleep and can be called in any context.
	* Trying to use a non-existing identifier silently gets ignored.
	*/
	void remove_acceptable_latency(char *identifier)
	{
	unsigned long flags;
	int newmax = 0;
	struct latency_info iter, temp;

	spin_lock_irqsave(&latency_lock, flags);

	list_for_each_entry_safe(iter, temp, &latency_list, list) {
	if (strcmp(iter->identifier, identifier) == 0) {
	list_del(&iter->list);
	newmax = iter->usecs;
	kfree(iter->identifier);
	kfree(iter);
	break;
	}
	}

	/* If we just deleted the system wide value, we need to
	* recalculate with a full search
	*/
	if (newmax == atomic_read(&current_max_latency)) {
	newmax = __find_max_latency();
	atomic_set(&current_max_latency, newmax);
	}
	spin_unlock_irqrestore(&latency_lock, flags);
	}
	EXPORT_SYMBOL_GPL(remove_acceptable_latency);

	/**
	* system_latency_constraint - queries the system wide latency maximum
	*
	* This function returns the system wide maximum latency in
	* microseconds.
	*
	* This function does not sleep and can be called in any context.
	*/
	int system_latency_constraint(void)
	{
	return atomic_read(&current_max_latency);
	}
	EXPORT_SYMBOL_GPL(system_latency_constraint);

	/**
	* synchronize_acceptable_latency - recalculates all latency decisions
	*
	* This function will cause a callback to various kernel pieces that
	* will make those pieces rethink their latency decisions. This implies
	* that if there are overlong latencies in hardware state already, those
	* latencies get taken right now. When this call completes no overlong
	* latency decisions should be active anymore.
	*
	* Typical usecase of this is after a modify_acceptable_latency() call,
	* which in itself is non-blocking and non-synchronizing.
	*
	* This function blocks and should not be called with locks held.
	*/

	void synchronize_acceptable_latency(void)
	{
	blocking_notifier_call_chain(&latency_notifier,
	atomic_read(&current_max_latency), NULL);
	}
	EXPORT_SYMBOL_GPL(synchronize_acceptable_latency);

	/*
	* Latency notifier: this notifier gets called when a non-atomic new
	* latency value gets set. The expectation nof the caller of the
	* non-atomic set is that when the call returns, future latencies
	* are within bounds, so the functions on the notifier list are
	* expected to take the overlong latencies immediately, inside the
	* callback, and not make a overlong latency decision anymore.
	*
	* The callback gets called when the new latency value is made
	* active so system_latency_constraint() returns the new latency.
	*/
	int register_latency_notifier(struct notifier_block * nb)
	{
	return blocking_notifier_chain_register(&latency_notifier, nb);
	}
	EXPORT_SYMBOL_GPL(register_latency_notifier);

	int unregister_latency_notifier(struct notifier_block * nb)
	{
	return blocking_notifier_chain_unregister(&latency_notifier, nb);
	}
	EXPORT_SYMBOL_GPL(unregister_latency_notifier);

	static __init int latency_init(void)
	{
	atomic_set(&current_max_latency, INFINITE_LATENCY);
	/*
	* we don't want by default to have longer latencies than 2 ticks,
	* since that would cause lost ticks
	*/
	set_acceptable_latency("kernel", 2*1000000/HZ);
	return 0;
	}

	module_init(latency_init);