Kernel/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-01-12 00:00:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

sem2mutex: drivers/char/drm/

Browse Source 
From: Arjan van de Ven <arjan@infradead.org>

Semaphore to mutex conversion.

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

Signed-off-by: Arjan van de Ven <arjan@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Dave Airlie <airlied@linux.ie>
This commit is contained in:
Dave Airlie 2006-02-02 19:37:46 +11:00 committed by Dave Airlie
parent ce60fe02fb
commit 30e2fb1881
11 changed files with 126 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
drivers/char/drm/drmP.h
View File

@ -57,6 +57,7 @@
#include <linux/smp_lock.h> /* For (un)lock_kernel */ #include <linux/smp_lock.h> /* For (un)lock_kernel */
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/cdev.h> #include <linux/cdev.h>
#include <linux/mutex.h>
#if defined(__alpha__) || defined(__powerpc__) #if defined(__alpha__) || defined(__powerpc__)
#include <asm/pgtable.h> /* For pte_wrprotect */ #include <asm/pgtable.h> /* For pte_wrprotect */
#endif #endif
@ -623,7 +624,7 @@ typedef struct drm_device {
/** \name Locks */ /** \name Locks */
/*@{ */ /*@{ */
spinlock_t count_lock; /**< For inuse, drm_device::open_count, drm_device::buf_use */ spinlock_t count_lock; /**< For inuse, drm_device::open_count, drm_device::buf_use */
struct semaphore struct_sem; /**< For others */ struct mutex struct_mutex; /**< For others */
/*@} */ /*@} */
/** \name Usage Counters */ /** \name Usage Counters */
@ -658,7 +659,7 @@ typedef struct drm_device {
/*@{ */ /*@{ */
drm_ctx_list_t *ctxlist; /**< Linked list of context handles */ drm_ctx_list_t *ctxlist; /**< Linked list of context handles */
int ctx_count; /**< Number of context handles */ int ctx_count; /**< Number of context handles */
struct semaphore ctxlist_sem; /**< For ctxlist */ struct mutex ctxlist_mutex; /**< For ctxlist */
drm_map_t **context_sareas; /**< per-context SAREA's */ drm_map_t **context_sareas; /**< per-context SAREA's */
int max_context; int max_context;

20
drivers/char/drm/drm_auth.c
View File

@ -56,7 +56,7 @@ static int drm_hash_magic(drm_magic_t magic)
* \param magic magic number. * \param magic magic number.
* *
* Searches in drm_device::magiclist within all files with the same hash key * Searches in drm_device::magiclist within all files with the same hash key
* the one with matching magic number, while holding the drm_device::struct_sem * the one with matching magic number, while holding the drm_device::struct_mutex
* lock. * lock.
*/ */
static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic) static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
@ -65,14 +65,14 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
drm_magic_entry_t *pt; drm_magic_entry_t *pt;
int hash = drm_hash_magic(magic); int hash = drm_hash_magic(magic);
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
for (pt = dev->magiclist[hash].head; pt; pt = pt->next) { for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
if (pt->magic == magic) { if (pt->magic == magic) {
retval = pt->priv; retval = pt->priv;
break; break;
} }
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return retval; return retval;
} }
@ -85,7 +85,7 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
* *
* Creates a drm_magic_entry structure and appends to the linked list * Creates a drm_magic_entry structure and appends to the linked list
* associated the magic number hash key in drm_device::magiclist, while holding * associated the magic number hash key in drm_device::magiclist, while holding
* the drm_device::struct_sem lock. * the drm_device::struct_mutex lock.
*/ */
static int drm_add_magic(drm_device_t * dev, drm_file_t * priv, static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
drm_magic_t magic) drm_magic_t magic)
@ -104,7 +104,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
entry->priv = priv; entry->priv = priv;
entry->next = NULL; entry->next = NULL;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
if (dev->magiclist[hash].tail) { if (dev->magiclist[hash].tail) {
dev->magiclist[hash].tail->next = entry; dev->magiclist[hash].tail->next = entry;
dev->magiclist[hash].tail = entry; dev->magiclist[hash].tail = entry;
@ -112,7 +112,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
dev->magiclist[hash].head = entry; dev->magiclist[hash].head = entry;
dev->magiclist[hash].tail = entry; dev->magiclist[hash].tail = entry;
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return 0; return 0;
} }
@ -124,7 +124,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
* \param magic magic number. * \param magic magic number.
* *
* Searches and unlinks the entry in drm_device::magiclist with the magic * Searches and unlinks the entry in drm_device::magiclist with the magic
* number hash key, while holding the drm_device::struct_sem lock. * number hash key, while holding the drm_device::struct_mutex lock.
*/ */
static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic) static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
{ {
@ -135,7 +135,7 @@ static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
DRM_DEBUG("%d\n", magic); DRM_DEBUG("%d\n", magic);
hash = drm_hash_magic(magic); hash = drm_hash_magic(magic);
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) { for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
if (pt->magic == magic) { if (pt->magic == magic) {
if (dev->magiclist[hash].head == pt) { if (dev->magiclist[hash].head == pt) {
@ -147,11 +147,11 @@ static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
if (prev) { if (prev) {
prev->next = pt->next; prev->next = pt->next;
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return 0; return 0;
} }
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC); drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);

80
drivers/char/drm/drm_bufs.c
View File

@ -255,14 +255,14 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
memset(list, 0, sizeof(*list)); memset(list, 0, sizeof(*list));
list->map = map; list->map = map;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
list_add(&list->head, &dev->maplist->head); list_add(&list->head, &dev->maplist->head);
/* Assign a 32-bit handle */ /* Assign a 32-bit handle */
/* We do it here so that dev->struct_sem protects the increment */ /* We do it here so that dev->struct_mutex protects the increment */
list->user_token = HandleID(map->type == _DRM_SHM list->user_token = HandleID(map->type == _DRM_SHM
? (unsigned long)map->handle ? (unsigned long)map->handle
: map->offset, dev); : map->offset, dev);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
*maplist = list; *maplist = list;
return 0; return 0;
@ -392,9 +392,9 @@ int drm_rmmap(drm_device_t *dev, drm_local_map_t *map)
{ {
int ret; int ret;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
ret = drm_rmmap_locked(dev, map); ret = drm_rmmap_locked(dev, map);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return ret; return ret;
} }
@ -423,7 +423,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
return -EFAULT; return -EFAULT;
} }
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
list_for_each(list, &dev->maplist->head) { list_for_each(list, &dev->maplist->head) {
drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head); drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
@ -439,7 +439,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
* find anything. * find anything.
*/ */
if (list == (&dev->maplist->head)) { if (list == (&dev->maplist->head)) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -EINVAL; return -EINVAL;
} }
@ -448,13 +448,13 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
/* Register and framebuffer maps are permanent */ /* Register and framebuffer maps are permanent */
if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) { if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return 0; return 0;
} }
ret = drm_rmmap_locked(dev, map); ret = drm_rmmap_locked(dev, map);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return ret; return ret;
} }
@ -566,16 +566,16 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
atomic_inc(&dev->buf_alloc); atomic_inc(&dev->buf_alloc);
spin_unlock(&dev->count_lock); spin_unlock(&dev->count_lock);
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
entry = &dma->bufs[order]; entry = &dma->bufs[order];
if (entry->buf_count) { if (entry->buf_count) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; /* May only call once for each order */ return -ENOMEM; /* May only call once for each order */
} }
if (count < 0 || count > 4096) { if (count < 0 || count > 4096) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -EINVAL; return -EINVAL;
} }
@ -583,7 +583,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
entry->buflist = drm_alloc(count * sizeof(*entry->buflist), entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
DRM_MEM_BUFS); DRM_MEM_BUFS);
if (!entry->buflist) { if (!entry->buflist) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -616,7 +616,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
/* Set count correctly so we free the proper amount. */ /* Set count correctly so we free the proper amount. */
entry->buf_count = count; entry->buf_count = count;
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -638,7 +638,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
if (!temp_buflist) { if (!temp_buflist) {
/* Free the entry because it isn't valid */ /* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -656,7 +656,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count); DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count); DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
request->count = entry->buf_count; request->count = entry->buf_count;
request->size = size; request->size = size;
@ -722,16 +722,16 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
atomic_inc(&dev->buf_alloc); atomic_inc(&dev->buf_alloc);
spin_unlock(&dev->count_lock); spin_unlock(&dev->count_lock);
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
entry = &dma->bufs[order]; entry = &dma->bufs[order];
if (entry->buf_count) { if (entry->buf_count) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; /* May only call once for each order */ return -ENOMEM; /* May only call once for each order */
} }
if (count < 0 || count > 4096) { if (count < 0 || count > 4096) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -EINVAL; return -EINVAL;
} }
@ -739,7 +739,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
entry->buflist = drm_alloc(count * sizeof(*entry->buflist), entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
DRM_MEM_BUFS); DRM_MEM_BUFS);
if (!entry->buflist) { if (!entry->buflist) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -750,7 +750,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
if (!entry->seglist) { if (!entry->seglist) {
drm_free(entry->buflist, drm_free(entry->buflist,
count * sizeof(*entry->buflist), DRM_MEM_BUFS); count * sizeof(*entry->buflist), DRM_MEM_BUFS);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -766,7 +766,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
count * sizeof(*entry->buflist), DRM_MEM_BUFS); count * sizeof(*entry->buflist), DRM_MEM_BUFS);
drm_free(entry->seglist, drm_free(entry->seglist,
count * sizeof(*entry->seglist), DRM_MEM_SEGS); count * sizeof(*entry->seglist), DRM_MEM_SEGS);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -790,7 +790,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
drm_free(temp_pagelist, drm_free(temp_pagelist,
(dma->page_count + (count << page_order)) (dma->page_count + (count << page_order))
* sizeof(*dma->pagelist), DRM_MEM_PAGES); * sizeof(*dma->pagelist), DRM_MEM_PAGES);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -831,7 +831,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
(count << page_order)) (count << page_order))
* sizeof(*dma->pagelist), * sizeof(*dma->pagelist),
DRM_MEM_PAGES); DRM_MEM_PAGES);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -853,7 +853,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
drm_free(temp_pagelist, drm_free(temp_pagelist,
(dma->page_count + (count << page_order)) (dma->page_count + (count << page_order))
* sizeof(*dma->pagelist), DRM_MEM_PAGES); * sizeof(*dma->pagelist), DRM_MEM_PAGES);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -878,7 +878,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
dma->page_count += entry->seg_count << page_order; dma->page_count += entry->seg_count << page_order;
dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order); dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
request->count = entry->buf_count; request->count = entry->buf_count;
request->size = size; request->size = size;
@ -948,16 +948,16 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
atomic_inc(&dev->buf_alloc); atomic_inc(&dev->buf_alloc);
spin_unlock(&dev->count_lock); spin_unlock(&dev->count_lock);
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
entry = &dma->bufs[order]; entry = &dma->bufs[order];
if (entry->buf_count) { if (entry->buf_count) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; /* May only call once for each order */ return -ENOMEM; /* May only call once for each order */
} }
if (count < 0 || count > 4096) { if (count < 0 || count > 4096) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -EINVAL; return -EINVAL;
} }
@ -965,7 +965,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
entry->buflist = drm_alloc(count * sizeof(*entry->buflist), entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
DRM_MEM_BUFS); DRM_MEM_BUFS);
if (!entry->buflist) { if (!entry->buflist) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -999,7 +999,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
/* Set count correctly so we free the proper amount. */ /* Set count correctly so we free the proper amount. */
entry->buf_count = count; entry->buf_count = count;
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -1022,7 +1022,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
if (!temp_buflist) { if (!temp_buflist) {
/* Free the entry because it isn't valid */ /* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -1040,7 +1040,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count); DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count); DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
request->count = entry->buf_count; request->count = entry->buf_count;
request->size = size; request->size = size;
@ -1110,16 +1110,16 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
atomic_inc(&dev->buf_alloc); atomic_inc(&dev->buf_alloc);
spin_unlock(&dev->count_lock); spin_unlock(&dev->count_lock);
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
entry = &dma->bufs[order]; entry = &dma->bufs[order];
if (entry->buf_count) { if (entry->buf_count) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; /* May only call once for each order */ return -ENOMEM; /* May only call once for each order */
} }
if (count < 0 || count > 4096) { if (count < 0 || count > 4096) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -EINVAL; return -EINVAL;
} }
@ -1127,7 +1127,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
entry->buflist = drm_alloc(count * sizeof(*entry->buflist), entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
DRM_MEM_BUFS); DRM_MEM_BUFS);
if (!entry->buflist) { if (!entry->buflist) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -1160,7 +1160,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
/* Set count correctly so we free the proper amount. */ /* Set count correctly so we free the proper amount. */
entry->buf_count = count; entry->buf_count = count;
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -1182,7 +1182,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
if (!temp_buflist) { if (!temp_buflist) {
/* Free the entry because it isn't valid */ /* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
} }
@ -1200,7 +1200,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count); DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count); DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
request->count = entry->buf_count; request->count = entry->buf_count;
request->size = size; request->size = size;

52
drivers/char/drm/drm_context.c
View File

@ -53,7 +53,7 @@
* \param ctx_handle context handle. * \param ctx_handle context handle.
* *
* Clears the bit specified by \p ctx_handle in drm_device::ctx_bitmap and the entry * Clears the bit specified by \p ctx_handle in drm_device::ctx_bitmap and the entry
* in drm_device::context_sareas, while holding the drm_device::struct_sem * in drm_device::context_sareas, while holding the drm_device::struct_mutex
* lock. * lock.
*/ */
void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle) void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
@ -64,10 +64,10 @@ void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
goto failed; goto failed;
if (ctx_handle < DRM_MAX_CTXBITMAP) { if (ctx_handle < DRM_MAX_CTXBITMAP) {
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
clear_bit(ctx_handle, dev->ctx_bitmap); clear_bit(ctx_handle, dev->ctx_bitmap);
dev->context_sareas[ctx_handle] = NULL; dev->context_sareas[ctx_handle] = NULL;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return; return;
} }
failed: failed:
@ -83,7 +83,7 @@ void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
* *
* Find the first zero bit in drm_device::ctx_bitmap and (re)allocates * Find the first zero bit in drm_device::ctx_bitmap and (re)allocates
* drm_device::context_sareas to accommodate the new entry while holding the * drm_device::context_sareas to accommodate the new entry while holding the
* drm_device::struct_sem lock. * drm_device::struct_mutex lock.
*/ */
static int drm_ctxbitmap_next(drm_device_t * dev) static int drm_ctxbitmap_next(drm_device_t * dev)
{ {
@ -92,7 +92,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
if (!dev->ctx_bitmap) if (!dev->ctx_bitmap)
return -1; return -1;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP); bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP);
if (bit < DRM_MAX_CTXBITMAP) { if (bit < DRM_MAX_CTXBITMAP) {
set_bit(bit, dev->ctx_bitmap); set_bit(bit, dev->ctx_bitmap);
@ -113,7 +113,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
DRM_MEM_MAPS); DRM_MEM_MAPS);
if (!ctx_sareas) { if (!ctx_sareas) {
clear_bit(bit, dev->ctx_bitmap); clear_bit(bit, dev->ctx_bitmap);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -1; return -1;
} }
dev->context_sareas = ctx_sareas; dev->context_sareas = ctx_sareas;
@ -126,16 +126,16 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
DRM_MEM_MAPS); DRM_MEM_MAPS);
if (!dev->context_sareas) { if (!dev->context_sareas) {
clear_bit(bit, dev->ctx_bitmap); clear_bit(bit, dev->ctx_bitmap);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -1; return -1;
} }
dev->context_sareas[bit] = NULL; dev->context_sareas[bit] = NULL;
} }
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return bit; return bit;
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -1; return -1;
} }
@ -145,24 +145,24 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
* \param dev DRM device. * \param dev DRM device.
* *
* Allocates and initialize drm_device::ctx_bitmap and drm_device::context_sareas, while holding * Allocates and initialize drm_device::ctx_bitmap and drm_device::context_sareas, while holding
* the drm_device::struct_sem lock. * the drm_device::struct_mutex lock.
*/ */
int drm_ctxbitmap_init(drm_device_t * dev) int drm_ctxbitmap_init(drm_device_t * dev)
{ {
int i; int i;
int temp; int temp;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
dev->ctx_bitmap = (unsigned long *)drm_alloc(PAGE_SIZE, dev->ctx_bitmap = (unsigned long *)drm_alloc(PAGE_SIZE,
DRM_MEM_CTXBITMAP); DRM_MEM_CTXBITMAP);
if (dev->ctx_bitmap == NULL) { if (dev->ctx_bitmap == NULL) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -ENOMEM; return -ENOMEM;
} }
memset((void *)dev->ctx_bitmap, 0, PAGE_SIZE); memset((void *)dev->ctx_bitmap, 0, PAGE_SIZE);
dev->context_sareas = NULL; dev->context_sareas = NULL;
dev->max_context = -1; dev->max_context = -1;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) { for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
temp = drm_ctxbitmap_next(dev); temp = drm_ctxbitmap_next(dev);
@ -178,17 +178,17 @@ int drm_ctxbitmap_init(drm_device_t * dev)
* \param dev DRM device. * \param dev DRM device.
* *
* Frees drm_device::ctx_bitmap and drm_device::context_sareas, while holding * Frees drm_device::ctx_bitmap and drm_device::context_sareas, while holding
* the drm_device::struct_sem lock. * the drm_device::struct_mutex lock.
*/ */
void drm_ctxbitmap_cleanup(drm_device_t * dev) void drm_ctxbitmap_cleanup(drm_device_t * dev)
{ {
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
if (dev->context_sareas) if (dev->context_sareas)
drm_free(dev->context_sareas, drm_free(dev->context_sareas,
sizeof(*dev->context_sareas) * sizeof(*dev->context_sareas) *
dev->max_context, DRM_MEM_MAPS); dev->max_context, DRM_MEM_MAPS);
drm_free((void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP); drm_free((void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
} }
/*@}*/ /*@}*/
@ -222,15 +222,15 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
if (copy_from_user(&request, argp, sizeof(request))) if (copy_from_user(&request, argp, sizeof(request)))
return -EFAULT; return -EFAULT;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
if (dev->max_context < 0 if (dev->max_context < 0
|| request.ctx_id >= (unsigned)dev->max_context) { || request.ctx_id >= (unsigned)dev->max_context) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -EINVAL; return -EINVAL;
} }
map = dev->context_sareas[request.ctx_id]; map = dev->context_sareas[request.ctx_id];
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
request.handle = NULL; request.handle = NULL;
list_for_each_entry(_entry, &dev->maplist->head, head) { list_for_each_entry(_entry, &dev->maplist->head, head) {
@ -274,7 +274,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
(drm_ctx_priv_map_t __user *) arg, sizeof(request))) (drm_ctx_priv_map_t __user *) arg, sizeof(request)))
return -EFAULT; return -EFAULT;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
list_for_each(list, &dev->maplist->head) { list_for_each(list, &dev->maplist->head) {
r_list = list_entry(list, drm_map_list_t, head); r_list = list_entry(list, drm_map_list_t, head);
if (r_list->map if (r_list->map
@ -282,7 +282,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
goto found; goto found;
} }
bad: bad:
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -EINVAL; return -EINVAL;
found: found:
@ -294,7 +294,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
if (request.ctx_id >= (unsigned)dev->max_context) if (request.ctx_id >= (unsigned)dev->max_context)
goto bad; goto bad;
dev->context_sareas[request.ctx_id] = map; dev->context_sareas[request.ctx_id] = map;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return 0; return 0;
} }
@ -448,10 +448,10 @@ int drm_addctx(struct inode *inode, struct file *filp,
ctx_entry->handle = ctx.handle; ctx_entry->handle = ctx.handle;
ctx_entry->tag = priv; ctx_entry->tag = priv;
down(&dev->ctxlist_sem); mutex_lock(&dev->ctxlist_mutex);
list_add(&ctx_entry->head, &dev->ctxlist->head); list_add(&ctx_entry->head, &dev->ctxlist->head);
++dev->ctx_count; ++dev->ctx_count;
up(&dev->ctxlist_sem); mutex_unlock(&dev->ctxlist_mutex);
if (copy_to_user(argp, &ctx, sizeof(ctx))) if (copy_to_user(argp, &ctx, sizeof(ctx)))
return -EFAULT; return -EFAULT;
@ -574,7 +574,7 @@ int drm_rmctx(struct inode *inode, struct file *filp,
drm_ctxbitmap_free(dev, ctx.handle); drm_ctxbitmap_free(dev, ctx.handle);
} }
down(&dev->ctxlist_sem); mutex_lock(&dev->ctxlist_mutex);
if (!list_empty(&dev->ctxlist->head)) { if (!list_empty(&dev->ctxlist->head)) {
drm_ctx_list_t *pos, *n; drm_ctx_list_t *pos, *n;
@ -586,7 +586,7 @@ int drm_rmctx(struct inode *inode, struct file *filp,
} }
} }
} }
up(&dev->ctxlist_sem); mutex_unlock(&dev->ctxlist_mutex);
return 0; return 0;
} }

