[PATCH] sem2mutex: vfs_rename_mutex

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>
Cc: Al Viro <viro@ftp.linux.org.uk>
Cc: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index fed55e3c53dfab365c72886001ed4f240ddd6cee..632561dd9c5004d0bdf68e987d068e69e2a520e0 100644 (file)
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -138,9 +138,9 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
        cifs_sb = CIFS_SB(inode->i_sb);
        pTcon = cifs_sb->tcon;
 
-       down(&direntry->d_sb->s_vfs_rename_sem);
+       mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&direntry->d_sb->s_vfs_rename_sem);
+       mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);
        if(full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;
@@ -317,9 +317,9 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
        cifs_sb = CIFS_SB(inode->i_sb);
        pTcon = cifs_sb->tcon;
 
-       down(&direntry->d_sb->s_vfs_rename_sem);
+       mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&direntry->d_sb->s_vfs_rename_sem);
+       mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);
        if(full_path == NULL)
                rc = -ENOMEM;
        else if (pTcon->ses->capabilities & CAP_UNIX) {

diff --git a/fs/cifs/fcntl.c b/fs/cifs/fcntl.c
index a7a47bb36bf30888ea87bd62592ed732bba05d25..ec4dfe9bf5ef2c84fe91351da3804f37d1b9f502 100644 (file)
--- a/fs/cifs/fcntl.c
+++ b/fs/cifs/fcntl.c
@@ -86,9 +86,9 @@ int cifs_dir_notify(struct file * file, unsigned long arg)
        cifs_sb = CIFS_SB(file->f_dentry->d_sb);
        pTcon = cifs_sb->tcon;
 
-       down(&file->f_dentry->d_sb->s_vfs_rename_sem);
+       mutex_lock(&file->f_dentry->d_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(file->f_dentry);
-       up(&file->f_dentry->d_sb->s_vfs_rename_sem);
+       mutex_unlock(&file->f_dentry->d_sb->s_vfs_rename_mutex);
 
        if(full_path == NULL) {
                rc = -ENOMEM;

diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 675bd25682979fc8a87bdb082da0bc3ec37d0ce9..165d67426381df8aa814ba904266b2b227da1980 100644 (file)
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -203,9 +203,9 @@ int cifs_open(struct inode *inode, struct file *file)
                }
        }
 
-       down(&inode->i_sb->s_vfs_rename_sem);
+       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(file->f_dentry);
-       up(&inode->i_sb->s_vfs_rename_sem);
+       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);
        if (full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;

diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 59359911f4810c601923261c94cd49ffeebf5542..ff93a9f81d1c0ff0264a3647655292fcaab91156 100644 (file)
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -574,9 +574,9 @@ int cifs_unlink(struct inode *inode, struct dentry *direntry)
 
        /* Unlink can be called from rename so we can not grab the sem here
           since we deadlock otherwise */
-/*     down(&direntry->d_sb->s_vfs_rename_sem);*/
+/*     mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);*/
        full_path = build_path_from_dentry(direntry);
-/*     up(&direntry->d_sb->s_vfs_rename_sem);*/
+/*     mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);*/
        if (full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;
@@ -718,9 +718,9 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
        cifs_sb = CIFS_SB(inode->i_sb);
        pTcon = cifs_sb->tcon;
 
-       down(&inode->i_sb->s_vfs_rename_sem);
+       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&inode->i_sb->s_vfs_rename_sem);
+       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);
        if (full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;
@@ -803,9 +803,9 @@ int cifs_rmdir(struct inode *inode, struct dentry *direntry)
        cifs_sb = CIFS_SB(inode->i_sb);
        pTcon = cifs_sb->tcon;
 
-       down(&inode->i_sb->s_vfs_rename_sem);
+       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&inode->i_sb->s_vfs_rename_sem);
+       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);
        if (full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;
@@ -1137,9 +1137,9 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        rc = 0;
        }
                
