Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6

23 files changed, 158 insertions, 194 deletions

diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index 88e3787c6ea9..e298fe194093 100644
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -119,6 +119,7 @@ int v9fs_dir_release(struct inode *inode, struct file *filp)
 
 const struct file_operations v9fs_dir_operations = {
         .read = generic_read_dir,
+        .llseek = generic_file_llseek,
         .readdir = v9fs_dir_readdir,
         .open = v9fs_file_open,
         .release = v9fs_dir_release,
diff --git a/fs/adfs/dir.c b/fs/adfs/dir.c
index fc1a8dc64d78..85a30e929800 100644
--- a/fs/adfs/dir.c
+++ b/fs/adfs/dir.c
@@ -197,6 +197,7 @@ out:
 
 const struct file_operations adfs_dir_operations = {
         .read           = generic_read_dir,
+        .llseek         = generic_file_llseek,
         .readdir        = adfs_readdir,
         .fsync          = file_fsync,
 };
diff --git a/fs/affs/dir.c b/fs/affs/dir.c
index 6e3f282424b0..7b36904dbeac 100644
--- a/fs/affs/dir.c
+++ b/fs/affs/dir.c
@@ -19,6 +19,7 @@ static int affs_readdir(struct file *, void *, filldir_t);
 
 const struct file_operations affs_dir_operations = {
         .read           = generic_read_dir,
+        .llseek         = generic_file_llseek,
         .readdir        = affs_readdir,
         .fsync          = file_fsync,
 };
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index bcfb2dc0a61b..2a41c2a7fc52 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -36,6 +36,7 @@ const struct file_operations autofs4_root_operations = {
         .release        = dcache_dir_close,
         .read           = generic_read_dir,
         .readdir        = dcache_readdir,
+        .llseek         = dcache_dir_lseek,
         .ioctl          = autofs4_root_ioctl,
 };
 
@@ -44,6 +45,7 @@ const struct file_operations autofs4_dir_operations = {
         .release        = dcache_dir_close,
         .read           = generic_read_dir,
         .readdir        = dcache_readdir,
+        .llseek         = dcache_dir_lseek,
 };
 
 const struct inode_operations autofs4_indirect_root_inode_operations = {
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 02c6e62b72f8..740f53672a8a 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -66,6 +66,7 @@ static struct kmem_cache *befs_inode_cachep;
 static const struct file_operations befs_dir_operations = {
         .read           = generic_read_dir,
         .readdir        = befs_readdir,
+        .llseek         = generic_file_llseek,
 };
 
 static const struct inode_operations befs_dir_inode_operations = {
diff --git a/fs/bio.c b/fs/bio.c
index 8000e2fa16cb..3cba7ae34d75 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -469,20 +469,21 @@ static void bio_free_map_data(struct bio_map_data *bmd)
         kfree(bmd);
 }
 
-static struct bio_map_data *bio_alloc_map_data(int nr_segs, int iov_count)
+static struct bio_map_data *bio_alloc_map_data(int nr_segs, int iov_count,
+                                               gfp_t gfp_mask)
 {
-        struct bio_map_data *bmd = kmalloc(sizeof(*bmd), GFP_KERNEL);
+        struct bio_map_data *bmd = kmalloc(sizeof(*bmd), gfp_mask);
 
         if (!bmd)
                 return NULL;
 
-        bmd->iovecs = kmalloc(sizeof(struct bio_vec) * nr_segs, GFP_KERNEL);
+        bmd->iovecs = kmalloc(sizeof(struct bio_vec) * nr_segs, gfp_mask);
         if (!bmd->iovecs) {
                 kfree(bmd);
                 return NULL;
         }
 
-        bmd->sgvecs = kmalloc(sizeof(struct sg_iovec) * iov_count, GFP_KERNEL);
+        bmd->sgvecs = kmalloc(sizeof(struct sg_iovec) * iov_count, gfp_mask);
         if (bmd->sgvecs)
                 return bmd;
 
@@ -491,8 +492,8 @@ static struct bio_map_data *bio_alloc_map_data(int nr_segs, int iov_count)
         return NULL;
 }
 
-static int __bio_copy_iov(struct bio *bio, struct sg_iovec *iov, int iov_count,
-                          int uncopy)
+static int __bio_copy_iov(struct bio *bio, struct bio_vec *iovecs,
+                          struct sg_iovec *iov, int iov_count, int uncopy)
 {
         int ret = 0, i;
         struct bio_vec *bvec;
@@ -502,7 +503,7 @@ static int __bio_copy_iov(struct bio *bio, struct sg_iovec *iov, int iov_count,
 
         __bio_for_each_segment(bvec, bio, i, 0) {
                 char *bv_addr = page_address(bvec->bv_page);
-                unsigned int bv_len = bvec->bv_len;
+                unsigned int bv_len = iovecs[i].bv_len;
 
                 while (bv_len && iov_idx < iov_count) {
                         unsigned int bytes;
@@ -554,7 +555,7 @@ int bio_uncopy_user(struct bio *bio)
         struct bio_map_data *bmd = bio->bi_private;
         int ret;
 
-        ret = __bio_copy_iov(bio, bmd->sgvecs, bmd->nr_sgvecs, 1);
+        ret = __bio_copy_iov(bio, bmd->iovecs, bmd->sgvecs, bmd->nr_sgvecs, 1);
 
         bio_free_map_data(bmd);
         bio_put(bio);
@@ -596,7 +597,7 @@ struct bio *bio_copy_user_iov(struct request_queue *q, struct sg_iovec *iov,
                 len += iov[i].iov_len;
         }
 
-        bmd = bio_alloc_map_data(nr_pages, iov_count);
+        bmd = bio_alloc_map_data(nr_pages, iov_count, GFP_KERNEL);
         if (!bmd)
                 return ERR_PTR(-ENOMEM);
 
@@ -633,7 +634,7 @@ struct bio *bio_copy_user_iov(struct request_queue *q, struct sg_iovec *iov,
          * success
          */
         if (!write_to_vm) {
-                ret = __bio_copy_iov(bio, iov, iov_count, 0);
+                ret = __bio_copy_iov(bio, bio->bi_io_vec, iov, iov_count, 0);
                 if (ret)
                         goto cleanup;
         }
@@ -942,19 +943,22 @@ static void bio_copy_kern_endio(struct bio *bio, int err)
 {
         struct bio_vec *bvec;
         const int read = bio_data_dir(bio) == READ;
-        char *p = bio->bi_private;
+        struct bio_map_data *bmd = bio->bi_private;
         int i;
+        char *p = bmd->sgvecs[0].iov_base;
 
         __bio_for_each_segment(bvec, bio, i, 0) {
                 char *addr = page_address(bvec->bv_page);
+                int len = bmd->iovecs[i].bv_len;
 
                 if (read && !err)
-                        memcpy(p, addr, bvec->bv_len);
+                        memcpy(p, addr, len);
 
                 __free_page(bvec->bv_page);
-                p += bvec->bv_len;
+                p += len;
         }
 
+        bio_free_map_data(bmd);
         bio_put(bio);
 }
 
@@ -978,11 +982,21 @@ struct bio *bio_copy_kern(struct request_queue *q, void *data, unsigned int len,
         const int nr_pages = end - start;
         struct bio *bio;
         struct bio_vec *bvec;
+        struct bio_map_data *bmd;
         int i, ret;
+        struct sg_iovec iov;
+
+        iov.iov_base = data;
+        iov.iov_len = len;
+
+        bmd = bio_alloc_map_data(nr_pages, 1, gfp_mask);
+        if (!bmd)
+                return ERR_PTR(-ENOMEM);
 
+        ret = -ENOMEM;
         bio = bio_alloc(gfp_mask, nr_pages);
         if (!bio)
-                return ERR_PTR(-ENOMEM);
+                goto out_bmd;
 
         while (len) {
                 struct page *page;
@@ -1016,14 +1030,18 @@ struct bio *bio_copy_kern(struct request_queue *q, void *data, unsigned int len,
                 }
         }
 
-        bio->bi_private = data;
+        bio->bi_private = bmd;
         bio->bi_end_io = bio_copy_kern_endio;
+
+        bio_set_map_data(bmd, bio, &iov, 1);
         return bio;
 cleanup:
         bio_for_each_segment(bvec, bio, i)
                 __free_page(bvec->bv_page);
 
         bio_put(bio);
+out_bmd:
+        bio_free_map_data(bmd);
 
         return ERR_PTR(ret);
 }
diff --git a/fs/buffer.c b/fs/buffer.c
index 38653e36e225..ac78d4c19b3b 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2926,14 +2926,17 @@ int submit_bh(int rw, struct buffer_head * bh)
         BUG_ON(!buffer_mapped(bh));
         BUG_ON(!bh->b_end_io);
 
-        if (buffer_ordered(bh) && (rw == WRITE))
-                rw = WRITE_BARRIER;
+        /*
+         * Mask in barrier bit for a write (could be either a WRITE or a
+         * WRITE_SYNC
+         */
+        if (buffer_ordered(bh) && (rw & WRITE))
+                rw |= WRITE_BARRIER;
 
         /*
-         * Only clear out a write error when rewriting, should this
-         * include WRITE_SYNC as well?
+         * Only clear out a write error when rewriting
          */
-        if (test_set_buffer_req(bh) && (rw == WRITE || rw == WRITE_BARRIER))
+        if (test_set_buffer_req(bh) && (rw & WRITE))
                 clear_buffer_write_io_error(bh);
 
         /*
diff --git a/fs/compat.c b/fs/compat.c
index c9d1472e65c5..075d0509970d 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -792,8 +792,10 @@ static int compat_fillonedir(void *__buf, const char *name, int namlen,
         if (buf->result)
                 return -EINVAL;
         d_ino = ino;
-        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
+                buf->result = -EOVERFLOW;
                 return -EOVERFLOW;
+        }
         buf->result++;
         dirent = buf->dirent;
         if (!access_ok(VERIFY_WRITE, dirent,
@@ -862,8 +864,10 @@ static int compat_filldir(void *__buf, const char *name, int namlen,
         if (reclen > buf->count)
                 return -EINVAL;
         d_ino = ino;
-        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
+                buf->error = -EOVERFLOW;
                 return -EOVERFLOW;
+        }
         dirent = buf->previous;
         if (dirent) {
                 if (__put_user(offset, &dirent->d_off))
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index 7a8db78a91d2..8e93341f3e82 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -1311,16 +1311,18 @@ static int configfs_rmdir(struct inode *dir, struct dentry *dentry)
          * Ensure that no racing symlink() will make detach_prep() fail while
          * the new link is temporarily attached
          */
-        mutex_lock(&configfs_symlink_mutex);
-        spin_lock(&configfs_dirent_lock);
         do {
                 struct mutex *wait_mutex;
 
+                mutex_lock(&configfs_symlink_mutex);
+                spin_lock(&configfs_dirent_lock);
                 ret = configfs_detach_prep(dentry, &wait_mutex);
-                if (ret) {
+                if (ret)
                         configfs_detach_rollback(dentry);
-                        spin_unlock(&configfs_dirent_lock);
-                        mutex_unlock(&configfs_symlink_mutex);
+                spin_unlock(&configfs_dirent_lock);
+                mutex_unlock(&configfs_symlink_mutex);
+
+                if (ret) {
                         if (ret != -EAGAIN) {
                                 config_item_put(parent_item);
                                 return ret;
@@ -1329,13 +1331,8 @@ static int configfs_rmdir(struct inode *dir, struct dentry *dentry)
                         /* Wait until the racing operation terminates */
                         mutex_lock(wait_mutex);
                         mutex_unlock(wait_mutex);
-
-                        mutex_lock(&configfs_symlink_mutex);
-                        spin_lock(&configfs_dirent_lock);
                 }
         } while (ret == -EAGAIN);
-        spin_unlock(&configfs_dirent_lock);
-        mutex_unlock(&configfs_symlink_mutex);
 
         /* Get a working ref for the duration of this function */
         item = configfs_get_config_item(dentry);
diff --git a/fs/dcache.c b/fs/dcache.c
index 101663d15e9f..80e93956aced 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -1236,7 +1236,7 @@ struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)
  * If no entry exists with the exact case name, allocate new dentry with
  * the exact case, and return the spliced entry.
  */
-struct dentry *d_add_ci(struct inode *inode, struct dentry *dentry,
+struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode,
                         struct qstr *name)
 {
         int error;
diff --git a/fs/efs/namei.c b/fs/efs/namei.c
index 3a404e7fad53..291abb11e20e 100644
--- a/fs/efs/namei.c
+++ b/fs/efs/namei.c
@@ -74,8 +74,7 @@ struct dentry *efs_lookup(struct inode *dir, struct dentry *dentry, struct namei
         }
         unlock_kernel();
 
-        d_add(dentry, inode);
-        return NULL;
+        return d_splice_alias(inode, dentry);
 }
 
 static struct inode *efs_nfs_get_inode(struct super_block *sb, u64 ino,
diff --git a/fs/ntfs/namei.c b/fs/ntfs/namei.c
index e1781c8b1650..9e8a95be7a1e 100644
--- a/fs/ntfs/namei.c
+++ b/fs/ntfs/namei.c
@@ -174,7 +174,6 @@ static struct dentry *ntfs_lookup(struct inode *dir_ino, struct dentry *dent,
         // TODO: Consider moving this lot to a separate function! (AIA)
 handle_name:
    {
-        struct dentry *real_dent, *new_dent;
         MFT_RECORD *m;
         ntfs_attr_search_ctx *ctx;
         ntfs_inode *ni = NTFS_I(dent_inode);
@@ -255,93 +254,9 @@ handle_name:
         }
         nls_name.hash = full_name_hash(nls_name.name, nls_name.len);
 
-        /*
-         * Note: No need for dent->d_lock lock as i_mutex is held on the
-         * parent inode.
-         */
-
-        /* Does a dentry matching the nls_name exist already? */
-        real_dent = d_lookup(dent->d_parent, &nls_name);
-        /* If not, create it now. */
-        if (!real_dent) {
-                real_dent = d_alloc(dent->d_parent, &nls_name);
-                kfree(nls_name.name);
-                if (!real_dent) {
-                        err = -ENOMEM;
-                        goto err_out;
-                }
-                new_dent = d_splice_alias(dent_inode, real_dent);
-                if (new_dent)
-                        dput(real_dent);
-                else
-                        new_dent = real_dent;
-                ntfs_debug("Done.  (Created new dentry.)");
-                return new_dent;
-        }
+        dent = d_add_ci(dent, dent_inode, &nls_name);
         kfree(nls_name.name);
-        /* Matching dentry exists, check if it is negative. */
-        if (real_dent->d_inode) {
-                if (unlikely(real_dent->d_inode != dent_inode)) {
-                        /* This can happen because bad inodes are unhashed. */
-                        BUG_ON(!is_bad_inode(dent_inode));
-                        BUG_ON(!is_bad_inode(real_dent->d_inode));
-                }
-                /*
-                 * Already have the inode and the dentry attached, decrement
-                 * the reference count to balance the ntfs_iget() we did
-                 * earlier on.  We found the dentry using d_lookup() so it
-                 * cannot be disconnected and thus we do not need to worry
-                 * about any NFS/disconnectedness issues here.
-                 */
-                iput(dent_inode);
-                ntfs_debug("Done.  (Already had inode and dentry.)");
-                return real_dent;
-        }
-        /*
-         * Negative dentry: instantiate it unless the inode is a directory and
-         * has a 'disconnected' dentry (i.e. IS_ROOT and DCACHE_DISCONNECTED),
-         * in which case d_move() that in place of the found dentry.
-         */
-        if (!S_ISDIR(dent_inode->i_mode)) {
-                /* Not a directory; everything is easy. */
-                d_instantiate(real_dent, dent_inode);
-                ntfs_debug("Done.  (Already had negative file dentry.)");
-                return real_dent;
-        }
-        spin_lock(&dcache_lock);
-        if (list_empty(&dent_inode->i_dentry)) {
-                /*
-                 * Directory without a 'disconnected' dentry; we need to do
-                 * d_instantiate() by hand because it takes dcache_lock which
-                 * we already hold.
-                 */
-                list_add(&real_dent->d_alias, &dent_inode->i_dentry);
-                real_dent->d_inode = dent_inode;
-                spin_unlock(&dcache_lock);
-                security_d_instantiate(real_dent, dent_inode);
-                ntfs_debug("Done.  (Already had negative directory dentry.)");
-                return real_dent;
-        }
-        /*
-         * Directory with a 'disconnected' dentry; get a reference to the
-         * 'disconnected' dentry.
-         */
-        new_dent = list_entry(dent_inode->i_dentry.next, struct dentry,
-                        d_alias);
-        dget_locked(new_dent);
-        spin_unlock(&dcache_lock);
-        /* Do security vodoo. */
-        security_d_instantiate(real_dent, dent_inode);
-        /* Move new_dent in place of real_dent. */
-        d_move(new_dent, real_dent);
-        /* Balance the ntfs_iget() we did above. */
-        iput(dent_inode);
-        /* Throw away real_dent. */
-        dput(real_dent);
-        /* Use new_dent as the actual dentry. */
-        ntfs_debug("Done.  (Already had negative, disconnected directory "
-                        "dentry.)");
-        return new_dent;
+        return dent;
 
 eio_err_out:
         ntfs_error(vol->sb, "Illegal file name attribute. Run chkdsk.");
diff --git a/fs/ocfs2/cluster/netdebug.c b/fs/ocfs2/cluster/netdebug.c
index d8bfa0eb41b2..52276c02f710 100644
--- a/fs/ocfs2/cluster/netdebug.c
+++ b/fs/ocfs2/cluster/netdebug.c
@@ -138,20 +138,20 @@ static int nst_seq_show(struct seq_file *seq, void *v)
                            "  message id:   %d\n"
                            "  message type: %u\n"
                            "  message key:  0x%08x\n"
-                           "  sock acquiry: %lu.%lu\n"
-                           "  send start:   %lu.%lu\n"
-                           "  wait start:   %lu.%lu\n",
+                           "  sock acquiry: %lu.%ld\n"
+                           "  send start:   %lu.%ld\n"
+                           "  wait start:   %lu.%ld\n",
                            nst, (unsigned long)nst->st_task->pid,
                            (unsigned long)nst->st_task->tgid,
                            nst->st_task->comm, nst->st_node,
                            nst->st_sc, nst->st_id, nst->st_msg_type,
                            nst->st_msg_key,
                            nst->st_sock_time.tv_sec,
-                           (unsigned long)nst->st_sock_time.tv_usec,
+                           (long)nst->st_sock_time.tv_usec,
                            nst->st_send_time.tv_sec,
-                           (unsigned long)nst->st_send_time.tv_usec,
+                           (long)nst->st_send_time.tv_usec,
                            nst->st_status_time.tv_sec,
-                           nst->st_status_time.tv_usec);
+                           (long)nst->st_status_time.tv_usec);
         }
 
         spin_unlock(&o2net_debug_lock);
@@ -276,7 +276,7 @@ static void *sc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
         return sc; /* unused, just needs to be null when done */
 }
 
-#define TV_SEC_USEC(TV) TV.tv_sec, (unsigned long)TV.tv_usec
+#define TV_SEC_USEC(TV) TV.tv_sec, (long)TV.tv_usec
 
 static int sc_seq_show(struct seq_file *seq, void *v)
 {
@@ -309,12 +309,12 @@ static int sc_seq_show(struct seq_file *seq, void *v)
                            "  remote node:     %s\n"
                            "  page off:        %zu\n"
                            "  handshake ok:    %u\n"
-                           "  timer:           %lu.%lu\n"
-                           "  data ready:      %lu.%lu\n"
-                           "  advance start:   %lu.%lu\n"
-                           "  advance stop:    %lu.%lu\n"
-                           "  func start:      %lu.%lu\n"
-                           "  func stop:       %lu.%lu\n"
+                           "  timer:           %lu.%ld\n"
+                           "  data ready:      %lu.%ld\n"
+                           "  advance start:   %lu.%ld\n"
+                           "  advance stop:    %lu.%ld\n"
+                           "  func start:      %lu.%ld\n"
+                           "  func stop:       %lu.%ld\n"
                            "  func key:        %u\n"
                            "  func type:       %u\n",
                            sc,
diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index a27d61581bd6..2bcf706d9dd3 100644
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -143,8 +143,8 @@ static void o2net_sc_postpone_idle(struct o2net_sock_container *sc);
 static void o2net_sc_reset_idle_timer(struct o2net_sock_container *sc);
 
 #ifdef CONFIG_DEBUG_FS
-void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
-                    u32 msgkey, struct task_struct *task, u8 node)
+static void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
+                           u32 msgkey, struct task_struct *task, u8 node)
 {
         INIT_LIST_HEAD(&nst->st_net_debug_item);
         nst->st_task = task;
@@ -153,31 +153,61 @@ void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
         nst->st_node = node;
 }
 
-void o2net_set_nst_sock_time(struct o2net_send_tracking *nst)
+static void o2net_set_nst_sock_time(struct o2net_send_tracking *nst)
 {
         do_gettimeofday(&nst->st_sock_time);
 }
 
-void o2net_set_nst_send_time(struct o2net_send_tracking *nst)
+static void o2net_set_nst_send_time(struct o2net_send_tracking *nst)
 {
         do_gettimeofday(&nst->st_send_time);
 }
 
-void o2net_set_nst_status_time(struct o2net_send_tracking *nst)
+static void o2net_set_nst_status_time(struct o2net_send_tracking *nst)
 {
         do_gettimeofday(&nst->st_status_time);
 }
 
-void o2net_set_nst_sock_container(struct o2net_send_tracking *nst,
+static void o2net_set_nst_sock_container(struct o2net_send_tracking *nst,
                                          struct o2net_sock_container *sc)
 {
         nst->st_sc = sc;
 }
 
-void o2net_set_nst_msg_id(struct o2net_send_tracking *nst, u32 msg_id)
+static void o2net_set_nst_msg_id(struct o2net_send_tracking *nst, u32 msg_id)
 {
         nst->st_id = msg_id;
 }
+
+#else  /* CONFIG_DEBUG_FS */
+
+static inline void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
+                                  u32 msgkey, struct task_struct *task, u8 node)
+{
+}
+
+static inline void o2net_set_nst_sock_time(struct o2net_send_tracking *nst)
+{
+}
+
+static inline void o2net_set_nst_send_time(struct o2net_send_tracking *nst)
+{
+}
+
+static inline void o2net_set_nst_status_time(struct o2net_send_tracking *nst)
+{
+}
+
+static inline void o2net_set_nst_sock_container(struct o2net_send_tracking *nst,
+                                                struct o2net_sock_container *sc)
+{
+}
+
+static inline void o2net_set_nst_msg_id(struct o2net_send_tracking *nst,
+                                        u32 msg_id)
+{
+}
+
 #endif /* CONFIG_DEBUG_FS */
 
 static inline int o2net_reconnect_delay(void)
diff --git a/fs/ocfs2/cluster/tcp_internal.h b/fs/ocfs2/cluster/tcp_internal.h
index 18307ff81b77..8d58cfe410b1 100644
--- a/fs/ocfs2/cluster/tcp_internal.h
+++ b/fs/ocfs2/cluster/tcp_internal.h
@@ -224,42 +224,10 @@ struct o2net_send_tracking {
         struct timeval                  st_send_time;
         struct timeval                  st_status_time;
 };
-
-void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
-                    u32 msgkey, struct task_struct *task, u8 node);
-void o2net_set_nst_sock_time(struct o2net_send_tracking *nst);
-void o2net_set_nst_send_time(struct o2net_send_tracking *nst);
-void o2net_set_nst_status_time(struct o2net_send_tracking *nst);
-void o2net_set_nst_sock_container(struct o2net_send_tracking *nst,
-                                  struct o2net_sock_container *sc);
-void o2net_set_nst_msg_id(struct o2net_send_tracking *nst, u32 msg_id);
-
 #else
 struct o2net_send_tracking {
         u32     dummy;
 };
-
-static inline void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
-                                  u32 msgkey, struct task_struct *task, u8 node)
-{
-}
-static inline void o2net_set_nst_sock_time(struct o2net_send_tracking *nst)
-{
-}
-static inline void o2net_set_nst_send_time(struct o2net_send_tracking *nst)
-{
-}
-static inline void o2net_set_nst_status_time(struct o2net_send_tracking *nst)
-{
-}
-static inline void o2net_set_nst_sock_container(struct o2net_send_tracking *nst,
-                                                struct o2net_sock_container *sc)
-{
-}
-static inline void o2net_set_nst_msg_id(struct o2net_send_tracking *nst,
-                                        u32 msg_id)
-{
-}
 #endif  /* CONFIG_DEBUG_FS */
 
 #endif /* O2CLUSTER_TCP_INTERNAL_H */
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index 8a1875848080..9cce563fd627 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -1300,7 +1300,6 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
         di->i_size = cpu_to_le64(sb->s_blocksize);
         di->i_ctime = di->i_mtime = cpu_to_le64(dir->i_ctime.tv_sec);
         di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(dir->i_ctime.tv_nsec);
-        dir->i_blocks = ocfs2_inode_sector_count(dir);
 
         /*
          * This should never fail as our extent list is empty and all
@@ -1310,9 +1309,15 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
                                   NULL);
         if (ret) {
                 mlog_errno(ret);
-                goto out;
+                goto out_commit;
         }
 
+        /*
+         * Set i_blocks after the extent insert for the most up to
+         * date ip_clusters value.
+         */
+        dir->i_blocks = ocfs2_inode_sector_count(dir);
+
         ret = ocfs2_journal_dirty(handle, di_bh);
         if (ret) {
                 mlog_errno(ret);
@@ -1336,7 +1341,7 @@ static int ocfs2_expand_inline_dir(struct inode *dir, struct buffer_head *di_bh,
                                           len, 0, NULL);
                 if (ret) {
                         mlog_errno(ret);
-                        goto out;
+                        goto out_commit;
                 }
         }
 
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index 7a37240f7a31..c47bc2a809c2 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -1418,13 +1418,13 @@ int ocfs2_mark_dead_nodes(struct ocfs2_super *osb)
 {
         unsigned int node_num;
         int status, i;
+        u32 gen;
         struct buffer_head *bh = NULL;
         struct ocfs2_dinode *di;
 
         /* This is called with the super block cluster lock, so we
          * know that the slot map can't change underneath us. */
 
-        spin_lock(&osb->osb_lock);
         for (i = 0; i < osb->max_slots; i++) {
                 /* Read journal inode to get the recovery generation */
                 status = ocfs2_read_journal_inode(osb, i, &bh, NULL);
@@ -1433,23 +1433,31 @@ int ocfs2_mark_dead_nodes(struct ocfs2_super *osb)
                         goto bail;
                 }
                 di = (struct ocfs2_dinode *)bh->b_data;
-                osb->slot_recovery_generations[i] =
-                                        ocfs2_get_recovery_generation(di);
+                gen = ocfs2_get_recovery_generation(di);
                 brelse(bh);
                 bh = NULL;
 
+                spin_lock(&osb->osb_lock);
+                osb->slot_recovery_generations[i] = gen;
+
                 mlog(0, "Slot %u recovery generation is %u\n", i,
                      osb->slot_recovery_generations[i]);
 
-                if (i == osb->slot_num)
+                if (i == osb->slot_num) {
+                        spin_unlock(&osb->osb_lock);
                         continue;
+                }
 
                 status = ocfs2_slot_to_node_num_locked(osb, i, &node_num);
-                if (status == -ENOENT)
+                if (status == -ENOENT) {
+                        spin_unlock(&osb->osb_lock);
                         continue;
+                }
 
-                if (__ocfs2_recovery_map_test(osb, node_num))
+                if (__ocfs2_recovery_map_test(osb, node_num)) {
+                        spin_unlock(&osb->osb_lock);
                         continue;
+                }
                 spin_unlock(&osb->osb_lock);
 
                 /* Ok, we have a slot occupied by another node which
@@ -1465,10 +1473,7 @@ int ocfs2_mark_dead_nodes(struct ocfs2_super *osb)
                         mlog_errno(status);
                         goto bail;
                 }
-
-                spin_lock(&osb->osb_lock);
         }
-        spin_unlock(&osb->osb_lock);
 
         status = 0;
 bail:
diff --git a/fs/ocfs2/stackglue.c b/fs/ocfs2/stackglue.c
index 10e149ae5e3a..07f348b8d721 100644
--- a/fs/ocfs2/stackglue.c
+++ b/fs/ocfs2/stackglue.c
@@ -97,13 +97,14 @@ static int ocfs2_stack_driver_request(const char *stack_name,
                 goto out;
         }
 
-        /* Ok, the stack is pinned */
-        p->sp_count++;
         active_stack = p;
-
         rc = 0;
 
 out:
+        /* If we found it, pin it */
+        if (!rc)
+                active_stack->sp_count++;
+
         spin_unlock(&ocfs2_stack_lock);
         return rc;
 }
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 4fb81e9c94e3..bca0f81eb687 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -330,6 +330,7 @@ retry:
                 spin_lock(&proc_inum_lock);
                 ida_remove(&proc_inum_ida, i);
                 spin_unlock(&proc_inum_lock);
+                return 0;
         }
         return PROC_DYNAMIC_FIRST + i;
 }
diff --git a/fs/readdir.c b/fs/readdir.c
index 4e026e5407fb..93a7559bbfd8 100644
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -80,8 +80,10 @@ static int fillonedir(void * __buf, const char * name, int namlen, loff_t offset
         if (buf->result)
                 return -EINVAL;
         d_ino = ino;
-        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
+                buf->result = -EOVERFLOW;
                 return -EOVERFLOW;
+        }
         buf->result++;
         dirent = buf->dirent;
         if (!access_ok(VERIFY_WRITE, dirent,
@@ -155,8 +157,10 @@ static int filldir(void * __buf, const char * name, int namlen, loff_t offset,
         if (reclen > buf->count)
                 return -EINVAL;
         d_ino = ino;
-        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+        if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
+                buf->error = -EOVERFLOW;
                 return -EOVERFLOW;
+        }
         dirent = buf->previous;
         if (dirent) {
                 if (__put_user(offset, &dirent->d_off))
diff --git a/fs/seq_file.c b/fs/seq_file.c
index 5d54205e486b..bd20f7f5a933 100644
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -108,9 +108,9 @@ ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
                         goto Done;
         }
         /* we need at least one record in buffer */
+        pos = m->index;
+        p = m->op->start(m, &pos);
         while (1) {
-                pos = m->index;
-                p = m->op->start(m, &pos);
                 err = PTR_ERR(p);
                 if (!p || IS_ERR(p))
                         break;
@@ -119,6 +119,11 @@ ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
                         break;
                 if (unlikely(err))
                         m->count = 0;
+                if (unlikely(!m->count)) {
+                        p = m->op->next(m, p, &pos);
+                        m->index = pos;
+                        continue;
+                }
                 if (m->count < m->size)
                         goto Fill;
                 m->op->stop(m, p);
@@ -128,6 +133,8 @@ ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
                         goto Enomem;
                 m->count = 0;
                 m->version = 0;
+                pos = m->index;
+                p = m->op->start(m, &pos);
         }
         m->op->stop(m, p);
         m->count = 0;
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 5f60363b9343..5311c1acdd40 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -475,6 +475,7 @@ const struct file_operations xfs_invis_file_operations = {
 const struct file_operations xfs_dir_file_operations = {
         .read           = generic_read_dir,
         .readdir        = xfs_file_readdir,
+        .llseek         = generic_file_llseek,
         .unlocked_ioctl = xfs_file_ioctl,
 #ifdef CONFIG_COMPAT
         .compat_ioctl   = xfs_file_compat_ioctl,
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 91bcd979242c..095d271f3434 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -355,7 +355,7 @@ xfs_vn_ci_lookup(
         /* else case-insensitive match... */
         dname.name = ci_name.name;
         dname.len = ci_name.len;
-        dentry = d_add_ci(VFS_I(ip), dentry, &dname);
+        dentry = d_add_ci(dentry, VFS_I(ip), &dname);
         kmem_free(ci_name.name);
         return dentry;
 }