4
drivers/char/drm/drm_drv.c
View File

@ -151,7 +151,7 @@ int drm_lastclose(drm_device_t * dev)
if (dev->irq_enabled) if (dev->irq_enabled)
drm_irq_uninstall(dev); drm_irq_uninstall(dev);
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
del_timer(&dev->timer); del_timer(&dev->timer);
/* Clear pid list */ /* Clear pid list */
@ -231,7 +231,7 @@ int drm_lastclose(drm_device_t * dev)
dev->lock.filp = NULL; dev->lock.filp = NULL;
wake_up_interruptible(&dev->lock.lock_queue); wake_up_interruptible(&dev->lock.lock_queue);
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
DRM_DEBUG("lastclose completed\n"); DRM_DEBUG("lastclose completed\n");
return 0; return 0;

12
drivers/char/drm/drm_fops.c
View File

@ -262,7 +262,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
goto out_free; goto out_free;
} }
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
if (!dev->file_last) { if (!dev->file_last) {
priv->next = NULL; priv->next = NULL;
priv->prev = NULL; priv->prev = NULL;
@ -276,7 +276,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
dev->file_last->next = priv; dev->file_last->next = priv;
dev->file_last = priv; dev->file_last = priv;
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
#ifdef __alpha__ #ifdef __alpha__
/* /*
@ -413,7 +413,7 @@ int drm_release(struct inode *inode, struct file *filp)
drm_fasync(-1, filp, 0); drm_fasync(-1, filp, 0);
down(&dev->ctxlist_sem); mutex_lock(&dev->ctxlist_mutex);
if (dev->ctxlist && (!list_empty(&dev->ctxlist->head))) { if (dev->ctxlist && (!list_empty(&dev->ctxlist->head))) {
drm_ctx_list_t *pos, *n; drm_ctx_list_t *pos, *n;
@ -432,9 +432,9 @@ int drm_release(struct inode *inode, struct file *filp)
} }
} }
} }
up(&dev->ctxlist_sem); mutex_unlock(&dev->ctxlist_mutex);
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
if (priv->remove_auth_on_close == 1) { if (priv->remove_auth_on_close == 1) {
drm_file_t *temp = dev->file_first; drm_file_t *temp = dev->file_first;
while (temp) { while (temp) {
@ -452,7 +452,7 @@ int drm_release(struct inode *inode, struct file *filp)
} else { } else {
dev->file_last = priv->prev; dev->file_last = priv->prev;
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
if (dev->driver->postclose) if (dev->driver->postclose)
dev->driver->postclose(dev, priv); dev->driver->postclose(dev, priv);

18
drivers/char/drm/drm_ioctl.c
View File

@ -194,9 +194,9 @@ int drm_getmap(struct inode *inode, struct file *filp,
return -EFAULT; return -EFAULT;
idx = map.offset; idx = map.offset;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
if (idx < 0) { if (idx < 0) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -EINVAL; return -EINVAL;
} }
@ -209,7 +209,7 @@ int drm_getmap(struct inode *inode, struct file *filp,
i++; i++;
} }
if (!r_list || !r_list->map) { if (!r_list || !r_list->map) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -EINVAL; return -EINVAL;
} }
@ -219,7 +219,7 @@ int drm_getmap(struct inode *inode, struct file *filp,
map.flags = r_list->map->flags; map.flags = r_list->map->flags;
map.handle = (void *)(unsigned long)r_list->user_token; map.handle = (void *)(unsigned long)r_list->user_token;
map.mtrr = r_list->map->mtrr; map.mtrr = r_list->map->mtrr;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
if (copy_to_user(argp, &map, sizeof(map))) if (copy_to_user(argp, &map, sizeof(map)))
return -EFAULT; return -EFAULT;
@ -253,11 +253,11 @@ int drm_getclient(struct inode *inode, struct file *filp,
if (copy_from_user(&client, argp, sizeof(client))) if (copy_from_user(&client, argp, sizeof(client)))
return -EFAULT; return -EFAULT;
idx = client.idx; idx = client.idx;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
for (i = 0, pt = dev->file_first; i < idx && pt; i++, pt = pt->next) ; for (i = 0, pt = dev->file_first; i < idx && pt; i++, pt = pt->next) ;
if (!pt) { if (!pt) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -EINVAL; return -EINVAL;
} }
client.auth = pt->authenticated; client.auth = pt->authenticated;
@ -265,7 +265,7 @@ int drm_getclient(struct inode *inode, struct file *filp,
client.uid = pt->uid; client.uid = pt->uid;
client.magic = pt->magic; client.magic = pt->magic;
client.iocs = pt->ioctl_count; client.iocs = pt->ioctl_count;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
if (copy_to_user(argp, &client, sizeof(client))) if (copy_to_user(argp, &client, sizeof(client)))
return -EFAULT; return -EFAULT;
@ -292,7 +292,7 @@ int drm_getstats(struct inode *inode, struct file *filp,
memset(&stats, 0, sizeof(stats)); memset(&stats, 0, sizeof(stats));
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
for (i = 0; i < dev->counters; i++) { for (i = 0; i < dev->counters; i++) {
if (dev->types[i] == _DRM_STAT_LOCK) if (dev->types[i] == _DRM_STAT_LOCK)
@ -305,7 +305,7 @@ int drm_getstats(struct inode *inode, struct file *filp,
stats.count = dev->counters; stats.count = dev->counters;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
if (copy_to_user((drm_stats_t __user *) arg, &stats, sizeof(stats))) if (copy_to_user((drm_stats_t __user *) arg, &stats, sizeof(stats)))
return -EFAULT; return -EFAULT;

16
drivers/char/drm/drm_irq.c
View File

@ -98,20 +98,20 @@ static int drm_irq_install(drm_device_t * dev)
if (dev->irq == 0) if (dev->irq == 0)
return -EINVAL; return -EINVAL;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
/* Driver must have been initialized */ /* Driver must have been initialized */
if (!dev->dev_private) { if (!dev->dev_private) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -EINVAL; return -EINVAL;
} }
if (dev->irq_enabled) { if (dev->irq_enabled) {
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return -EBUSY; return -EBUSY;
} }
dev->irq_enabled = 1; dev->irq_enabled = 1;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq); DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq);
@ -135,9 +135,9 @@ static int drm_irq_install(drm_device_t * dev)
ret = request_irq(dev->irq, dev->driver->irq_handler, ret = request_irq(dev->irq, dev->driver->irq_handler,
sh_flags, dev->devname, dev); sh_flags, dev->devname, dev);
if (ret < 0) { if (ret < 0) {
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
dev->irq_enabled = 0; dev->irq_enabled = 0;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return ret; return ret;
} }
@ -161,10 +161,10 @@ int drm_irq_uninstall(drm_device_t * dev)
if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ)) if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
return -EINVAL; return -EINVAL;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
irq_enabled = dev->irq_enabled; irq_enabled = dev->irq_enabled;
dev->irq_enabled = 0; dev->irq_enabled = 0;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
if (!irq_enabled) if (!irq_enabled)
return -EINVAL; return -EINVAL;

