hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[PATCH] sem2mutex: fs/ 

Semaphore to mutex conversion.

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

Signed-off-by: Ingo Molnar <mingo@elte.hu>
Cc: Eric Van Hensbergen <ericvh@ericvh.myip.org>
Cc: Robert Love <rml@tech9.net>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: David Woodhouse <dwmw2@infradead.org>
Cc: Neil Brown <neilb@cse.unsw.edu.au>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Cc: Dave Kleikamp <shaggy@austin.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Ingo Molnar 2006-03-26 01:37:12 -08:00 committed by Linus Torvalds
parent e655a250d5
commit 353ab6e97b
11 changed files with 99 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
fs/cramfs/inode.c
View File

@ -22,6 +22,7 @@
#include <linux/cramfs_fs_sb.h> #include <linux/cramfs_fs_sb.h>
#include <linux/buffer_head.h> #include <linux/buffer_head.h>
#include <linux/vfs.h> #include <linux/vfs.h>
#include <linux/mutex.h>
#include <asm/semaphore.h> #include <asm/semaphore.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -31,7 +32,7 @@ static struct inode_operations cramfs_dir_inode_operations;
static struct file_operations cramfs_directory_operations; static struct file_operations cramfs_directory_operations;
static struct address_space_operations cramfs_aops; static struct address_space_operations cramfs_aops;
static DECLARE_MUTEX(read_mutex); static DEFINE_MUTEX(read_mutex);
/* These two macros may change in future, to provide better st_ino /* These two macros may change in future, to provide better st_ino
@ -250,20 +251,20 @@ static int cramfs_fill_super(struct super_block *sb, void *data, int silent)
memset(sbi, 0, sizeof(struct cramfs_sb_info)); memset(sbi, 0, sizeof(struct cramfs_sb_info));
/* Invalidate the read buffers on mount: think disk change.. */ /* Invalidate the read buffers on mount: think disk change.. */
down(&read_mutex); mutex_lock(&read_mutex);
for (i = 0; i < READ_BUFFERS; i++) for (i = 0; i < READ_BUFFERS; i++)
buffer_blocknr[i] = -1; buffer_blocknr[i] = -1;
/* Read the first block and get the superblock from it */ /* Read the first block and get the superblock from it */
memcpy(&super, cramfs_read(sb, 0, sizeof(super)), sizeof(super)); memcpy(&super, cramfs_read(sb, 0, sizeof(super)), sizeof(super));
up(&read_mutex); mutex_unlock(&read_mutex);
/* Do sanity checks on the superblock */ /* Do sanity checks on the superblock */
if (super.magic != CRAMFS_MAGIC) { if (super.magic != CRAMFS_MAGIC) {
/* check at 512 byte offset */ /* check at 512 byte offset */
down(&read_mutex); mutex_lock(&read_mutex);
memcpy(&super, cramfs_read(sb, 512, sizeof(super)), sizeof(super)); memcpy(&super, cramfs_read(sb, 512, sizeof(super)), sizeof(super));
up(&read_mutex); mutex_unlock(&read_mutex);
if (super.magic != CRAMFS_MAGIC) { if (super.magic != CRAMFS_MAGIC) {
if (!silent) if (!silent)
printk(KERN_ERR "cramfs: wrong magic\n"); printk(KERN_ERR "cramfs: wrong magic\n");
@ -366,7 +367,7 @@ static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
mode_t mode; mode_t mode;
int namelen, error; int namelen, error;
down(&read_mutex); mutex_lock(&read_mutex);
de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+256); de = cramfs_read(sb, OFFSET(inode) + offset, sizeof(*de)+256);
name = (char *)(de+1); name = (char *)(de+1);
@ -379,7 +380,7 @@ static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)
memcpy(buf, name, namelen); memcpy(buf, name, namelen);
ino = CRAMINO(de); ino = CRAMINO(de);
mode = de->mode; mode = de->mode;
up(&read_mutex); mutex_unlock(&read_mutex);
nextoffset = offset + sizeof(*de) + namelen; nextoffset = offset + sizeof(*de) + namelen;
for (;;) { for (;;) {
if (!namelen) { if (!namelen) {
@ -410,7 +411,7 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, s
unsigned int offset = 0; unsigned int offset = 0;
int sorted; int sorted;
down(&read_mutex); mutex_lock(&read_mutex);
sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS; sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS;
while (offset < dir->i_size) { while (offset < dir->i_size) {
struct cramfs_inode *de; struct cramfs_inode *de;
@ -433,7 +434,7 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, s
for (;;) { for (;;) {
if (!namelen) { if (!namelen) {
up(&read_mutex); mutex_unlock(&read_mutex);
return ERR_PTR(-EIO); return ERR_PTR(-EIO);
} }
if (name[namelen-1]) if (name[namelen-1])
@ -447,7 +448,7 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, s
continue; continue;
if (!retval) { if (!retval) {
struct cramfs_inode entry = *de; struct cramfs_inode entry = *de;
up(&read_mutex); mutex_unlock(&read_mutex);
d_add(dentry, get_cramfs_inode(dir->i_sb, &entry)); d_add(dentry, get_cramfs_inode(dir->i_sb, &entry));
return NULL; return NULL;
} }
@ -455,7 +456,7 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, s
if (sorted) if (sorted)
break; break;
} }
up(&read_mutex); mutex_unlock(&read_mutex);
d_add(dentry, NULL); d_add(dentry, NULL);
return NULL; return NULL;
} }
@ -474,21 +475,21 @@ static int cramfs_readpage(struct file *file, struct page * page)
u32 start_offset, compr_len; u32 start_offset, compr_len;
start_offset = OFFSET(inode) + maxblock*4; start_offset = OFFSET(inode) + maxblock*4;
down(&read_mutex); mutex_lock(&read_mutex);
if (page->index) if (page->index)
start_offset = *(u32 *) cramfs_read(sb, blkptr_offset-4, 4); start_offset = *(u32 *) cramfs_read(sb, blkptr_offset-4, 4);
compr_len = (*(u32 *) cramfs_read(sb, blkptr_offset, 4) - start_offset); compr_len = (*(u32 *) cramfs_read(sb, blkptr_offset, 4) - start_offset);
up(&read_mutex); mutex_unlock(&read_mutex);
pgdata = kmap(page); pgdata = kmap(page);
if (compr_len == 0) if (compr_len == 0)
; /* hole */ ; /* hole */
else { else {
down(&read_mutex); mutex_lock(&read_mutex);
bytes_filled = cramfs_uncompress_block(pgdata, bytes_filled = cramfs_uncompress_block(pgdata,
PAGE_CACHE_SIZE, PAGE_CACHE_SIZE,
cramfs_read(sb, start_offset, compr_len), cramfs_read(sb, start_offset, compr_len),
compr_len); compr_len);
up(&read_mutex); mutex_unlock(&read_mutex);
} }
} else } else
pgdata = kmap(page); pgdata = kmap(page);

19
fs/dcookies.c
View File

@ -23,6 +23,7 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/dcookies.h> #include <linux/dcookies.h>
#include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
/* The dcookies are allocated from a kmem_cache and /* The dcookies are allocated from a kmem_cache and
@ -36,7 +37,7 @@ struct dcookie_struct {
}; };
static LIST_HEAD(dcookie_users); static LIST_HEAD(dcookie_users);
static DECLARE_MUTEX(dcookie_sem); static DEFINE_MUTEX(dcookie_mutex);
static kmem_cache_t * dcookie_cache; static kmem_cache_t * dcookie_cache;
static struct list_head * dcookie_hashtable; static struct list_head * dcookie_hashtable;
static size_t hash_size; static size_t hash_size;
@ -114,7 +115,7 @@ int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
int err = 0; int err = 0;
struct dcookie_struct * dcs; struct dcookie_struct * dcs;
down(&dcookie_sem); mutex_lock(&dcookie_mutex);
if (!is_live()) { if (!is_live()) {
err = -EINVAL; err = -EINVAL;
@ -134,7 +135,7 @@ int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
*cookie = dcookie_value(dcs); *cookie = dcookie_value(dcs);
out: out:
up(&dcookie_sem); mutex_unlock(&dcookie_mutex);
return err; return err;
} }
@ -157,7 +158,7 @@ asmlinkage long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len)
if (!capable(CAP_SYS_ADMIN)) if (!capable(CAP_SYS_ADMIN))
return -EPERM; return -EPERM;
down(&dcookie_sem); mutex_lock(&dcookie_mutex);
if (!is_live()) { if (!is_live()) {
err = -EINVAL; err = -EINVAL;
@ -192,7 +193,7 @@ asmlinkage long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len)
out_free: out_free:
kfree(kbuf); kfree(kbuf);
out: out:
up(&dcookie_sem); mutex_unlock(&dcookie_mutex);
return err; return err;
} }
@ -290,7 +291,7 @@ struct dcookie_user * dcookie_register(void)
{ {
struct dcookie_user * user; struct dcookie_user * user;
down(&dcookie_sem); mutex_lock(&dcookie_mutex);
user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL); user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL);
if (!user) if (!user)
@ -302,7 +303,7 @@ struct dcookie_user * dcookie_register(void)
list_add(&user->next, &dcookie_users); list_add(&user->next, &dcookie_users);
out: out:
up(&dcookie_sem); mutex_unlock(&dcookie_mutex);
return user; return user;
out_free: out_free:
kfree(user); kfree(user);
@ -313,7 +314,7 @@ out_free:
void dcookie_unregister(struct dcookie_user * user) void dcookie_unregister(struct dcookie_user * user)
{ {
down(&dcookie_sem); mutex_lock(&dcookie_mutex);
list_del(&user->next); list_del(&user->next);
kfree(user); kfree(user);
@ -321,7 +322,7 @@ void dcookie_unregister(struct dcookie_user * user)
if (!is_live()) if (!is_live())
dcookie_exit(); dcookie_exit();
up(&dcookie_sem); mutex_unlock(&dcookie_mutex);
} }
EXPORT_SYMBOL_GPL(dcookie_register); EXPORT_SYMBOL_GPL(dcookie_register);

19
fs/jffs2/compr_zlib.c
View File

@ -33,13 +33,14 @@
*/ */
#define STREAM_END_SPACE 12 #define STREAM_END_SPACE 12
static DECLARE_MUTEX(deflate_sem); static DEFINE_MUTEX(deflate_mutex);
static DECLARE_MUTEX(inflate_sem); static DEFINE_MUTEX(inflate_mutex);
static z_stream inf_strm, def_strm; static z_stream inf_strm, def_strm;
#ifdef __KERNEL__ /* Linux-only */ #ifdef __KERNEL__ /* Linux-only */
#include <linux/vmalloc.h> #include <linux/vmalloc.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/mutex.h>
static int __init alloc_workspaces(void) static int __init alloc_workspaces(void)
{ {
@ -79,11 +80,11 @@ static int jffs2_zlib_compress(unsigned char *data_in,
if (*dstlen <= STREAM_END_SPACE) if (*dstlen <= STREAM_END_SPACE)
return -1; return -1;
down(&deflate_sem); mutex_lock(&deflate_mutex);
if (Z_OK != zlib_deflateInit(&def_strm, 3)) { if (Z_OK != zlib_deflateInit(&def_strm, 3)) {
printk(KERN_WARNING "deflateInit failed\n"); printk(KERN_WARNING "deflateInit failed\n");
up(&deflate_sem); mutex_unlock(&deflate_mutex);
return -1; return -1;
} }
@ -104,7 +105,7 @@ static int jffs2_zlib_compress(unsigned char *data_in,
if (ret != Z_OK) { if (ret != Z_OK) {
D1(printk(KERN_DEBUG "deflate in loop returned %d\n", ret)); D1(printk(KERN_DEBUG "deflate in loop returned %d\n", ret));
zlib_deflateEnd(&def_strm); zlib_deflateEnd(&def_strm);
up(&deflate_sem); mutex_unlock(&deflate_mutex);
return -1; return -1;
} }
} }
@ -133,7 +134,7 @@ static int jffs2_zlib_compress(unsigned char *data_in,
*sourcelen = def_strm.total_in; *sourcelen = def_strm.total_in;
ret = 0; ret = 0;
out: out:
up(&deflate_sem); mutex_unlock(&deflate_mutex);
return ret; return ret;
} }
@ -145,7 +146,7 @@ static int jffs2_zlib_decompress(unsigned char *data_in,
int ret; int ret;
int wbits = MAX_WBITS; int wbits = MAX_WBITS;
down(&inflate_sem); mutex_lock(&inflate_mutex);
inf_strm.next_in = data_in; inf_strm.next_in = data_in;
inf_strm.avail_in = srclen; inf_strm.avail_in = srclen;
@ -173,7 +174,7 @@ static int jffs2_zlib_decompress(unsigned char *data_in,
if (Z_OK != zlib_inflateInit2(&inf_strm, wbits)) { if (Z_OK != zlib_inflateInit2(&inf_strm, wbits)) {
printk(KERN_WARNING "inflateInit failed\n"); printk(KERN_WARNING "inflateInit failed\n");
up(&inflate_sem); mutex_unlock(&inflate_mutex);
return 1; return 1;
} }
@ -183,7 +184,7 @@ static int jffs2_zlib_decompress(unsigned char *data_in,
printk(KERN_NOTICE "inflate returned %d\n", ret); printk(KERN_NOTICE "inflate returned %d\n", ret);
} }
zlib_inflateEnd(&inf_strm); zlib_inflateEnd(&inf_strm);
up(&inflate_sem); mutex_unlock(&inflate_mutex);
return 0; return 0;
} }

27
fs/jfs/jfs_logmgr.c
View File

@ -69,6 +69,7 @@
#include <linux/bio.h> #include <linux/bio.h>
#include <linux/suspend.h> #include <linux/suspend.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/mutex.h>
#include "jfs_incore.h" #include "jfs_incore.h"
#include "jfs_filsys.h" #include "jfs_filsys.h"
#include "jfs_metapage.h" #include "jfs_metapage.h"
@ -165,7 +166,7 @@ do { \
*/ */
static LIST_HEAD(jfs_external_logs); static LIST_HEAD(jfs_external_logs);
static struct jfs_log *dummy_log = NULL; static struct jfs_log *dummy_log = NULL;
static DECLARE_MUTEX(jfs_log_sem); static DEFINE_MUTEX(jfs_log_mutex);
/* /*
* forward references * forward references
@ -1085,20 +1086,20 @@ int lmLogOpen(struct super_block *sb)
if (sbi->mntflag & JFS_INLINELOG) if (sbi->mntflag & JFS_INLINELOG)
return open_inline_log(sb); return open_inline_log(sb);
down(&jfs_log_sem); mutex_lock(&jfs_log_mutex);
list_for_each_entry(log, &jfs_external_logs, journal_list) { list_for_each_entry(log, &jfs_external_logs, journal_list) {
if (log->bdev->bd_dev == sbi->logdev) { if (log->bdev->bd_dev == sbi->logdev) {
if (memcmp(log->uuid, sbi->loguuid, if (memcmp(log->uuid, sbi->loguuid,
sizeof(log->uuid))) { sizeof(log->uuid))) {
jfs_warn("wrong uuid on JFS journal\n"); jfs_warn("wrong uuid on JFS journal\n");
up(&jfs_log_sem); mutex_unlock(&jfs_log_mutex);
return -EINVAL; return -EINVAL;
} }
/* /*
* add file system to log active file system list * add file system to log active file system list
*/ */
if ((rc = lmLogFileSystem(log, sbi, 1))) { if ((rc = lmLogFileSystem(log, sbi, 1))) {
up(&jfs_log_sem); mutex_unlock(&jfs_log_mutex);
return rc; return rc;
} }
goto journal_found; goto journal_found;
@ -1106,7 +1107,7 @@ int lmLogOpen(struct super_block *sb)
} }
if (!(log = kzalloc(sizeof(struct jfs_log), GFP_KERNEL))) { if (!(log = kzalloc(sizeof(struct jfs_log), GFP_KERNEL))) {
up(&jfs_log_sem); mutex_unlock(&jfs_log_mutex);
return -ENOMEM; return -ENOMEM;
} }
INIT_LIST_HEAD(&log->sb_list); INIT_LIST_HEAD(&log->sb_list);
@ -1151,7 +1152,7 @@ journal_found:
sbi->log = log; sbi->log = log;
LOG_UNLOCK(log); LOG_UNLOCK(log);
up(&jfs_log_sem); mutex_unlock(&jfs_log_mutex);
return 0; return 0;
/* /*
@ -1168,7 +1169,7 @@ journal_found:
blkdev_put(bdev); blkdev_put(bdev);
free: /* free log descriptor */ free: /* free log descriptor */
up(&jfs_log_sem); mutex_unlock(&jfs_log_mutex);
kfree(log); kfree(log);
jfs_warn("lmLogOpen: exit(%d)", rc); jfs_warn("lmLogOpen: exit(%d)", rc);
@ -1212,11 +1213,11 @@ static int open_dummy_log(struct super_block *sb)
{ {
int rc; int rc;
down(&jfs_log_sem); mutex_lock(&jfs_log_mutex);
if (!dummy_log) { if (!dummy_log) {
dummy_log = kzalloc(sizeof(struct jfs_log), GFP_KERNEL); dummy_log = kzalloc(sizeof(struct jfs_log), GFP_KERNEL);
if (!dummy_log) { if (!dummy_log) {
up(&jfs_log_sem); mutex_unlock(&jfs_log_mutex);
return -ENOMEM; return -ENOMEM;
} }
INIT_LIST_HEAD(&dummy_log->sb_list); INIT_LIST_HEAD(&dummy_log->sb_list);
@ -1229,7 +1230,7 @@ static int open_dummy_log(struct super_block *sb)
if (rc) { if (rc) {
kfree(dummy_log); kfree(dummy_log);
dummy_log = NULL; dummy_log = NULL;
up(&jfs_log_sem); mutex_unlock(&jfs_log_mutex);
return rc; return rc;
} }
} }
@ -1238,7 +1239,7 @@ static int open_dummy_log(struct super_block *sb)
list_add(&JFS_SBI(sb)->log_list, &dummy_log->sb_list); list_add(&JFS_SBI(sb)->log_list, &dummy_log->sb_list);
JFS_SBI(sb)->log = dummy_log; JFS_SBI(sb)->log = dummy_log;
LOG_UNLOCK(dummy_log); LOG_UNLOCK(dummy_log);
up(&jfs_log_sem); mutex_unlock(&jfs_log_mutex);
return 0; return 0;
} }
@ -1466,7 +1467,7 @@ int lmLogClose(struct super_block *sb)
jfs_info("lmLogClose: log:0x%p", log); jfs_info("lmLogClose: log:0x%p", log);
down(&jfs_log_sem); mutex_lock(&jfs_log_mutex);
LOG_LOCK(log); LOG_LOCK(log);
list_del(&sbi->log_list); list_del(&sbi->log_list);
LOG_UNLOCK(log); LOG_UNLOCK(log);
@ -1516,7 +1517,7 @@ int lmLogClose(struct super_block *sb)
kfree(log); kfree(log);
out: out:
up(&jfs_log_sem); mutex_unlock(&jfs_log_mutex);
jfs_info("lmLogClose: exit(%d)", rc); jfs_info("lmLogClose: exit(%d)", rc);
return rc; return rc;
} }

19
fs/lockd/host.c
View File

@ -16,6 +16,7 @@
#include <linux/sunrpc/svc.h> #include <linux/sunrpc/svc.h>
#include <linux/lockd/lockd.h> #include <linux/lockd/lockd.h>
#include <linux/lockd/sm_inter.h> #include <linux/lockd/sm_inter.h>
#include <linux/mutex.h>
#define NLMDBG_FACILITY NLMDBG_HOSTCACHE #define NLMDBG_FACILITY NLMDBG_HOSTCACHE
@ -30,7 +31,7 @@
static struct nlm_host * nlm_hosts[NLM_HOST_NRHASH]; static struct nlm_host * nlm_hosts[NLM_HOST_NRHASH];
static unsigned long next_gc; static unsigned long next_gc;
static int nrhosts; static int nrhosts;
static DECLARE_MUTEX(nlm_host_sema); static DEFINE_MUTEX(nlm_host_mutex);
static void nlm_gc_hosts(void); static void nlm_gc_hosts(void);
@ -71,7 +72,7 @@ nlm_lookup_host(int server, struct sockaddr_in *sin,
hash = NLM_ADDRHASH(sin->sin_addr.s_addr); hash = NLM_ADDRHASH(sin->sin_addr.s_addr);
/* Lock hash table */ /* Lock hash table */
down(&nlm_host_sema); mutex_lock(&nlm_host_mutex);
if (time_after_eq(jiffies, next_gc)) if (time_after_eq(jiffies, next_gc))
nlm_gc_hosts(); nlm_gc_hosts();
@ -91,7 +92,7 @@ nlm_lookup_host(int server, struct sockaddr_in *sin,
nlm_hosts[hash] = host; nlm_hosts[hash] = host;
} }
nlm_get_host(host); nlm_get_host(host);
up(&nlm_host_sema); mutex_unlock(&nlm_host_mutex);
return host; return host;
} }
} }
@ -130,7 +131,7 @@ nlm_lookup_host(int server, struct sockaddr_in *sin,
next_gc = 0; next_gc = 0;
nohost: nohost:
up(&nlm_host_sema); mutex_unlock(&nlm_host_mutex);
return host; return host;
} }
@ -141,19 +142,19 @@ nlm_find_client(void)
* and return it * and return it
*/ */
int hash; int hash;
down(&nlm_host_sema); mutex_lock(&nlm_host_mutex);
for (hash = 0 ; hash < NLM_HOST_NRHASH; hash++) { for (hash = 0 ; hash < NLM_HOST_NRHASH; hash++) {
struct nlm_host *host, **hp; struct nlm_host *host, **hp;
for (hp = &nlm_hosts[hash]; (host = *hp) != 0; hp = &host->h_next) { for (hp = &nlm_hosts[hash]; (host = *hp) != 0; hp = &host->h_next) {
if (host->h_server && if (host->h_server &&
host->h_killed == 0) { host->h_killed == 0) {
nlm_get_host(host); nlm_get_host(host);
up(&nlm_host_sema); mutex_unlock(&nlm_host_mutex);
return host; return host;
} }
} }
} }
up(&nlm_host_sema); mutex_unlock(&nlm_host_mutex);
return NULL; return NULL;
} }
@ -265,7 +266,7 @@ nlm_shutdown_hosts(void)
int i; int i;
dprintk("lockd: shutting down host module\n"); dprintk("lockd: shutting down host module\n");
down(&nlm_host_sema); mutex_lock(&nlm_host_mutex);
/* First, make all hosts eligible for gc */ /* First, make all hosts eligible for gc */
dprintk("lockd: nuking all hosts...\n"); dprintk("lockd: nuking all hosts...\n");
@ -276,7 +277,7 @@ nlm_shutdown_hosts(void)
/* Then, perform a garbage collection pass */ /* Then, perform a garbage collection pass */
nlm_gc_hosts(); nlm_gc_hosts();
up(&nlm_host_sema); mutex_unlock(&nlm_host_mutex);
/* complain if any hosts are left */ /* complain if any hosts are left */
if (nrhosts) { if (nrhosts) {

17
fs/lockd/svc.c
View File

@ -25,6 +25,7 @@
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/smp.h> #include <linux/smp.h>
#include <linux/smp_lock.h> #include <linux/smp_lock.h>
#include <linux/mutex.h>
#include <linux/sunrpc/types.h> #include <linux/sunrpc/types.h>
#include <linux/sunrpc/stats.h> #include <linux/sunrpc/stats.h>
@ -43,13 +44,13 @@ static struct svc_program nlmsvc_program;
struct nlmsvc_binding * nlmsvc_ops; struct nlmsvc_binding * nlmsvc_ops;
EXPORT_SYMBOL(nlmsvc_ops); EXPORT_SYMBOL(nlmsvc_ops);
static DECLARE_MUTEX(nlmsvc_sema); static DEFINE_MUTEX(nlmsvc_mutex);
static unsigned int nlmsvc_users; static unsigned int nlmsvc_users;
static pid_t nlmsvc_pid; static pid_t nlmsvc_pid;
int nlmsvc_grace_period; int nlmsvc_grace_period;
unsigned long nlmsvc_timeout; unsigned long nlmsvc_timeout;
static DECLARE_MUTEX_LOCKED(lockd_start); static DECLARE_COMPLETION(lockd_start_done);
static DECLARE_WAIT_QUEUE_HEAD(lockd_exit); static DECLARE_WAIT_QUEUE_HEAD(lockd_exit);
/* /*
@ -112,7 +113,7 @@ lockd(struct svc_rqst *rqstp)
* Let our maker know we're running. * Let our maker know we're running.
*/ */
nlmsvc_pid = current->pid; nlmsvc_pid = current->pid;
up(&lockd_start); complete(&lockd_start_done);
daemonize("lockd"); daemonize("lockd");
@ -215,7 +216,7 @@ lockd_up(void)
struct svc_serv * serv; struct svc_serv * serv;
int error = 0; int error = 0;
down(&nlmsvc_sema); mutex_lock(&nlmsvc_mutex);
/* /*
* Unconditionally increment the user count ... this is * Unconditionally increment the user count ... this is
* the number of clients who _want_ a lockd process. * the number of clients who _want_ a lockd process.
@ -263,7 +264,7 @@ lockd_up(void)
"lockd_up: create thread failed, error=%d\n", error); "lockd_up: create thread failed, error=%d\n", error);
goto destroy_and_out; goto destroy_and_out;
} }
down(&lockd_start); wait_for_completion(&lockd_start_done);
/* /*
* Note: svc_serv structures have an initial use count of 1, * Note: svc_serv structures have an initial use count of 1,
@ -272,7 +273,7 @@ lockd_up(void)
destroy_and_out: destroy_and_out:
svc_destroy(serv); svc_destroy(serv);
out: out:
up(&nlmsvc_sema); mutex_unlock(&nlmsvc_mutex);
return error; return error;
} }
EXPORT_SYMBOL(lockd_up); EXPORT_SYMBOL(lockd_up);
@ -285,7 +286,7 @@ lockd_down(void)
{ {
static int warned; static int warned;
down(&nlmsvc_sema); mutex_lock(&nlmsvc_mutex);
if (nlmsvc_users) { if (nlmsvc_users) {
if (--nlmsvc_users) if (--nlmsvc_users)
goto out; goto out;
@ -315,7 +316,7 @@ lockd_down(void)
recalc_sigpending(); recalc_sigpending();
spin_unlock_irq(&current->sighand->siglock); spin_unlock_irq(&current->sighand->siglock);
out: out:
up(&nlmsvc_sema); mutex_unlock(&nlmsvc_mutex);
} }
EXPORT_SYMBOL(lockd_down); EXPORT_SYMBOL(lockd_down);

17
fs/lockd/svcsubs.c
View File

@ -11,6 +11,7 @@
#include <linux/string.h> #include <linux/string.h>
#include <linux/time.h> #include <linux/time.h>
#include <linux/in.h> #include <linux/in.h>
#include <linux/mutex.h>
#include <linux/sunrpc/svc.h> #include <linux/sunrpc/svc.h>
#include <linux/sunrpc/clnt.h> #include <linux/sunrpc/clnt.h>
#include <linux/nfsd/nfsfh.h> #include <linux/nfsd/nfsfh.h>
@ -28,7 +29,7 @@
#define FILE_HASH_BITS 5 #define FILE_HASH_BITS 5
#define FILE_NRHASH (1<<FILE_HASH_BITS) #define FILE_NRHASH (1<<FILE_HASH_BITS)
static struct nlm_file * nlm_files[FILE_NRHASH]; static struct nlm_file * nlm_files[FILE_NRHASH];
static DECLARE_MUTEX(nlm_file_sema); static DEFINE_MUTEX(nlm_file_mutex);
#ifdef NFSD_DEBUG #ifdef NFSD_DEBUG
static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f) static inline void nlm_debug_print_fh(char *msg, struct nfs_fh *f)
@ -91,7 +92,7 @@ nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result,
hash = file_hash(f); hash = file_hash(f);
/* Lock file table */ /* Lock file table */
down(&nlm_file_sema); mutex_lock(&nlm_file_mutex);
for (file = nlm_files[hash]; file; file = file->f_next) for (file = nlm_files[hash]; file; file = file->f_next)
if (!nfs_compare_fh(&file->f_handle, f)) if (!nfs_compare_fh(&file->f_handle, f))
@ -130,7 +131,7 @@ found:
nfserr = 0; nfserr = 0;
out_unlock: out_unlock:
up(&nlm_file_sema); mutex_unlock(&nlm_file_mutex);
return nfserr; return nfserr;
out_free: out_free:
@ -239,14 +240,14 @@ nlm_traverse_files(struct nlm_host *host, int action)
struct nlm_file *file, **fp; struct nlm_file *file, **fp;
int i; int i;
down(&nlm_file_sema); mutex_lock(&nlm_file_mutex);
for (i = 0; i < FILE_NRHASH; i++) { for (i = 0; i < FILE_NRHASH; i++) {
fp = nlm_files + i; fp = nlm_files + i;
while ((file = *fp) != NULL) { while ((file = *fp) != NULL) {
/* Traverse locks, blocks and shares of this file /* Traverse locks, blocks and shares of this file
* and update file->f_locks count */ * and update file->f_locks count */
if (nlm_inspect_file(host, file, action)) { if (nlm_inspect_file(host, file, action)) {
up(&nlm_file_sema); mutex_unlock(&nlm_file_mutex);
return 1; return 1;
} }
@ -261,7 +262,7 @@ nlm_traverse_files(struct nlm_host *host, int action)
} }
} }
} }
up(&nlm_file_sema); mutex_unlock(&nlm_file_mutex);
return 0; return 0;
} }
@ -281,7 +282,7 @@ nlm_release_file(struct nlm_file *file)
file, file->f_count); file, file->f_count);
/* Lock file table */ /* Lock file table */
down(&nlm_file_sema); mutex_lock(&nlm_file_mutex);
/* If there are no more locks etc, delete the file */ /* If there are no more locks etc, delete the file */
if(--file->f_count == 0) { if(--file->f_count == 0) {
@ -289,7 +290,7 @@ nlm_release_file(struct nlm_file *file)
nlm_delete_file(file); nlm_delete_file(file);
} }
up(&nlm_file_sema); mutex_unlock(&nlm_file_mutex);
} }
/* /*

11
fs/nfs/callback.c
View File

@ -14,6 +14,7 @@
#include <linux/sunrpc/svc.h> #include <linux/sunrpc/svc.h>
#include <linux/sunrpc/svcsock.h> #include <linux/sunrpc/svcsock.h>
#include <linux/nfs_fs.h> #include <linux/nfs_fs.h>
#include <linux/mutex.h>
#include <net/inet_sock.h> #include <net/inet_sock.h>
@ -31,7 +32,7 @@ struct nfs_callback_data {
}; };
static struct nfs_callback_data nfs_callback_info; static struct nfs_callback_data nfs_callback_info;
static DECLARE_MUTEX(nfs_callback_sema); static DEFINE_MUTEX(nfs_callback_mutex);
static struct svc_program nfs4_callback_program; static struct svc_program nfs4_callback_program;
unsigned int nfs_callback_set_tcpport; unsigned int nfs_callback_set_tcpport;
@ -95,7 +96,7 @@ int nfs_callback_up(void)
int ret = 0; int ret = 0;
lock_kernel(); lock_kernel();
down(&nfs_callback_sema); mutex_lock(&nfs_callback_mutex);
if (nfs_callback_info.users++ || nfs_callback_info.pid != 0) if (nfs_callback_info.users++ || nfs_callback_info.pid != 0)
goto out; goto out;
init_completion(&nfs_callback_info.started); init_completion(&nfs_callback_info.started);
@ -121,7 +122,7 @@ int nfs_callback_up(void)
nfs_callback_info.serv = serv; nfs_callback_info.serv = serv;
wait_for_completion(&nfs_callback_info.started); wait_for_completion(&nfs_callback_info.started);
out: out:
up(&nfs_callback_sema); mutex_unlock(&nfs_callback_mutex);
unlock_kernel(); unlock_kernel();
return ret; return ret;
out_destroy: out_destroy:
@ -139,7 +140,7 @@ int nfs_callback_down(void)
int ret = 0; int ret = 0;
lock_kernel(); lock_kernel();
down(&nfs_callback_sema); mutex_lock(&nfs_callback_mutex);
nfs_callback_info.users--; nfs_callback_info.users--;
do { do {
if (nfs_callback_info.users != 0 || nfs_callback_info.pid == 0) if (nfs_callback_info.users != 0 || nfs_callback_info.pid == 0)
@ -147,7 +148,7 @@ int nfs_callback_down(void)
if (kill_proc(nfs_callback_info.pid, SIGKILL, 1) < 0) if (kill_proc(nfs_callback_info.pid, SIGKILL, 1) < 0)
break; break;
} while (wait_for_completion_timeout(&nfs_callback_info.stopped, 5*HZ) == 0); } while (wait_for_completion_timeout(&nfs_callback_info.stopped, 5*HZ) == 0);
up(&nfs_callback_sema); mutex_unlock(&nfs_callback_mutex);
unlock_kernel(); unlock_kernel();
return ret; return ret;
} }

9
fs/nfsd/nfs4state.c
View File

@ -49,6 +49,7 @@
#include <linux/nfsd/state.h> #include <linux/nfsd/state.h>
#include <linux/nfsd/xdr4.h> #include <linux/nfsd/xdr4.h>
#include <linux/namei.h> #include <linux/namei.h>
#include <linux/mutex.h>
#define NFSDDBG_FACILITY NFSDDBG_PROC #define NFSDDBG_FACILITY NFSDDBG_PROC
@ -77,11 +78,11 @@ static void nfs4_set_recdir(char *recdir);
/* Locking: /* Locking:
* *
* client_sema: * client_mutex:
* protects clientid_hashtbl[], clientstr_hashtbl[], * protects clientid_hashtbl[], clientstr_hashtbl[],
* unconfstr_hashtbl[], uncofid_hashtbl[]. * unconfstr_hashtbl[], uncofid_hashtbl[].
*/ */
static DECLARE_MUTEX(client_sema); static DEFINE_MUTEX(client_mutex);
static kmem_cache_t *stateowner_slab = NULL; static kmem_cache_t *stateowner_slab = NULL;
static kmem_cache_t *file_slab = NULL; static kmem_cache_t *file_slab = NULL;
@ -91,13 +92,13 @@ static kmem_cache_t *deleg_slab = NULL;
void void
nfs4_lock_state(void) nfs4_lock_state(void)
{ {
down(&client_sema); mutex_lock(&client_mutex);
} }
void void
nfs4_unlock_state(void) nfs4_unlock_state(void)
{ {
up(&client_sema); mutex_unlock(&client_mutex);
} }
static inline u32 static inline u32