-       down(&direntry->d_sb->s_vfs_rename_sem);
+       mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&direntry->d_sb->s_vfs_rename_sem);
+       mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);
        if (full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;

diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 0f99aae33162fbd68f5e08a32713db3055a418cf..8d0da7c87c7b6f0c0025df01b408c673204bc744 100644 (file)
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -48,10 +48,10 @@ cifs_hardlink(struct dentry *old_file, struct inode *inode,
 /* No need to check for cross device links since server will do that
    BB note DFS case in future though (when we may have to check) */
 
-       down(&inode->i_sb->s_vfs_rename_sem);
+       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);
        fromName = build_path_from_dentry(old_file);
        toName = build_path_from_dentry(direntry);
-       up(&inode->i_sb->s_vfs_rename_sem);
+       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);
        if((fromName == NULL) || (toName == NULL)) {
                rc = -ENOMEM;
                goto cifs_hl_exit;
@@ -103,9 +103,9 @@ cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
 
        xid = GetXid();
 
-       down(&direntry->d_sb->s_vfs_rename_sem);
+       mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&direntry->d_sb->s_vfs_rename_sem);
+       mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);
 
        if (!full_path)
                goto out_no_free;
@@ -164,9 +164,9 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
        cifs_sb = CIFS_SB(inode->i_sb);
        pTcon = cifs_sb->tcon;
 
