Merge branch 'master' of /usr/src/ntfs-2.6/

6 files changed, 20 insertions, 43 deletions

diff --git a/fs/smbfs/Makefile b/fs/smbfs/Makefile
index 93246b7dd6fb..6673ee82cb4c 100644
--- a/fs/smbfs/Makefile
+++ b/fs/smbfs/Makefile
@@ -13,7 +13,6 @@ smbfs-objs := proc.o dir.o cache.o sock.o inode.o file.o ioctl.o getopt.o \
 EXTRA_CFLAGS += -DSMBFS_PARANOIA
 #EXTRA_CFLAGS += -DSMBFS_DEBUG
 #EXTRA_CFLAGS += -DSMBFS_DEBUG_VERBOSE
-#EXTRA_CFLAGS += -DDEBUG_SMB_MALLOC
 #EXTRA_CFLAGS += -DDEBUG_SMB_TIMESTAMP
 #EXTRA_CFLAGS += -Werror
 
diff --git a/fs/smbfs/cache.c b/fs/smbfs/cache.c
index f3e6b81288ab..74b86d9725a6 100644
--- a/fs/smbfs/cache.c
+++ b/fs/smbfs/cache.c
@@ -66,7 +66,7 @@ smb_invalidate_dircache_entries(struct dentry *parent)
         spin_lock(&dcache_lock);
         next = parent->d_subdirs.next;
         while (next != &parent->d_subdirs) {
-                dentry = list_entry(next, struct dentry, d_child);
+                dentry = list_entry(next, struct dentry, d_u.d_child);
                 dentry->d_fsdata = NULL;
                 smb_age_dentry(server, dentry);
                 next = next->next;
@@ -100,7 +100,7 @@ smb_dget_fpos(struct dentry *dentry, struct dentry *parent, unsigned long fpos)
         spin_lock(&dcache_lock);
         next = parent->d_subdirs.next;
         while (next != &parent->d_subdirs) {
-                dent = list_entry(next, struct dentry, d_child);
+                dent = list_entry(next, struct dentry, d_u.d_child);
                 if ((unsigned long)dent->d_fsdata == fpos) {
                         if (dent->d_inode)
                                 dget_locked(dent);
diff --git a/fs/smbfs/file.c b/fs/smbfs/file.c
index b4fcfa8b55a1..7042e62726a4 100644
--- a/fs/smbfs/file.c
+++ b/fs/smbfs/file.c
@@ -209,8 +209,8 @@ smb_updatepage(struct file *file, struct page *page, unsigned long offset,
 {
         struct dentry *dentry = file->f_dentry;
 
-        DEBUG1("(%s/%s %d@%ld)\n", DENTRY_PATH(dentry), 
-               count, (page->index << PAGE_CACHE_SHIFT)+offset);
+        DEBUG1("(%s/%s %d@%lld)\n", DENTRY_PATH(dentry), count,
+                ((unsigned long long)page->index << PAGE_CACHE_SHIFT) + offset);
 
         return smb_writepage_sync(dentry->d_inode, page, offset, count);
 }
@@ -374,8 +374,7 @@ smb_file_release(struct inode *inode, struct file * file)
                 /* We must flush any dirty pages now as we won't be able to
                    write anything after close. mmap can trigger this.
                    "openers" should perhaps include mmap'ers ... */
-                filemap_fdatawrite(inode->i_mapping);
-                filemap_fdatawait(inode->i_mapping);
+                filemap_write_and_wait(inode->i_mapping);
                 smb_close(inode);
         }
         unlock_kernel();
diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c
index 10b994428fef..02e3e82d465c 100644
--- a/fs/smbfs/inode.c
+++ b/fs/smbfs/inode.c
@@ -487,11 +487,11 @@ smb_put_super(struct super_block *sb)
         if (server->conn_pid)
                 kill_proc(server->conn_pid, SIGTERM, 1);
 
-        smb_kfree(server->ops);
+        kfree(server->ops);
         smb_unload_nls(server);
         sb->s_fs_info = NULL;
         smb_unlock_server(server);
-        smb_kfree(server);
+        kfree(server);
 }
 
 static int smb_fill_super(struct super_block *sb, void *raw_data, int silent)
@@ -519,11 +519,10 @@ static int smb_fill_super(struct super_block *sb, void *raw_data, int silent)
         sb->s_op = &smb_sops;
         sb->s_time_gran = 100;
 
-        server = smb_kmalloc(sizeof(struct smb_sb_info), GFP_KERNEL);
+        server = kzalloc(sizeof(struct smb_sb_info), GFP_KERNEL);
         if (!server)
                 goto out_no_server;
         sb->s_fs_info = server;
-        memset(server, 0, sizeof(struct smb_sb_info));
 
         server->super_block = sb;
         server->mnt = NULL;
@@ -542,8 +541,8 @@ static int smb_fill_super(struct super_block *sb, void *raw_data, int silent)
         /* FIXME: move these to the smb_sb_info struct */
         VERBOSE("alloc chunk = %d\n", sizeof(struct smb_ops) +
                 sizeof(struct smb_mount_data_kernel));
-        mem = smb_kmalloc(sizeof(struct smb_ops) +
-                          sizeof(struct smb_mount_data_kernel), GFP_KERNEL);
+        mem = kmalloc(sizeof(struct smb_ops) +
+                      sizeof(struct smb_mount_data_kernel), GFP_KERNEL);
         if (!mem)
                 goto out_no_mem;
 
@@ -621,12 +620,12 @@ out_no_root:
 out_no_smbiod:
         smb_unload_nls(server);
 out_bad_option:
-        smb_kfree(mem);
+        kfree(mem);
 out_no_mem:
         if (!server->mnt)
                 printk(KERN_ERR "smb_fill_super: allocation failure\n");
         sb->s_fs_info = NULL;
-        smb_kfree(server);
+        kfree(server);
         goto out_fail;
 out_wrong_data:
         printk(KERN_ERR "smbfs: mount_data version %d is not supported\n", ver);
@@ -697,8 +696,7 @@ smb_notify_change(struct dentry *dentry, struct iattr *attr)
                         DENTRY_PATH(dentry),
                         (long) inode->i_size, (long) attr->ia_size);
 
-                filemap_fdatawrite(inode->i_mapping);
-                filemap_fdatawait(inode->i_mapping);
+                filemap_write_and_wait(inode->i_mapping);
 
                 error = smb_open(dentry, O_WRONLY);
                 if (error)
@@ -783,12 +781,6 @@ out:
         return error;
 }
 
