Merge branch 'master' of git+ssh://galak@master.kernel.org/pub/scm/linux/kernel/git/galak/powerpc

46 files changed, 707 insertions, 495 deletions

diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
index 5250c428fc..ef33865491 100644
--- a/fs/9p/v9fs.c
+++ b/fs/9p/v9fs.c
@@ -66,7 +66,7 @@ static match_table_t tokens = {
         {Opt_afid, "afid=%u"},
         {Opt_rfdno, "rfdno=%u"},
         {Opt_wfdno, "wfdno=%u"},
-        {Opt_debug, "debug=%u"},
+        {Opt_debug, "debug=%x"},
         {Opt_name, "name=%s"},
         {Opt_remotename, "aname=%s"},
         {Opt_unix, "proto=unix"},
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 1b117a4412..c2eac2a50b 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -938,6 +938,11 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                 kfree(elf_interpreter);
         } else {
                 elf_entry = loc->elf_ex.e_entry;
+                if (BAD_ADDR(elf_entry)) {
+                        send_sig(SIGSEGV, current, 0);
+                        retval = -ENOEXEC; /* Nobody gets to see this, but.. */
+                        goto out_free_dentry;
+                }
         }
 
         kfree(elf_phdata);
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 217323b0c8..b41e8b3796 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -1048,13 +1048,14 @@ CIFSSMBRead(const int xid, struct cifsTconInfo *tcon,
                         cifs_small_buf_release(iov[0].iov_base);
                 else if(resp_buf_type == CIFS_LARGE_BUFFER)
                         cifs_buf_release(iov[0].iov_base);
-        } else /* return buffer to caller to free */ /* BB FIXME how do we tell caller if it is not a large buffer */ {
-                *buf = iov[0].iov_base;
+        } else if(resp_buf_type != CIFS_NO_BUFFER) {
+                /* return buffer to caller to free */ 
+                *buf = iov[0].iov_base;         
                 if(resp_buf_type == CIFS_SMALL_BUFFER)
                         *pbuf_type = CIFS_SMALL_BUFFER;
                 else if(resp_buf_type == CIFS_LARGE_BUFFER)
                         *pbuf_type = CIFS_LARGE_BUFFER;
-        }
+        } /* else no valid buffer on return - leave as null */
 
         /* Note: On -EAGAIN error only caller can retry on handle based calls
                 since file handle passed in no longer valid */
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index e488603fb1..ef5ae6f93c 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -1795,10 +1795,10 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                            conjunction with 52K kvec constraint on arch with 4K
                            page size  */
 
-                if(cifs_sb->rsize < PAGE_CACHE_SIZE) {
-                        cifs_sb->rsize = PAGE_CACHE_SIZE; 
-                        /* Windows ME does this */
-                        cFYI(1,("Attempt to set readsize for mount to less than one page (4096)"));
+                if(cifs_sb->rsize < 2048) {
+                        cifs_sb->rsize = 2048; 
+                        /* Windows ME may prefer this */
+                        cFYI(1,("readsize set to minimum 2048"));
                 }
                 cifs_sb->mnt_uid = volume_info.linux_uid;
                 cifs_sb->mnt_gid = volume_info.linux_gid;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index d17c97d07c..675bd25682 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1442,13 +1442,15 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
                                          &bytes_read, &smb_read_data,
                                          &buf_type);
                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