12
fs/partitions/devfs.c
View File

@ -6,7 +6,7 @@
#include <linux/vmalloc.h> #include <linux/vmalloc.h>
#include <linux/genhd.h> #include <linux/genhd.h>
#include <linux/bitops.h> #include <linux/bitops.h>
#include <asm/semaphore.h> #include <linux/mutex.h>
struct unique_numspace { struct unique_numspace {
@ -16,7 +16,7 @@ struct unique_numspace {
struct semaphore mutex; struct semaphore mutex;
}; };
static DECLARE_MUTEX(numspace_mutex); static DEFINE_MUTEX(numspace_mutex);
static int expand_numspace(struct unique_numspace *s) static int expand_numspace(struct unique_numspace *s)
{ {
@ -48,7 +48,7 @@ static int alloc_unique_number(struct unique_numspace *s)
{ {
int rval = 0; int rval = 0;
down(&numspace_mutex); mutex_lock(&numspace_mutex);
if (s->num_free < 1) if (s->num_free < 1)
rval = expand_numspace(s); rval = expand_numspace(s);
if (!rval) { if (!rval) {
@ -56,7 +56,7 @@ static int alloc_unique_number(struct unique_numspace *s)
--s->num_free; --s->num_free;
__set_bit(rval, s->bits); __set_bit(rval, s->bits);
} }
up(&numspace_mutex); mutex_unlock(&numspace_mutex);
return rval; return rval;
} }
@ -66,11 +66,11 @@ static void dealloc_unique_number(struct unique_numspace *s, int number)
int old_val; int old_val;
if (number >= 0) { if (number >= 0) {
down(&numspace_mutex); mutex_lock(&numspace_mutex);
old_val = __test_and_clear_bit(number, s->bits); old_val = __test_and_clear_bit(number, s->bits);
if (old_val) if (old_val)
++s->num_free; ++s->num_free;
up(&numspace_mutex); mutex_unlock(&numspace_mutex);
} }
} }

7
fs/super.c
View File

@ -37,6 +37,7 @@
#include <linux/writeback.h> /* for the emergency remount stuff */ #include <linux/writeback.h> /* for the emergency remount stuff */
#include <linux/idr.h> #include <linux/idr.h>
#include <linux/kobject.h> #include <linux/kobject.h>
#include <linux/mutex.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -380,9 +381,9 @@ restart:
void sync_filesystems(int wait) void sync_filesystems(int wait)
{ {
struct super_block *sb; struct super_block *sb;
static DECLARE_MUTEX(mutex); static DEFINE_MUTEX(mutex);
down(&mutex); /* Could be down_interruptible */ mutex_lock(&mutex); /* Could be down_interruptible */
spin_lock(&sb_lock); spin_lock(&sb_lock);
list_for_each_entry(sb, &super_blocks, s_list) { list_for_each_entry(sb, &super_blocks, s_list) {
if (!sb->s_op->sync_fs) if (!sb->s_op->sync_fs)
@ -411,7 +412,7 @@ restart:
goto restart; goto restart;
} }
spin_unlock(&sb_lock); spin_unlock(&sb_lock);
up(&mutex); mutex_unlock(&mutex);
} }
/** /**