From SRS0+a5501d92eec33f199aa0+870+infradead.org+arjan@pentafluge.srs.infradead.org Wed Jan 11 13:56:06 2006 Date: Tue, 10 Jan 2006 05:52:55 +0000 From: arjan@infradead.org To: Cc: Subject: driver model: convert driver model to mutexes Message-ID: <20060110055255.GA21364@infradead.org> Content-Disposition: inline Patch below converts drivers/base to mutexes, including some of the subsystems that register semaphores(mutexes) to the driver subsystem. Signed-off-by: Arjan van de Ven Signed-off-by: Greg Kroah-Hartman --- block/genhd.c | 21 +++++++++++---------- drivers/base/attribute_container.c | 27 ++++++++++++++------------- drivers/base/bus.c | 16 ++++++++-------- drivers/base/class.c | 22 +++++++++++----------- drivers/base/core.c | 2 +- drivers/base/dd.c | 36 ++++++++++++++++++------------------ drivers/base/dmapool.c | 15 ++++++++------- drivers/base/firmware_class.c | 21 +++++++++++---------- drivers/base/map.c | 20 ++++++++++---------- drivers/base/memory.c | 6 +++--- drivers/base/power/resume.c | 4 ++-- drivers/base/power/suspend.c | 4 ++-- drivers/base/sys.c | 23 ++++++++++++----------- drivers/usb/core/devio.c | 4 ++-- drivers/usb/core/hub.c | 8 ++++---- fs/char_dev.c | 13 +++++++------ include/linux/device.h | 5 +++-- include/linux/kobj_map.h | 4 ++-- include/linux/memory.h | 5 ++--- include/linux/usb.h | 6 +++--- 20 files changed, 134 insertions(+), 128 deletions(-) --- gregkh-2.6.orig/block/genhd.c +++ gregkh-2.6/block/genhd.c @@ -15,12 +15,13 @@ #include #include #include +#include #define MAX_PROBE_HASH 255 /* random */ static struct subsystem block_subsys; -static DECLARE_MUTEX(block_subsys_sem); +static DEFINE_MUTEX(block_subsys_mutex); /* * Can be deleted altogether. Later. @@ -138,7 +139,7 @@ int register_blkdev(unsigned int major, struct blk_major_name **n, *p; int index, ret = 0; - down(&block_subsys_sem); + mutex_lock(&block_subsys_mutex); /* temporary */ if (major == 0) { @@ -183,7 +184,7 @@ int register_blkdev(unsigned int major, kfree(p); } out: - up(&block_subsys_sem); + mutex_unlock(&block_subsys_mutex); return ret; } @@ -197,7 +198,7 @@ int unregister_blkdev(unsigned int major int index = major_to_index(major); int ret = 0; - down(&block_subsys_sem); + mutex_lock(&block_subsys_mutex); for (n = &major_names[index]; *n; n = &(*n)->next) if ((*n)->major == major) break; @@ -207,7 +208,7 @@ int unregister_blkdev(unsigned int major p = *n; *n = p->next; } - up(&block_subsys_sem); + mutex_unlock(&block_subsys_mutex); kfree(p); return ret; @@ -301,7 +302,7 @@ static void *part_start(struct seq_file struct list_head *p; loff_t l = *pos; - down(&block_subsys_sem); + mutex_lock(&block_subsys_mutex); list_for_each(p, &block_subsys.kset.list) if (!l--) return list_entry(p, struct gendisk, kobj.entry); @@ -318,7 +319,7 @@ static void *part_next(struct seq_file * static void part_stop(struct seq_file *part, void *v) { - up(&block_subsys_sem); + mutex_unlock(&block_subsys_mutex); } static int show_partition(struct seq_file *part, void *v) @@ -377,7 +378,7 @@ static struct kobject *base_probe(dev_t static int __init genhd_device_init(void) { - bdev_map = kobj_map_init(base_probe, &block_subsys_sem); + bdev_map = kobj_map_init(base_probe, &block_subsys_mutex); blk_dev_init(); subsystem_register(&block_subsys); return 0; @@ -611,7 +612,7 @@ static void *diskstats_start(struct seq_ loff_t k = *pos; struct list_head *p; - down(&block_subsys_sem); + mutex_lock(&block_subsys_mutex); list_for_each(p, &block_subsys.kset.list) if (!k--) return list_entry(p, struct gendisk, kobj.entry); @@ -628,7 +629,7 @@ static void *diskstats_next(struct seq_f static void diskstats_stop(struct seq_file *part, void *v) { - up(&block_subsys_sem); + mutex_unlock(&block_subsys_mutex); } static int diskstats_show(struct seq_file *s, void *v) --- gregkh-2.6.orig/drivers/base/attribute_container.c +++ gregkh-2.6/drivers/base/attribute_container.c @@ -18,6 +18,7 @@ #include #include #include +#include #include "base.h" @@ -62,7 +63,7 @@ EXPORT_SYMBOL_GPL(attribute_container_cl static struct list_head attribute_container_list; -static DECLARE_MUTEX(attribute_container_mutex); +static DEFINE_MUTEX(attribute_container_mutex); /** * attribute_container_register - register an attribute container @@ -77,9 +78,9 @@ attribute_container_register(struct attr klist_init(&cont->containers,internal_container_klist_get, internal_container_klist_put); - down(&attribute_container_mutex); + mutex_lock(&attribute_container_mutex); list_add_tail(&cont->node, &attribute_container_list); - up(&attribute_container_mutex); + mutex_unlock(&attribute_container_mutex); return 0; } @@ -94,7 +95,7 @@ int attribute_container_unregister(struct attribute_container *cont) { int retval = -EBUSY; - down(&attribute_container_mutex); + mutex_lock(&attribute_container_mutex); spin_lock(&cont->containers.k_lock); if (!list_empty(&cont->containers.k_list)) goto out; @@ -102,7 +103,7 @@ attribute_container_unregister(struct at list_del(&cont->node); out: spin_unlock(&cont->containers.k_lock); - up(&attribute_container_mutex); + mutex_unlock(&attribute_container_mutex); return retval; } @@ -145,7 +146,7 @@ attribute_container_add_device(struct de { struct attribute_container *cont; - down(&attribute_container_mutex); + mutex_lock(&attribute_container_mutex); list_for_each_entry(cont, &attribute_container_list, node) { struct internal_container *ic; @@ -173,7 +174,7 @@ attribute_container_add_device(struct de attribute_container_add_class_device(&ic->classdev); klist_add_tail(&ic->node, &cont->containers); } - up(&attribute_container_mutex); + mutex_unlock(&attribute_container_mutex); } /* FIXME: can't break out of this unless klist_iter_exit is also @@ -211,7 +212,7 @@ attribute_container_remove_device(struct { struct attribute_container *cont; - down(&attribute_container_mutex); + mutex_lock(&attribute_container_mutex); list_for_each_entry(cont, &attribute_container_list, node) { struct internal_container *ic; struct klist_iter iter; @@ -234,7 +235,7 @@ attribute_container_remove_device(struct } } } - up(&attribute_container_mutex); + mutex_unlock(&attribute_container_mutex); } EXPORT_SYMBOL_GPL(attribute_container_remove_device); @@ -256,7 +257,7 @@ attribute_container_device_trigger(struc { struct attribute_container *cont; - down(&attribute_container_mutex); + mutex_lock(&attribute_container_mutex); list_for_each_entry(cont, &attribute_container_list, node) { struct internal_container *ic; struct klist_iter iter; @@ -274,7 +275,7 @@ attribute_container_device_trigger(struc fn(cont, dev, &ic->classdev); } } - up(&attribute_container_mutex); + mutex_unlock(&attribute_container_mutex); } EXPORT_SYMBOL_GPL(attribute_container_device_trigger); @@ -297,12 +298,12 @@ attribute_container_trigger(struct devic { struct attribute_container *cont; - down(&attribute_container_mutex); + mutex_lock(&attribute_container_mutex); list_for_each_entry(cont, &attribute_container_list, node) { if (cont->match(cont, dev)) fn(cont, dev); } - up(&attribute_container_mutex); + mutex_unlock(&attribute_container_mutex); } EXPORT_SYMBOL_GPL(attribute_container_trigger); --- gregkh-2.6.orig/drivers/base/bus.c +++ gregkh-2.6/drivers/base/bus.c @@ -153,10 +153,10 @@ static ssize_t driver_unbind(struct devi dev = bus_find_device(bus, NULL, (void *)buf, driver_helper); if (dev && dev->driver == drv) { if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); + mutex_lock(&dev->parent->mutex); device_release_driver(dev); if (dev->parent) - up(&dev->parent->sem); + mutex_unlock(&dev->parent->mutex); err = count; } put_device(dev); @@ -180,12 +180,12 @@ static ssize_t driver_bind(struct device dev = bus_find_device(bus, NULL, (void *)buf, driver_helper); if (dev && dev->driver == NULL) { if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); - down(&dev->sem); + mutex_lock(&dev->parent->mutex); + mutex_lock(&dev->mutex); err = driver_probe_device(drv, dev); - up(&dev->sem); + mutex_unlock(&dev->mutex); if (dev->parent) - up(&dev->parent->sem); + mutex_unlock(&dev->parent->mutex); } put_device(dev); put_bus(bus); @@ -512,10 +512,10 @@ static int bus_rescan_devices_helper(str { if (!dev->driver) { if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); + mutex_lock(&dev->parent->mutex); device_attach(dev); if (dev->parent) - up(&dev->parent->sem); + mutex_unlock(&dev->parent->mutex); } return 0; } --- gregkh-2.6.orig/drivers/base/class.c +++ gregkh-2.6/drivers/base/class.c @@ -143,7 +143,7 @@ int class_register(struct class * cls) INIT_LIST_HEAD(&cls->children); INIT_LIST_HEAD(&cls->interfaces); - init_MUTEX(&cls->sem); + mutex_init(&cls->mutex); error = kobject_set_name(&cls->subsys.kset.kobj, "%s", cls->name); if (error) return error; @@ -563,12 +563,12 @@ int class_device_add(struct class_device /* notify any interfaces this device is now here */ if (parent_class) { - down(&parent_class->sem); + mutex_lock(&parent_class->mutex); list_add_tail(&class_dev->node, &parent_class->children); list_for_each_entry(class_intf, &parent_class->interfaces, node) if (class_intf->add) class_intf->add(class_dev, class_intf); - up(&parent_class->sem); + mutex_unlock(&parent_class->mutex); } register_done: @@ -656,12 +656,12 @@ void class_device_del(struct class_devic char *class_name = NULL; if (parent_class) { - down(&parent_class->sem); + mutex_lock(&parent_class->mutex); list_del_init(&class_dev->node); list_for_each_entry(class_intf, &parent_class->interfaces, node) if (class_intf->remove) class_intf->remove(class_dev, class_intf); - up(&parent_class->sem); + mutex_unlock(&parent_class->mutex); } if (class_dev->dev) { @@ -703,14 +703,14 @@ void class_device_destroy(struct class * struct class_device *class_dev = NULL; struct class_device *class_dev_tmp; - down(&cls->sem); + mutex_lock(&cls->mutex); list_for_each_entry(class_dev_tmp, &cls->children, node) { if (class_dev_tmp->devt == devt) { class_dev = class_dev_tmp; break; } } - up(&cls->sem); + mutex_unlock(&cls->mutex); if (class_dev) class_device_unregister(class_dev); @@ -775,13 +775,13 @@ int class_interface_register(struct clas if (!parent) return -EINVAL; - down(&parent->sem); + mutex_lock(&parent->mutex); list_add_tail(&class_intf->node, &parent->interfaces); if (class_intf->add) { list_for_each_entry(class_dev, &parent->children, node) class_intf->add(class_dev, class_intf); } - up(&parent->sem); + mutex_unlock(&parent->mutex); return 0; } @@ -794,13 +794,13 @@ void class_interface_unregister(struct c if (!parent) return; - down(&parent->sem); + mutex_lock(&parent->mutex); list_del_init(&class_intf->node); if (class_intf->remove) { list_for_each_entry(class_dev, &parent->children, node) class_intf->remove(class_dev, class_intf); } - up(&parent->sem); + mutex_unlock(&parent->mutex); class_put(parent); } --- gregkh-2.6.orig/drivers/base/core.c +++ gregkh-2.6/drivers/base/core.c @@ -231,7 +231,7 @@ void device_initialize(struct device *de klist_init(&dev->klist_children, klist_children_get, klist_children_put); INIT_LIST_HEAD(&dev->dma_pools); - init_MUTEX(&dev->sem); + mutex_init(&dev->mutex); device_init_wakeup(dev, 0); } --- gregkh-2.6.orig/drivers/base/dd.c +++ gregkh-2.6/drivers/base/dd.c @@ -36,7 +36,7 @@ * for before calling this. (It is ok to call with no other effort * from a driver's probe() method.) * - * This function must be called with @dev->sem held. + * This function must be called with @dev->mutex held. */ void device_bind_driver(struct device * dev) { @@ -65,8 +65,8 @@ void device_bind_driver(struct device * * This function returns 1 if a match is found, an error if one * occurs (that is not -ENODEV or -ENXIO), and 0 otherwise. * - * This function must be called with @dev->sem held. When called - * for a USB interface, @dev->parent->sem must be held as well. + * This function must be called with @dev->mutex held. When called + * for a USB interface, @dev->parent->mutex must be held as well. */ int driver_probe_device(struct device_driver * drv, struct device * dev) { @@ -131,19 +131,19 @@ static int __device_attach(struct device * Returns 1 if the device was bound to a driver; * 0 if no matching device was found; error code otherwise. * - * When called for a USB interface, @dev->parent->sem must be held. + * When called for a USB interface, @dev->parent->mutex must be held. */ int device_attach(struct device * dev) { int ret = 0; - down(&dev->sem); + mutex_lock(&dev->mutex); if (dev->driver) { device_bind_driver(dev); ret = 1; } else ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach); - up(&dev->sem); + mutex_unlock(&dev->mutex); return ret; } @@ -162,13 +162,13 @@ static int __driver_attach(struct device */ if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); - down(&dev->sem); + mutex_lock(&dev->parent->mutex); + mutex_lock(&dev->mutex); if (!dev->driver) driver_probe_device(drv, dev); - up(&dev->sem); + mutex_unlock(&dev->mutex); if (dev->parent) - up(&dev->parent->sem); + mutex_unlock(&dev->parent->mutex); return 0; } @@ -193,8 +193,8 @@ void driver_attach(struct device_driver * * Manually detach device from driver. * - * __device_release_driver() must be called with @dev->sem held. - * When called for a USB interface, @dev->parent->sem must be held + * __device_release_driver() must be called with @dev->mutex held. + * When called for a USB interface, @dev->parent->mutex must be held * as well. */ @@ -225,9 +225,9 @@ void device_release_driver(struct device * within their ->remove callback for the same device, they * will deadlock right here. */ - down(&dev->sem); + mutex_lock(&dev->mutex); __device_release_driver(dev); - up(&dev->sem); + mutex_unlock(&dev->mutex); } @@ -251,13 +251,13 @@ void driver_detach(struct device_driver spin_unlock(&drv->klist_devices.k_lock); if (dev->parent) /* Needed for USB */ - down(&dev->parent->sem); - down(&dev->sem); + mutex_lock(&dev->parent->mutex); + mutex_lock(&dev->mutex); if (dev->driver == drv) __device_release_driver(dev); - up(&dev->sem); + mutex_unlock(&dev->mutex); if (dev->parent) - up(&dev->parent->sem); + mutex_unlock(&dev->parent->mutex); put_device(dev); } } --- gregkh-2.6.orig/drivers/base/dmapool.c +++ gregkh-2.6/drivers/base/dmapool.c @@ -7,6 +7,7 @@ #include #include #include +#include /* * Pool allocator ... wraps the dma_alloc_coherent page allocator, so @@ -38,7 +39,7 @@ struct dma_page { /* cacheable header fo #define POOL_POISON_FREED 0xa7 /* !inuse */ #define POOL_POISON_ALLOCATED 0xa9 /* !initted */ -static DECLARE_MUTEX (pools_lock); +static DEFINE_MUTEX(pools_lock); static ssize_t show_pools (struct device *dev, struct device_attribute *attr, char *buf) @@ -56,7 +57,7 @@ show_pools (struct device *dev, struct d size -= temp; next += temp; - down (&pools_lock); + mutex_lock(&pools_lock); list_for_each_entry(pool, &dev->dma_pools, pools) { unsigned pages = 0; unsigned blocks = 0; @@ -74,7 +75,7 @@ show_pools (struct device *dev, struct d size -= temp; next += temp; } - up (&pools_lock); + mutex_unlock(&pools_lock); return PAGE_SIZE - size; } @@ -142,12 +143,12 @@ dma_pool_create (const char *name, struc init_waitqueue_head (&retval->waitq); if (dev) { - down (&pools_lock); + mutex_lock(&pools_lock); if (list_empty (&dev->dma_pools)) device_create_file (dev, &dev_attr_pools); /* note: not currently insisting "name" be unique */ list_add (&retval->pools, &dev->dma_pools); - up (&pools_lock); + mutex_unlock(&pools_lock); } else INIT_LIST_HEAD (&retval->pools); @@ -223,11 +224,11 @@ pool_free_page (struct dma_pool *pool, s void dma_pool_destroy (struct dma_pool *pool) { - down (&pools_lock); + mutex_lock(&pools_lock); list_del (&pool->pools); if (pool->dev && list_empty (&pool->dev->dma_pools)) device_remove_file (pool->dev, &dev_attr_pools); - up (&pools_lock); + mutex_unlock(&pools_lock); while (!list_empty (&pool->page_list)) { struct dma_page *page; --- gregkh-2.6.orig/drivers/base/firmware_class.c +++ gregkh-2.6/drivers/base/firmware_class.c @@ -15,6 +15,7 @@ #include #include #include +#include #include #include @@ -36,7 +37,7 @@ static int loading_timeout = 10; /* In s /* fw_lock could be moved to 'struct firmware_priv' but since it is just * guarding for corner cases a global lock should be OK */ -static DECLARE_MUTEX(fw_lock); +static DEFINE_MUTEX(fw_lock); struct firmware_priv { char fw_id[FIRMWARE_NAME_MAX]; @@ -145,9 +146,9 @@ firmware_loading_store(struct class_devi switch (loading) { case 1: - down(&fw_lock); + mutex_lock(&fw_lock); if (!fw_priv->fw) { - up(&fw_lock); + mutex_unlock(&fw_lock); break; } vfree(fw_priv->fw->data); @@ -155,7 +156,7 @@ firmware_loading_store(struct class_devi fw_priv->fw->size = 0; fw_priv->alloc_size = 0; set_bit(FW_STATUS_LOADING, &fw_priv->status); - up(&fw_lock); + mutex_unlock(&fw_lock); break; case 0: if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) { @@ -188,7 +189,7 @@ firmware_data_read(struct kobject *kobj, struct firmware *fw; ssize_t ret_count = count; - down(&fw_lock); + mutex_lock(&fw_lock); fw = fw_priv->fw; if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) { ret_count = -ENODEV; @@ -203,7 +204,7 @@ firmware_data_read(struct kobject *kobj, memcpy(buffer, fw->data + offset, ret_count); out: - up(&fw_lock); + mutex_unlock(&fw_lock); return ret_count; } @@ -254,7 +255,7 @@ firmware_data_write(struct kobject *kobj if (!capable(CAP_SYS_RAWIO)) return -EPERM; - down(&fw_lock); + mutex_lock(&fw_lock); fw = fw_priv->fw; if (!fw || test_bit(FW_STATUS_DONE, &fw_priv->status)) { retval = -ENODEV; @@ -269,7 +270,7 @@ firmware_data_write(struct kobject *kobj fw->size = max_t(size_t, offset + count, fw->size); retval = count; out: - up(&fw_lock); + mutex_unlock(&fw_lock); return retval; } @@ -437,14 +438,14 @@ _request_firmware(const struct firmware } else wait_for_completion(&fw_priv->completion); - down(&fw_lock); + mutex_lock(&fw_lock); if (!fw_priv->fw->size || test_bit(FW_STATUS_ABORT, &fw_priv->status)) { retval = -ENOENT; release_firmware(fw_priv->fw); *firmware_p = NULL; } fw_priv->fw = NULL; - up(&fw_lock); + mutex_unlock(&fw_lock); class_device_unregister(class_dev); goto out; --- gregkh-2.6.orig/drivers/base/map.c +++ gregkh-2.6/drivers/base/map.c @@ -25,7 +25,7 @@ struct kobj_map { int (*lock)(dev_t, void *); void *data; } *probes[255]; - struct semaphore *sem; + struct mutex *mutex; }; int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range, @@ -53,7 +53,7 @@ int kobj_map(struct kobj_map *domain, de p->range = range; p->data = data; } - down(domain->sem); + mutex_lock(domain->mutex); for (i = 0, p -= n; i < n; i++, p++, index++) { struct probe **s = &domain->probes[index % 255]; while (*s && (*s)->range < range) @@ -61,7 +61,7 @@ int kobj_map(struct kobj_map *domain, de p->next = *s; *s = p; } - up(domain->sem); + mutex_unlock(domain->mutex); return 0; } @@ -75,7 +75,7 @@ void kobj_unmap(struct kobj_map *domain, if (n > 255) n = 255; - down(domain->sem); + mutex_lock(domain->mutex); for (i = 0; i < n; i++, index++) { struct probe **s; for (s = &domain->probes[index % 255]; *s; s = &(*s)->next) { @@ -88,7 +88,7 @@ void kobj_unmap(struct kobj_map *domain, } } } - up(domain->sem); + mutex_unlock(domain->mutex); kfree(found); } @@ -99,7 +99,7 @@ struct kobject *kobj_lookup(struct kobj_ unsigned long best = ~0UL; retry: - down(domain->sem); + mutex_lock(domain->mutex); for (p = domain->probes[MAJOR(dev) % 255]; p; p = p->next) { struct kobject *(*probe)(dev_t, int *, void *); struct module *owner; @@ -120,7 +120,7 @@ retry: module_put(owner); continue; } - up(domain->sem); + mutex_unlock(domain->mutex); kobj = probe(dev, index, data); /* Currently ->owner protects _only_ ->probe() itself. */ module_put(owner); @@ -128,11 +128,11 @@ retry: return kobj; goto retry; } - up(domain->sem); + mutex_unlock(domain->mutex); return NULL; } -struct kobj_map *kobj_map_init(kobj_probe_t *base_probe, struct semaphore *sem) +struct kobj_map *kobj_map_init(kobj_probe_t *base_probe, struct mutex *mutex) { struct kobj_map *p = kmalloc(sizeof(struct kobj_map), GFP_KERNEL); struct probe *base = kzalloc(sizeof(*base), GFP_KERNEL); @@ -149,6 +149,6 @@ struct kobj_map *kobj_map_init(kobj_prob base->get = base_probe; for (i = 0; i < 255; i++) p->probes[i] = base; - p->sem = sem; + p->mutex = mutex; return p; } --- gregkh-2.6.orig/drivers/base/memory.c +++ gregkh-2.6/drivers/base/memory.c @@ -213,7 +213,7 @@ static int memory_block_change_state(str unsigned long to_state, unsigned long from_state_req) { int ret = 0; - down(&mem->state_sem); + mutex_lock(&mem->state_mutex); if (mem->state != from_state_req) { ret = -EINVAL; @@ -225,7 +225,7 @@ static int memory_block_change_state(str mem->state = to_state; out: - up(&mem->state_sem); + mutex_unlock(&mem->state_mutex); return ret; } @@ -346,7 +346,7 @@ static int add_memory_block(unsigned lon mem->phys_index = __section_nr(section); mem->state = state; - init_MUTEX(&mem->state_sem); + mutex_init(&mem->state_mutex); mem->phys_device = phys_device; ret = register_memory(mem, section, NULL); --- gregkh-2.6.orig/drivers/base/power/resume.c +++ gregkh-2.6/drivers/base/power/resume.c @@ -24,7 +24,7 @@ int resume_device(struct device * dev) { int error = 0; - down(&dev->sem); + mutex_lock(&dev->mutex); if (dev->power.pm_parent && dev->power.pm_parent->power.power_state.event) { dev_err(dev, "PM: resume from %d, parent %s still %d\n", @@ -36,7 +36,7 @@ int resume_device(struct device * dev) dev_dbg(dev,"resuming\n"); error = dev->bus->resume(dev); } - up(&dev->sem); + mutex_unlock(&dev->mutex); return error; } --- gregkh-2.6.orig/drivers/base/power/suspend.c +++ gregkh-2.6/drivers/base/power/suspend.c @@ -39,7 +39,7 @@ int suspend_device(struct device * dev, { int error = 0; - down(&dev->sem); + mutex_lock(&dev->mutex); if (dev->power.power_state.event) { dev_dbg(dev, "PM: suspend %d-->%d\n", dev->power.power_state.event, state.event); @@ -59,7 +59,7 @@ int suspend_device(struct device * dev, dev_dbg(dev, "suspending\n"); error = dev->bus->suspend(dev, state); } - up(&dev->sem); + mutex_unlock(&dev->mutex); return error; } --- gregkh-2.6.orig/drivers/base/sys.c +++ gregkh-2.6/drivers/base/sys.c @@ -21,6 +21,7 @@ #include #include #include +#include #include extern struct subsystem devices_subsys; @@ -104,7 +105,7 @@ EXPORT_SYMBOL_GPL(sysdev_class_unregiste static LIST_HEAD(sysdev_drivers); -static DECLARE_MUTEX(sysdev_drivers_lock); +static DEFINE_MUTEX(sysdev_drivers_lock); /** * sysdev_driver_register - Register auxillary driver @@ -121,7 +122,7 @@ static DECLARE_MUTEX(sysdev_drivers_lock int sysdev_driver_register(struct sysdev_class * cls, struct sysdev_driver * drv) { - down(&sysdev_drivers_lock); + mutex_lock(&sysdev_drivers_lock); if (cls && kset_get(&cls->kset)) { list_add_tail(&drv->entry, &cls->drivers); @@ -133,7 +134,7 @@ int sysdev_driver_register(struct sysdev } } else list_add_tail(&drv->entry, &sysdev_drivers); - up(&sysdev_drivers_lock); + mutex_unlock(&sysdev_drivers_lock); return 0; } @@ -146,7 +147,7 @@ int sysdev_driver_register(struct sysdev void sysdev_driver_unregister(struct sysdev_class * cls, struct sysdev_driver * drv) { - down(&sysdev_drivers_lock); + mutex_lock(&sysdev_drivers_lock); list_del_init(&drv->entry); if (cls) { if (drv->remove) { @@ -156,7 +157,7 @@ void sysdev_driver_unregister(struct sys } kset_put(&cls->kset); } - up(&sysdev_drivers_lock); + mutex_unlock(&sysdev_drivers_lock); } EXPORT_SYMBOL_GPL(sysdev_driver_register); @@ -195,7 +196,7 @@ int sysdev_register(struct sys_device * if (!error) { struct sysdev_driver * drv; - down(&sysdev_drivers_lock); + mutex_lock(&sysdev_drivers_lock); /* Generic notification is implicit, because it's that * code that should have called us. */ @@ -211,7 +212,7 @@ int sysdev_register(struct sys_device * if (drv->add) drv->add(sysdev); } - up(&sysdev_drivers_lock); + mutex_unlock(&sysdev_drivers_lock); } return error; } @@ -220,7 +221,7 @@ void sysdev_unregister(struct sys_device { struct sysdev_driver * drv; - down(&sysdev_drivers_lock); + mutex_lock(&sysdev_drivers_lock); list_for_each_entry(drv, &sysdev_drivers, entry) { if (drv->remove) drv->remove(sysdev); @@ -230,7 +231,7 @@ void sysdev_unregister(struct sys_device if (drv->remove) drv->remove(sysdev); } - up(&sysdev_drivers_lock); + mutex_unlock(&sysdev_drivers_lock); kobject_unregister(&sysdev->kobj); } @@ -257,7 +258,7 @@ void sysdev_shutdown(void) pr_debug("Shutting Down System Devices\n"); - down(&sysdev_drivers_lock); + mutex_lock(&sysdev_drivers_lock); list_for_each_entry_reverse(cls, &system_subsys.kset.list, kset.kobj.entry) { struct sys_device * sysdev; @@ -286,7 +287,7 @@ void sysdev_shutdown(void) cls->shutdown(sysdev); } } - up(&sysdev_drivers_lock); + mutex_unlock(&sysdev_drivers_lock); } static void __sysdev_resume(struct sys_device *dev) --- gregkh-2.6.orig/drivers/usb/core/devio.c +++ gregkh-2.6/drivers/usb/core/devio.c @@ -522,14 +522,14 @@ static struct usb_device *usbdev_lookup_ struct class_device *class_dev; struct usb_device *dev = NULL; - down(&usb_device_class->sem); + mutex_lock(&usb_device_class->mutex); list_for_each_entry(class_dev, &usb_device_class->children, node) { if (class_dev->devt == MKDEV(USB_DEVICE_MAJOR, minor)) { dev = class_dev->class_data; break; } } - up(&usb_device_class->sem); + mutex_unlock(&usb_device_class->mutex); return dev; }; --- gregkh-2.6.orig/fs/char_dev.c +++ gregkh-2.6/fs/char_dev.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include @@ -28,7 +29,7 @@ static struct kobj_map *cdev_map; #define MAX_PROBE_HASH 255 /* random */ -static DECLARE_MUTEX(chrdevs_lock); +static DEFINE_MUTEX(chrdevs_lock); static struct char_device_struct { struct char_device_struct *next; @@ -151,7 +152,7 @@ __register_chrdev_region(unsigned int ma memset(cd, 0, sizeof(struct char_device_struct)); - down(&chrdevs_lock); + mutex_lock(&chrdevs_lock); /* temporary */ if (major == 0) { @@ -186,10 +187,10 @@ __register_chrdev_region(unsigned int ma } cd->next = *cp; *cp = cd; - up(&chrdevs_lock); + mutex_unlock(&chrdevs_lock); return cd; out: - up(&chrdevs_lock); + mutex_unlock(&chrdevs_lock); kfree(cd); return ERR_PTR(ret); } @@ -200,7 +201,7 @@ __unregister_chrdev_region(unsigned majo struct char_device_struct *cd = NULL, **cp; int i = major_to_index(major); - down(&chrdevs_lock); + mutex_lock(&chrdevs_lock); for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next) if ((*cp)->major == major && (*cp)->baseminor == baseminor && @@ -210,7 +211,7 @@ __unregister_chrdev_region(unsigned majo cd = *cp; *cp = cd->next; } - up(&chrdevs_lock); + mutex_unlock(&chrdevs_lock); return cd; } --- gregkh-2.6.orig/include/linux/device.h +++ gregkh-2.6/include/linux/device.h @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -149,7 +150,7 @@ struct class { struct subsystem subsys; struct list_head children; struct list_head interfaces; - struct semaphore sem; /* locks both the children and interfaces lists */ + struct mutex mutex; /* locks both the children and interfaces lists */ struct class_attribute * class_attrs; struct class_device_attribute * class_dev_attrs; @@ -313,7 +314,7 @@ struct device { char bus_id[BUS_ID_SIZE]; /* position on parent bus */ struct device_attribute uevent_attr; - struct semaphore sem; /* semaphore to synchronize calls to + struct mutex mutex; /* semaphore to synchronize calls to * its driver. */ --- gregkh-2.6.orig/include/linux/kobj_map.h +++ gregkh-2.6/include/linux/kobj_map.h @@ -1,6 +1,6 @@ #ifdef __KERNEL__ -#include +#include typedef struct kobject *kobj_probe_t(dev_t, int *, void *); struct kobj_map; @@ -9,6 +9,6 @@ int kobj_map(struct kobj_map *, dev_t, u kobj_probe_t *, int (*)(dev_t, void *), void *); void kobj_unmap(struct kobj_map *, dev_t, unsigned long); struct kobject *kobj_lookup(struct kobj_map *, dev_t, int *); -struct kobj_map *kobj_map_init(kobj_probe_t *, struct semaphore *); +struct kobj_map *kobj_map_init(kobj_probe_t *, struct mutex *); #endif --- gregkh-2.6.orig/include/linux/memory.h +++ gregkh-2.6/include/linux/memory.h @@ -18,8 +18,7 @@ #include #include #include - -#include +#include struct memory_block { unsigned long phys_index; @@ -30,7 +29,7 @@ struct memory_block { * created long after the critical areas during * initialization. */ - struct semaphore state_sem; + struct mutex state_mutex; int phys_device; /* to which fru does this belong? */ void *hw; /* optional pointer to fw/hw data */ int (*phys_callback)(struct memory_block *); --- gregkh-2.6.orig/drivers/usb/core/hub.c +++ gregkh-2.6/drivers/usb/core/hub.c @@ -32,8 +32,8 @@ #include "hub.h" /* Protect struct usb_device->state and ->children members - * Note: Both are also protected by ->dev.sem, except that ->state can - * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */ + * Note: Both are also protected by ->dev.mutex, except that ->state can + * change to USB_STATE_NOTATTACHED even when the mutex isn't held. */ static DEFINE_SPINLOCK(device_state_lock); /* khubd's worklist and its lock */ @@ -1785,9 +1785,9 @@ static int finish_device_resume(struct u struct device *dev = &udev->actconfig->interface[i]->dev; - down(&dev->sem); + mutex_lock(&dev->mutex); (void) resume(dev); - up(&dev->sem); + mutex_unlock(&dev->mutex); } status = 0; --- gregkh-2.6.orig/include/linux/usb.h +++ gregkh-2.6/include/linux/usb.h @@ -379,9 +379,9 @@ extern struct usb_device *usb_get_dev(st extern void usb_put_dev(struct usb_device *dev); /* USB device locking */ -#define usb_lock_device(udev) down(&(udev)->dev.sem) -#define usb_unlock_device(udev) up(&(udev)->dev.sem) -#define usb_trylock_device(udev) down_trylock(&(udev)->dev.sem) +#define usb_lock_device(udev) mutex_lock(&(udev)->dev.mutex) +#define usb_unlock_device(udev) mutex_unlock(&(udev)->dev.mutex) +#define usb_trylock_device(udev) mutex_trylock(&(udev)->dev.mutex) extern int usb_lock_device_for_reset(struct usb_device *udev, struct usb_interface *iface);