28
drivers/char/drm/drm_proc.c
View File

@ -258,7 +258,7 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
} }
/** /**
* Simply calls _vm_info() while holding the drm_device::struct_sem lock. * Simply calls _vm_info() while holding the drm_device::struct_mutex lock.
*/ */
static int drm_vm_info(char *buf, char **start, off_t offset, int request, static int drm_vm_info(char *buf, char **start, off_t offset, int request,
int *eof, void *data) int *eof, void *data)
@ -266,9 +266,9 @@ static int drm_vm_info(char *buf, char **start, off_t offset, int request,
drm_device_t *dev = (drm_device_t *) data; drm_device_t *dev = (drm_device_t *) data;
int ret; int ret;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
ret = drm__vm_info(buf, start, offset, request, eof, data); ret = drm__vm_info(buf, start, offset, request, eof, data);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return ret; return ret;
} }
@ -331,7 +331,7 @@ static int drm__queues_info(char *buf, char **start, off_t offset,
} }
/** /**
* Simply calls _queues_info() while holding the drm_device::struct_sem lock. * Simply calls _queues_info() while holding the drm_device::struct_mutex lock.
*/ */
static int drm_queues_info(char *buf, char **start, off_t offset, int request, static int drm_queues_info(char *buf, char **start, off_t offset, int request,
int *eof, void *data) int *eof, void *data)
@ -339,9 +339,9 @@ static int drm_queues_info(char *buf, char **start, off_t offset, int request,
drm_device_t *dev = (drm_device_t *) data; drm_device_t *dev = (drm_device_t *) data;
int ret; int ret;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
ret = drm__queues_info(buf, start, offset, request, eof, data); ret = drm__queues_info(buf, start, offset, request, eof, data);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return ret; return ret;
} }
@ -403,7 +403,7 @@ static int drm__bufs_info(char *buf, char **start, off_t offset, int request,
} }
/** /**
* Simply calls _bufs_info() while holding the drm_device::struct_sem lock. * Simply calls _bufs_info() while holding the drm_device::struct_mutex lock.
*/ */
static int drm_bufs_info(char *buf, char **start, off_t offset, int request, static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
int *eof, void *data) int *eof, void *data)
@ -411,9 +411,9 @@ static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
drm_device_t *dev = (drm_device_t *) data; drm_device_t *dev = (drm_device_t *) data;
int ret; int ret;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
ret = drm__bufs_info(buf, start, offset, request, eof, data); ret = drm__bufs_info(buf, start, offset, request, eof, data);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return ret; return ret;
} }
@ -459,7 +459,7 @@ static int drm__clients_info(char *buf, char **start, off_t offset,
} }
/** /**
* Simply calls _clients_info() while holding the drm_device::struct_sem lock. * Simply calls _clients_info() while holding the drm_device::struct_mutex lock.
*/ */
static int drm_clients_info(char *buf, char **start, off_t offset, static int drm_clients_info(char *buf, char **start, off_t offset,
int request, int *eof, void *data) int request, int *eof, void *data)
@ -467,9 +467,9 @@ static int drm_clients_info(char *buf, char **start, off_t offset,
drm_device_t *dev = (drm_device_t *) data; drm_device_t *dev = (drm_device_t *) data;
int ret; int ret;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
ret = drm__clients_info(buf, start, offset, request, eof, data); ret = drm__clients_info(buf, start, offset, request, eof, data);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return ret; return ret;
} }
@ -540,9 +540,9 @@ static int drm_vma_info(char *buf, char **start, off_t offset, int request,
drm_device_t *dev = (drm_device_t *) data; drm_device_t *dev = (drm_device_t *) data;
int ret; int ret;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
ret = drm__vma_info(buf, start, offset, request, eof, data); ret = drm__vma_info(buf, start, offset, request, eof, data);
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
return ret; return ret;
} }
#endif #endif

