Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6

Conflicts:

	drivers/net/e1000e/ich8lan.c

14 files changed, 57 insertions, 18 deletions

diff --git a/fs/block_dev.c b/fs/block_dev.c
index db831efbdbbd..99e0ae1a4c78 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -1135,12 +1135,15 @@ static int blkdev_open(struct inode * inode, struct file * filp)
         if (res)
                 return res;
 
-        if (!(filp->f_mode & FMODE_EXCL))
-                return 0;
+        if (filp->f_mode & FMODE_EXCL) {
+                res = bd_claim(bdev, filp);
+                if (res)
+                        goto out_blkdev_put;
+        }
 
-        if (!(res = bd_claim(bdev, filp)))
-                return 0;
+        return 0;
 
+ out_blkdev_put:
         blkdev_put(bdev, filp->f_mode);
         return res;
 }
@@ -1203,8 +1206,16 @@ static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 {
         struct block_device *bdev = I_BDEV(file->f_mapping->host);
         fmode_t mode = file->f_mode;
+
+        /*
+         * O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
+         * to updated it before every ioctl.
+         */
         if (file->f_flags & O_NDELAY)
-                mode |= FMODE_NDELAY_NOW;
+                mode |= FMODE_NDELAY;
+        else
+                mode &= ~FMODE_NDELAY;
+
         return blkdev_ioctl(bdev, mode, cmd, arg);
 }
 
