Merge branch 'linux-2.6' into for-2.6.24

20 files changed, 172 insertions, 287 deletions

diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index 5a5b7116cefb..37310b0e8107 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -3190,6 +3190,8 @@ COMPATIBLE_IOCTL(SIOCSIWRETRY)
 COMPATIBLE_IOCTL(SIOCGIWRETRY)
 COMPATIBLE_IOCTL(SIOCSIWPOWER)
 COMPATIBLE_IOCTL(SIOCGIWPOWER)
+COMPATIBLE_IOCTL(SIOCSIWAUTH)
+COMPATIBLE_IOCTL(SIOCGIWAUTH)
 /* hiddev */
 COMPATIBLE_IOCTL(HIDIOCGVERSION)
 COMPATIBLE_IOCTL(HIDIOCAPPLICATION)
diff --git a/fs/exec.c b/fs/exec.c
index c21a8cc06277..073b0b8c6d05 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -50,7 +50,6 @@
 #include <linux/tsacct_kern.h>
 #include <linux/cn_proc.h>
 #include <linux/audit.h>
-#include <linux/signalfd.h>
 
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
@@ -784,7 +783,6 @@ static int de_thread(struct task_struct *tsk)
          * and we can just re-use it all.
          */
         if (atomic_read(&oldsighand->count) <= 1) {
-                signalfd_detach(tsk);
                 exit_itimers(sig);
                 return 0;
         }
@@ -923,7 +921,6 @@ static int de_thread(struct task_struct *tsk)
         sig->flags = 0;
 
 no_thread_group:
-        signalfd_detach(tsk);
         exit_itimers(sig);
         if (leader)
                 release_task(leader);
diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c
index a21e4bc5444b..d098c7af0d22 100644
--- a/fs/lockd/svclock.c
+++ b/fs/lockd/svclock.c
@@ -171,19 +171,14 @@ found:
  * GRANTED_RES message by cookie, without having to rely on the client's IP
  * address. --okir
  */
-static inline struct nlm_block *
-nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file,
-                struct nlm_lock *lock, struct nlm_cookie *cookie)
+static struct nlm_block *
+nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_host *host,
+                    struct nlm_file *file, struct nlm_lock *lock,
+                    struct nlm_cookie *cookie)
 {
         struct nlm_block        *block;
-        struct nlm_host         *host;
         struct nlm_rqst         *call = NULL;
 
-        /* Create host handle for callback */
-        host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
-        if (host == NULL)
-                return NULL;
-
         call = nlm_alloc_call(host);
         if (call == NULL)
                 return NULL;
@@ -366,6 +361,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
                         struct nlm_lock *lock, int wait, struct nlm_cookie *cookie)
 {
         struct nlm_block        *block = NULL;
+        struct nlm_host         *host;
         int                     error;
         __be32                  ret;
 
@@ -377,6 +373,10 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
                                 (long long)lock->fl.fl_end,
                                 wait);
 
+        /* Create host handle for callback */
+        host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
+        if (host == NULL)
+                return nlm_lck_denied_nolocks;
 
         /* Lock file against concurrent access */
         mutex_lock(&file->f_mutex);
@@ -385,7 +385,8 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
          */
         block = nlmsvc_lookup_block(file, lock);
         if (block == NULL) {
-                block = nlmsvc_create_block(rqstp, file, lock, cookie);
+                block = nlmsvc_create_block(rqstp, nlm_get_host(host), file,
+                                lock, cookie);
                 ret = nlm_lck_denied_nolocks;
                 if (block == NULL)
                         goto out;
@@ -449,6 +450,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
 out:
         mutex_unlock(&file->f_mutex);
         nlmsvc_release_block(block);
+        nlm_release_host(host);
         dprintk("lockd: nlmsvc_lock returned %u\n", ret);
         return ret;
 }