-       down(&inode->i_sb->s_vfs_rename_sem);
+       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&inode->i_sb->s_vfs_rename_sem);
+       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);
 
        if(full_path == NULL) {
                FreeXid(xid);
@@ -232,9 +232,9 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
 
 /* BB would it be safe against deadlock to grab this sem 
       even though rename itself grabs the sem and calls lookup? */
-/*       down(&inode->i_sb->s_vfs_rename_sem);*/
+/*       mutex_lock(&inode->i_sb->s_vfs_rename_mutex);*/
        full_path = build_path_from_dentry(direntry);
-/*       up(&inode->i_sb->s_vfs_rename_sem);*/
+/*       mutex_unlock(&inode->i_sb->s_vfs_rename_mutex);*/
 
        if(full_path == NULL) {
                FreeXid(xid);

diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 288cc048d37f1e5b2373c8dd04157bcc90383bcc..edb3b6eb34bc12fd5a35ee632488484d34e1b3fa 100644 (file)
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -404,9 +404,9 @@ static int initiate_cifs_search(const int xid, struct file *file)
        if(pTcon == NULL)
                return -EINVAL;
 
-       down(&file->f_dentry->d_sb->s_vfs_rename_sem);
+       mutex_lock(&file->f_dentry->d_sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(file->f_dentry);
-       up(&file->f_dentry->d_sb->s_vfs_rename_sem);
+       mutex_unlock(&file->f_dentry->d_sb->s_vfs_rename_mutex);
 
        if(full_path == NULL) {
                return -ENOMEM;

diff --git a/fs/cifs/xattr.c b/fs/cifs/xattr.c
index 777e3363c2a4dd95ec3c05f51678ae3810369229..3938444d87b29d557ceaaffeb5f5430421b030e2 100644 (file)
--- a/fs/cifs/xattr.c
+++ b/fs/cifs/xattr.c
@@ -62,9 +62,9 @@ int cifs_removexattr(struct dentry * direntry, const char * ea_name)
        cifs_sb = CIFS_SB(sb);
        pTcon = cifs_sb->tcon;
                                                                                      
-       down(&sb->s_vfs_rename_sem);
+       mutex_lock(&sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&sb->s_vfs_rename_sem);
+       mutex_unlock(&sb->s_vfs_rename_mutex);
        if(full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;
@@ -116,9 +116,9 @@ int cifs_setxattr(struct dentry * direntry, const char * ea_name,
        cifs_sb = CIFS_SB(sb);
        pTcon = cifs_sb->tcon;
 
-       down(&sb->s_vfs_rename_sem);
+       mutex_lock(&sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&sb->s_vfs_rename_sem);
+       mutex_unlock(&sb->s_vfs_rename_mutex);
        if(full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;
@@ -223,9 +223,9 @@ ssize_t cifs_getxattr(struct dentry * direntry, const char * ea_name,
        cifs_sb = CIFS_SB(sb);
        pTcon = cifs_sb->tcon;
 
-       down(&sb->s_vfs_rename_sem);
+       mutex_lock(&sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&sb->s_vfs_rename_sem);
+       mutex_unlock(&sb->s_vfs_rename_mutex);
        if(full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;
@@ -341,9 +341,9 @@ ssize_t cifs_listxattr(struct dentry * direntry, char * data, size_t buf_size)
        cifs_sb = CIFS_SB(sb);
        pTcon = cifs_sb->tcon;
 
-       down(&sb->s_vfs_rename_sem);
+       mutex_lock(&sb->s_vfs_rename_mutex);
        full_path = build_path_from_dentry(direntry);
-       up(&sb->s_vfs_rename_sem);
+       mutex_unlock(&sb->s_vfs_rename_mutex);
        if(full_path == NULL) {
                FreeXid(xid);
                return -ENOMEM;

diff --git a/fs/namei.c b/fs/namei.c
index 8dc2b038d5d9c8965b71ec08bd1e5432af62f97e..c72b940797fc0321fcb6043610bc50138a2325ed 100644 (file)
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -104,7 +104,7 @@
  */
 /*
  * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
- * implemented.  Let's see if raised priority of ->s_vfs_rename_sem gives
+ * implemented.  Let's see if raised priority of ->s_vfs_rename_mutex gives
  * any extra contention...
  */
 
@@ -1422,7 +1422,7 @@ struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
                return NULL;
        }
 
-       down(&p1->d_inode->i_sb->s_vfs_rename_sem);
+       mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
 
        for (p = p1; p->d_parent != p; p = p->d_parent) {
                if (p->d_parent == p2) {
@@ -1450,7 +1450,7 @@ void unlock_rename(struct dentry *p1, struct dentry *p2)
        mutex_unlock(&p1->d_inode->i_mutex);
        if (p1 != p2) {
                mutex_unlock(&p2->d_inode->i_mutex);
-               up(&p1->d_inode->i_sb->s_vfs_rename_sem);
+               mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
        }
 }
 
@@ -2277,17 +2277,17 @@ asmlinkage long sys_link(const char __user *oldname, const char __user *newname)
  *     a) we can get into loop creation. Check is done in is_subdir().
  *     b) race potential - two innocent renames can create a loop together.
  *        That's where 4.4 screws up. Current fix: serialization on
- *        sb->s_vfs_rename_sem. We might be more accurate, but that's another
+ *        sb->s_vfs_rename_mutex. We might be more accurate, but that's another
  *        story.
  *     c) we have to lock _three_ objects - parents and victim (if it exists).
  *        And that - after we got ->i_mutex on parents (until then we don't know
  *        whether the target exists).  Solution: try to be smart with locking
  *        order for inodes.  We rely on the fact that tree topology may change
- *        only under ->s_vfs_rename_sem _and_ that parent of the object we
+ *        only under ->s_vfs_rename_mutex _and_ that parent of the object we
  *        move will be locked.  Thus we can rank directories by the tree
  *        (ancestors first) and rank all non-directories after them.
  *        That works since everybody except rename does "lock parent, lookup,
- *        lock child" and rename is under ->s_vfs_rename_sem.
+ *        lock child" and rename is under ->s_vfs_rename_mutex.
  *        HOWEVER, it relies on the assumption that any object with ->lookup()
  *        has no more than 1 dentry.  If "hybrid" objects will ever appear,
  *        we'd better make sure that there's no link(2) for them.

diff --git a/fs/super.c b/fs/super.c
index 9cc6545dfa4c52c89d68753e6a3d8b2a3f9f9a52..425861cb1caa3ed7c1bbe623cfec889e0255b3fe 100644 (file)
--- a/fs/super.c
+++ b/fs/super.c
@@ -76,7 +76,7 @@ static struct super_block *alloc_super(void)
                down_write(&s->s_umount);
                s->s_count = S_BIAS;
                atomic_set(&s->s_active, 1);
-               sema_init(&s->s_vfs_rename_sem,1);
+               mutex_init(&s->s_vfs_rename_mutex);
                mutex_init(&s->s_dquot.dqio_mutex);
                mutex_init(&s->s_dquot.dqonoff_mutex);
                init_rwsem(&s->s_dquot.dqptr_sem);

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 9ed1f36b6d54fb95d9a965ba227975b119de19a5..0f71ee7301270c60821c5ce2755cf551a74ed1e4 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -847,7 +847,7 @@ struct super_block {
         * The next field is for VFS *only*. No filesystems have any business
         * even looking at it. You had been warned.
         */
-       struct semaphore s_vfs_rename_sem;      /* Kludge */
+       struct mutex s_vfs_rename_mutex;        /* Kludge */
 
        /* Granuality of c/m/atime in ns.
           Cannot be worse than a second */