diff --git a/fs/exec.c b/fs/exec.c
index 4e834f16d9da..ec5df9a38313 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1159,6 +1159,7 @@ EXPORT_SYMBOL(remove_arg_zero);
  */
 int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
 {
+        unsigned int depth = bprm->recursion_depth;
         int try,retval;
         struct linux_binfmt *fmt;
 #ifdef __alpha__
@@ -1219,8 +1220,15 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
                                 continue;
                         read_unlock(&binfmt_lock);
                         retval = fn(bprm, regs);
+                        /*
+                         * Restore the depth counter to its starting value
+                         * in this call, so we don't have to rely on every
+                         * load_binary function to restore it on return.
+                         */
+                        bprm->recursion_depth = depth;
                         if (retval >= 0) {
-                                tracehook_report_exec(fmt, bprm, regs);
+                                if (depth == 0)
+                                        tracehook_report_exec(fmt, bprm, regs);
                                 put_binfmt(fmt);
                                 allow_write_access(bprm->file);
                                 if (bprm->file)
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index 80246bad1b7f..890e01828817 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -367,6 +367,8 @@ struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
          * Try to get any dentry for the given file handle from the filesystem.
          */
         result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
+        if (!result)
+                result = ERR_PTR(-ESTALE);
         if (IS_ERR(result))
                 return result;
 
@@ -420,6 +422,8 @@ struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
 
                 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
                                 fh_len, fileid_type);
+                if (!target_dir)
+                        goto err_result;
                 err = PTR_ERR(target_dir);
                 if (IS_ERR(target_dir))
                         goto err_result;
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index d2003cdc36aa..db35cfdb3c8b 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -609,8 +609,8 @@ int ext4_has_free_blocks(struct ext4_sb_info *sbi, s64 nblocks)
 
         if (free_blocks - (nblocks + root_blocks + dirty_blocks) <
                                                 EXT4_FREEBLOCKS_WATERMARK) {
-                free_blocks  = percpu_counter_sum(fbc);
-                dirty_blocks = percpu_counter_sum(dbc);
+                free_blocks  = percpu_counter_sum_positive(fbc);
+                dirty_blocks = percpu_counter_sum_positive(dbc);
                 if (dirty_blocks < 0) {
                         printk(KERN_CRIT "Dirty block accounting "
                                         "went wrong %lld\n",
diff --git a/fs/fcntl.c b/fs/fcntl.c
index ac4f7db9f134..549daf8005fb 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -19,6 +19,7 @@
 #include <linux/signal.h>
 #include <linux/rcupdate.h>
 #include <linux/pid_namespace.h>
+#include <linux/smp_lock.h>
 
 #include <asm/poll.h>
 #include <asm/siginfo.h>
@@ -175,6 +176,11 @@ static int setfl(int fd, struct file * filp, unsigned long arg)
         if (error)
                 return error;
 
+        /*
+         * We still need a lock here for now to keep multiple FASYNC calls
+         * from racing with each other.
+         */
+        lock_kernel();
         if ((arg ^ filp->f_flags) & FASYNC) {
                 if (filp->f_op && filp->f_op->fasync) {
                         error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
@@ -185,6 +191,7 @@ static int setfl(int fd, struct file * filp, unsigned long arg)
 
         filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
  out:
+        unlock_kernel();
         return error;
 }
 
diff --git a/fs/inotify.c b/fs/inotify.c
index 7bbed1b89825..dae3f28f30d4 100644
--- a/fs/inotify.c
+++ b/fs/inotify.c
@@ -428,11 +428,13 @@ void inotify_unmount_inodes(struct list_head *list)
                 watches = &inode->inotify_watches;
                 list_for_each_entry_safe(watch, next_w, watches, i_list) {
                         struct inotify_handle *ih= watch->ih;
+                        get_inotify_watch(watch);
                         mutex_lock(&ih->mutex);
                         ih->in_ops->handle_event(watch, watch->wd, IN_UNMOUNT, 0,
                                                  NULL, NULL);
                         inotify_remove_watch_locked(ih, watch);
                         mutex_unlock(&ih->mutex);
+                        put_inotify_watch(watch);
                 }
                 mutex_unlock(&inode->inotify_mutex);
                 iput(inode);            
diff --git a/fs/ioctl.c b/fs/ioctl.c
index d152856c371b..43e8b2c0664b 100644
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -400,11 +400,9 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,
 
         /* Did FASYNC state change ? */
         if ((flag ^ filp->f_flags) & FASYNC) {
-                if (filp->f_op && filp->f_op->fasync) {
-                        lock_kernel();
+                if (filp->f_op && filp->f_op->fasync)
                         error = filp->f_op->fasync(fd, filp, on);
-                        unlock_kernel();
-                } else
+                else
                         error = -ENOTTY;
         }
         if (error)
@@ -440,11 +438,17 @@ int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
                 break;
 
         case FIONBIO:
+                /* BKL needed to avoid races tweaking f_flags */
+                lock_kernel();
                 error = ioctl_fionbio(filp, argp);
+                unlock_kernel();
                 break;
 
         case FIOASYNC:
+                /* BKL needed to avoid races tweaking f_flags */
+                lock_kernel();
                 error = ioctl_fioasync(fd, filp, argp);
+                unlock_kernel();
                 break;
 
         case FIOQSIZE:
diff --git a/fs/lockd/host.c b/fs/lockd/host.c
index c48c26380771..e05d04416037 100644
--- a/fs/lockd/host.c
+++ b/fs/lockd/host.c
@@ -167,7 +167,8 @@ static struct nlm_host *nlm_lookup_host(struct nlm_lookup_host_info *ni)
                         continue;
                 if (host->h_server != ni->server)
                         continue;
-                if (!nlm_cmp_addr(nlm_srcaddr(host), ni->src_sap))
+                if (ni->server &&
+                    !nlm_cmp_addr(nlm_srcaddr(host), ni->src_sap))
                         continue;
 
                 /* Move to head of hash chain. */
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index c631a83931ce..56b076736b56 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -181,6 +181,7 @@ lockd(void *vrqstp)
         }
         flush_signals(current);
         cancel_delayed_work_sync(&grace_period_end);
+        locks_end_grace(&lockd_manager);
         if (nlmsvc_ops)
                 nlmsvc_invalidate_all();
         nlm_shutdown_hosts();
diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index bb93946ace22..b79ec930d9f1 100644
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -225,12 +225,12 @@ nfsd4_list_rec_dir(struct dentry *dir, recdir_func *f)
                 return 0;
 
         nfs4_save_user(&uid, &gid);
+        INIT_LIST_HEAD(dentries);
 
         filp = dentry_open(dget(dir), mntget(rec_dir.mnt), O_RDONLY);
         status = PTR_ERR(filp);
         if (IS_ERR(filp))
                 goto out;
-        INIT_LIST_HEAD(dentries);
         status = vfs_readdir(filp, nfsd4_build_dentrylist, &dla);
         fput(filp);
         while (!list_empty(dentries)) {
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 16efb8f8e062..bf4cd46a5a11 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -3261,6 +3261,7 @@ nfs4_state_shutdown(void)
 {
         cancel_rearming_delayed_workqueue(laundry_wq, &laundromat_work);
         destroy_workqueue(laundry_wq);
+        locks_end_grace(&nfsd4_manager);
         nfs4_lock_state();
         nfs4_release_reclaim();
         __nfs4_state_shutdown();
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 486cf3fe7139..d4677603c889 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -371,7 +371,7 @@ static int lstats_show_proc(struct seq_file *m, void *v)
                                 task->latency_record[i].time,
                                 task->latency_record[i].max);
                         for (q = 0; q < LT_BACKTRACEDEPTH; q++) {
-                                char sym[KSYM_NAME_LEN];
+                                char sym[KSYM_SYMBOL_LEN];
                                 char *c;
                                 if (!task->latency_record[i].backtrace[q])
                                         break;
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index b770c095e45c..3a8bdd7f5756 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -557,9 +557,9 @@ static u64 swap_pte_to_pagemap_entry(pte_t pte)
         return swp_type(e) | (swp_offset(e) << MAX_SWAPFILES_SHIFT);
 }
 
-static unsigned long pte_to_pagemap_entry(pte_t pte)
+static u64 pte_to_pagemap_entry(pte_t pte)
 {
-        unsigned long pme = 0;
+        u64 pme = 0;
         if (is_swap_pte(pte))
                 pme = PM_PFRAME(swap_pte_to_pagemap_entry(pte))
                         | PM_PSHIFT(PAGE_SHIFT) | PM_SWAP;
diff --git a/fs/xfs/xfs_rename.c b/fs/xfs/xfs_rename.c
index d700dacdb10e..c903130be7fd 100644
--- a/fs/xfs/xfs_rename.c
+++ b/fs/xfs/xfs_rename.c
@@ -212,7 +212,7 @@ xfs_rename(
         if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
                      (target_dp->i_d.di_projid != src_ip->i_d.di_projid))) {
                 error = XFS_ERROR(EXDEV);
-                xfs_rename_unlock4(inodes, XFS_ILOCK_SHARED);
+                xfs_rename_unlock4(inodes, XFS_ILOCK_EXCL);
                 xfs_trans_cancel(tp, cancel_flags);
                 goto std_return;
         }