-#ifdef DEBUG_SMB_MALLOC
-int smb_malloced;
-int smb_current_kmalloced;
-int smb_current_vmalloced;
-#endif
-
 static struct super_block *smb_get_sb(struct file_system_type *fs_type,
         int flags, const char *dev_name, void *data)
 {
@@ -808,12 +800,6 @@ static int __init init_smb_fs(void)
         int err;
         DEBUG1("registering ...\n");
 
-#ifdef DEBUG_SMB_MALLOC
-        smb_malloced = 0;
-        smb_current_kmalloced = 0;
-        smb_current_vmalloced = 0;
-#endif
-
         err = init_inodecache();
         if (err)
                 goto out_inode;
@@ -838,11 +824,6 @@ static void __exit exit_smb_fs(void)
         unregister_filesystem(&smb_fs_type);
         smb_destroy_request_cache();
         destroy_inodecache();
-#ifdef DEBUG_SMB_MALLOC
-        printk(KERN_DEBUG "smb_malloced: %d\n", smb_malloced);
-        printk(KERN_DEBUG "smb_current_kmalloced: %d\n",smb_current_kmalloced);
-        printk(KERN_DEBUG "smb_current_vmalloced: %d\n",smb_current_vmalloced);
-#endif
 }
 
 module_init(init_smb_fs)
diff --git a/fs/smbfs/proc.c b/fs/smbfs/proc.c
index 38ab558835c4..b1b878b81730 100644
--- a/fs/smbfs/proc.c
+++ b/fs/smbfs/proc.c
@@ -8,6 +8,7 @@
  */
 
 #include <linux/types.h>
+#include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
@@ -3113,7 +3114,7 @@ smb_proc_setattr_unix(struct dentry *d, struct iattr *attr,
         LSET(data, 32, SMB_TIME_NO_CHANGE);
         LSET(data, 40, SMB_UID_NO_CHANGE);
         LSET(data, 48, SMB_GID_NO_CHANGE);
-        LSET(data, 56, smb_filetype_from_mode(attr->ia_mode));
+        DSET(data, 56, smb_filetype_from_mode(attr->ia_mode));
         LSET(data, 60, major);
         LSET(data, 68, minor);
         LSET(data, 76, 0);
diff --git a/fs/smbfs/request.c b/fs/smbfs/request.c
index a0f296d9928a..c71c375863cc 100644
--- a/fs/smbfs/request.c
+++ b/fs/smbfs/request.c
@@ -68,7 +68,7 @@ static struct smb_request *smb_do_alloc_request(struct smb_sb_info *server,
                 goto out;
 
         if (bufsize > 0) {
-                buf = smb_kmalloc(bufsize, GFP_NOFS);
+                buf = kmalloc(bufsize, GFP_NOFS);
                 if (!buf) {
                         kmem_cache_free(req_cachep, req);
                         return NULL;
@@ -124,9 +124,8 @@ static void smb_free_request(struct smb_request *req)
 {
         atomic_dec(&req->rq_server->nr_requests);
         if (req->rq_buffer && !(req->rq_flags & SMB_REQ_STATIC))
-                smb_kfree(req->rq_buffer);
-        if (req->rq_trans2buffer)
-                smb_kfree(req->rq_trans2buffer);
+                kfree(req->rq_buffer);
+        kfree(req->rq_trans2buffer);
         kmem_cache_free(req_cachep, req);
 }
 
@@ -183,8 +182,7 @@ static int smb_setup_request(struct smb_request *req)
         req->rq_err = 0;
         req->rq_errno = 0;
         req->rq_fragment = 0;
-        if (req->rq_trans2buffer)
-                smb_kfree(req->rq_trans2buffer);
+        kfree(req->rq_trans2buffer);
 
         return 0;
 }
@@ -647,10 +645,9 @@ static int smb_recv_trans2(struct smb_sb_info *server, struct smb_request *req)
                         goto out_too_long;
 
                 req->rq_trans2bufsize = buf_len;
-                req->rq_trans2buffer = smb_kmalloc(buf_len, GFP_NOFS);
+                req->rq_trans2buffer = kzalloc(buf_len, GFP_NOFS);
                 if (!req->rq_trans2buffer)
                         goto out_no_mem;
-                memset(req->rq_trans2buffer, 0, buf_len);
 
                 req->rq_parm = req->rq_trans2buffer;
                 req->rq_data = req->rq_trans2buffer + parm_tot;