@@ -477,10 +479,15 @@ nlmsvc_testlock(struct svc_rqst *rqstp, struct nlm_file *file,
 
         if (block == NULL) {
                 struct file_lock *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
+                struct nlm_host *host;
 
                 if (conf == NULL)
                         return nlm_granted;
-                block = nlmsvc_create_block(rqstp, file, lock, cookie);
+                /* Create host handle for callback */
+                host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
+                if (host == NULL)
+                        return nlm_lck_denied_nolocks;
+                block = nlmsvc_create_block(rqstp, host, file, lock, cookie);
                 if (block == NULL) {
                         kfree(conf);
                         return nlm_granted;
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index a49f9feff776..a204484072f3 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -588,16 +588,6 @@ static int nfs_init_server(struct nfs_server *server, const struct nfs_mount_dat
         server->namelen  = data->namlen;
         /* Create a client RPC handle for the NFSv3 ACL management interface */
         nfs_init_server_aclclient(server);
-        if (clp->cl_nfsversion == 3) {
-                if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
-                        server->namelen = NFS3_MAXNAMLEN;
-                if (!(data->flags & NFS_MOUNT_NORDIRPLUS))
-                        server->caps |= NFS_CAP_READDIRPLUS;
-        } else {
-                if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
-                        server->namelen = NFS2_MAXNAMLEN;
-        }
-
         dprintk("<-- nfs_init_server() = 0 [new %p]\n", clp);
         return 0;
 
@@ -794,6 +784,16 @@ struct nfs_server *nfs_create_server(const struct nfs_mount_data *data,
         error = nfs_probe_fsinfo(server, mntfh, &fattr);
         if (error < 0)
                 goto error;
+        if (server->nfs_client->rpc_ops->version == 3) {
+                if (server->namelen == 0 || server->namelen > NFS3_MAXNAMLEN)
+                        server->namelen = NFS3_MAXNAMLEN;
+                if (!(data->flags & NFS_MOUNT_NORDIRPLUS))
+                        server->caps |= NFS_CAP_READDIRPLUS;
+        } else {
+                if (server->namelen == 0 || server->namelen > NFS2_MAXNAMLEN)
+                        server->namelen = NFS2_MAXNAMLEN;
+        }
+
         if (!(fattr.valid & NFS_ATTR_FATTR)) {
                 error = server->nfs_client->rpc_ops->getattr(server, mntfh, &fattr);
                 if (error < 0) {
@@ -984,6 +984,9 @@ struct nfs_server *nfs4_create_server(const struct nfs4_mount_data *data,
         if (error < 0)
                 goto error;
 
+        if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
+                server->namelen = NFS4_MAXNAMLEN;
+
         BUG_ON(!server->nfs_client);
         BUG_ON(!server->nfs_client->rpc_ops);
         BUG_ON(!server->nfs_client->rpc_ops->file_inode_ops);
@@ -1056,6 +1059,9 @@ struct nfs_server *nfs4_create_referral_server(struct nfs_clone_mount *data,
         if (error < 0)
                 goto error;
 
+        if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
+                server->namelen = NFS4_MAXNAMLEN;
+
         dprintk("Referral FSID: %llx:%llx\n",
                 (unsigned long long) server->fsid.major,
                 (unsigned long long) server->fsid.minor);
@@ -1115,6 +1121,9 @@ struct nfs_server *nfs_clone_server(struct nfs_server *source,
         if (error < 0)
                 goto out_free_server;
 
+        if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
+                server->namelen = NFS4_MAXNAMLEN;
+
         dprintk("Cloned FSID: %llx:%llx\n",
                 (unsigned long long) server->fsid.major,
                 (unsigned long long) server->fsid.minor);
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index ea97408e423e..e4a04d16b8b0 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -1162,6 +1162,8 @@ static struct dentry *nfs_readdir_lookup(nfs_readdir_descriptor_t *desc)
         }
         if (!desc->plus || !(entry->fattr->valid & NFS_ATTR_FATTR))
                 return NULL;
+        if (name.len > NFS_SERVER(dir)->namelen)
+                return NULL;
         /* Note: caller is already holding the dir->i_mutex! */
         dentry = d_alloc(parent, &name);
         if (dentry == NULL)
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index d1cbf0a0fbb2..522e5ad4d8ad 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -175,6 +175,9 @@ next_component:
                 path++;
         name.len = path - (const char *) name.name;
 
+        if (name.len > NFS4_MAXNAMLEN)
+                return -ENAMETOOLONG;
+
 eat_dot_dir:
         while (*path == '/')
                 path++;
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 50cd8a209012..f37f25c931f5 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -930,18 +930,11 @@ static void ocfs2_write_failure(struct inode *inode,
                                 loff_t user_pos, unsigned user_len)
 {
         int i;
-        unsigned from, to;
+        unsigned from = user_pos & (PAGE_CACHE_SIZE - 1),
+                to = user_pos + user_len;
         struct page *tmppage;
 
-        ocfs2_zero_new_buffers(wc->w_target_page, user_pos, user_len);
-
-        if (wc->w_large_pages) {
-                from = wc->w_target_from;
-                to = wc->w_target_to;
-        } else {
-                from = 0;
-                to = PAGE_CACHE_SIZE;
-        }
+        ocfs2_zero_new_buffers(wc->w_target_page, from, to);
 
         for(i = 0; i < wc->w_num_pages; i++) {
                 tmppage = wc->w_pages[i];
@@ -991,9 +984,6 @@ static int ocfs2_prepare_page_for_write(struct inode *inode, u64 *p_blkno,
                         map_from = cluster_start;
                         map_to = cluster_end;
                 }
-
-                wc->w_target_from = map_from;
-                wc->w_target_to = map_to;
         } else {
                 /*
                  * If we haven't allocated the new page yet, we
@@ -1211,18 +1201,33 @@ static int ocfs2_write_cluster_by_desc(struct address_space *mapping,
                                        loff_t pos, unsigned len)
 {
         int ret, i;
+        loff_t cluster_off;
+        unsigned int local_len = len;
         struct ocfs2_write_cluster_desc *desc;
+        struct ocfs2_super *osb = OCFS2_SB(mapping->host->i_sb);
 
         for (i = 0; i < wc->w_clen; i++) {
                 desc = &wc->w_desc[i];
 
+                /*
+                 * We have to make sure that the total write passed in
+                 * doesn't extend past a single cluster.
+                 */
+                local_len = len;
+                cluster_off = pos & (osb->s_clustersize - 1);
+                if ((cluster_off + local_len) > osb->s_clustersize)
+                        local_len = osb->s_clustersize - cluster_off;
+
                 ret = ocfs2_write_cluster(mapping, desc->c_phys,
                                           desc->c_unwritten, data_ac, meta_ac,
-                                          wc, desc->c_cpos, pos, len);
+                                          wc, desc->c_cpos, pos, local_len);
                 if (ret) {
                         mlog_errno(ret);
                         goto out;
                 }
+
+                len -= local_len;
+                pos += local_len;
         }
 
         ret = 0;
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 7e34e66159c6..f3bc3658e7a5 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -491,8 +491,8 @@ int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
                 goto leave;
         }
 
-        status = ocfs2_claim_clusters(osb, handle, data_ac, 1,
-                                      &bit_off, &num_bits);
+        status = __ocfs2_claim_clusters(osb, handle, data_ac, 1,
+                                        clusters_to_add, &bit_off, &num_bits);
         if (status < 0) {
                 if (status != -ENOSPC)
                         mlog_errno(status);
diff --git a/fs/ocfs2/localalloc.c b/fs/ocfs2/localalloc.c
index 545f7892cdf3..de984d272576 100644
--- a/fs/ocfs2/localalloc.c
+++ b/fs/ocfs2/localalloc.c
@@ -524,13 +524,12 @@ bail:
 int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
                                  handle_t *handle,
                                  struct ocfs2_alloc_context *ac,
-                                 u32 min_bits,
+                                 u32 bits_wanted,
                                  u32 *bit_off,
                                  u32 *num_bits)
 {
         int status, start;
         struct inode *local_alloc_inode;
-        u32 bits_wanted;
         void *bitmap;
         struct ocfs2_dinode *alloc;
         struct ocfs2_local_alloc *la;
@@ -538,7 +537,6 @@ int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
         mlog_entry_void();
         BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL);
 
-        bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given;
         local_alloc_inode = ac->ac_inode;
         alloc = (struct ocfs2_dinode *) osb->local_alloc_bh->b_data;
         la = OCFS2_LOCAL_ALLOC(alloc);
diff --git a/fs/ocfs2/localalloc.h b/fs/ocfs2/localalloc.h
index 385a10152f9c..3f76631e110c 100644
--- a/fs/ocfs2/localalloc.h
+++ b/fs/ocfs2/localalloc.h
@@ -48,7 +48,7 @@ int ocfs2_reserve_local_alloc_bits(struct ocfs2_super *osb,
 int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
                                  handle_t *handle,
                                  struct ocfs2_alloc_context *ac,
-                                 u32 min_bits,
+                                 u32 bits_wanted,
                                  u32 *bit_off,
                                  u32 *num_bits);
 
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index d9c5c9fcb30f..8f09f5235e3a 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -1486,21 +1486,21 @@ static inline void ocfs2_block_to_cluster_group(struct inode *inode,
  * contig. allocation, set to '1' to indicate we can deal with extents
  * of any size.
  */
-int ocfs2_claim_clusters(struct ocfs2_super *osb,
-                         handle_t *handle,
-                         struct ocfs2_alloc_context *ac,
-                         u32 min_clusters,
-                         u32 *cluster_start,
-                         u32 *num_clusters)
+int __ocfs2_claim_clusters(struct ocfs2_super *osb,
+                           handle_t *handle,
+                           struct ocfs2_alloc_context *ac,
+                           u32 min_clusters,
+                           u32 max_clusters,
+                           u32 *cluster_start,
+                           u32 *num_clusters)
 {
         int status;
-        unsigned int bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given;
+        unsigned int bits_wanted = max_clusters;
         u64 bg_blkno = 0;
         u16 bg_bit_off;
 
         mlog_entry_void();
 
-        BUG_ON(!ac);
         BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted);
 
         BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL
@@ -1557,6 +1557,19 @@ bail:
         return status;
 }
 
+int ocfs2_claim_clusters(struct ocfs2_super *osb,
+                         handle_t *handle,
+                         struct ocfs2_alloc_context *ac,
+                         u32 min_clusters,
+                         u32 *cluster_start,
+                         u32 *num_clusters)
+{
+        unsigned int bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given;
+
+        return __ocfs2_claim_clusters(osb, handle, ac, min_clusters,
+                                      bits_wanted, cluster_start, num_clusters);
+}
+
 static inline int ocfs2_block_group_clear_bits(handle_t *handle,
                                                struct inode *alloc_inode,
                                                struct ocfs2_group_desc *bg,
diff --git a/fs/ocfs2/suballoc.h b/fs/ocfs2/suballoc.h
index f212dc01a84b..cafe93703095 100644
--- a/fs/ocfs2/suballoc.h
+++ b/fs/ocfs2/suballoc.h
@@ -85,6 +85,17 @@ int ocfs2_claim_clusters(struct ocfs2_super *osb,
                          u32 min_clusters,
                          u32 *cluster_start,
                          u32 *num_clusters);
+/*
+ * Use this variant of ocfs2_claim_clusters to specify a maxiumum
+ * number of clusters smaller than the allocation reserved.
+ */
+int __ocfs2_claim_clusters(struct ocfs2_super *osb,
+                           handle_t *handle,
+                           struct ocfs2_alloc_context *ac,
+                           u32 min_clusters,
+                           u32 max_clusters,
+                           u32 *cluster_start,
+                           u32 *num_clusters);
 
 int ocfs2_free_suballoc_bits(handle_t *handle,
                              struct inode *alloc_inode,
diff --git a/fs/ocfs2/vote.c b/fs/ocfs2/vote.c
index 66a13ee63d4c..c05358538f2b 100644
--- a/fs/ocfs2/vote.c
+++ b/fs/ocfs2/vote.c
@@ -66,7 +66,7 @@ struct ocfs2_vote_msg
 {
         struct ocfs2_msg_hdr v_hdr;
         __be32 v_reserved1;
-};
+} __attribute__ ((packed));
 
 /* Responses are given these values to maintain backwards
  * compatibility with older ocfs2 versions */
@@ -78,7 +78,7 @@ struct ocfs2_response_msg
 {
         struct ocfs2_msg_hdr r_hdr;
         __be32 r_response;
-};
+} __attribute__ ((packed));
 
 struct ocfs2_vote_work {
         struct list_head   w_list;
diff --git a/fs/signalfd.c b/fs/signalfd.c
index a8e293d30034..aefb0be07942 100644
--- a/fs/signalfd.c
+++ b/fs/signalfd.c
@@ -11,8 +11,10 @@
  *      Now using anonymous inode source.
  *      Thanks to Oleg Nesterov for useful code review and suggestions.
  *      More comments and suggestions from Arnd Bergmann.
- * Sat May 19, 2007: Davi E. M. Arnaut <davi@haxent.com.br>
+ *  Sat May 19, 2007: Davi E. M. Arnaut <davi@haxent.com.br>
  *      Retrieve multiple signals with one read() call
+ *  Sun Jul 15, 2007: Davide Libenzi <davidel@xmailserver.org>
+ *      Attach to the sighand only during read() and poll().
  */
 
 #include <linux/file.h>
@@ -27,102 +29,12 @@
 #include <linux/signalfd.h>
 
 struct signalfd_ctx {
-        struct list_head lnk;
-        wait_queue_head_t wqh;
         sigset_t sigmask;
-        struct task_struct *tsk;
 };
 
-struct signalfd_lockctx {
-        struct task_struct *tsk;
-        unsigned long flags;
-};
-
-/*
- * Tries to acquire the sighand lock. We do not increment the sighand
- * use count, and we do not even pin the task struct, so we need to
- * do it inside an RCU read lock, and we must be prepared for the
- * ctx->tsk going to NULL (in signalfd_deliver()), and for the sighand
- * being detached. We return 0 if the sighand has been detached, or
- * 1 if we were able to pin the sighand lock.
- */
-static int signalfd_lock(struct signalfd_ctx *ctx, struct signalfd_lockctx *lk)
-{
-        struct sighand_struct *sighand = NULL;
-
-        rcu_read_lock();
-        lk->tsk = rcu_dereference(ctx->tsk);
-        if (likely(lk->tsk != NULL))
-                sighand = lock_task_sighand(lk->tsk, &lk->flags);
-        rcu_read_unlock();
-
-        if (!sighand)
-                return 0;
-
-        if (!ctx->tsk) {
-                unlock_task_sighand(lk->tsk, &lk->flags);
-                return 0;
-        }
-
-        if (lk->tsk->tgid == current->tgid)
-                lk->tsk = current;
-
-        return 1;
-}
-
-static void signalfd_unlock(struct signalfd_lockctx *lk)
-{
-        unlock_task_sighand(lk->tsk, &lk->flags);
-}
-
-/*
- * This must be called with the sighand lock held.
- */
-void signalfd_deliver(struct task_struct *tsk, int sig)
-{
-        struct sighand_struct *sighand = tsk->sighand;
-        struct signalfd_ctx *ctx, *tmp;
-
-        BUG_ON(!sig);
-        list_for_each_entry_safe(ctx, tmp, &sighand->signalfd_list, lnk) {
-                /*
-                 * We use a negative signal value as a way to broadcast that the
-                 * sighand has been orphaned, so that we can notify all the
-                 * listeners about this. Remember the ctx->sigmask is inverted,
-                 * so if the user is interested in a signal, that corresponding
-                 * bit will be zero.
-                 */
-                if (sig < 0) {
-                        if (ctx->tsk == tsk) {
-                                ctx->tsk = NULL;
-                                list_del_init(&ctx->lnk);
-                                wake_up(&ctx->wqh);
-                        }
-                } else {
-                        if (!sigismember(&ctx->sigmask, sig))
-                                wake_up(&ctx->wqh);
-                }
-        }
-}
-
-static void signalfd_cleanup(struct signalfd_ctx *ctx)
-{
-        struct signalfd_lockctx lk;
-
-        /*
-         * This is tricky. If the sighand is gone, we do not need to remove
-         * context from the list, the list itself won't be there anymore.
-         */
-        if (signalfd_lock(ctx, &lk)) {
-                list_del(&ctx->lnk);
-                signalfd_unlock(&lk);
-        }
-        kfree(ctx);
-}
-
 static int signalfd_release(struct inode *inode, struct file *file)
 {
-        signalfd_cleanup(file->private_data);
+        kfree(file->private_data);
         return 0;
 }
 
@@ -130,23 +42,15 @@ static unsigned int signalfd_poll(struct file *file, poll_table *wait)
 {
         struct signalfd_ctx *ctx = file->private_data;
         unsigned int events = 0;
-        struct signalfd_lockctx lk;
 
-        poll_wait(file, &ctx->wqh, wait);
+        poll_wait(file, &current->sighand->signalfd_wqh, wait);
 
-        /*
-         * Let the caller get a POLLIN in this case, ala socket recv() when
-         * the peer disconnects.
-         */
-        if (signalfd_lock(ctx, &lk)) {
-                if ((lk.tsk == current &&
-                     next_signal(&lk.tsk->pending, &ctx->sigmask) > 0) ||
-                    next_signal(&lk.tsk->signal->shared_pending,
-                                &ctx->sigmask) > 0)
-                        events |= POLLIN;
-                signalfd_unlock(&lk);
-        } else
+        spin_lock_irq(&current->sighand->siglock);
+        if (next_signal(&current->pending, &ctx->sigmask) ||
+            next_signal(&current->signal->shared_pending,
+                        &ctx->sigmask))
                 events |= POLLIN;
+        spin_unlock_irq(&current->sighand->siglock);
 
         return events;
 }
@@ -219,59 +123,46 @@ static ssize_t signalfd_dequeue(struct signalfd_ctx *ctx, siginfo_t *info,
                                 int nonblock)
 {
         ssize_t ret;
-        struct signalfd_lockctx lk;
         DECLARE_WAITQUEUE(wait, current);
 
-        if (!signalfd_lock(ctx, &lk))
-                return 0;
-
-        ret = dequeue_signal(lk.tsk, &ctx->sigmask, info);
+        spin_lock_irq(&current->sighand->siglock);
+        ret = dequeue_signal(current, &ctx->sigmask, info);
         switch (ret) {
         case 0:
                 if (!nonblock)
                         break;
                 ret = -EAGAIN;
         default:
-                signalfd_unlock(&lk);
+                spin_unlock_irq(&current->sighand->siglock);
                 return ret;
         }
 
-        add_wait_queue(&ctx->wqh, &wait);
+        add_wait_queue(&current->sighand->signalfd_wqh, &wait);
         for (;;) {
                 set_current_state(TASK_INTERRUPTIBLE);
-                ret = dequeue_signal(lk.tsk, &ctx->sigmask, info);
-                signalfd_unlock(&lk);
+                ret = dequeue_signal(current, &ctx->sigmask, info);
                 if (ret != 0)
                         break;
                 if (signal_pending(current)) {
                         ret = -ERESTARTSYS;
                         break;
                 }
+                spin_unlock_irq(&current->sighand->siglock);
                 schedule();
-                ret = signalfd_lock(ctx, &lk);
-                if (unlikely(!ret)) {
-                        /*
-                         * Let the caller read zero byte, ala socket
-                         * recv() when the peer disconnect. This test
-                         * must be done before doing a dequeue_signal(),
-                         * because if the sighand has been orphaned,
-                         * the dequeue_signal() call is going to crash
-                         * because ->sighand will be long gone.
-                         */
-                         break;
-                }
+                spin_lock_irq(&current->sighand->siglock);
         }
+        spin_unlock_irq(&current->sighand->siglock);
 
-        remove_wait_queue(&ctx->wqh, &wait);
+        remove_wait_queue(&current->sighand->signalfd_wqh, &wait);
         __set_current_state(TASK_RUNNING);
 
         return ret;
 }
 
 /*
- * Returns either the size of a "struct signalfd_siginfo", or zero if the
- * sighand we are attached to, has been orphaned. The "count" parameter
- * must be at least the size of a "struct signalfd_siginfo".
+ * Returns a multiple of the size of a "struct signalfd_siginfo", or a negative
+ * error code. The "count" parameter must be at least the size of a
+ * "struct signalfd_siginfo".
  */
 static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
                              loff_t *ppos)
@@ -287,7 +178,6 @@ static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
                 return -EINVAL;
 
         siginfo = (struct signalfd_siginfo __user *) buf;
-
         do {
                 ret = signalfd_dequeue(ctx, &info, nonblock);
                 if (unlikely(ret <= 0))
@@ -300,7 +190,7 @@ static ssize_t signalfd_read(struct file *file, char __user *buf, size_t count,
                 nonblock = 1;
         } while (--count);
 
-        return total ? total : ret;
+        return total ? total: ret;
 }
 
 static const struct file_operations signalfd_fops = {
@@ -309,20 +199,13 @@ static const struct file_operations signalfd_fops = {
         .read           = signalfd_read,
 };
 
-/*
- * Create a file descriptor that is associated with our signal
- * state. We can pass it around to others if we want to, but
- * it will always be _our_ signal state.
- */
 asmlinkage long sys_signalfd(int ufd, sigset_t __user *user_mask, size_t sizemask)
 {
         int error;
         sigset_t sigmask;
         struct signalfd_ctx *ctx;
-        struct sighand_struct *sighand;
         struct file *file;
         struct inode *inode;
-        struct signalfd_lockctx lk;
 
         if (sizemask != sizeof(sigset_t) ||
             copy_from_user(&sigmask, user_mask, sizeof(sigmask)))
@@ -335,17 +218,7 @@ asmlinkage long sys_signalfd(int ufd, sigset_t __user *user_mask, size_t sizemas
                 if (!ctx)
                         return -ENOMEM;
 
-                init_waitqueue_head(&ctx->wqh);
                 ctx->sigmask = sigmask;
-                ctx->tsk = current->group_leader;
-
-                sighand = current->sighand;
-                /*
-                 * Add this fd to the list of signal listeners.
-                 */
-                spin_lock_irq(&sighand->siglock);
-                list_add_tail(&ctx->lnk, &sighand->signalfd_list);
-                spin_unlock_irq(&sighand->siglock);
 
                 /*
                  * When we call this, the initialization must be complete, since
@@ -364,23 +237,18 @@ asmlinkage long sys_signalfd(int ufd, sigset_t __user *user_mask, size_t sizemas
                         fput(file);
                         return -EINVAL;
                 }
-                /*
-                 * We need to be prepared of the fact that the sighand this fd
-                 * is attached to, has been detched. In that case signalfd_lock()
-                 * will return 0, and we'll just skip setting the new mask.
-                 */
-                if (signalfd_lock(ctx, &lk)) {
-                        ctx->sigmask = sigmask;
-                        signalfd_unlock(&lk);
-                }
-                wake_up(&ctx->wqh);
+                spin_lock_irq(&current->sighand->siglock);
+                ctx->sigmask = sigmask;
+                spin_unlock_irq(&current->sighand->siglock);
+
+                wake_up(&current->sighand->signalfd_wqh);
                 fput(file);
         }
 
         return ufd;
 
 err_fdalloc:
-        signalfd_cleanup(ctx);
+        kfree(ctx);
         return error;
 }
 
diff --git a/fs/splice.c b/fs/splice.c
index c010a72ca2d2..e95a36228863 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -1224,6 +1224,33 @@ static long do_splice(struct file *in, loff_t __user *off_in,
 }
 
 /*
+ * Do a copy-from-user while holding the mmap_semaphore for reading, in a
+ * manner safe from deadlocking with simultaneous mmap() (grabbing mmap_sem
+ * for writing) and page faulting on the user memory pointed to by src.
+ * This assumes that we will very rarely hit the partial != 0 path, or this
+ * will not be a win.
+ */
+static int copy_from_user_mmap_sem(void *dst, const void __user *src, size_t n)
+{
+        int partial;
+
+        pagefault_disable();
+        partial = __copy_from_user_inatomic(dst, src, n);
+        pagefault_enable();
+
+        /*
+         * Didn't copy everything, drop the mmap_sem and do a faulting copy
+         */
+        if (unlikely(partial)) {
+                up_read(&current->mm->mmap_sem);
+                partial = copy_from_user(dst, src, n);
+                down_read(&current->mm->mmap_sem);
+        }
+
+        return partial;
+}
+
+/*
  * Map an iov into an array of pages and offset/length tupples. With the
  * partial_page structure, we can map several non-contiguous ranges into
  * our ones pages[] map instead of splitting that operation into pieces.
@@ -1236,31 +1263,26 @@ static int get_iovec_page_array(const struct iovec __user *iov,
 {
         int buffers = 0, error = 0;
 
-        /*
-         * It's ok to take the mmap_sem for reading, even
-         * across a "get_user()".
-         */
         down_read(&current->mm->mmap_sem);
 
         while (nr_vecs) {
                 unsigned long off, npages;
+                struct iovec entry;
                 void __user *base;
                 size_t len;
                 int i;
 
-                /*
-                 * Get user address base and length for this iovec.
-                 */
-                error = get_user(base, &iov->iov_base);
-                if (unlikely(error))
-                        break;
-                error = get_user(len, &iov->iov_len);
-                if (unlikely(error))
+                error = -EFAULT;
+                if (copy_from_user_mmap_sem(&entry, iov, sizeof(entry)))
                         break;
 
+                base = entry.iov_base;
+                len = entry.iov_len;
+
                 /*
                  * Sanity check this iovec. 0 read succeeds.
                  */
+                error = 0;
                 if (unlikely(!len))
                         break;
                 error = -EFAULT;
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 73402c5eeb8a..38eb0b7a1f3d 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -894,7 +894,7 @@ magic_found:
                 goto again;
         }
 
-
+        sbi->s_flags = flags;/*after that line some functions use s_flags*/
         ufs_print_super_stuff(sb, usb1, usb2, usb3);
 
         /*
@@ -1025,8 +1025,6 @@ magic_found:
             UFS_MOUNT_UFSTYPE_44BSD)
                 uspi->s_maxsymlinklen =
                     fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
-        
-        sbi->s_flags = flags;
 
         inode = iget(sb, UFS_ROOTINO);
         if (!inode || is_bad_inode(inode))
diff --git a/fs/xfs/xfs_buf_item.h b/fs/xfs/xfs_buf_item.h
index fa25b7dcc6c3..d7e136143066 100644
--- a/fs/xfs/xfs_buf_item.h
+++ b/fs/xfs/xfs_buf_item.h
@@ -52,11 +52,6 @@ typedef struct xfs_buf_log_format_t {
 #define XFS_BLI_UDQUOT_BUF      0x4
 #define XFS_BLI_PDQUOT_BUF      0x8
 #define XFS_BLI_GDQUOT_BUF      0x10
-/*
- * This flag indicates that the buffer contains newly allocated
- * inodes.
- */
-#define XFS_BLI_INODE_NEW_BUF   0x20
 
 #define XFS_BLI_CHUNK           128
 #define XFS_BLI_SHIFT           7
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index 16f8e175167d..36d8f6aa11af 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -350,9 +350,10 @@ _xfs_filestream_update_ag(
 /* xfs_fstrm_free_func(): callback for freeing cached stream items. */
 void
 xfs_fstrm_free_func(
-        xfs_ino_t       ino,
-        fstrm_item_t    *item)
+        unsigned long   ino,
+        void            *data)
 {
+        fstrm_item_t    *item  = (fstrm_item_t *)data;
         xfs_inode_t     *ip = item->ip;
         int ref;
 
@@ -438,7 +439,7 @@ xfs_filestream_mount(
         grp_count = 10;
 
         err = xfs_mru_cache_create(&mp->m_filestream, lifetime, grp_count,
-                             (xfs_mru_cache_free_func_t)xfs_fstrm_free_func);
+                             xfs_fstrm_free_func);
 
         return err;
 }
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index dacb19739cc2..8ae6e8e5f3db 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -1874,7 +1874,6 @@ xlog_recover_do_inode_buffer(
 /*ARGSUSED*/
 STATIC void
 xlog_recover_do_reg_buffer(
-        xfs_mount_t             *mp,
         xlog_recover_item_t     *item,
         xfs_buf_t               *bp,
         xfs_buf_log_format_t    *buf_f)
@@ -1885,50 +1884,6 @@ xlog_recover_do_reg_buffer(
         unsigned int            *data_map = NULL;
         unsigned int            map_size = 0;
         int                     error;
-        int                     stale_buf = 1;
-
-        /*
-         * Scan through the on-disk inode buffer and attempt to
-         * determine if it has been written to since it was logged.
-         *
-         * - If any of the magic numbers are incorrect then the buffer is stale
-         * - If any of the modes are non-zero then the buffer is not stale
-         * - If all of the modes are zero and at least one of the generation
-         *   counts is non-zero then the buffer is stale
-         *
-         * If the end result is a stale buffer then the log buffer is replayed
-         * otherwise it is skipped.
-         *
-         * This heuristic is not perfect.  It can be improved by scanning the
-         * entire inode chunk for evidence that any of the inode clusters have
-         * been updated.  To fix this problem completely we will need a major
-         * architectural change to the logging system.
-         */
-        if (buf_f->blf_flags & XFS_BLI_INODE_NEW_BUF) {
-                xfs_dinode_t    *dip;
-                int             inodes_per_buf;
-                int             mode_count = 0;
-                int             gen_count = 0;
-
-                stale_buf = 0;
-                inodes_per_buf = XFS_BUF_COUNT(bp) >> mp->m_sb.sb_inodelog;
-                for (i = 0; i < inodes_per_buf; i++) {
-                        dip = (xfs_dinode_t *)xfs_buf_offset(bp,
-                                i * mp->m_sb.sb_inodesize);
-                        if (be16_to_cpu(dip->di_core.di_magic) !=
-                                        XFS_DINODE_MAGIC) {
-                                stale_buf = 1;
-                                break;
-                        }
-                        if (be16_to_cpu(dip->di_core.di_mode))
-                                mode_count++;
-                        if (be16_to_cpu(dip->di_core.di_gen))
-                                gen_count++;
-                }
-
-                if (!mode_count && gen_count)
-                        stale_buf = 1;
-        }
 
         switch (buf_f->blf_type) {
         case XFS_LI_BUF:
@@ -1962,7 +1917,7 @@ xlog_recover_do_reg_buffer(
                                                -1, 0, XFS_QMOPT_DOWARN,
                                                "dquot_buf_recover");
                 }
-                if (!error && stale_buf)
+                if (!error)
                         memcpy(xfs_buf_offset(bp,
                                 (uint)bit << XFS_BLI_SHIFT),    /* dest */
                                 item->ri_buf[i].i_addr,         /* source */
@@ -2134,7 +2089,7 @@ xlog_recover_do_dquot_buffer(
         if (log->l_quotaoffs_flag & type)
                 return;
 
-        xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
+        xlog_recover_do_reg_buffer(item, bp, buf_f);
 }
 
 /*
@@ -2235,7 +2190,7 @@ xlog_recover_do_buffer_trans(
                   (XFS_BLI_UDQUOT_BUF|XFS_BLI_PDQUOT_BUF|XFS_BLI_GDQUOT_BUF)) {
                 xlog_recover_do_dquot_buffer(mp, log, item, bp, buf_f);
         } else {
-                xlog_recover_do_reg_buffer(mp, item, bp, buf_f);
+                xlog_recover_do_reg_buffer(item, bp, buf_f);
         }
         if (error)
                 return XFS_ERROR(error);
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 95fff6872a2f..60b6b898022b 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -966,7 +966,6 @@ xfs_trans_inode_alloc_buf(
         ASSERT(atomic_read(&bip->bli_refcount) > 0);
 
         bip->bli_flags |= XFS_BLI_INODE_ALLOC_BUF;
-        bip->bli_format.blf_flags |= XFS_BLI_INODE_NEW_BUF;
 }