11 files changed, 66 insertions, 69 deletions

diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index 3e0fcc394810..8a2de038882e 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -178,7 +178,7 @@ improperly zeroed buffer in CIFS Unix extensions set times call.
 Version 1.25
 ------------
 Fix internationalization problem in cifs readdir with filenames that map to 
-longer UTF8 strings than the string on the wire was in Unicode.  Add workaround
+longer UTF-8 strings than the string on the wire was in Unicode.  Add workaround
 for readdir to netapp servers. Fix search rewind (seek into readdir to return 
 non-consecutive entries).  Do not do readdir when server negotiates 
 buffer size to small to fit filename. Add support for reading POSIX ACLs from
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 8219c02145a7..d4b713e5affb 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -476,7 +476,7 @@ cifs_get_sb(struct file_system_type *fs_type,
 
         sb->s_flags = flags;
 
-        rc = cifs_read_super(sb, data, dev_name, flags & MS_VERBOSE ? 1 : 0);
+        rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
         if (rc) {
                 up_write(&sb->s_umount);
                 deactivate_super(sb);
@@ -580,7 +580,7 @@ struct inode_operations cifs_symlink_inode_ops = {
 #endif 
 };
 
-struct file_operations cifs_file_ops = {
+const struct file_operations cifs_file_ops = {
         .read = do_sync_read,
         .write = do_sync_write,
         .readv = generic_file_readv,
@@ -604,7 +604,7 @@ struct file_operations cifs_file_ops = {
 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 };
 
-struct file_operations cifs_file_direct_ops = {
+const struct file_operations cifs_file_direct_ops = {
         /* no mmap, no aio, no readv - 
            BB reevaluate whether they can be done with directio, no cache */
         .read = cifs_user_read,
@@ -623,7 +623,7 @@ struct file_operations cifs_file_direct_ops = {
         .dir_notify = cifs_dir_notify,
 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 };
-struct file_operations cifs_file_nobrl_ops = {
+const struct file_operations cifs_file_nobrl_ops = {
         .read = do_sync_read,
         .write = do_sync_write,
         .readv = generic_file_readv,
@@ -646,7 +646,7 @@ struct file_operations cifs_file_nobrl_ops = {
 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 };
 
-struct file_operations cifs_file_direct_nobrl_ops = {
+const struct file_operations cifs_file_direct_nobrl_ops = {
         /* no mmap, no aio, no readv - 
            BB reevaluate whether they can be done with directio, no cache */
         .read = cifs_user_read,
@@ -665,7 +665,7 @@ struct file_operations cifs_file_direct_nobrl_ops = {
 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 };
 
-struct file_operations cifs_dir_ops = {
+const struct file_operations cifs_dir_ops = {
         .readdir = cifs_readdir,
         .release = cifs_closedir,
         .read    = generic_read_dir,
@@ -692,7 +692,8 @@ cifs_init_inodecache(void)
 {
         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
                                               sizeof (struct cifsInodeInfo),
-                                              0, SLAB_RECLAIM_ACCOUNT,
+                                              0, (SLAB_RECLAIM_ACCOUNT|
+                                                SLAB_MEM_SPREAD),
                                               cifs_init_once, NULL);
         if (cifs_inode_cachep == NULL)
                 return -ENOMEM;
@@ -734,10 +735,8 @@ cifs_init_request_bufs(void)
                 cERROR(1,("cifs_min_rcv set to maximum (64)"));
         }
 
-        cifs_req_poolp = mempool_create(cifs_min_rcv,
-                                        mempool_alloc_slab,
-                                        mempool_free_slab,
-                                        cifs_req_cachep);
+        cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
+                                                  cifs_req_cachep);
 
         if(cifs_req_poolp == NULL) {
                 kmem_cache_destroy(cifs_req_cachep);
@@ -767,10 +766,8 @@ cifs_init_request_bufs(void)
                 cFYI(1,("cifs_min_small set to maximum (256)"));
         }
 
-        cifs_sm_req_poolp = mempool_create(cifs_min_small,
-                                mempool_alloc_slab,
-                                mempool_free_slab,
-                                cifs_sm_req_cachep);
+        cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
+                                                     cifs_sm_req_cachep);
 
         if(cifs_sm_req_poolp == NULL) {
                 mempool_destroy(cifs_req_poolp);
@@ -804,10 +801,8 @@ cifs_init_mids(void)
         if (cifs_mid_cachep == NULL)
                 return -ENOMEM;
 
-        cifs_mid_poolp = mempool_create(3 /* a reasonable min simultan opers */,
-                                        mempool_alloc_slab,
-                                        mempool_free_slab,
-                                        cifs_mid_cachep);
+        /* 3 is a reasonable minimum number of simultaneous operations */
+        cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
         if(cifs_mid_poolp == NULL) {
                 kmem_cache_destroy(cifs_mid_cachep);
                 return -ENOMEM;
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index b4dcdc2052a0..4e829dc672a6 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -61,10 +61,10 @@ extern struct inode_operations cifs_file_inode_ops;
 extern struct inode_operations cifs_symlink_inode_ops;
 
 /* Functions related to files and directories */
-extern struct file_operations cifs_file_ops;
-extern struct file_operations cifs_file_direct_ops; /* if directio mount */
-extern struct file_operations cifs_file_nobrl_ops;
-extern struct file_operations cifs_file_direct_nobrl_ops; /* if directio mount */
+extern const struct file_operations cifs_file_ops;
+extern const struct file_operations cifs_file_direct_ops; /* if directio mount */
+extern const struct file_operations cifs_file_nobrl_ops;
+extern const struct file_operations cifs_file_direct_nobrl_ops; /* if directio mount */
 extern int cifs_open(struct inode *inode, struct file *file);
 extern int cifs_close(struct inode *inode, struct file *file);
 extern int cifs_closedir(struct inode *inode, struct file *file);
@@ -76,7 +76,7 @@ extern int cifs_lock(struct file *, int, struct file_lock *);
 extern int cifs_fsync(struct file *, struct dentry *, int);
 extern int cifs_flush(struct file *);
 extern int cifs_file_mmap(struct file * , struct vm_area_struct *);
-extern struct file_operations cifs_dir_ops;
+extern const struct file_operations cifs_dir_ops;
 extern int cifs_dir_open(struct inode *inode, struct file *file);
 extern int cifs_readdir(struct file *file, void *direntry, filldir_t filldir);
 extern int cifs_dir_notify(struct file *, unsigned long arg);
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index a5941872d3f7..d705500aa283 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -5023,7 +5023,7 @@ SetEARetry:
         parm_data->list_len = cpu_to_le32(count);
         parm_data->list[0].EA_flags = 0;
         /* we checked above that name len is less than 255 */
-        parm_data->list[0].name_len = (__u8)name_len;;
+        parm_data->list[0].name_len = (__u8)name_len;
         /* EA names are always ASCII */
         if(ea_name)
                 strncpy(parm_data->list[0].name,ea_name,name_len);
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index ddd11fa15528..1d0ca3eaaca5 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -139,9 +139,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;
@@ -316,9 +316,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 a7a47bb36bf3..ec4dfe9bf5ef 100644
--- 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 2c093de26225..5c497c529772 100644
--- 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;
@@ -1377,7 +1377,7 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
         return rc;
 }
 
-/* static int cifs_sync_page(struct page *page)
+/* static void cifs_sync_page(struct page *page)
 {
         struct address_space *mapping;
         struct inode *inode;
@@ -1391,16 +1391,18 @@ int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
                 return 0;
         inode = mapping->host;
         if (!inode)
-                return 0; */
+                return; */
 
 /*      fill in rpages then 
         result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
 
 /*      cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
 
+#if 0
         if (rc < 0)
                 return rc;
         return 0;
+#endif
 } */
 
 /*
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index b21038b99fc2..e842ce9f6547 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -163,9 +163,9 @@ int cifs_get_inode_info_unix(struct inode **pinode,
 
                 if (num_of_bytes < end_of_file)
                         cFYI(1, ("allocation size less than end of file"));
-                cFYI(1,
-                     ("Size %ld and blocks %ld",
-                      (unsigned long) inode->i_size, inode->i_blocks));
+                cFYI(1, ("Size %ld and blocks %llu",
+                        (unsigned long) inode->i_size,
+                        (unsigned long long)inode->i_blocks));
                 if (S_ISREG(inode->i_mode)) {
                         cFYI(1, ("File inode"));
                         inode->i_op = &cifs_file_inode_ops;
@@ -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;
@@ -717,9 +717,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;
@@ -802,9 +802,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;
@@ -1136,9 +1136,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 ce86ec69fe01..9562f5bba65c 100644
--- 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 405d4b7ec3ac..2f6e2825571e 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -197,10 +197,10 @@ static void fill_in_inode(struct inode *tmp_inode,
 
         if (allocation_size < end_of_file)
                 cFYI(1, ("May be sparse file, allocation less than file size"));
-        cFYI(1,
-             ("File Size %ld and blocks %ld and blocksize %ld",
-              (unsigned long)tmp_inode->i_size, tmp_inode->i_blocks,
-              tmp_inode->i_blksize));
+        cFYI(1, ("File Size %ld and blocks %llu and blocksize %ld",
+                (unsigned long)tmp_inode->i_size,
+                (unsigned long long)tmp_inode->i_blocks,
+                tmp_inode->i_blksize));
         if (S_ISREG(tmp_inode->i_mode)) {
                 cFYI(1, ("File inode"));
                 tmp_inode->i_op = &cifs_file_inode_ops;
@@ -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 777e3363c2a4..3938444d87b2 100644
--- 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;