kernel/watch64.c - kernel/skids - Git at Google

 /*
  * kernel/watch64.c
  *
  * Copyright (C) 2003 Josef "Jeff" Sipek <jeffpc@xxxxxxxxxxxxx>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  */

 #include <asm/param.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/jiffies.h>
 #include <linux/module.h>
 #include <linux/list.h>
 #include <linux/timer.h>
 #include <linux/kernel.h>
 #include <linux/seqlock.h>
 #include <linux/spinlock.h>
 #include <linux/rcupdate.h>
 #include <linux/rculist.h>
 #include <linux/watch64.h>

 /*
  * Watch64 global variables
  */

 spinlock_t watch64_biglock = SPIN_LOCK_UNLOCKED;
 LIST_HEAD(watch64_head);
 struct timer_list watch64_timer;
 int watch64_setup;

 #if (BITS_PER_LONG == 64)

 void watch64_init(void)
 {
 }

 void watch64_run(unsigned long var)
 {
 }

 int watch64_register(unsigned long* ptr, unsigned int interval)
 {
 	return 0;
 }

 int watch64_unregister(unsigned long* ptr, struct watch64* st)
 {
 	return 0;
 }

 void watch64_rcufree(void* p)
 {
 }

 struct watch64* watch64_find(unsigned long* ptr)
 {
 	return NULL;
 }

 struct watch64* __watch64_find(unsigned long* ptr)
 {
 	return NULL;
 }

 int watch64_disable(unsigned long* ptr, struct watch64* st)
 {
 	return 0;
 }

 int __watch64_disable(unsigned long* ptr, struct watch64* st)
 {
 	return 0;
 }

 int watch64_reset(unsigned long* ptr, struct watch64* st)
 {
 	return 0;
 }

 int __watch64_reset(unsigned long* ptr, struct watch64* st)
 {
 	return 0;
 }

 int watch64_enable(unsigned long* ptr, struct watch64* st)
 {
 	return 0;
 }

 int __watch64_enable(unsigned long* ptr, struct watch64* st)
 {
 	return 0;
 }

 int watch64_toggle(unsigned long* ptr, struct watch64* st)
 {
 	return 0;
 }

 inline u_int64_t watch64_getval(unsigned long* ptr, struct watch64* st)
 {
 	return (u_int64_t) *ptr;
 }

 #else

 /*
  * Initiate watch64 system
  */

 void watch64_init(void)
 {
 	spin_lock(&watch64_biglock);

 	if (watch64_setup==WATCH64_MAGIC) {
 		spin_unlock(&watch64_biglock);
 		return;
 	}

 	printk(KERN_WARNING "watch64: 2003/08/22 Josef 'Jeff' Sipek "
 			"<jeffpc@xxxxxxxxxxxxx>\n");
 	printk(KERN_WARNING "watch64: Enabling Watch64 extensions...");

 	init_timer(&watch64_timer);
 	watch64_timer.function = watch64_run;
 	watch64_timer.data = (unsigned long) NULL;
 	watch64_timer.expires = jiffies + WATCH64_MINIMUM;
 	add_timer(&watch64_timer);

 	printk("done.\n");

 	watch64_setup = WATCH64_MAGIC;

 	spin_unlock(&watch64_biglock);
 }

 /*
  * Go through the list of registered variables and check them for changes
  */

 void watch64_run(unsigned long var)
 {
 	struct list_head* entry;
 	struct watch64* watch_struct;
 	unsigned long tmp;

 	rcu_read_lock();
 	__list_for_each_rcu(entry, &watch64_head) {
 		watch_struct = list_entry(entry, struct watch64, list);
 		if (*watch_struct->ptr == watch_struct->oldval)
 			continue;

 		tmp = *watch_struct->ptr;
 		if (tmp > watch_struct->oldval) {
 			write_seqlock(&watch_struct->lock);
 			watch_struct->total += tmp - watch_struct->oldval;
 			write_sequnlock(&watch_struct->lock);
 		} else if (tmp < watch_struct->oldval) {
 			write_seqlock(&watch_struct->lock);
 			watch_struct->total += ((u_int64_t)1 << BITS_PER_LONG) -
 					watch_struct->oldval + tmp;
 			write_sequnlock(&watch_struct->lock);
 		}

 		watch_struct->oldval = tmp;
 	}
 	rcu_read_unlock();

 	mod_timer(&watch64_timer, jiffies + WATCH64_MINIMUM);
 }

 /*
  * Register a new variable with watch64
  */

 int watch64_register(unsigned long* ptr, unsigned int interval)
 {
 	struct watch64* temp;

 	temp = (struct watch64*)kmalloc(sizeof(struct watch64), GFP_ATOMIC);

 	if (!temp)
 		return -ENOMEM;

 	if (watch64_setup != WATCH64_MAGIC)
 		watch64_init();

 	temp->ptr = ptr;
 	temp->oldval = 0;
 	temp->total = 0;
 	if (interval == 0)
 		temp->interval = WATCH64_INTERVAL;
 	else if (interval < WATCH64_MINIMUM) {
 		temp->interval = WATCH64_MINIMUM;
 		printk("watch64: attempted to add new watch with "
 				"interval below %d jiffies",WATCH64_MINIMUM);
 	} else
 		temp->interval = interval;

 	temp->active = 0;

 	seqlock_init(&temp->lock);

 	list_add_rcu(&temp->list, &watch64_head);

 	return 0;
 }

 /*
  * Unregister a variable with watch64
  */

 int watch64_unregister(unsigned long* ptr, struct watch64* st)
 {
 	rcu_read_lock();
 	if (!st)
 		st = __watch64_find(ptr);

 	if (!st)
 		return -EINVAL;

 	__watch64_disable(ptr, st);
 	list_del_rcu(&st->list);

 	call_rcu(&st->rcuhead, watch64_rcufree);
 	rcu_read_unlock();

 	return 0;
 }

 /*
  * Free memory via RCU
  */

 void watch64_rcufree(struct rcu_head* p)
 {
 	kfree(container_of(p, struct watch64, rcuhead));
 }

 /*
  * Find watch64 structure with RCU lock
  */

 struct watch64* watch64_find(unsigned long* ptr)
 {
 	struct watch64* tmp;

 	rcu_read_lock();
 	tmp = __watch64_find(ptr);
 	rcu_read_unlock();

 	return tmp;
 }

 /*
  * Find watch64 structure without RCU lock
  */

 inline struct watch64* __watch64_find(unsigned long* ptr)
 {
 	struct list_head* tmp;
 	struct watch64* watch64_struct;

 	__list_for_each_rcu(tmp, &watch64_head) {
 		watch64_struct = list_entry(tmp, struct watch64, list);
 		if (watch64_struct->ptr == ptr)
 			return watch64_struct;
 	}

 	return NULL;
 }

 /*
  * Disable a variable watch with RCU lock
  */

 int watch64_disable(unsigned long* ptr, struct watch64* st)
 {
 	int tmp;

 	rcu_read_lock();
 	tmp = __watch64_disable(ptr,st);
 	rcu_read_unlock();

 	return tmp;
 }

 /*
  * Disable a variable watch without RCU lock
  */

 inline int __watch64_disable(unsigned long* ptr, struct watch64* st)
 {
 	if (!st)
 		st = watch64_find(ptr);

 	if (!st)
 		return -EINVAL;

 	st->active = 0;

 	return 0;
 }

 inline int __watch64_write(unsigned long* ptr, struct watch64* st, int enable_flag)
 {
 	if (!st)
 		st = __watch64_find(ptr);

 	if (!st)
 		return -EINVAL;

 	st->oldval = *ptr;
 	write_seqlock(&st->lock);
 	st->total = (u_int64_t) st->oldval;
 	write_sequnlock(&st->lock);

 	if (enable_flag)
 		st->active = 1;

 	return 0;
 }

 /*
  * Reset a variable watch with RCU lock
  */

 int watch64_reset(unsigned long* ptr, struct watch64* st)
 {
 	int tmp;

 	rcu_read_lock();
 	tmp = __watch64_reset(ptr, st);
 	rcu_read_unlock();

 	return tmp;
 }

 /*
  * Reset a variable watch without RCU lock
  */

 inline int __watch64_reset(unsigned long* ptr, struct watch64* st)
 {
 	return __watch64_write(ptr, st, 0);
 }

 /*
  * Enable a variable watch with RCU lock
  */

 int watch64_enable(unsigned long* ptr, struct watch64* st)
 {
 	int tmp;

 	rcu_read_lock();
 	tmp = __watch64_enable(ptr,st);
 	rcu_read_unlock();

 	return tmp;
 }

 /*
  * Enable a variable watch without RCU lock
  */

 inline int __watch64_enable(unsigned long* ptr, struct watch64* st)
 {
 	return __watch64_write(ptr, st, 1);
 }

 /*
  * Toggle a variable watch
  */

 int watch64_toggle(unsigned long* ptr, struct watch64* st)
 {
 	rcu_read_lock();
 	if (!st)
 		st = __watch64_find(ptr);

 	if (!st) {
 		rcu_read_unlock();
 		return -EINVAL;
 	}

 	if (st->active)
 		__watch64_disable(ptr,st);
 	else
 		__watch64_enable(ptr,st);

 	rcu_read_unlock();

 	return 0;
 }

 /*
  * Return the total 64-bit value
  */

 u_int64_t watch64_getval(unsigned long* ptr, struct watch64* st)
 {
 	unsigned int seq;
 	u_int64_t total;

 	rcu_read_lock();

 	if (!st)
 		st = __watch64_find(ptr);

 	if (!st) {
 		rcu_read_unlock();
 		return *ptr;
 	}

 	do {
 		seq = read_seqbegin(&st->lock);
 		total = st->total;
 	} while (read_seqretry(&st->lock, seq));

 	rcu_read_unlock();

 	return total;
 }

 #endif /* (BITS_PER_LONG == 64) */

 /*
  * Export all the necessary symbols
  */

 EXPORT_SYMBOL(watch64_register);
 EXPORT_SYMBOL(watch64_unregister);
 EXPORT_SYMBOL(watch64_find);
 EXPORT_SYMBOL(watch64_disable);
 EXPORT_SYMBOL(watch64_reset);
 EXPORT_SYMBOL(watch64_enable);
 EXPORT_SYMBOL(watch64_toggle);
 EXPORT_SYMBOL(watch64_getval);
	/*
	* kernel/watch64.c
	*
	* Copyright (C) 2003 Josef "Jeff" Sipek <jeffpc@xxxxxxxxxxxxx>
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*
	*/

	#include <asm/param.h>
	#include <linux/slab.h>
	#include <linux/errno.h>
	#include <linux/jiffies.h>
	#include <linux/module.h>
	#include <linux/list.h>
	#include <linux/timer.h>
	#include <linux/kernel.h>
	#include <linux/seqlock.h>
	#include <linux/spinlock.h>
	#include <linux/rcupdate.h>
	#include <linux/rculist.h>
	#include <linux/watch64.h>

	/*
	* Watch64 global variables
	*/

	spinlock_t watch64_biglock = SPIN_LOCK_UNLOCKED;
	LIST_HEAD(watch64_head);
	struct timer_list watch64_timer;
	int watch64_setup;

	#if (BITS_PER_LONG == 64)

	void watch64_init(void)
	{
	}

	void watch64_run(unsigned long var)
	{
	}

	int watch64_register(unsigned long* ptr, unsigned int interval)
	{
	return 0;
	}

	int watch64_unregister(unsigned long* ptr, struct watch64* st)
	{
	return 0;
	}

	void watch64_rcufree(void* p)
	{
	}

	struct watch64* watch64_find(unsigned long* ptr)
	{
	return NULL;
	}

	struct watch64* __watch64_find(unsigned long* ptr)
	{
	return NULL;
	}

	int watch64_disable(unsigned long* ptr, struct watch64* st)
	{
	return 0;
	}

	int __watch64_disable(unsigned long* ptr, struct watch64* st)
	{
	return 0;
	}

	int watch64_reset(unsigned long* ptr, struct watch64* st)
	{
	return 0;
	}

	int __watch64_reset(unsigned long* ptr, struct watch64* st)
	{
	return 0;
	}

	int watch64_enable(unsigned long* ptr, struct watch64* st)
	{
	return 0;
	}

	int __watch64_enable(unsigned long* ptr, struct watch64* st)
	{
	return 0;
	}

	int watch64_toggle(unsigned long* ptr, struct watch64* st)
	{
	return 0;
	}

	inline u_int64_t watch64_getval(unsigned long* ptr, struct watch64* st)
	{
	return (u_int64_t) *ptr;
	}

	#else

	/*
	* Initiate watch64 system
	*/

	void watch64_init(void)
	{
	spin_lock(&watch64_biglock);

	if (watch64_setup==WATCH64_MAGIC) {
	spin_unlock(&watch64_biglock);
	return;
	}

	printk(KERN_WARNING "watch64: 2003/08/22 Josef 'Jeff' Sipek "
	"<jeffpc@xxxxxxxxxxxxx>\n");
	printk(KERN_WARNING "watch64: Enabling Watch64 extensions...");

	init_timer(&watch64_timer);
	watch64_timer.function = watch64_run;
	watch64_timer.data = (unsigned long) NULL;
	watch64_timer.expires = jiffies + WATCH64_MINIMUM;
	add_timer(&watch64_timer);

	printk("done.\n");

	watch64_setup = WATCH64_MAGIC;

	spin_unlock(&watch64_biglock);
	}

	/*
	* Go through the list of registered variables and check them for changes
	*/

	void watch64_run(unsigned long var)
	{
	struct list_head* entry;
	struct watch64* watch_struct;
	unsigned long tmp;

	rcu_read_lock();
	__list_for_each_rcu(entry, &watch64_head) {
	watch_struct = list_entry(entry, struct watch64, list);
	if (*watch_struct->ptr == watch_struct->oldval)
	continue;

	tmp = *watch_struct->ptr;
	if (tmp > watch_struct->oldval) {
	write_seqlock(&watch_struct->lock);
	watch_struct->total += tmp - watch_struct->oldval;
	write_sequnlock(&watch_struct->lock);
	} else if (tmp < watch_struct->oldval) {
	write_seqlock(&watch_struct->lock);
	watch_struct->total += ((u_int64_t)1 << BITS_PER_LONG) -
	watch_struct->oldval + tmp;
	write_sequnlock(&watch_struct->lock);
	}

	watch_struct->oldval = tmp;
	}
	rcu_read_unlock();

	mod_timer(&watch64_timer, jiffies + WATCH64_MINIMUM);
	}

	/*
	* Register a new variable with watch64
	*/

	int watch64_register(unsigned long* ptr, unsigned int interval)
	{
	struct watch64* temp;

	temp = (struct watch64*)kmalloc(sizeof(struct watch64), GFP_ATOMIC);

	if (!temp)
	return -ENOMEM;

	if (watch64_setup != WATCH64_MAGIC)
	watch64_init();

	temp->ptr = ptr;
	temp->oldval = 0;
	temp->total = 0;
	if (interval == 0)
	temp->interval = WATCH64_INTERVAL;
	else if (interval < WATCH64_MINIMUM) {
	temp->interval = WATCH64_MINIMUM;
	printk("watch64: attempted to add new watch with "
	"interval below %d jiffies",WATCH64_MINIMUM);
	} else
	temp->interval = interval;

	temp->active = 0;

	seqlock_init(&temp->lock);

	list_add_rcu(&temp->list, &watch64_head);

	return 0;
	}

	/*
	* Unregister a variable with watch64
	*/

	int watch64_unregister(unsigned long* ptr, struct watch64* st)
	{
	rcu_read_lock();
	if (!st)
	st = __watch64_find(ptr);

	if (!st)
	return -EINVAL;

	__watch64_disable(ptr, st);
	list_del_rcu(&st->list);

	call_rcu(&st->rcuhead, watch64_rcufree);
	rcu_read_unlock();

	return 0;
	}

	/*
	* Free memory via RCU
	*/

	void watch64_rcufree(struct rcu_head* p)
	{
	kfree(container_of(p, struct watch64, rcuhead));
	}

	/*
	* Find watch64 structure with RCU lock
	*/

	struct watch64* watch64_find(unsigned long* ptr)
	{
	struct watch64* tmp;

	rcu_read_lock();
	tmp = __watch64_find(ptr);
	rcu_read_unlock();

	return tmp;
	}

	/*
	* Find watch64 structure without RCU lock
	*/

	inline struct watch64* __watch64_find(unsigned long* ptr)
	{
	struct list_head* tmp;
	struct watch64* watch64_struct;

	__list_for_each_rcu(tmp, &watch64_head) {
	watch64_struct = list_entry(tmp, struct watch64, list);
	if (watch64_struct->ptr == ptr)
	return watch64_struct;
	}

	return NULL;
	}

	/*
	* Disable a variable watch with RCU lock
	*/

	int watch64_disable(unsigned long* ptr, struct watch64* st)
	{
	int tmp;

	rcu_read_lock();
	tmp = __watch64_disable(ptr,st);
	rcu_read_unlock();

	return tmp;
	}

	/*
	* Disable a variable watch without RCU lock
	*/

	inline int __watch64_disable(unsigned long* ptr, struct watch64* st)
	{
	if (!st)
	st = watch64_find(ptr);

	if (!st)
	return -EINVAL;

	st->active = 0;

	return 0;
	}

	inline int __watch64_write(unsigned long* ptr, struct watch64* st, int enable_flag)
	{
	if (!st)
	st = __watch64_find(ptr);

	if (!st)
	return -EINVAL;

	st->oldval = *ptr;
	write_seqlock(&st->lock);
	st->total = (u_int64_t) st->oldval;
	write_sequnlock(&st->lock);

	if (enable_flag)
	st->active = 1;

	return 0;
	}

	/*
	* Reset a variable watch with RCU lock
	*/

	int watch64_reset(unsigned long* ptr, struct watch64* st)
	{
	int tmp;

	rcu_read_lock();
	tmp = __watch64_reset(ptr, st);
	rcu_read_unlock();

	return tmp;
	}

	/*
	* Reset a variable watch without RCU lock
	*/

	inline int __watch64_reset(unsigned long* ptr, struct watch64* st)
	{
	return __watch64_write(ptr, st, 0);
	}

	/*
	* Enable a variable watch with RCU lock
	*/

	int watch64_enable(unsigned long* ptr, struct watch64* st)
	{
	int tmp;

	rcu_read_lock();
	tmp = __watch64_enable(ptr,st);
	rcu_read_unlock();

	return tmp;
	}

	/*
	* Enable a variable watch without RCU lock
	*/

	inline int __watch64_enable(unsigned long* ptr, struct watch64* st)
	{
	return __watch64_write(ptr, st, 1);
	}

	/*
	* Toggle a variable watch
	*/

	int watch64_toggle(unsigned long* ptr, struct watch64* st)
	{
	rcu_read_lock();
	if (!st)
	st = __watch64_find(ptr);

	if (!st) {
	rcu_read_unlock();
	return -EINVAL;
	}

	if (st->active)
	__watch64_disable(ptr,st);
	else
	__watch64_enable(ptr,st);

	rcu_read_unlock();

	return 0;
	}

	/*
	* Return the total 64-bit value
	*/

	u_int64_t watch64_getval(unsigned long* ptr, struct watch64* st)
	{
	unsigned int seq;
	u_int64_t total;

	rcu_read_lock();

	if (!st)
	st = __watch64_find(ptr);

	if (!st) {
	rcu_read_unlock();
	return *ptr;
	}

	do {
	seq = read_seqbegin(&st->lock);
	total = st->total;
	} while (read_seqretry(&st->lock, seq));

	rcu_read_unlock();

	return total;
	}

	#endif /* (BITS_PER_LONG == 64) */

	/*
	* Export all the necessary symbols
	*/

	EXPORT_SYMBOL(watch64_register);
	EXPORT_SYMBOL(watch64_unregister);
	EXPORT_SYMBOL(watch64_find);
	EXPORT_SYMBOL(watch64_disable);
	EXPORT_SYMBOL(watch64_reset);
	EXPORT_SYMBOL(watch64_enable);
	EXPORT_SYMBOL(watch64_toggle);
	EXPORT_SYMBOL(watch64_getval);