-                        if (copy_to_user(current_offset, 
-                                         smb_read_data + 4 /* RFC1001 hdr */
-                                         + le16_to_cpu(pSMBr->DataOffset), 
-                                         bytes_read)) {
-                                rc = -EFAULT;
-                        }
                         if (smb_read_data) {
+                                if (copy_to_user(current_offset,
+                                                smb_read_data +
+                                                4 /* RFC1001 length field */ +
+                                                le16_to_cpu(pSMBr->DataOffset),
+                                                bytes_read)) {
+                                        rc = -EFAULT;
+                                }
+
                                 if(buf_type == CIFS_SMALL_BUFFER)
                                         cifs_small_buf_release(smb_read_data);
                                 else if(buf_type == CIFS_LARGE_BUFFER)
diff --git a/fs/compat.c b/fs/compat.c
index 70c5af4cc2..5333c7d742 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -1751,11 +1751,15 @@ asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
         ret = compat_core_sys_select(n, inp, outp, exp, &timeout);
 
         if (tvp) {
+                struct compat_timeval rtv;
+
                 if (current->personality & STICKY_TIMEOUTS)
                         goto sticky;
-                tv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
-                tv.tv_sec = timeout;
-                if (copy_to_user(tvp, &tv, sizeof(tv))) {
+                rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
+                rtv.tv_sec = timeout;
+                if (compat_timeval_compare(&rtv, &tv) >= 0)
+                        rtv = tv;
+                if (copy_to_user(tvp, &rtv, sizeof(rtv))) {
 sticky:
                         /*
                          * If an application puts its timeval in read-only
@@ -1822,13 +1826,17 @@ asmlinkage long compat_sys_pselect7(int n, compat_ulong_t __user *inp,
         } while (!ret && !timeout && tsp && (ts.tv_sec || ts.tv_nsec));
 
         if (tsp && !(current->personality & STICKY_TIMEOUTS)) {
-                ts.tv_sec += timeout / HZ;
-                ts.tv_nsec += (timeout % HZ) * (1000000000/HZ);
-                if (ts.tv_nsec >= 1000000000) {
-                        ts.tv_sec++;
-                        ts.tv_nsec -= 1000000000;
+                struct compat_timespec rts;
+
+                rts.tv_sec = timeout / HZ;
+                rts.tv_nsec = (timeout % HZ) * (NSEC_PER_SEC/HZ);
+                if (rts.tv_nsec >= NSEC_PER_SEC) {
+                        rts.tv_sec++;
+                        rts.tv_nsec -= NSEC_PER_SEC;
                 }
-                (void)copy_to_user(tsp, &ts, sizeof(ts));
+                if (compat_timespec_compare(&rts, &ts) >= 0)
+                        rts = ts;
+                copy_to_user(tsp, &rts, sizeof(rts));
         }
 
         if (ret == -ERESTARTNOHAND) {
@@ -1918,12 +1926,17 @@ asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
 
         if (tsp && timeout >= 0) {
+                struct compat_timespec rts;
+
                 if (current->personality & STICKY_TIMEOUTS)
                         goto sticky;
                 /* Yes, we know it's actually an s64, but it's also positive. */
-                ts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) * 1000;
-                ts.tv_sec = timeout;
-                if (copy_to_user(tsp, &ts, sizeof(ts))) {
+                rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
+                                        1000;
+                rts.tv_sec = timeout;
+                if (compat_timespec_compare(&rts, &ts) >= 0)
+                        rts = ts;
+                if (copy_to_user(tsp, &rts, sizeof(rts))) {
 sticky:
                         /*
                          * If an application puts its timeval in read-only
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index 057e60217f..537ac70edf 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -2531,18 +2531,9 @@ static int rtc_ioctl(unsigned fd, unsigned cmd, unsigned long arg)
                 val32 = kval;
                 return put_user(val32, (unsigned int __user *)arg);
         case RTC_IRQP_SET32:
+                return sys_ioctl(fd, RTC_IRQP_SET, arg); 
         case RTC_EPOCH_SET32:
-                ret = get_user(val32, (unsigned int __user *)arg);
-                if (ret)
-                        return ret;
-                kval = val32;
-
-                set_fs(KERNEL_DS);
-                ret = sys_ioctl(fd, (cmd == RTC_IRQP_SET32) ?
-                                RTC_IRQP_SET : RTC_EPOCH_SET,
-                                (unsigned long)&kval);
-                set_fs(oldfs);
-                return ret;
+                return sys_ioctl(fd, RTC_EPOCH_SET, arg);
         default:
                 /* unreached */
                 return -ENOIOCTLCMD;
diff --git a/fs/exec.c b/fs/exec.c
index 055378d251..0e1c95074d 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1403,7 +1403,7 @@ static void zap_threads (struct mm_struct *mm)
                 do_each_thread(g,p) {
                         if (mm == p->mm && p != tsk &&
                             p->ptrace && p->parent->mm == mm) {
-                                __ptrace_unlink(p);
+                                __ptrace_detach(p, 0);
                         }
                 } while_each_thread(g,p);
                 write_unlock_irq(&tasklist_lock);
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index a2ca3107d4..86ae8e93ad 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -792,18 +792,20 @@ ext2_xattr_delete_inode(struct inode *inode)
                 ext2_free_blocks(inode, EXT2_I(inode)->i_file_acl, 1);
                 get_bh(bh);
                 bforget(bh);
+                unlock_buffer(bh);
         } else {
                 HDR(bh)->h_refcount = cpu_to_le32(
                         le32_to_cpu(HDR(bh)->h_refcount) - 1);
                 if (ce)
                         mb_cache_entry_release(ce);
+                ea_bdebug(bh, "refcount now=%d",
+                        le32_to_cpu(HDR(bh)->h_refcount));
+                unlock_buffer(bh);
                 mark_buffer_dirty(bh);
                 if (IS_SYNC(inode))
                         sync_dirty_buffer(bh);
                 DQUOT_FREE_BLOCK(inode, 1);
         }
-        ea_bdebug(bh, "refcount now=%d", le32_to_cpu(HDR(bh)->h_refcount) - 1);
-        unlock_buffer(bh);
         EXT2_I(inode)->i_file_acl = 0;
 
 cleanup:
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index f556a0d5c0..0c9a2ee54c 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -66,6 +66,12 @@ static void restore_sigs(sigset_t *oldset)
         sigprocmask(SIG_SETMASK, oldset, NULL);
 }
 
+/*
+ * Reset request, so that it can be reused
+ *
+ * The caller must be _very_ careful to make sure, that it is holding
+ * the only reference to req
+ */
 void fuse_reset_request(struct fuse_req *req)
 {
         int preallocated = req->preallocated;
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 296351615b..6f05379b0a 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -116,9 +116,14 @@ int fuse_open_common(struct inode *inode, struct file *file, int isdir)
 /* Special case for failed iget in CREATE */
 static void fuse_release_end(struct fuse_conn *fc, struct fuse_req *req)
 {
-        u64 nodeid = req->in.h.nodeid;
-        fuse_reset_request(req);
-        fuse_send_forget(fc, req, nodeid, 1);
+        /* If called from end_io_requests(), req has more than one
+           reference and fuse_reset_request() cannot work */
+        if (fc->connected) {
+                u64 nodeid = req->in.h.nodeid;
+                fuse_reset_request(req);
+                fuse_send_forget(fc, req, nodeid, 1);
+        } else
+                fuse_put_request(fc, req);
 }
 
 void fuse_send_release(struct fuse_conn *fc, struct fuse_file *ff,
diff --git a/fs/jbd/checkpoint.c b/fs/jbd/checkpoint.c
index e6265a0b56..543ed543d1 100644
--- a/fs/jbd/checkpoint.c
+++ b/fs/jbd/checkpoint.c
@@ -24,75 +24,29 @@
 #include <linux/slab.h>
 
 /*
- * Unlink a buffer from a transaction checkpoint list.
+ * Unlink a buffer from a transaction.
  *
  * Called with j_list_lock held.
  */
 
-static void __buffer_unlink_first(struct journal_head *jh)
+static inline void __buffer_unlink(struct journal_head *jh)
 {
         transaction_t *transaction;
 
         transaction = jh->b_cp_transaction;
+        jh->b_cp_transaction = NULL;
 
         jh->b_cpnext->b_cpprev = jh->b_cpprev;
         jh->b_cpprev->b_cpnext = jh->b_cpnext;
-        if (transaction->t_checkpoint_list == jh) {
+        if (transaction->t_checkpoint_list == jh)
                 transaction->t_checkpoint_list = jh->b_cpnext;
-                if (transaction->t_checkpoint_list == jh)
-                        transaction->t_checkpoint_list = NULL;
-        }
-}
-
-/*
- * Unlink a buffer from a transaction checkpoint(io) list.
- *
- * Called with j_list_lock held.
- */
-
-static inline void __buffer_unlink(struct journal_head *jh)
-{
-        transaction_t *transaction;
-
-        transaction = jh->b_cp_transaction;
-
-        __buffer_unlink_first(jh);
-        if (transaction->t_checkpoint_io_list == jh) {
-                transaction->t_checkpoint_io_list = jh->b_cpnext;
-                if (transaction->t_checkpoint_io_list == jh)
-                        transaction->t_checkpoint_io_list = NULL;
-        }
-}
-
-/*
- * Move a buffer from the checkpoint list to the checkpoint io list
- *
- * Called with j_list_lock held
- */
-
-static inline void __buffer_relink_io(struct journal_head *jh)
-{
-        transaction_t *transaction;
-
-        transaction = jh->b_cp_transaction;
-        __buffer_unlink_first(jh);
-
-        if (!transaction->t_checkpoint_io_list) {
-                jh->b_cpnext = jh->b_cpprev = jh;
-        } else {
-                jh->b_cpnext = transaction->t_checkpoint_io_list;
-                jh->b_cpprev = transaction->t_checkpoint_io_list->b_cpprev;
-                jh->b_cpprev->b_cpnext = jh;
-                jh->b_cpnext->b_cpprev = jh;
-        }
-        transaction->t_checkpoint_io_list = jh;
+        if (transaction->t_checkpoint_list == jh)
+                transaction->t_checkpoint_list = NULL;
 }
 
 /*
  * Try to release a checkpointed buffer from its transaction.
- * Returns 1 if we released it and 2 if we also released the
- * whole transaction.
- *
+ * Returns 1 if we released it.
  * Requires j_list_lock
  * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
  */
@@ -103,11 +57,12 @@ static int __try_to_free_cp_buf(struct journal_head *jh)
 
         if (jh->b_jlist == BJ_None && !buffer_locked(bh) && !buffer_dirty(bh)) {
                 JBUFFER_TRACE(jh, "remove from checkpoint list");
-                ret = __journal_remove_checkpoint(jh) + 1;
+                __journal_remove_checkpoint(jh);
                 jbd_unlock_bh_state(bh);
                 journal_remove_journal_head(bh);
                 BUFFER_TRACE(bh, "release");
                 __brelse(bh);
+                ret = 1;
         } else {
                 jbd_unlock_bh_state(bh);
         }
@@ -162,53 +117,83 @@ static void jbd_sync_bh(journal_t *journal, struct buffer_head *bh)
 }
 
 /*
- * Clean up transaction's list of buffers submitted for io.
- * We wait for any pending IO to complete and remove any clean
- * buffers. Note that we take the buffers in the opposite ordering
- * from the one in which they were submitted for IO.
+ * Clean up a transaction's checkpoint list.
+ *
+ * We wait for any pending IO to complete and make sure any clean
+ * buffers are removed from the transaction.
+ *
+ * Return 1 if we performed any actions which might have destroyed the
+ * checkpoint.  (journal_remove_checkpoint() deletes the transaction when
+ * the last checkpoint buffer is cleansed)
  *
  * Called with j_list_lock held.
  */
-
-static void __wait_cp_io(journal_t *journal, transaction_t *transaction)
+static int __cleanup_transaction(journal_t *journal, transaction_t *transaction)
 {
-        struct journal_head *jh;
+        struct journal_head *jh, *next_jh, *last_jh;
         struct buffer_head *bh;
-        tid_t this_tid;
-        int released = 0;
-
-        this_tid = transaction->t_tid;
-restart:
-        /* Didn't somebody clean up the transaction in the meanwhile */
-        if (journal->j_checkpoint_transactions != transaction ||
-                transaction->t_tid != this_tid)
-                return;
-        while (!released && transaction->t_checkpoint_io_list) {
-                jh = transaction->t_checkpoint_io_list;
+        int ret = 0;
+
+        assert_spin_locked(&journal->j_list_lock);
+        jh = transaction->t_checkpoint_list;
+        if (!jh)
+                return 0;
+
+        last_jh = jh->b_cpprev;
+        next_jh = jh;
+        do {
+                jh = next_jh;
                 bh = jh2bh(jh);
-                if (!jbd_trylock_bh_state(bh)) {
-                        jbd_sync_bh(journal, bh);
-                        spin_lock(&journal->j_list_lock);
-                        goto restart;
-                }
                 if (buffer_locked(bh)) {
                         atomic_inc(&bh->b_count);
                         spin_unlock(&journal->j_list_lock);
-                        jbd_unlock_bh_state(bh);
                         wait_on_buffer(bh);
                         /* the journal_head may have gone by now */
                         BUFFER_TRACE(bh, "brelse");
                         __brelse(bh);
-                        spin_lock(&journal->j_list_lock);
-                        goto restart;
+                        goto out_return_1;
                 }
+
                 /*
-                 * Now in whatever state the buffer currently is, we know that
-                 * it has been written out and so we can drop it from the list
+                 * This is foul
                  */
-                released = __journal_remove_checkpoint(jh);
-                jbd_unlock_bh_state(bh);
-        }
+                if (!jbd_trylock_bh_state(bh)) {
+                        jbd_sync_bh(journal, bh);
+                        goto out_return_1;
+                }
+
+                if (jh->b_transaction != NULL) {
+                        transaction_t *t = jh->b_transaction;
+                        tid_t tid = t->t_tid;
+
+                        spin_unlock(&journal->j_list_lock);
+                        jbd_unlock_bh_state(bh);
+                        log_start_commit(journal, tid);
+                        log_wait_commit(journal, tid);
+                        goto out_return_1;
+                }
+
+                /*
+                 * AKPM: I think the buffer_jbddirty test is redundant - it
+                 * shouldn't have NULL b_transaction?
+                 */
+                next_jh = jh->b_cpnext;
+                if (!buffer_dirty(bh) && !buffer_jbddirty(bh)) {
+                        BUFFER_TRACE(bh, "remove from checkpoint");
+                        __journal_remove_checkpoint(jh);
+                        jbd_unlock_bh_state(bh);
+                        journal_remove_journal_head(bh);
+                        __brelse(bh);
+                        ret = 1;
+                } else {
+                        jbd_unlock_bh_state(bh);
+                }
+        } while (jh != last_jh);
+
+        return ret;
+out_return_1:
+        spin_lock(&journal->j_list_lock);
+        return 1;
 }
 
 #define NR_BATCH        64
@@ -218,7 +203,9 @@ __flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count)
 {
         int i;
 
+        spin_unlock(&journal->j_list_lock);
         ll_rw_block(SWRITE, *batch_count, bhs);
+        spin_lock(&journal->j_list_lock);
         for (i = 0; i < *batch_count; i++) {
                 struct buffer_head *bh = bhs[i];
                 clear_buffer_jwrite(bh);
@@ -234,46 +221,19 @@ __flush_batch(journal_t *journal, struct buffer_head **bhs, int *batch_count)
  * Return 1 if something happened which requires us to abort the current
  * scan of the checkpoint list.  
  *
- * Called with j_list_lock held and drops it if 1 is returned
+ * Called with j_list_lock held.
  * Called under jbd_lock_bh_state(jh2bh(jh)), and drops it
  */
-static int __process_buffer(journal_t *journal, struct journal_head *jh,
-                        struct buffer_head **bhs, int *batch_count)
+static int __flush_buffer(journal_t *journal, struct journal_head *jh,
+                        struct buffer_head **bhs, int *batch_count,
+                        int *drop_count)
 {
         struct buffer_head *bh = jh2bh(jh);
         int ret = 0;
 
-        if (buffer_locked(bh)) {
-                get_bh(bh);
-                spin_unlock(&journal->j_list_lock);
-                jbd_unlock_bh_state(bh);
-                wait_on_buffer(bh);
-                /* the journal_head may have gone by now */
-                BUFFER_TRACE(bh, "brelse");
-                put_bh(bh);
-                ret = 1;
-        }
-        else if (jh->b_transaction != NULL) {
-                transaction_t *t = jh->b_transaction;
-                tid_t tid = t->t_tid;
+        if (buffer_dirty(bh) && !buffer_locked(bh) && jh->b_jlist == BJ_None) {
+                J_ASSERT_JH(jh, jh->b_transaction == NULL);
 
-                spin_unlock(&journal->j_list_lock);
-                jbd_unlock_bh_state(bh);
-                log_start_commit(journal, tid);
-                log_wait_commit(journal, tid);
-                ret = 1;
-        }
-        else if (!buffer_dirty(bh)) {
-                J_ASSERT_JH(jh, !buffer_jbddirty(bh));
-                BUFFER_TRACE(bh, "remove from checkpoint");
-                __journal_remove_checkpoint(jh);
-                spin_unlock(&journal->j_list_lock);
-                jbd_unlock_bh_state(bh);
-                journal_remove_journal_head(bh);
-                put_bh(bh);
-                ret = 1;
-        }
-        else {
                 /*
                  * Important: we are about to write the buffer, and
                  * possibly block, while still holding the journal lock.
@@ -286,30 +246,45 @@ static int __process_buffer(journal_t *journal, struct journal_head *jh,
                 J_ASSERT_BH(bh, !buffer_jwrite(bh));
                 set_buffer_jwrite(bh);
                 bhs[*batch_count] = bh;
-                __buffer_relink_io(jh);
                 jbd_unlock_bh_state(bh);
                 (*batch_count)++;
                 if (*batch_count == NR_BATCH) {
-                        spin_unlock(&journal->j_list_lock);
                         __flush_batch(journal, bhs, batch_count);
                         ret = 1;
                 }
+        } else {
+                int last_buffer = 0;
+                if (jh->b_cpnext == jh) {
+                        /* We may be about to drop the transaction.  Tell the
+                         * caller that the lists have changed.
+                         */
+                        last_buffer = 1;
+                }
+                if (__try_to_free_cp_buf(jh)) {
+                        (*drop_count)++;
+                        ret = last_buffer;
+                }
         }
         return ret;
 }
 
 /*
- * Perform an actual checkpoint. We take the first transaction on the
- * list of transactions to be checkpointed and send all its buffers
- * to disk. We submit larger chunks of data at once.
+ * Perform an actual checkpoint.  We don't write out only enough to
+ * satisfy the current blocked requests: rather we submit a reasonably
+ * sized chunk of the outstanding data to disk at once for
+ * efficiency.  __log_wait_for_space() will retry if we didn't free enough.
  * 
+ * However, we _do_ take into account the amount requested so that once
+ * the IO has been queued, we can return as soon as enough of it has
+ * completed to disk.
+ *
  * The journal should be locked before calling this function.
  */
 int log_do_checkpoint(journal_t *journal)
 {
-        transaction_t *transaction;
-        tid_t this_tid;
         int result;
+        int batch_count = 0;
+        struct buffer_head *bhs[NR_BATCH];
 
         jbd_debug(1, "Start checkpoint\n");
 
@@ -324,70 +299,79 @@ int log_do_checkpoint(journal_t *journal)
                 return result;
 
         /*
-         * OK, we need to start writing disk blocks.  Take one transaction
-         * and write it.
+         * OK, we need to start writing disk blocks.  Try to free up a
+         * quarter of the log in a single checkpoint if we can.
          */
-        spin_lock(&journal->j_list_lock);
-        if (!journal->j_checkpoint_transactions)
-                goto out;
-        transaction = journal->j_checkpoint_transactions;
-        this_tid = transaction->t_tid;
-restart:
         /*
-         * If someone cleaned up this transaction while we slept, we're
-         * done (maybe it's a new transaction, but it fell at the same
-         * address).
+         * AKPM: check this code.  I had a feeling a while back that it
+         * degenerates into a busy loop at unmount time.
          */
-        if (journal->j_checkpoint_transactions == transaction &&
-                        transaction->t_tid == this_tid) {
-                int batch_count = 0;
-                struct buffer_head *bhs[NR_BATCH];
-                struct journal_head *jh;
-                int retry = 0;
-
-                while (!retry && transaction->t_checkpoint_list) {
+        spin_lock(&journal->j_list_lock);
+        while (journal->j_checkpoint_transactions) {
+                transaction_t *transaction;
+                struct journal_head *jh, *last_jh, *next_jh;
+                int drop_count = 0;
+                int cleanup_ret, retry = 0;
+                tid_t this_tid;
+
+                transaction = journal->j_checkpoint_transactions;
+                this_tid = transaction->t_tid;
+                jh = transaction->t_checkpoint_list;
+                last_jh = jh->b_cpprev;
+                next_jh = jh;
+                do {
                         struct buffer_head *bh;
 
-                        jh = transaction->t_checkpoint_list;
+                        jh = next_jh;
+                        next_jh = jh->b_cpnext;
                         bh = jh2bh(jh);
                         if (!jbd_trylock_bh_state(bh)) {
                                 jbd_sync_bh(journal, bh);
+                                spin_lock(&journal->j_list_lock);
                                 retry = 1;
                                 break;
                         }
-                        retry = __process_buffer(journal, jh, bhs,
-                                                &batch_count);
-                        if (!retry &&
-                            lock_need_resched(&journal->j_list_lock)) {
-                                spin_unlock(&journal->j_list_lock);
+                        retry = __flush_buffer(journal, jh, bhs, &batch_count, &drop_count);
+                        if (cond_resched_lock(&journal->j_list_lock)) {
                                 retry = 1;
                                 break;
                         }
-                }
+                } while (jh != last_jh && !retry);
 
                 if (batch_count) {
-                        if (!retry) {
-                                spin_unlock(&journal->j_list_lock);
-                                retry = 1;
-                        }
                         __flush_batch(journal, bhs, &batch_count);
+                        retry = 1;
                 }
 
-                if (retry) {
-                        spin_lock(&journal->j_list_lock);
-                        goto restart;
-                }
                 /*
-                 * Now we have cleaned up the first transaction's checkpoint
-                 * list.  Let's clean up the second one.
+                 * If someone cleaned up this transaction while we slept, we're
+                 * done
+                 */
+                if (journal->j_checkpoint_transactions != transaction)
+                        break;
+                if (retry)
+                        continue;
+                /*
+                 * Maybe it's a new transaction, but it fell at the same
+                 * address
                  */
-                __wait_cp_io(journal, transaction);
+                if (transaction->t_tid != this_tid)
+                        continue;
+                /*
+                 * We have walked the whole transaction list without
+                 * finding anything to write to disk.  We had better be
+                 * able to make some progress or we are in trouble.
+                 */
+                cleanup_ret = __cleanup_transaction(journal, transaction);
+                J_ASSERT(drop_count != 0 || cleanup_ret != 0);
+                if (journal->j_checkpoint_transactions != transaction)
+                        break;
         }
-out:
         spin_unlock(&journal->j_list_lock);
         result = cleanup_journal_tail(journal);
         if (result < 0)
                 return result;
+
         return 0;
 }
 
@@ -472,91 +456,52 @@ int cleanup_journal_tail(journal_t *journal)
 /* Checkpoint list management */
 
 /*
- * journal_clean_one_cp_list
- *
- * Find all the written-back checkpoint buffers in the given list and release them.
- *
- * Called with the journal locked.
- * Called with j_list_lock held.
- * Returns number of bufers reaped (for debug)
- */
-
-static int journal_clean_one_cp_list(struct journal_head *jh, int *released)
-{
-        struct journal_head *last_jh;
-        struct journal_head *next_jh = jh;
-        int ret, freed = 0;
-
-        *released = 0;
-        if (!jh)
-                return 0;
-
-        last_jh = jh->b_cpprev;
-        do {
-                jh = next_jh;
-                next_jh = jh->b_cpnext;
-                /* Use trylock because of the ranking */
-                if (jbd_trylock_bh_state(jh2bh(jh))) {
-                        ret = __try_to_free_cp_buf(jh);
-                        if (ret) {
-                                freed++;
-                                if (ret == 2) {
-                                        *released = 1;
-                                        return freed;
-                                }
-                        }
-                }
-                /*
-                 * This function only frees up some memory if possible so we
-                 * dont have an obligation to finish processing. Bail out if
-                 * preemption requested:
-                 */
-                if (need_resched())
-                        return freed;
-        } while (jh != last_jh);
-
-        return freed;
-}
-
-/*
  * journal_clean_checkpoint_list
  *
  * Find all the written-back checkpoint buffers in the journal and release them.
  *
  * Called with the journal locked.
  * Called with j_list_lock held.
- * Returns number of buffers reaped (for debug)
+ * Returns number of bufers reaped (for debug)
  */
 
 int __journal_clean_checkpoint_list(journal_t *journal)
 {
         transaction_t *transaction, *last_transaction, *next_transaction;
-        int ret = 0, released;
+        int ret = 0;
 
         transaction = journal->j_checkpoint_transactions;
-        if (!transaction)
+        if (transaction == 0)
                 goto out;
 
         last_transaction = transaction->t_cpprev;
         next_transaction = transaction;
         do {
+                struct journal_head *jh;
+
                 transaction = next_transaction;
                 next_transaction = transaction->t_cpnext;
-                ret += journal_clean_one_cp_list(transaction->
-                                t_checkpoint_list, &released);
-                if (need_resched())
-                        goto out;
-                if (released)
-                        continue;
-                /*
-                 * It is essential that we are as careful as in the case of
-                 * t_checkpoint_list with removing the buffer from the list as
-                 * we can possibly see not yet submitted buffers on io_list
-                 */
-                ret += journal_clean_one_cp_list(transaction->
-                                t_checkpoint_io_list, &released);
-                if (need_resched())
-                        goto out;
+                jh = transaction->t_checkpoint_list;
+                if (jh) {
+                        struct journal_head *last_jh = jh->b_cpprev;
+                        struct journal_head *next_jh = jh;
+
+                        do {
+                                jh = next_jh;
+                                next_jh = jh->b_cpnext;
+                                /* Use trylock because of the ranknig */
+                                if (jbd_trylock_bh_state(jh2bh(jh)))
+                                        ret += __try_to_free_cp_buf(jh);
+                                /*
+                                 * This function only frees up some memory
+                                 * if possible so we dont have an obligation
+                                 * to finish processing. Bail out if preemption
+                                 * requested:
+                                 */
+                                if (need_resched())
+                                        goto out;
+                        } while (jh != last_jh);
+                }
         } while (transaction != last_transaction);
 out:
         return ret;
@@ -571,22 +516,18 @@ out:
  * buffer updates committed in that transaction have safely been stored
  * elsewhere on disk.  To achieve this, all of the buffers in a
  * transaction need to be maintained on the transaction's checkpoint
- * lists until they have been rewritten, at which point this function is
+ * list until they have been rewritten, at which point this function is
  * called to remove the buffer from the existing transaction's
- * checkpoint lists.
- *
- * The function returns 1 if it frees the transaction, 0 otherwise.
+ * checkpoint list.
  *
  * This function is called with the journal locked.
  * This function is called with j_list_lock held.
- * This function is called with jbd_lock_bh_state(jh2bh(jh))
  */
 
-int __journal_remove_checkpoint(struct journal_head *jh)
+void __journal_remove_checkpoint(struct journal_head *jh)
 {
         transaction_t *transaction;
         journal_t *journal;
-        int ret = 0;
 
         JBUFFER_TRACE(jh, "entry");
 
@@ -597,10 +538,8 @@ int __journal_remove_checkpoint(struct journal_head *jh)
         journal = transaction->t_journal;
 
         __buffer_unlink(jh);
-        jh->b_cp_transaction = NULL;
 
-        if (transaction->t_checkpoint_list != NULL ||
-            transaction->t_checkpoint_io_list != NULL)
+        if (transaction->t_checkpoint_list != NULL)
                 goto out;
         JBUFFER_TRACE(jh, "transaction has no more buffers");
 
@@ -626,10 +565,8 @@ int __journal_remove_checkpoint(struct journal_head *jh)
         /* Just in case anybody was waiting for more transactions to be
            checkpointed... */
         wake_up(&journal->j_wait_logspace);
-        ret = 1;
 out:
         JBUFFER_TRACE(jh, "exit");
-        return ret;
 }
 
 /*
@@ -691,7 +628,6 @@ void __journal_drop_transaction(journal_t *journal, transaction_t *transaction)
         J_ASSERT(transaction->t_shadow_list == NULL);
         J_ASSERT(transaction->t_log_list == NULL);
         J_ASSERT(transaction->t_checkpoint_list == NULL);
-        J_ASSERT(transaction->t_checkpoint_io_list == NULL);
         J_ASSERT(transaction->t_updates == 0);
         J_ASSERT(journal->j_committing_transaction != transaction);
         J_ASSERT(journal->j_running_transaction != transaction);
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
index 29e62d98ba..002ad2bbc7 100644
--- a/fs/jbd/commit.c
+++ b/fs/jbd/commit.c
@@ -829,8 +829,7 @@ restart_loop:
         journal->j_committing_transaction = NULL;
         spin_unlock(&journal->j_state_lock);
 
-        if (commit_transaction->t_checkpoint_list == NULL &&
-            commit_transaction->t_checkpoint_io_list == NULL) {
+        if (commit_transaction->t_checkpoint_list == NULL) {
                 __journal_drop_transaction(journal, commit_transaction);
         } else {
                 if (journal->j_checkpoint_transactions == NULL) {
diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c
index 3eaf6e7010..da6354baa0 100644
--- a/fs/lockd/clntlock.c
+++ b/fs/lockd/clntlock.c
@@ -111,9 +111,10 @@ long nlmclnt_block(struct nlm_rqst *req, long timeout)
 /*
  * The server lockd has called us back to tell us the lock was granted
  */
-u32
-nlmclnt_grant(struct nlm_lock *lock)
+u32 nlmclnt_grant(const struct sockaddr_in *addr, const struct nlm_lock *lock)
 {
+        const struct file_lock *fl = &lock->fl;
+        const struct nfs_fh *fh = &lock->fh;
         struct nlm_wait *block;
         u32 res = nlm_lck_denied;
 
@@ -122,14 +123,20 @@ nlmclnt_grant(struct nlm_lock *lock)
          * Warning: must not use cookie to match it!
          */
         list_for_each_entry(block, &nlm_blocked, b_list) {
-                if (nlm_compare_locks(block->b_lock, &lock->fl)) {
-                        /* Alright, we found a lock. Set the return status
-                         * and wake up the caller
-                         */
-                        block->b_status = NLM_LCK_GRANTED;
-                        wake_up(&block->b_wait);
-                        res = nlm_granted;
-                }
+                struct file_lock *fl_blocked = block->b_lock;
+
+                if (!nlm_compare_locks(fl_blocked, fl))
+                        continue;
+                if (!nlm_cmp_addr(&block->b_host->h_addr, addr))
+                        continue;
+                if (nfs_compare_fh(NFS_FH(fl_blocked->fl_file->f_dentry->d_inode) ,fh) != 0)
+                        continue;
+                /* Alright, we found a lock. Set the return status
+                 * and wake up the caller
+                 */
+                block->b_status = NLM_LCK_GRANTED;
+                wake_up(&block->b_wait);
+                res = nlm_granted;
         }
         return res;
 }
diff --git a/fs/lockd/svc4proc.c b/fs/lockd/svc4proc.c
index 4063095d84..b10f913aa0 100644
--- a/fs/lockd/svc4proc.c
+++ b/fs/lockd/svc4proc.c
@@ -228,7 +228,7 @@ nlm4svc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
         resp->cookie = argp->cookie;
 
         dprintk("lockd: GRANTED       called\n");
-        resp->status = nlmclnt_grant(&argp->lock);
+        resp->status = nlmclnt_grant(&rqstp->rq_addr, &argp->lock);
         dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
         return rpc_success;
 }
diff --git a/fs/lockd/svcproc.c b/fs/lockd/svcproc.c
index 3bc437e0cf..35681d9cf1 100644
--- a/fs/lockd/svcproc.c
+++ b/fs/lockd/svcproc.c
@@ -256,7 +256,7 @@ nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
         resp->cookie = argp->cookie;
 
         dprintk("lockd: GRANTED       called\n");
-        resp->status = nlmclnt_grant(&argp->lock);
+        resp->status = nlmclnt_grant(&rqstp->rq_addr, &argp->lock);
         dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
         return rpc_success;
 }
diff --git a/fs/namei.c b/fs/namei.c
index e28de846c5..557dcf395c 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2224,13 +2224,17 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de
  * and other special files.  --ADM
  */
 asmlinkage long sys_linkat(int olddfd, const char __user *oldname,
-                           int newdfd, const char __user *newname)
+                           int newdfd, const char __user *newname,
+                           int flags)
 {
         struct dentry *new_dentry;
         struct nameidata nd, old_nd;
         int error;
         char * to;
 
+        if (flags != 0)
+                return -EINVAL;
+
         to = getname(newname);
         if (IS_ERR(to))
                 return PTR_ERR(to);
@@ -2263,7 +2267,7 @@ exit:
 
 asmlinkage long sys_link(const char __user *oldname, const char __user *newname)
 {
-        return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname);
+        return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
 }
 
 /*
diff --git a/fs/ntfs/ChangeLog b/fs/ntfs/ChangeLog
index 02f44094bd..9d8ffa89e2 100644
--- a/fs/ntfs/ChangeLog
+++ b/fs/ntfs/ChangeLog
@@ -1,9 +1,9 @@
 ToDo/Notes:
         - Find and fix bugs.
         - The only places in the kernel where a file is resized are
-          ntfs_file_write*() and ntfs_truncate() for both of which i_sem is
+          ntfs_file_write*() and ntfs_truncate() for both of which i_mutex is
           held.  Just have to be careful in read-/writepage and other helpers
-          not running under i_sem that we play nice...  Also need to be careful
+          not running under i_mutex that we play nice.  Also need to be careful
           with initialized_size extension in ntfs_file_write*() and writepage.
           UPDATE: The only things that need to be checked are the compressed
           write and the other attribute resize/write cases like index
@@ -19,6 +19,24 @@ ToDo/Notes:
         - Enable the code for setting the NT4 compatibility flag when we start
           making NTFS 1.2 specific modifications.
 
+2.1.26 - Minor bug fixes and updates.
+
+        - Fix a potential overflow in file.c where a cast to s64 was missing in
+          a left shift of a page index.
+        - The struct inode has had its i_sem semaphore changed to a mutex named
+          i_mutex.
+        - We have struct kmem_cache now so use it instead of the typedef
+          kmem_cache_t.  (Pekka Enberg)
+        - Implement support for sector sizes above 512 bytes (up to the maximum
+          supported by NTFS which is 4096 bytes).
+        - Do more detailed reporting of why we cannot mount read-write by
+          special casing the VOLUME_MODIFIED_BY_CHKDSK flag.
+        - Miscellaneous updates to layout.h.
+        - Cope with attribute list attribute having invalid flags.  Windows
+          copes with this and even chkdsk does not detect or fix this so we
+          have to cope with it, too.  Thanks to Pawel Kot for reporting the
+          problem.
+
 2.1.25 - (Almost) fully implement write(2) and truncate(2).
 
         - Change ntfs_map_runlist_nolock(), ntfs_attr_find_vcn_nolock() and
@@ -373,7 +391,7 @@ ToDo/Notes:
           single one of them had an mst error.  (Thanks to Ken MacFerrin for
           the bug report.)
         - Fix error handling in fs/ntfs/quota.c::ntfs_mark_quotas_out_of_date()
-          where we failed to release i_sem on the $Quota/$Q attribute inode.
+          where we failed to release i_mutex on the $Quota/$Q attribute inode.
         - Fix bug in handling of bad inodes in fs/ntfs/namei.c::ntfs_lookup().
         - Add mapping of unmapped buffers to all remaining code paths, i.e.
           fs/ntfs/aops.c::ntfs_write_mst_block(), mft.c::ntfs_sync_mft_mirror(),
@@ -874,7 +892,7 @@ ToDo/Notes:
           clusters. (Philipp Thomas)
         - attrib.c::load_attribute_list(): Fix bug when initialized_size is a
           multiple of the block_size but not the cluster size. (Szabolcs
-          Szakacsits <szaka@sienet.hu>)
+          Szakacsits)
 
 2.1.2 - Important bug fixes aleviating the hangs in statfs.
 
@@ -884,7 +902,7 @@ ToDo/Notes:
 
         - Add handling for initialized_size != data_size in compressed files.
         - Reduce function local stack usage from 0x3d4 bytes to just noise in
-          fs/ntfs/upcase.c. (Randy Dunlap <rdunlap@xenotime.net>)
+          fs/ntfs/upcase.c. (Randy Dunlap)
         - Remove compiler warnings for newer gcc.
         - Pages are no longer kmapped by mm/filemap.c::generic_file_write()
           around calls to ->{prepare,commit}_write.  Adapt NTFS appropriately
@@ -1201,11 +1219,11 @@ ToDo/Notes:
           the kernel. We probably want a kernel generic init_address_space()
           function...
         - Drop BKL from ntfs_readdir() after consultation with Al Viro. The
-          only caller of ->readdir() is vfs_readdir() which holds i_sem during
-          the call, and i_sem is sufficient protection against changes in the
-          directory inode (including ->i_size).
+          only caller of ->readdir() is vfs_readdir() which holds i_mutex
+          during the call, and i_mutex is sufficient protection against changes
+          in the directory inode (including ->i_size).
         - Use generic_file_llseek() for directories (as opposed to
-          default_llseek()) as this downs i_sem instead of the BKL which is
+          default_llseek()) as this downs i_mutex instead of the BKL which is
           what we now need for exclusion against ->f_pos changes considering we
           no longer take the BKL in ntfs_readdir().
 
diff --git a/fs/ntfs/Makefile b/fs/ntfs/Makefile
index d0d45d1c85..d95fac7fde 100644
--- a/fs/ntfs/Makefile
+++ b/fs/ntfs/Makefile
@@ -6,7 +6,7 @@ ntfs-objs := aops.o attrib.o collate.o compress.o debug.o dir.o file.o \
              index.o inode.o mft.o mst.o namei.o runlist.o super.o sysctl.o \
              unistr.o upcase.o
 
-EXTRA_CFLAGS = -DNTFS_VERSION=\"2.1.25\"
+EXTRA_CFLAGS = -DNTFS_VERSION=\"2.1.26\"
 
 ifeq ($(CONFIG_NTFS_DEBUG),y)
 EXTRA_CFLAGS += -DDEBUG
diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index 1c0a431587..7e361da770 100644
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -2,7 +2,7 @@
  * aops.c - NTFS kernel address space operations and page cache handling.
  *          Part of the Linux-NTFS project.
  *
- * Copyright (c) 2001-2005 Anton Altaparmakov
+ * Copyright (c) 2001-2006 Anton Altaparmakov
  * Copyright (c) 2002 Richard Russon
  *
  * This program/include file is free software; you can redistribute it and/or
@@ -200,8 +200,8 @@ static int ntfs_read_block(struct page *page)
         /* $MFT/$DATA must have its complete runlist in memory at all times. */
         BUG_ON(!ni->runlist.rl && !ni->mft_no && !NInoAttr(ni));
 
-        blocksize_bits = VFS_I(ni)->i_blkbits;
-        blocksize = 1 << blocksize_bits;
+        blocksize = vol->sb->s_blocksize;
+        blocksize_bits = vol->sb->s_blocksize_bits;
 
         if (!page_has_buffers(page)) {
                 create_empty_buffers(page, blocksize, 0);
@@ -569,10 +569,8 @@ static int ntfs_write_block(struct page *page, struct writeback_control *wbc)
 
         BUG_ON(!NInoNonResident(ni));
         BUG_ON(NInoMstProtected(ni));
-
-        blocksize_bits = vi->i_blkbits;
-        blocksize = 1 << blocksize_bits;
-
+        blocksize = vol->sb->s_blocksize;
+        blocksize_bits = vol->sb->s_blocksize_bits;
         if (!page_has_buffers(page)) {
                 BUG_ON(!PageUptodate(page));
                 create_empty_buffers(page, blocksize,
@@ -949,8 +947,8 @@ static int ntfs_write_mst_block(struct page *page,
          */
         BUG_ON(!(is_mft || S_ISDIR(vi->i_mode) ||
                         (NInoAttr(ni) && ni->type == AT_INDEX_ALLOCATION)));
-        bh_size_bits = vi->i_blkbits;
-        bh_size = 1 << bh_size_bits;
+        bh_size = vol->sb->s_blocksize;
+        bh_size_bits = vol->sb->s_blocksize_bits;
         max_bhs = PAGE_CACHE_SIZE / bh_size;
         BUG_ON(!max_bhs);
         BUG_ON(max_bhs > MAX_BUF_PER_PAGE);
@@ -1596,7 +1594,7 @@ void mark_ntfs_record_dirty(struct page *page, const unsigned int ofs) {
 
         BUG_ON(!PageUptodate(page));
         end = ofs + ni->itype.index.block_size;
-        bh_size = 1 << VFS_I(ni)->i_blkbits;
+        bh_size = VFS_I(ni)->i_sb->s_blocksize;
         spin_lock(&mapping->private_lock);
         if (unlikely(!page_has_buffers(page))) {
                 spin_unlock(&mapping->private_lock);
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index fb413d3d86..5027d3d1b3 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -1,7 +1,7 @@
 /*
  * file.c - NTFS kernel file operations.  Part of the Linux-NTFS project.
  *
- * Copyright (c) 2001-2005 Anton Altaparmakov
+ * Copyright (c) 2001-2006 Anton Altaparmakov
  *
  * This program/include file is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as published
@@ -248,7 +248,7 @@ do_non_resident_extend:
                  * enough to make ntfs_writepage() work.
                  */
                 write_lock_irqsave(&ni->size_lock, flags);
-                ni->initialized_size = (index + 1) << PAGE_CACHE_SHIFT;
+                ni->initialized_size = (s64)(index + 1) << PAGE_CACHE_SHIFT;
                 if (ni->initialized_size > new_init_size)
                         ni->initialized_size = new_init_size;
                 write_unlock_irqrestore(&ni->size_lock, flags);
@@ -529,8 +529,8 @@ static int ntfs_prepare_pages_for_non_resident_write(struct page **pages,
                         "index 0x%lx, nr_pages 0x%x, pos 0x%llx, bytes 0x%zx.",
                         vi->i_ino, ni->type, pages[0]->index, nr_pages,
                         (long long)pos, bytes);
-        blocksize_bits = vi->i_blkbits;
-        blocksize = 1 << blocksize_bits;
+        blocksize = vol->sb->s_blocksize;
+        blocksize_bits = vol->sb->s_blocksize_bits;
         u = 0;
         do {
                 struct page *page = pages[u];
@@ -1525,7 +1525,7 @@ static inline int ntfs_commit_pages_after_non_resident_write(
 
         vi = pages[0]->mapping->host;
         ni = NTFS_I(vi);
-        blocksize = 1 << vi->i_blkbits;
+        blocksize = vi->i_sb->s_blocksize;
         end = pos + bytes;
         u = 0;
         do {
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index ea1bd3feea..55263b7de9 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -677,13 +677,28 @@ static int ntfs_read_locked_inode(struct inode *vi)
                 ntfs_debug("Attribute list found in inode 0x%lx.", vi->i_ino);
                 NInoSetAttrList(ni);
                 a = ctx->attr;
-                if (a->flags & ATTR_IS_ENCRYPTED ||
-                                a->flags & ATTR_COMPRESSION_MASK ||
-                                a->flags & ATTR_IS_SPARSE) {
+                if (a->flags & ATTR_COMPRESSION_MASK) {
                         ntfs_error(vi->i_sb, "Attribute list attribute is "
-                                        "compressed/encrypted/sparse.");
+                                        "compressed.");
                         goto unm_err_out;
                 }
+                if (a->flags & ATTR_IS_ENCRYPTED ||
+                                a->flags & ATTR_IS_SPARSE) {
+                        if (a->non_resident) {
+                                ntfs_error(vi->i_sb, "Non-resident attribute "
+                                                "list attribute is encrypted/"
+                                                "sparse.");
+                                goto unm_err_out;
+                        }
+                        ntfs_warning(vi->i_sb, "Resident attribute list "
+                                        "attribute in inode 0x%lx is marked "
+                                        "encrypted/sparse which is not true.  "
+                                        "However, Windows allows this and "
+                                        "chkdsk does not detect or correct it "
+                                        "so we will just ignore the invalid "
+                                        "flags and pretend they are not set.",
+                                        vi->i_ino);
+                }
                 /* Now allocate memory for the attribute list. */
                 ni->attr_list_size = (u32)ntfs_attr_size(a);
                 ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size);
@@ -1809,19 +1824,33 @@ int ntfs_read_inode_mount(struct inode *vi)
         } else /* if (!err) */ {
                 ATTR_LIST_ENTRY *al_entry, *next_al_entry;
                 u8 *al_end;
+                static const char *es = "  Not allowed.  $MFT is corrupt.  "
+                                "You should run chkdsk.";
 
                 ntfs_debug("Attribute list attribute found in $MFT.");
                 NInoSetAttrList(ni);
                 a = ctx->attr;
-                if (a->flags & ATTR_IS_ENCRYPTED ||
-                                a->flags & ATTR_COMPRESSION_MASK ||
-                                a->flags & ATTR_IS_SPARSE) {
+                if (a->flags & ATTR_COMPRESSION_MASK) {
                         ntfs_error(sb, "Attribute list attribute is "
-                                        "compressed/encrypted/sparse. Not "
-                                        "allowed. $MFT is corrupt. You should "
-                                        "run chkdsk.");
+                                        "compressed.%s", es);
                         goto put_err_out;
                 }
+                if (a->flags & ATTR_IS_ENCRYPTED ||
+                                a->flags & ATTR_IS_SPARSE) {
+                        if (a->non_resident) {
+                                ntfs_error(sb, "Non-resident attribute list "
+                                                "attribute is encrypted/"
+                                                "sparse.%s", es);
+                                goto put_err_out;
+                        }
+                        ntfs_warning(sb, "Resident attribute list attribute "
+                                        "in $MFT system file is marked "
+                                        "encrypted/sparse which is not true.  "
+                                        "However, Windows allows this and "
+                                        "chkdsk does not detect or correct it "
+                                        "so we will just ignore the invalid "
+                                        "flags and pretend they are not set.");
+                }
                 /* Now allocate memory for the attribute list. */
                 ni->attr_list_size = (u32)ntfs_attr_size(a);
                 ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size);
diff --git a/fs/ntfs/layout.h b/fs/ntfs/layout.h
index f5678d5d79..bb408d4dcb 100644
--- a/fs/ntfs/layout.h
+++ b/fs/ntfs/layout.h
@@ -838,15 +838,19 @@ enum {
            F_A_DEVICE, F_A_DIRECTORY, F_A_SPARSE_FILE, F_A_REPARSE_POINT,
            F_A_COMPRESSED, and F_A_ENCRYPTED and preserves the rest.  This mask
            is used to to obtain all flags that are valid for setting. */
-
         /*
-         * The following flags are only present in the FILE_NAME attribute (in
+         * The following flag is only present in the FILE_NAME attribute (in
          * the field file_attributes).
          */
         FILE_ATTR_DUP_FILE_NAME_INDEX_PRESENT   = const_cpu_to_le32(0x10000000),
         /* Note, this is a copy of the corresponding bit from the mft record,
            telling us whether this is a directory or not, i.e. whether it has
            an index root attribute or not. */
+        /*
+         * The following flag is present both in the STANDARD_INFORMATION
+         * attribute and in the FILE_NAME attribute (in the field
+         * file_attributes).
+         */
         FILE_ATTR_DUP_VIEW_INDEX_PRESENT        = const_cpu_to_le32(0x20000000),
         /* Note, this is a copy of the corresponding bit from the mft record,
            telling us whether this file has a view index present (eg. object id
@@ -1071,9 +1075,15 @@ typedef struct {
                                            modified. */
 /* 20*/ sle64 last_access_time;         /* Time this mft record was last
                                            accessed. */
-/* 28*/ sle64 allocated_size;           /* Byte size of allocated space for the
-                                           data attribute. NOTE: Is a multiple
-                                           of the cluster size. */
+/* 28*/ sle64 allocated_size;           /* Byte size of on-disk allocated space
+                                           for the data attribute.  So for
+                                           normal $DATA, this is the
+                                           allocated_size from the unnamed
+                                           $DATA attribute and for compressed
+                                           and/or sparse $DATA, this is the
+                                           compressed_size from the unnamed
+                                           $DATA attribute.  NOTE: This is a
+                                           multiple of the cluster size. */
 /* 30*/ sle64 data_size;                /* Byte size of actual data in data
                                            attribute. */
 /* 38*/ FILE_ATTR_FLAGS file_attributes;        /* Flags describing the file. */
@@ -1904,12 +1914,13 @@ enum {
         VOLUME_DELETE_USN_UNDERWAY      = const_cpu_to_le16(0x0010),
         VOLUME_REPAIR_OBJECT_ID         = const_cpu_to_le16(0x0020),
 
+        VOLUME_CHKDSK_UNDERWAY          = const_cpu_to_le16(0x4000),
         VOLUME_MODIFIED_BY_CHKDSK       = const_cpu_to_le16(0x8000),
 
-        VOLUME_FLAGS_MASK               = const_cpu_to_le16(0x803f),
+        VOLUME_FLAGS_MASK               = const_cpu_to_le16(0xc03f),
 
         /* To make our life easier when checking if we must mount read-only. */
-        VOLUME_MUST_MOUNT_RO_MASK       = const_cpu_to_le16(0x8027),
+        VOLUME_MUST_MOUNT_RO_MASK       = const_cpu_to_le16(0xc027),
 } __attribute__ ((__packed__));
 
 typedef le16 VOLUME_FLAGS;
diff --git a/fs/ntfs/mft.c b/fs/ntfs/mft.c
index 0c65cbb8c5..6499aafc22 100644
--- a/fs/ntfs/mft.c
+++ b/fs/ntfs/mft.c
@@ -1,7 +1,7 @@
 /**
  * mft.c - NTFS kernel mft record operations. Part of the Linux-NTFS project.
  *
- * Copyright (c) 2001-2005 Anton Altaparmakov
+ * Copyright (c) 2001-2006 Anton Altaparmakov
  * Copyright (c) 2002 Richard Russon
  *
  * This program/include file is free software; you can redistribute it and/or
@@ -473,7 +473,7 @@ int ntfs_sync_mft_mirror(ntfs_volume *vol, const unsigned long mft_no,
         runlist_element *rl;
         unsigned int block_start, block_end, m_start, m_end, page_ofs;
         int i_bhs, nr_bhs, err = 0;
-        unsigned char blocksize_bits = vol->mftmirr_ino->i_blkbits;
+        unsigned char blocksize_bits = vol->sb->s_blocksize_bits;
 
         ntfs_debug("Entering for inode 0x%lx.", mft_no);
         BUG_ON(!max_bhs);
@@ -672,8 +672,8 @@ int write_mft_record_nolock(ntfs_inode *ni, MFT_RECORD *m, int sync)
 {
         ntfs_volume *vol = ni->vol;
         struct page *page = ni->page;
-        unsigned char blocksize_bits = vol->mft_ino->i_blkbits;
-        unsigned int blocksize = 1 << blocksize_bits;
+        unsigned int blocksize = vol->sb->s_blocksize;
+        unsigned char blocksize_bits = vol->sb->s_blocksize_bits;
         int max_bhs = vol->mft_record_size / blocksize;
         struct buffer_head *bhs[max_bhs];
         struct buffer_head *bh, *head;
diff --git a/fs/ntfs/ntfs.h b/fs/ntfs/ntfs.h
index 446b501411..653d2a5c48 100644
--- a/fs/ntfs/ntfs.h
+++ b/fs/ntfs/ntfs.h
@@ -50,11 +50,11 @@ typedef enum {
 /* Global variables. */
 
 /* Slab caches (from super.c). */
-extern kmem_cache_t *ntfs_name_cache;
-extern kmem_cache_t *ntfs_inode_cache;
-extern kmem_cache_t *ntfs_big_inode_cache;
-extern kmem_cache_t *ntfs_attr_ctx_cache;
-extern kmem_cache_t *ntfs_index_ctx_cache;
+extern struct kmem_cache *ntfs_name_cache;
+extern struct kmem_cache *ntfs_inode_cache;
+extern struct kmem_cache *ntfs_big_inode_cache;
+extern struct kmem_cache *ntfs_attr_ctx_cache;
+extern struct kmem_cache *ntfs_index_ctx_cache;
 
 /* The various operations structs defined throughout the driver files. */
 extern struct address_space_operations ntfs_aops;
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index c3a3f1a831..368a8ec106 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -1,7 +1,7 @@
 /*
  * super.c - NTFS kernel super block handling. Part of the Linux-NTFS project.
  *
- * Copyright (c) 2001-2005 Anton Altaparmakov
+ * Copyright (c) 2001-2006 Anton Altaparmakov
  * Copyright (c) 2001,2002 Richard Russon
  *
  * This program/include file is free software; you can redistribute it and/or
@@ -22,6 +22,7 @@
 
 #include <linux/stddef.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/spinlock.h>
 #include <linux/blkdev.h>       /* For bdev_hardsect_size(). */
@@ -471,9 +472,16 @@ static int ntfs_remount(struct super_block *sb, int *flags, char *opt)
                         ntfs_error(sb, "Volume is dirty and read-only%s", es);
                         return -EROFS;
                 }
+                if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
+                        ntfs_error(sb, "Volume has been modified by chkdsk "
+                                        "and is read-only%s", es);
+                        return -EROFS;
+                }
                 if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
-                        ntfs_error(sb, "Volume has unsupported flags set and "
-                                        "is read-only%s", es);
+                        ntfs_error(sb, "Volume has unsupported flags set "
+                                        "(0x%x) and is read-only%s",
+                                        (unsigned)le16_to_cpu(vol->vol_flags),
+                                        es);
                         return -EROFS;
                 }
                 if (ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
@@ -641,7 +649,7 @@ static struct buffer_head *read_ntfs_boot_sector(struct super_block *sb,
 {
         const char *read_err_str = "Unable to read %s boot sector.";
         struct buffer_head *bh_primary, *bh_backup;
-        long nr_blocks = NTFS_SB(sb)->nr_blocks;
+        sector_t nr_blocks = NTFS_SB(sb)->nr_blocks;
 
         /* Try to read primary boot sector. */
         if ((bh_primary = sb_bread(sb, 0))) {
@@ -688,13 +696,18 @@ hotfix_primary_boot_sector:
                 /*
                  * If we managed to read sector zero and the volume is not
                  * read-only, copy the found, valid backup boot sector to the
-                 * primary boot sector.
+                 * primary boot sector.  Note we only copy the actual boot
+                 * sector structure, not the actual whole device sector as that
+                 * may be bigger and would potentially damage the $Boot system
+                 * file (FIXME: Would be nice to know if the backup boot sector
+                 * on a large sector device contains the whole boot loader or
+                 * just the first 512 bytes).
                  */
                 if (!(sb->s_flags & MS_RDONLY)) {
                         ntfs_warning(sb, "Hot-fix: Recovering invalid primary "
                                         "boot sector from backup copy.");
                         memcpy(bh_primary->b_data, bh_backup->b_data,
-                                        sb->s_blocksize);
+                                        NTFS_BLOCK_SIZE);
                         mark_buffer_dirty(bh_primary);
                         sync_dirty_buffer(bh_primary);
                         if (buffer_uptodate(bh_primary)) {
@@ -733,9 +746,13 @@ static BOOL parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
                         vol->sector_size);
         ntfs_debug("vol->sector_size_bits = %i (0x%x)", vol->sector_size_bits,
                         vol->sector_size_bits);
-        if (vol->sector_size != vol->sb->s_blocksize)
-                ntfs_warning(vol->sb, "The boot sector indicates a sector size "
-                                "different from the device sector size.");
+        if (vol->sector_size < vol->sb->s_blocksize) {
+                ntfs_error(vol->sb, "Sector size (%i) is smaller than the "
+                                "device block size (%lu).  This is not "
+                                "supported.  Sorry.", vol->sector_size,
+                                vol->sb->s_blocksize);
+                return FALSE;
+        }
         ntfs_debug("sectors_per_cluster = 0x%x", b->bpb.sectors_per_cluster);
         sectors_per_cluster_bits = ffs(b->bpb.sectors_per_cluster) - 1;
         ntfs_debug("sectors_per_cluster_bits = 0x%x",
@@ -748,16 +765,11 @@ static BOOL parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
         ntfs_debug("vol->cluster_size = %i (0x%x)", vol->cluster_size,
                         vol->cluster_size);
         ntfs_debug("vol->cluster_size_mask = 0x%x", vol->cluster_size_mask);
-        ntfs_debug("vol->cluster_size_bits = %i (0x%x)",
-                        vol->cluster_size_bits, vol->cluster_size_bits);
-        if (vol->sector_size > vol->cluster_size) {
-                ntfs_error(vol->sb, "Sector sizes above the cluster size are "
-                                "not supported.  Sorry.");
-                return FALSE;
-        }
-        if (vol->sb->s_blocksize > vol->cluster_size) {
-                ntfs_error(vol->sb, "Cluster sizes smaller than the device "
-                                "sector size are not supported.  Sorry.");
+        ntfs_debug("vol->cluster_size_bits = %i", vol->cluster_size_bits);
+        if (vol->cluster_size < vol->sector_size) {
+                ntfs_error(vol->sb, "Cluster size (%i) is smaller than the "
+                                "sector size (%i).  This is not supported.  "
+                                "Sorry.", vol->cluster_size, vol->sector_size);
                 return FALSE;
         }
         clusters_per_mft_record = b->clusters_per_mft_record;
@@ -786,11 +798,18 @@ static BOOL parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
          * we store $MFT/$DATA, the table of mft records in the page cache.
          */
         if (vol->mft_record_size > PAGE_CACHE_SIZE) {
-                ntfs_error(vol->sb, "Mft record size %i (0x%x) exceeds the "
-                                "page cache size on your system %lu (0x%lx).  "
+                ntfs_error(vol->sb, "Mft record size (%i) exceeds the "
+                                "PAGE_CACHE_SIZE on your system (%lu).  "
                                 "This is not supported.  Sorry.",
-                                vol->mft_record_size, vol->mft_record_size,
-                                PAGE_CACHE_SIZE, PAGE_CACHE_SIZE);
+                                vol->mft_record_size, PAGE_CACHE_SIZE);
+                return FALSE;
+        }
+        /* We cannot support mft record sizes below the sector size. */
+        if (vol->mft_record_size < vol->sector_size) {
+                ntfs_error(vol->sb, "Mft record size (%i) is smaller than the "
+                                "sector size (%i).  This is not supported.  "
+                                "Sorry.", vol->mft_record_size,
+                                vol->sector_size);
                 return FALSE;
         }
         clusters_per_index_record = b->clusters_per_index_record;
@@ -816,6 +835,14 @@ static BOOL parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
         ntfs_debug("vol->index_record_size_bits = %i (0x%x)",
                         vol->index_record_size_bits,
                         vol->index_record_size_bits);
+        /* We cannot support index record sizes below the sector size. */
+        if (vol->index_record_size < vol->sector_size) {
+                ntfs_error(vol->sb, "Index record size (%i) is smaller than "
+                                "the sector size (%i).  This is not "
+                                "supported.  Sorry.", vol->index_record_size,
+                                vol->sector_size);
+                return FALSE;
+        }
         /*
          * Get the size of the volume in clusters and check for 64-bit-ness.
          * Windows currently only uses 32 bits to save the clusters so we do
@@ -845,15 +872,18 @@ static BOOL parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
         }
         ll = sle64_to_cpu(b->mft_lcn);
         if (ll >= vol->nr_clusters) {
-                ntfs_error(vol->sb, "MFT LCN is beyond end of volume.  Weird.");
+                ntfs_error(vol->sb, "MFT LCN (%lli, 0x%llx) is beyond end of "
+                                "volume.  Weird.", (unsigned long long)ll,
+                                (unsigned long long)ll);
                 return FALSE;
         }
         vol->mft_lcn = ll;
         ntfs_debug("vol->mft_lcn = 0x%llx", (long long)vol->mft_lcn);
         ll = sle64_to_cpu(b->mftmirr_lcn);
         if (ll >= vol->nr_clusters) {
-                ntfs_error(vol->sb, "MFTMirr LCN is beyond end of volume.  "
-                                "Weird.");
+                ntfs_error(vol->sb, "MFTMirr LCN (%lli, 0x%llx) is beyond end "
+                                "of volume.  Weird.", (unsigned long long)ll,
+                                (unsigned long long)ll);
                 return FALSE;
         }
         vol->mftmirr_lcn = ll;
@@ -1822,11 +1852,24 @@ get_ctx_vol_failed:
         /* Make sure that no unsupported volume flags are set. */
         if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
                 static const char *es1a = "Volume is dirty";
-                static const char *es1b = "Volume has unsupported flags set";
-                static const char *es2 = ".  Run chkdsk and mount in Windows.";
-                const char *es1;
-                
-                es1 = vol->vol_flags & VOLUME_IS_DIRTY ? es1a : es1b;
+                static const char *es1b = "Volume has been modified by chkdsk";
+                static const char *es1c = "Volume has unsupported flags set";
+                static const char *es2a = ".  Run chkdsk and mount in Windows.";
+                static const char *es2b = ".  Mount in Windows.";
+                const char *es1, *es2;
+
+                es2 = es2a;
+                if (vol->vol_flags & VOLUME_IS_DIRTY)
+                        es1 = es1a;
+                else if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
+                        es1 = es1b;
+                        es2 = es2b;
+                } else {
+                        es1 = es1c;
+                        ntfs_warning(sb, "Unsupported volume flags 0x%x "
+                                        "encountered.",
+                                        (unsigned)le16_to_cpu(vol->vol_flags));
+                }
                 /* If a read-write mount, convert it to a read-only mount. */
                 if (!(sb->s_flags & MS_RDONLY)) {
                         if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
@@ -2685,7 +2728,7 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
         ntfs_volume *vol;
         struct buffer_head *bh;
         struct inode *tmp_ino;
-        int result;
+        int blocksize, result;
 
         ntfs_debug("Entering.");
 #ifndef NTFS_RW
@@ -2724,60 +2767,85 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
         if (!parse_options(vol, (char*)opt))
                 goto err_out_now;
 
+        /* We support sector sizes up to the PAGE_CACHE_SIZE. */
+        if (bdev_hardsect_size(sb->s_bdev) > PAGE_CACHE_SIZE) {
+                if (!silent)
+                        ntfs_error(sb, "Device has unsupported sector size "
+                                        "(%i).  The maximum supported sector "
+                                        "size on this architecture is %lu "
+                                        "bytes.",
+                                        bdev_hardsect_size(sb->s_bdev),
+                                        PAGE_CACHE_SIZE);
+                goto err_out_now;
+        }
         /*
-         * TODO: Fail safety check. In the future we should really be able to
-         * cope with this being the case, but for now just bail out.
+         * Setup the device access block size to NTFS_BLOCK_SIZE or the hard
+         * sector size, whichever is bigger.
          */
-        if (bdev_hardsect_size(sb->s_bdev) > NTFS_BLOCK_SIZE) {
+        blocksize = sb_min_blocksize(sb, NTFS_BLOCK_SIZE);
+        if (blocksize < NTFS_BLOCK_SIZE) {
                 if (!silent)
-                        ntfs_error(sb, "Device has unsupported hardsect_size.");
+                        ntfs_error(sb, "Unable to set device block size.");
                 goto err_out_now;
         }
-
-        /* Setup the device access block size to NTFS_BLOCK_SIZE. */
-        if (sb_set_blocksize(sb, NTFS_BLOCK_SIZE) != NTFS_BLOCK_SIZE) {
+        BUG_ON(blocksize != sb->s_blocksize);
+        ntfs_debug("Set device block size to %i bytes (block size bits %i).",
+                        blocksize, sb->s_blocksize_bits);
+        /* Determine the size of the device in units of block_size bytes. */
+        if (!i_size_read(sb->s_bdev->bd_inode)) {
                 if (!silent)
-                        ntfs_error(sb, "Unable to set block size.");
+                        ntfs_error(sb, "Unable to determine device size.");
                 goto err_out_now;
         }
-
-        /* Get the size of the device in units of NTFS_BLOCK_SIZE bytes. */
         vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
-                        NTFS_BLOCK_SIZE_BITS;
-
+                        sb->s_blocksize_bits;
         /* Read the boot sector and return unlocked buffer head to it. */
         if (!(bh = read_ntfs_boot_sector(sb, silent))) {
                 if (!silent)
                         ntfs_error(sb, "Not an NTFS volume.");
                 goto err_out_now;
         }
-
         /*
-         * Extract the data from the boot sector and setup the ntfs super block
+         * Extract the data from the boot sector and setup the ntfs volume
          * using it.
          */
         result = parse_ntfs_boot_sector(vol, (NTFS_BOOT_SECTOR*)bh->b_data);
-
-        /* Initialize the cluster and mft allocators. */
-        ntfs_setup_allocators(vol);
-
         brelse(bh);
-
         if (!result) {
                 if (!silent)
                         ntfs_error(sb, "Unsupported NTFS filesystem.");
                 goto err_out_now;
         }
-
         /*
-         * TODO: When we start coping with sector sizes different from
-         * NTFS_BLOCK_SIZE, we now probably need to set the blocksize of the
-         * device (probably to NTFS_BLOCK_SIZE).
+         * If the boot sector indicates a sector size bigger than the current
+         * device block size, switch the device block size to the sector size.
+         * TODO: It may be possible to support this case even when the set
+         * below fails, we would just be breaking up the i/o for each sector
+         * into multiple blocks for i/o purposes but otherwise it should just
+         * work.  However it is safer to leave disabled until someone hits this
+         * error message and then we can get them to try it without the setting
+         * so we know for sure that it works.
          */
-
+        if (vol->sector_size > blocksize) {
+                blocksize = sb_set_blocksize(sb, vol->sector_size);
+                if (blocksize != vol->sector_size) {
+                        if (!silent)
+                                ntfs_error(sb, "Unable to set device block "
+                                                "size to sector size (%i).",
+                                                vol->sector_size);
+                        goto err_out_now;
+                }
+                BUG_ON(blocksize != sb->s_blocksize);
+                vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
+                                sb->s_blocksize_bits;
+                ntfs_debug("Changed device block size to %i bytes (block size "
+                                "bits %i) to match volume sector size.",
+                                blocksize, sb->s_blocksize_bits);
+        }
+        /* Initialize the cluster and mft allocators. */
+        ntfs_setup_allocators(vol);
         /* Setup remaining fields in the super block. */
         sb->s_magic = NTFS_SB_MAGIC;
-
         /*
          * Ntfs allows 63 bits for the file size, i.e. correct would be:
          *      sb->s_maxbytes = ~0ULL >> 1;
@@ -2787,9 +2855,8 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
          * without overflowing the index or to 2^63 - 1, whichever is smaller.
          */
         sb->s_maxbytes = MAX_LFS_FILESIZE;
-
+        /* Ntfs measures time in 100ns intervals. */
         sb->s_time_gran = 100;
-
         /*
          * Now load the metadata required for the page cache and our address
          * space operations to function. We do this by setting up a specialised
@@ -2987,14 +3054,14 @@ err_out_now:
  * strings of the maximum length allowed by NTFS, which is NTFS_MAX_NAME_LEN
  * (255) Unicode characters + a terminating NULL Unicode character.
  */
-kmem_cache_t *ntfs_name_cache;
+struct kmem_cache *ntfs_name_cache;
 
 /* Slab caches for efficient allocation/deallocation of inodes. */
-kmem_cache_t *ntfs_inode_cache;
-kmem_cache_t *ntfs_big_inode_cache;
+struct kmem_cache *ntfs_inode_cache;
+struct kmem_cache *ntfs_big_inode_cache;
 
 /* Init once constructor for the inode slab cache. */
-static void ntfs_big_inode_init_once(void *foo, kmem_cache_t *cachep,
+static void ntfs_big_inode_init_once(void *foo, struct kmem_cache *cachep,
                 unsigned long flags)
 {
         ntfs_inode *ni = (ntfs_inode *)foo;
@@ -3008,8 +3075,8 @@ static void ntfs_big_inode_init_once(void *foo, kmem_cache_t *cachep,
  * Slab caches to optimize allocations and deallocations of attribute search
  * contexts and index contexts, respectively.
  */
-kmem_cache_t *ntfs_attr_ctx_cache;
-kmem_cache_t *ntfs_index_ctx_cache;
+struct kmem_cache *ntfs_attr_ctx_cache;
+struct kmem_cache *ntfs_index_ctx_cache;
 
 /* Driver wide semaphore. */
 DECLARE_MUTEX(ntfs_lock);
diff --git a/fs/ntfs/upcase.c b/fs/ntfs/upcase.c
index 879cdf1d5b..9101807dc8 100644
--- a/fs/ntfs/upcase.c
+++ b/fs/ntfs/upcase.c
@@ -3,10 +3,7 @@
  *            Part of the Linux-NTFS project.
  *
  * Copyright (c) 2001 Richard Russon <ntfs@flatcap.org>
- * Copyright (c) 2001-2004 Anton Altaparmakov
- *
- * Modified for mkntfs inclusion 9 June 2001 by Anton Altaparmakov.
- * Modified for kernel inclusion 10 September 2001 by Anton Altparmakov.
+ * Copyright (c) 2001-2006 Anton Altaparmakov
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
@@ -75,12 +72,13 @@ ntfschar *generate_default_upcase(void)
         if (!uc)
                 return uc;
         memset(uc, 0, default_upcase_len * sizeof(ntfschar));
+        /* Generate the little endian Unicode upcase table used by ntfs. */
         for (i = 0; i < default_upcase_len; i++)
                 uc[i] = cpu_to_le16(i);
         for (r = 0; uc_run_table[r][0]; r++)
                 for (i = uc_run_table[r][0]; i < uc_run_table[r][1]; i++)
-                        uc[i] = cpu_to_le16((le16_to_cpu(uc[i]) +
-                                        uc_run_table[r][2]));
+                        uc[i] = cpu_to_le16(le16_to_cpu(uc[i]) +
+                                        uc_run_table[r][2]);
         for (r = 0; uc_dup_table[r][0]; r++)
                 for (i = uc_dup_table[r][0]; i < uc_dup_table[r][1]; i += 2)
                         uc[i + 1] = cpu_to_le16(le16_to_cpu(uc[i + 1]) - 1);
diff --git a/fs/ntfs/volume.h b/fs/ntfs/volume.h
index 375cd20a9f..406ab55dfb 100644
--- a/fs/ntfs/volume.h
+++ b/fs/ntfs/volume.h
@@ -2,7 +2,7 @@
  * volume.h - Defines for volume structures in NTFS Linux kernel driver. Part
  *            of the Linux-NTFS project.
  *
- * Copyright (c) 2001-2005 Anton Altaparmakov
+ * Copyright (c) 2001-2006 Anton Altaparmakov
  * Copyright (c) 2002 Richard Russon
  *
  * This program/include file is free software; you can redistribute it and/or
@@ -41,10 +41,8 @@ typedef struct {
          * structure has stabilized... (AIA)
          */
         /* Device specifics. */
-        struct super_block *sb;         /* Pointer back to the super_block,
-                                           so we don't have to get the offset
-                                           every time. */
-        LCN nr_blocks;                  /* Number of NTFS_BLOCK_SIZE bytes
+        struct super_block *sb;         /* Pointer back to the super_block. */
+        LCN nr_blocks;                  /* Number of sb->s_blocksize bytes
                                            sized blocks on the device. */
         /* Configuration provided by user at mount time. */
         unsigned long flags;            /* Miscellaneous flags, see below. */
@@ -141,8 +139,8 @@ typedef enum {
         NV_ShowSystemFiles,     /* 1: Return system files in ntfs_readdir(). */
         NV_CaseSensitive,       /* 1: Treat file names as case sensitive and
                                       create filenames in the POSIX namespace.
-                                      Otherwise be case insensitive and create
-                                      file names in WIN32 namespace. */
+                                      Otherwise be case insensitive but still
+                                      create file names in POSIX namespace. */
         NV_LogFileEmpty,        /* 1: $LogFile journal is empty. */
         NV_QuotaOutOfDate,      /* 1: $Quota is out of date. */
         NV_UsnJrnlStamped,      /* 1: $UsnJrnl has been stamped. */
@@ -153,7 +151,7 @@ typedef enum {
  * Macro tricks to expand the NVolFoo(), NVolSetFoo(), and NVolClearFoo()
  * functions.
  */
-#define NVOL_FNS(flag)                                  \
+#define DEFINE_NVOL_BIT_OPS(flag)                                       \
 static inline int NVol##flag(ntfs_volume *vol)          \
 {                                                       \
         return test_bit(NV_##flag, &(vol)->flags);      \
@@ -168,12 +166,12 @@ static inline void NVolClear##flag(ntfs_volume *vol)	\
 }
 
 /* Emit the ntfs volume bitops functions. */
-NVOL_FNS(Errors)
-NVOL_FNS(ShowSystemFiles)
-NVOL_FNS(CaseSensitive)
-NVOL_FNS(LogFileEmpty)
-NVOL_FNS(QuotaOutOfDate)
-NVOL_FNS(UsnJrnlStamped)
-NVOL_FNS(SparseEnabled)
+DEFINE_NVOL_BIT_OPS(Errors)
+DEFINE_NVOL_BIT_OPS(ShowSystemFiles)
+DEFINE_NVOL_BIT_OPS(CaseSensitive)
+DEFINE_NVOL_BIT_OPS(LogFileEmpty)
+DEFINE_NVOL_BIT_OPS(QuotaOutOfDate)
+DEFINE_NVOL_BIT_OPS(UsnJrnlStamped)
+DEFINE_NVOL_BIT_OPS(SparseEnabled)
 
 #endif /* _LINUX_NTFS_VOLUME_H */
diff --git a/fs/ocfs2/dlm/dlmcommon.h b/fs/ocfs2/dlm/dlmcommon.h
index 42eb53b529..23ceaa7127 100644
--- a/fs/ocfs2/dlm/dlmcommon.h
+++ b/fs/ocfs2/dlm/dlmcommon.h
@@ -208,6 +208,9 @@ static inline void __dlm_set_joining_node(struct dlm_ctxt *dlm,
 #define DLM_LOCK_RES_IN_PROGRESS          0x00000010
 #define DLM_LOCK_RES_MIGRATING            0x00000020
 
+/* max milliseconds to wait to sync up a network failure with a node death */
+#define DLM_NODE_DEATH_WAIT_MAX (5 * 1000)
+
 #define DLM_PURGE_INTERVAL_MS   (8 * 1000)
 
 struct dlm_lock_resource
@@ -658,6 +661,7 @@ int dlm_launch_recovery_thread(struct dlm_ctxt *dlm);
 void dlm_complete_recovery_thread(struct dlm_ctxt *dlm);
 void dlm_wait_for_recovery(struct dlm_ctxt *dlm);
 int dlm_is_node_dead(struct dlm_ctxt *dlm, u8 node);
+int dlm_wait_for_node_death(struct dlm_ctxt *dlm, u8 node, int timeout);
 
 void dlm_put(struct dlm_ctxt *dlm);
 struct dlm_ctxt *dlm_grab(struct dlm_ctxt *dlm);
diff --git a/fs/ocfs2/dlm/dlmconvert.c b/fs/ocfs2/dlm/dlmconvert.c
index 6001b22a99..f66e2d818c 100644
--- a/fs/ocfs2/dlm/dlmconvert.c
+++ b/fs/ocfs2/dlm/dlmconvert.c
@@ -392,6 +392,11 @@ static enum dlm_status dlm_send_remote_convert_request(struct dlm_ctxt *dlm,
         } else {
                 mlog_errno(tmpret);
                 if (dlm_is_host_down(tmpret)) {
+                        /* instead of logging the same network error over
+                         * and over, sleep here and wait for the heartbeat
+                         * to notice the node is dead.  times out after 5s. */
+                        dlm_wait_for_node_death(dlm, res->owner, 
+                                                DLM_NODE_DEATH_WAIT_MAX);
                         ret = DLM_RECOVERING;
                         mlog(0, "node %u died so returning DLM_RECOVERING "
                              "from convert message!\n", res->owner);
@@ -421,7 +426,7 @@ int dlm_convert_lock_handler(struct o2net_msg *msg, u32 len, void *data)
         struct dlm_lockstatus *lksb;
         enum dlm_status status = DLM_NORMAL;
         u32 flags;
-        int call_ast = 0, kick_thread = 0;
+        int call_ast = 0, kick_thread = 0, ast_reserved = 0;
 
         if (!dlm_grab(dlm)) {
                 dlm_error(DLM_REJECTED);
@@ -490,6 +495,7 @@ int dlm_convert_lock_handler(struct o2net_msg *msg, u32 len, void *data)
         status = __dlm_lockres_state_to_status(res);
         if (status == DLM_NORMAL) {
                 __dlm_lockres_reserve_ast(res);
+                ast_reserved = 1;
                 res->state |= DLM_LOCK_RES_IN_PROGRESS;
                 status = __dlmconvert_master(dlm, res, lock, flags,
                                              cnv->requested_type,
@@ -512,10 +518,10 @@ leave:
         else
                 dlm_lock_put(lock);
 
-        /* either queue the ast or release it */
+        /* either queue the ast or release it, if reserved */
         if (call_ast)
                 dlm_queue_ast(dlm, lock);
-        else
+        else if (ast_reserved)
                 dlm_lockres_release_ast(dlm, res);
 
         if (kick_thread)
diff --git a/fs/ocfs2/dlm/dlmlock.c b/fs/ocfs2/dlm/dlmlock.c
index d1a0038557..671d4ff222 100644
--- a/fs/ocfs2/dlm/dlmlock.c
+++ b/fs/ocfs2/dlm/dlmlock.c
@@ -220,6 +220,17 @@ static enum dlm_status dlmlock_remote(struct dlm_ctxt *dlm,
                         dlm_error(status);
                 dlm_revert_pending_lock(res, lock);
                 dlm_lock_put(lock);
+        } else if (dlm_is_recovery_lock(res->lockname.name, 
+                                        res->lockname.len)) {
+                /* special case for the $RECOVERY lock.
+                 * there will never be an AST delivered to put
+                 * this lock on the proper secondary queue
+                 * (granted), so do it manually. */
+                mlog(0, "%s: $RECOVERY lock for this node (%u) is "
+                     "mastered by %u; got lock, manually granting (no ast)\n",
+                     dlm->name, dlm->node_num, res->owner);
+                list_del_init(&lock->list);
+                list_add_tail(&lock->list, &res->granted);
         }
         spin_unlock(&res->spinlock);
 
@@ -646,7 +657,19 @@ retry_lock:
                         mlog(0, "retrying lock with migration/"
                              "recovery/in progress\n");
                         msleep(100);
-                        dlm_wait_for_recovery(dlm);
+                        /* no waiting for dlm_reco_thread */
+                        if (recovery) {
+                                if (status == DLM_RECOVERING) {
+                                        mlog(0, "%s: got RECOVERING "
+                                             "for $REOCVERY lock, master "
+                                             "was %u\n", dlm->name, 
+                                             res->owner);
+                                        dlm_wait_for_node_death(dlm, res->owner, 
+                                                        DLM_NODE_DEATH_WAIT_MAX);
+                                }
+                        } else {
+                                dlm_wait_for_recovery(dlm);
+                        }
                         goto retry_lock;
                 }
 
diff --git a/fs/ocfs2/dlm/dlmmaster.c b/fs/ocfs2/dlm/dlmmaster.c
index a3194fe173..2e2e95e694 100644
--- a/fs/ocfs2/dlm/dlmmaster.c
+++ b/fs/ocfs2/dlm/dlmmaster.c
@@ -2482,7 +2482,9 @@ top:
                                 atomic_set(&mle->woken, 1);
                                 spin_unlock(&mle->spinlock);
                                 wake_up(&mle->wq);
-                                /* final put will take care of list removal */
+                                /* do not need events any longer, so detach 
+                                 * from heartbeat */
+                                __dlm_mle_detach_hb_events(dlm, mle);
                                 __dlm_put_mle(mle);
                         }
                         continue;
@@ -2537,6 +2539,9 @@ top:
                         spin_unlock(&res->spinlock);
                         dlm_lockres_put(res);
 
+                        /* about to get rid of mle, detach from heartbeat */
+                        __dlm_mle_detach_hb_events(dlm, mle);
+
                         /* dump the mle */
                         spin_lock(&dlm->master_lock);
                         __dlm_put_mle(mle);
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c
index 186e9a76aa..ed76bda1a5 100644
--- a/fs/ocfs2/dlm/dlmrecovery.c
+++ b/fs/ocfs2/dlm/dlmrecovery.c
@@ -278,6 +278,24 @@ int dlm_is_node_dead(struct dlm_ctxt *dlm, u8 node)
         return dead;
 }
 
+int dlm_wait_for_node_death(struct dlm_ctxt *dlm, u8 node, int timeout)
+{
+        if (timeout) {
+                mlog(ML_NOTICE, "%s: waiting %dms for notification of "
+                     "death of node %u\n", dlm->name, timeout, node);
+                wait_event_timeout(dlm->dlm_reco_thread_wq,
+                           dlm_is_node_dead(dlm, node),
+                           msecs_to_jiffies(timeout));
+        } else {
+                mlog(ML_NOTICE, "%s: waiting indefinitely for notification "
+                     "of death of node %u\n", dlm->name, node);
+                wait_event(dlm->dlm_reco_thread_wq,
+                           dlm_is_node_dead(dlm, node));
+        }
+        /* for now, return 0 */
+        return 0;
+}
+
 /* callers of the top-level api calls (dlmlock/dlmunlock) should
  * block on the dlm->reco.event when recovery is in progress.
  * the dlm recovery thread will set this state when it begins
@@ -2032,6 +2050,30 @@ again:
                              dlm->reco.new_master);
                         status = -EEXIST;
                 } else {
+                        status = 0;
+
+                        /* see if recovery was already finished elsewhere */
+                        spin_lock(&dlm->spinlock);
+                        if (dlm->reco.dead_node == O2NM_INVALID_NODE_NUM) {
+                                status = -EINVAL;       
+                                mlog(0, "%s: got reco EX lock, but "
+                                     "node got recovered already\n", dlm->name);
+                                if (dlm->reco.new_master != O2NM_INVALID_NODE_NUM) {
+                                        mlog(ML_ERROR, "%s: new master is %u "
+                                             "but no dead node!\n", 
+                                             dlm->name, dlm->reco.new_master);
+                                        BUG();
+                                }
+                        }
+                        spin_unlock(&dlm->spinlock);
+                }
+
+                /* if this node has actually become the recovery master,
+                 * set the master and send the messages to begin recovery */
+                if (!status) {
+                        mlog(0, "%s: dead=%u, this=%u, sending "
+                             "begin_reco now\n", dlm->name, 
+                             dlm->reco.dead_node, dlm->node_num);
                         status = dlm_send_begin_reco_message(dlm,
                                       dlm->reco.dead_node);
                         /* this always succeeds */
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index fa0bcac5ce..d329c9df90 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -1584,10 +1584,9 @@ static int ocfs2_commit_thread(void *arg)
         while (!(kthread_should_stop() &&
                  atomic_read(&journal->j_num_trans) == 0)) {
 
-                wait_event_interruptible_timeout(osb->checkpoint_event,
-                                                 atomic_read(&journal->j_num_trans)
-                                                 || kthread_should_stop(),
-                                                 OCFS2_CHECKPOINT_INTERVAL);
+                wait_event_interruptible(osb->checkpoint_event,
+                                         atomic_read(&journal->j_num_trans)
+                                         || kthread_should_stop());
 
                 status = ocfs2_commit_cache(osb);
                 if (status < 0)
diff --git a/fs/ocfs2/journal.h b/fs/ocfs2/journal.h
index 7d0a816184..2f3a6acdac 100644
--- a/fs/ocfs2/journal.h
+++ b/fs/ocfs2/journal.h
@@ -29,8 +29,6 @@
 #include <linux/fs.h>
 #include <linux/jbd.h>
 
-#define OCFS2_CHECKPOINT_INTERVAL        (8 * HZ)
-
 enum ocfs2_journal_state {
         OCFS2_JOURNAL_FREE = 0,
         OCFS2_JOURNAL_LOADED,
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 6573f31f1f..075d3e9456 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -204,10 +204,6 @@ int proc_fill_super(struct super_block *s, void *data, int silent)
         root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
         if (!root_inode)
                 goto out_no_root;
-        /*
-         * Fixup the root inode's nlink value
-         */
-        root_inode->i_nlink += nr_processes();
         root_inode->i_uid = 0;
         root_inode->i_gid = 0;
         s->s_root = d_alloc_root(root_inode);
diff --git a/fs/proc/root.c b/fs/proc/root.c
index 68896283c8..c3fd361111 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -80,16 +80,16 @@ void __init proc_root_init(void)
         proc_bus = proc_mkdir("bus", NULL);
 }
 
-static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentry, struct nameidata *nd)
+static int proc_root_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat
+)
 {
-        /*
-         * nr_threads is actually protected by the tasklist_lock;
-         * however, it's conventional to do reads, especially for
-         * reporting, without any locking whatsoever.
-         */
-        if (dir->i_ino == PROC_ROOT_INO) /* check for safety... */
-                dir->i_nlink = proc_root.nlink + nr_threads;
+        generic_fillattr(dentry->d_inode, stat);
+        stat->nlink = proc_root.nlink + nr_processes();
+        return 0;
+}
 
+static struct dentry *proc_root_lookup(struct inode * dir, struct dentry * dentry, struct nameidata *nd)
+{
         if (!proc_lookup(dir, dentry, nd)) {
                 return NULL;
         }
@@ -134,6 +134,7 @@ static struct file_operations proc_root_operations = {
  */
 static struct inode_operations proc_root_inode_operations = {
         .lookup         = proc_root_lookup,
+        .getattr        = proc_root_getattr,
 };
 
 /*
diff --git a/fs/ramfs/inode.c b/fs/ramfs/inode.c
index c66bd5e4c0..cde5d48994 100644
--- a/fs/ramfs/inode.c
+++ b/fs/ramfs/inode.c
@@ -27,6 +27,7 @@
 #include <linux/fs.h>
 #include <linux/pagemap.h>
 #include <linux/highmem.h>
+#include <linux/time.h>
 #include <linux/init.h>
 #include <linux/string.h>
 #include <linux/smp_lock.h>
@@ -104,6 +105,7 @@ ramfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
                 d_instantiate(dentry, inode);
                 dget(dentry);   /* Extra count - pin the dentry in core */
                 error = 0;
+                dir->i_mtime = dir->i_ctime = CURRENT_TIME;
         }
         return error;
 }
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index ef5e5414e7..d63da756eb 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -1124,8 +1124,6 @@ static void handle_attrs(struct super_block *s)
                                          "reiserfs: cannot support attributes until flag is set in super-block");
                         REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
                 }
-        } else if (le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared) {
-                REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ATTRS);
         }
 }
 
diff --git a/fs/reiserfs/xattr_acl.c b/fs/reiserfs/xattr_acl.c
index 43de3ba833..ab8894c3b9 100644
--- a/fs/reiserfs/xattr_acl.c
+++ b/fs/reiserfs/xattr_acl.c
@@ -228,7 +228,8 @@ struct posix_acl *reiserfs_get_acl(struct inode *inode, int type)
                 acl = ERR_PTR(retval);
         } else {
                 acl = posix_acl_from_disk(value, retval);
-                *p_acl = posix_acl_dup(acl);
+                if (!IS_ERR(acl))
+                        *p_acl = posix_acl_dup(acl);
         }
 
         kfree(value);
diff --git a/fs/select.c b/fs/select.c
index bc60a3e14e..1815a57d22 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -398,11 +398,15 @@ asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
         ret = core_sys_select(n, inp, outp, exp, &timeout);
 
         if (tvp) {
+                struct timeval rtv;
+
                 if (current->personality & STICKY_TIMEOUTS)
                         goto sticky;
-                tv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
-                tv.tv_sec = timeout;
-                if (copy_to_user(tvp, &tv, sizeof(tv))) {
+                rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
+                rtv.tv_sec = timeout;
+                if (timeval_compare(&rtv, &tv) >= 0)
+                        rtv = tv;
+                if (copy_to_user(tvp, &rtv, sizeof(rtv))) {
 sticky:
                         /*
                          * If an application puts its timeval in read-only
@@ -460,11 +464,16 @@ asmlinkage long sys_pselect7(int n, fd_set __user *inp, fd_set __user *outp,
         ret = core_sys_select(n, inp, outp, exp, &timeout);
 
         if (tsp) {
+                struct timespec rts;
+
                 if (current->personality & STICKY_TIMEOUTS)
                         goto sticky;
-                ts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) * 1000;
-                ts.tv_sec = timeout;
-                if (copy_to_user(tsp, &ts, sizeof(ts))) {
+                rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
+                                                1000;
+                rts.tv_sec = timeout;
+                if (timespec_compare(&rts, &ts) >= 0)
+                        rts = ts;
+                if (copy_to_user(tsp, &rts, sizeof(rts))) {
 sticky:
                         /*
                          * If an application puts its timeval in read-only
@@ -758,12 +767,17 @@ asmlinkage long sys_ppoll(struct pollfd __user *ufds, unsigned int nfds,
                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
 
         if (tsp && timeout >= 0) {
+                struct timespec rts;
+
                 if (current->personality & STICKY_TIMEOUTS)
                         goto sticky;
                 /* Yes, we know it's actually an s64, but it's also positive. */
-                ts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) * 1000;
-                ts.tv_sec = timeout;
-                if (copy_to_user(tsp, &ts, sizeof(ts))) {
+                rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
+                                                1000;
+                rts.tv_sec = timeout;
+                if (timespec_compare(&rts, &ts) >= 0)
+                        rts = ts;
+                if (copy_to_user(tsp, &rts, sizeof(rts))) {
                 sticky:
                         /*
                          * If an application puts its timeval in read-only
diff --git a/fs/stat.c b/fs/stat.c
index 24211b030f..9948cc1685 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -261,6 +261,7 @@ asmlinkage long sys_newlstat(char __user *filename, struct stat __user *statbuf)
         return error;
 }
 
+#ifndef __ARCH_WANT_STAT64
 asmlinkage long sys_newfstatat(int dfd, char __user *filename,
                                 struct stat __user *statbuf, int flag)
 {
@@ -281,6 +282,7 @@ asmlinkage long sys_newfstatat(int dfd, char __user *filename,
 out:
         return error;
 }
+#endif
 
 asmlinkage long sys_newfstat(unsigned int fd, struct stat __user *statbuf)
 {
@@ -395,6 +397,26 @@ asmlinkage long sys_fstat64(unsigned long fd, struct stat64 __user * statbuf)
         return error;
 }
 
+asmlinkage long sys_fstatat64(int dfd, char __user *filename,
+                               struct stat64 __user *statbuf, int flag)
+{
+        struct kstat stat;
+        int error = -EINVAL;
+
+        if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
+                goto out;
+
+        if (flag & AT_SYMLINK_NOFOLLOW)
+                error = vfs_lstat_fd(dfd, filename, &stat);
+        else
+                error = vfs_stat_fd(dfd, filename, &stat);
+
+        if (!error)
+                error = cp_new_stat64(&stat, statbuf);
+
+out:
+        return error;
+}
 #endif /* __ARCH_WANT_STAT64 */
 
 void inode_add_bytes(struct inode *inode, loff_t bytes)
diff --git a/fs/super.c b/fs/super.c
index 30294218fa..e20b5580af 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -666,6 +666,16 @@ static int test_bdev_super(struct super_block *s, void *data)
         return (void *)s->s_bdev == data;
 }
 
+static void bdev_uevent(struct block_device *bdev, enum kobject_action action)
+{
+        if (bdev->bd_disk) {
+                if (bdev->bd_part)
+                        kobject_uevent(&bdev->bd_part->kobj, action);
+                else
+                        kobject_uevent(&bdev->bd_disk->kobj, action);
+        }
+}
+
 struct super_block *get_sb_bdev(struct file_system_type *fs_type,
         int flags, const char *dev_name, void *data,
         int (*fill_super)(struct super_block *, void *, int))
@@ -707,8 +717,10 @@ struct super_block *get_sb_bdev(struct file_system_type *fs_type,
                         up_write(&s->s_umount);
                         deactivate_super(s);
                         s = ERR_PTR(error);
-                } else
+                } else {
                         s->s_flags |= MS_ACTIVE;
+                        bdev_uevent(bdev, KOBJ_MOUNT);
+                }
         }
 
         return s;
@@ -724,6 +736,7 @@ void kill_block_super(struct super_block *sb)
 {
         struct block_device *bdev = sb->s_bdev;
 
+        bdev_uevent(bdev, KOBJ_UMOUNT);
         generic_shutdown_super(sb);
         sync_blockdev(bdev);
         close_bdev_excl(bdev);
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 8f2beec526..74d8be87f9 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -540,7 +540,7 @@ xfs_probe_cluster(
 
         /* First sum forwards in this page */
         do {
-                if (mapped != buffer_mapped(bh))
+                if (!buffer_uptodate(bh) || (mapped != buffer_mapped(bh)))
                         return total;
                 total += bh->b_size;
         } while ((bh = bh->b_this_page) != head);
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index 53a00fb217..7c0e39dc61 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -68,6 +68,9 @@ kmem_zone_t	*qm_dqzone;
 kmem_zone_t     *qm_dqtrxzone;
 STATIC kmem_shaker_t    xfs_qm_shaker;
 
+STATIC cred_t   xfs_zerocr;
+STATIC xfs_inode_t      xfs_zeroino;
+
 STATIC void     xfs_qm_list_init(xfs_dqlist_t *, char *, int);
 STATIC void     xfs_qm_list_destroy(xfs_dqlist_t *);
 
@@ -1393,8 +1396,6 @@ xfs_qm_qino_alloc(
         xfs_trans_t     *tp;
         int             error;
         unsigned long   s;
-        cred_t          zerocr;
-        xfs_inode_t     zeroino;
         int             committed;
 
         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
@@ -1406,11 +1407,9 @@ xfs_qm_qino_alloc(
                 xfs_trans_cancel(tp, 0);
                 return error;
         }
-        memset(&zerocr, 0, sizeof(zerocr));
-        memset(&zeroino, 0, sizeof(zeroino));
 
-        if ((error = xfs_dir_ialloc(&tp, &zeroino, S_IFREG, 1, 0,
-                                   &zerocr, 0, 1, ip, &committed))) {
+        if ((error = xfs_dir_ialloc(&tp, &xfs_zeroino, S_IFREG, 1, 0,
+                                   &xfs_zerocr, 0, 1, ip, &committed))) {
                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
                                  XFS_TRANS_ABORT);
                 return error;
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 06fc061c50..5b413946b1 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -130,7 +130,8 @@ xfs_growfs_rt_alloc(
                 /*
                  * Lock the inode.
                  */
-                if ((error = xfs_trans_iget(mp, tp, ino, 0, XFS_ILOCK_EXCL, &ip)))
+                if ((error = xfs_trans_iget(mp, tp, ino, 0,
+                                                XFS_ILOCK_EXCL, &ip)))
                         goto error_exit;
                 XFS_BMAP_INIT(&flist, &firstblock);
                 /*
@@ -170,8 +171,8 @@ xfs_growfs_rt_alloc(
                         /*
                          * Lock the bitmap inode.
                          */
-                        if ((error = xfs_trans_iget(mp, tp, ino, 0, XFS_ILOCK_EXCL,
-                                        &ip)))
+                        if ((error = xfs_trans_iget(mp, tp, ino, 0,
+                                                        XFS_ILOCK_EXCL, &ip)))
                                 goto error_exit;
                         /*
                          * Get a buffer for the block.
@@ -2023,8 +2024,8 @@ xfs_growfs_rt(
                 /*
                  * Lock out other callers by grabbing the bitmap inode lock.
                  */
-                if ((error = xfs_trans_iget(mp, tp, 0, mp->m_sb.sb_rbmino,
-                                XFS_ILOCK_EXCL, &ip)))
+                if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0,
+                                                XFS_ILOCK_EXCL, &ip)))
                         goto error_exit;
                 ASSERT(ip == mp->m_rbmip);
                 /*
@@ -2037,8 +2038,8 @@ xfs_growfs_rt(
                 /*
                  * Get the summary inode into the transaction.
                  */
-                if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rsumino,
-                                0, XFS_ILOCK_EXCL, &ip)))
+                if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rsumino, 0,
+                                                XFS_ILOCK_EXCL, &ip)))
                         goto error_exit;
                 ASSERT(ip == mp->m_rsumip);
                 /*
@@ -2158,10 +2159,9 @@ xfs_rtallocate_extent(
         /*
          * Lock out other callers by grabbing the bitmap inode lock.
          */
-        error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0, XFS_ILOCK_EXCL, &ip);
-        if (error) {
+        if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0,
+                                        XFS_ILOCK_EXCL, &ip)))
                 return error;
-        }
         sumbp = NULL;
         /*
          * Allocate by size, or near another block, or exactly at some block.
@@ -2221,10 +2221,9 @@ xfs_rtfree_extent(
         /*
          * Synchronize by locking the bitmap inode.
          */
-        error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0, XFS_ILOCK_EXCL, &ip);
-        if (error) {
+        if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0,
+                                        XFS_ILOCK_EXCL, &ip)))
                 return error;
-        }
 #if defined(__KERNEL__) && defined(DEBUG)
         /*
          * Check to see that this whole range is currently allocated.
@@ -2365,8 +2364,8 @@ xfs_rtpick_extent(
         __uint64_t      seq;            /* sequence number of file creation */
         __uint64_t      *seqp;          /* pointer to seqno in inode */
 
-        error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0, XFS_ILOCK_EXCL, &ip);
-        if (error)
+        if ((error = xfs_trans_iget(mp, tp, mp->m_sb.sb_rbmino, 0,
+                                        XFS_ILOCK_EXCL, &ip)))
                 return error;
         ASSERT(ip == mp->m_rbmip);
         seqp = (__uint64_t *)&ip->i_d.di_atime;