4
drivers/char/drm/drm_stub.c
View File

@ -61,8 +61,8 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
spin_lock_init(&dev->count_lock); spin_lock_init(&dev->count_lock);
init_timer(&dev->timer); init_timer(&dev->timer);
sema_init(&dev->struct_sem, 1); mutex_init(&dev->struct_mutex);
sema_init(&dev->ctxlist_sem, 1); mutex_init(&dev->ctxlist_mutex);
dev->pdev = pdev; dev->pdev = pdev;

12
drivers/char/drm/drm_vm.c
View File

@ -188,7 +188,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
map = vma->vm_private_data; map = vma->vm_private_data;
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
for (pt = dev->vmalist, prev = NULL; pt; pt = next) { for (pt = dev->vmalist, prev = NULL; pt; pt = next) {
next = pt->next; next = pt->next;
if (pt->vma->vm_private_data == map) if (pt->vma->vm_private_data == map)
@ -248,7 +248,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
drm_free(map, sizeof(*map), DRM_MEM_MAPS); drm_free(map, sizeof(*map), DRM_MEM_MAPS);
} }
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
} }
/** /**
@ -404,12 +404,12 @@ static void drm_vm_open(struct vm_area_struct *vma)
vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS); vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS);
if (vma_entry) { if (vma_entry) {
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
vma_entry->vma = vma; vma_entry->vma = vma;
vma_entry->next = dev->vmalist; vma_entry->next = dev->vmalist;
vma_entry->pid = current->pid; vma_entry->pid = current->pid;
dev->vmalist = vma_entry; dev->vmalist = vma_entry;
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
} }
} }
@ -431,7 +431,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
vma->vm_start, vma->vm_end - vma->vm_start); vma->vm_start, vma->vm_end - vma->vm_start);
atomic_dec(&dev->vma_count); atomic_dec(&dev->vma_count);
down(&dev->struct_sem); mutex_lock(&dev->struct_mutex);
for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) { for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
if (pt->vma == vma) { if (pt->vma == vma) {
if (prev) { if (prev) {
@ -443,7 +443,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
break; break;
} }
} }
up(&dev->struct_sem); mutex_unlock(&dev->struct_mutex);
} }
/** /**