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

7 files changed, 110 insertions, 27 deletions

diff --git a/fs/direct-io.c b/fs/direct-io.c
index 8593f3dfd299..52bb2638f7ab 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -1106,7 +1106,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
         spin_lock_irqsave(&dio->bio_lock, flags);
         ret2 = --dio->refcount;
         spin_unlock_irqrestore(&dio->bio_lock, flags);
-        BUG_ON(!dio->is_async && ret2 != 0);
+
         if (ret2 == 0) {
                 ret = dio_complete(dio, offset, ret);
                 kfree(dio);
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index 403e3bad1455..1b9dd9a96f19 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -580,5 +580,7 @@ void
 ecryptfs_write_header_metadata(char *virt,
                                struct ecryptfs_crypt_stat *crypt_stat,
                                size_t *written);
+int ecryptfs_write_zeros(struct file *file, pgoff_t index, int start,
+                         int num_zeros);
 
 #endif /* #ifndef ECRYPTFS_KERNEL_H */
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 1548be26b5e6..83e94fedd4e9 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -800,6 +800,25 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
                         goto out_fput;
                 }
         } else { /* new_length < i_size_read(inode) */
+                pgoff_t index = 0;
+                int end_pos_in_page = -1;
+
+                if (new_length != 0) {
+                        index = ((new_length - 1) >> PAGE_CACHE_SHIFT);
+                        end_pos_in_page = ((new_length - 1) & ~PAGE_CACHE_MASK);
+                }
+                if (end_pos_in_page != (PAGE_CACHE_SIZE - 1)) {
+                        if ((rc = ecryptfs_write_zeros(&fake_ecryptfs_file,
+                                                       index,
+                                                       (end_pos_in_page + 1),
+                                                       ((PAGE_CACHE_SIZE - 1)
+                                                        - end_pos_in_page)))) {
+                                printk(KERN_ERR "Error attempting to zero out "
+                                       "the remainder of the end page on "
+                                       "reducing truncate; rc = [%d]\n", rc);
+                                goto out_fput;
+                        }
+                }
                 vmtruncate(inode, new_length);
                 rc = ecryptfs_write_inode_size_to_metadata(
                         lower_file, lower_dentry->d_inode, inode, dentry,
@@ -875,9 +894,54 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
         struct ecryptfs_crypt_stat *crypt_stat;
 
         crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat;
-        lower_dentry = ecryptfs_dentry_to_lower(dentry);
+        if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED))
+                ecryptfs_init_crypt_stat(crypt_stat);
         inode = dentry->d_inode;
         lower_inode = ecryptfs_inode_to_lower(inode);
+        lower_dentry = ecryptfs_dentry_to_lower(dentry);
+        mutex_lock(&crypt_stat->cs_mutex);
+        if (S_ISDIR(dentry->d_inode->i_mode))
+                crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
+        else if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED)
+                 || !(crypt_stat->flags & ECRYPTFS_KEY_VALID)) {
+                struct vfsmount *lower_mnt;
+                struct file *lower_file = NULL;
+                struct ecryptfs_mount_crypt_stat *mount_crypt_stat;
+                int lower_flags;
+
+                lower_mnt = ecryptfs_dentry_to_lower_mnt(dentry);
+                lower_flags = O_RDONLY;
+                if ((rc = ecryptfs_open_lower_file(&lower_file, lower_dentry,
+                                                   lower_mnt, lower_flags))) {
+                        printk(KERN_ERR
+                               "Error opening lower file; rc = [%d]\n", rc);
+                        mutex_unlock(&crypt_stat->cs_mutex);
+                        goto out;
+                }
+                mount_crypt_stat = &ecryptfs_superblock_to_private(
+                        dentry->d_sb)->mount_crypt_stat;
+                if ((rc = ecryptfs_read_metadata(dentry, lower_file))) {
+                        if (!(mount_crypt_stat->flags
+                              & ECRYPTFS_PLAINTEXT_PASSTHROUGH_ENABLED)) {
+                                rc = -EIO;
+                                printk(KERN_WARNING "Attempt to read file that "
+                                       "is not in a valid eCryptfs format, "
+                                       "and plaintext passthrough mode is not "
+                                       "enabled; returning -EIO\n");
+
+                                mutex_unlock(&crypt_stat->cs_mutex);
+                                fput(lower_file);
+                                goto out;
+                        }
+                        rc = 0;
+                        crypt_stat->flags &= ~(ECRYPTFS_ENCRYPTED);
+                        mutex_unlock(&crypt_stat->cs_mutex);
+                        fput(lower_file);
+                        goto out;
+                }
+                fput(lower_file);
+        }
+        mutex_unlock(&crypt_stat->cs_mutex);
         if (ia->ia_valid & ATTR_SIZE) {
                 ecryptfs_printk(KERN_DEBUG,
                                 "ia->ia_valid = [0x%x] ATTR_SIZE" " = [0x%x]\n",
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 55cec98a84e7..7d5a43cb0d5c 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -56,9 +56,6 @@ static struct page *ecryptfs_get1page(struct file *file, int index)
         return read_mapping_page(mapping, index, (void *)file);
 }
 
-static
-int write_zeros(struct file *file, pgoff_t index, int start, int num_zeros);
-
 /**
  * ecryptfs_fill_zeros
  * @file: The ecryptfs file
@@ -101,10 +98,13 @@ int ecryptfs_fill_zeros(struct file *file, loff_t new_length)
         if (old_end_page_index == new_end_page_index) {
                 /* Start and end are in the same page; we just need to
                  * set a portion of the existing page to zero's */
-                rc = write_zeros(file, index, (old_end_pos_in_page + 1),
-                                 (new_end_pos_in_page - old_end_pos_in_page));
+                rc = ecryptfs_write_zeros(file, index,
+                                          (old_end_pos_in_page + 1),
+                                          (new_end_pos_in_page
+                                           - old_end_pos_in_page));
                 if (rc)
-                        ecryptfs_printk(KERN_ERR, "write_zeros(file=[%p], "
+                        ecryptfs_printk(KERN_ERR, "ecryptfs_write_zeros("
+                                        "file=[%p], "
                                         "index=[0x%.16x], "
                                         "old_end_pos_in_page=[d], "
                                         "(PAGE_CACHE_SIZE - new_end_pos_in_page"
@@ -117,10 +117,10 @@ int ecryptfs_fill_zeros(struct file *file, loff_t new_length)
                 goto out;
         }
         /* Fill the remainder of the previous last page with zeros */
-        rc = write_zeros(file, index, (old_end_pos_in_page + 1),
+        rc = ecryptfs_write_zeros(file, index, (old_end_pos_in_page + 1),
                          ((PAGE_CACHE_SIZE - 1) - old_end_pos_in_page));
         if (rc) {
-                ecryptfs_printk(KERN_ERR, "write_zeros(file=[%p], "
+                ecryptfs_printk(KERN_ERR, "ecryptfs_write_zeros(file=[%p], "
                                 "index=[0x%.16x], old_end_pos_in_page=[d], "
                                 "(PAGE_CACHE_SIZE - old_end_pos_in_page)=[d]) "
                                 "returned [%d]\n", file, index,
@@ -131,9 +131,10 @@ int ecryptfs_fill_zeros(struct file *file, loff_t new_length)
         index++;
         while (index < new_end_page_index) {
                 /* Fill all intermediate pages with zeros */
-                rc = write_zeros(file, index, 0, PAGE_CACHE_SIZE);
+                rc = ecryptfs_write_zeros(file, index, 0, PAGE_CACHE_SIZE);
                 if (rc) {
-                        ecryptfs_printk(KERN_ERR, "write_zeros(file=[%p], "
+                        ecryptfs_printk(KERN_ERR, "ecryptfs_write_zeros("
+                                        "file=[%p], "
                                         "index=[0x%.16x], "
                                         "old_end_pos_in_page=[d], "
                                         "(PAGE_CACHE_SIZE - new_end_pos_in_page"
@@ -149,9 +150,9 @@ int ecryptfs_fill_zeros(struct file *file, loff_t new_length)
         }
         /* Fill the portion at the beginning of the last new page with
          * zero's */
-        rc = write_zeros(file, index, 0, (new_end_pos_in_page + 1));
+        rc = ecryptfs_write_zeros(file, index, 0, (new_end_pos_in_page + 1));
         if (rc) {
-                ecryptfs_printk(KERN_ERR, "write_zeros(file="
+                ecryptfs_printk(KERN_ERR, "ecryptfs_write_zeros(file="
                                 "[%p], index=[0x%.16x], 0, "
                                 "new_end_pos_in_page=[%d]"
                                 "returned [%d]\n", file, index,
@@ -400,7 +401,6 @@ out:
 static int ecryptfs_prepare_write(struct file *file, struct page *page,
                                   unsigned from, unsigned to)
 {
-        loff_t pos;
         int rc = 0;
 
         if (from == 0 && to == PAGE_CACHE_SIZE)
@@ -408,15 +408,22 @@ static int ecryptfs_prepare_write(struct file *file, struct page *page,
                                    up to date. */
         if (!PageUptodate(page))
                 rc = ecryptfs_do_readpage(file, page, page->index);
-        pos = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
-        if (pos > i_size_read(page->mapping->host)) {
-                rc = ecryptfs_truncate(file->f_path.dentry, pos);
-                if (rc) {
-                        printk(KERN_ERR "Error on attempt to "
-                               "truncate to (higher) offset [%lld];"
-                               " rc = [%d]\n", pos, rc);
-                        goto out;
+        if (page->index != 0) {
+                loff_t end_of_prev_pg_pos =
+                        (((loff_t)page->index << PAGE_CACHE_SHIFT) - 1);
+
+                if (end_of_prev_pg_pos > i_size_read(page->mapping->host)) {
+                        rc = ecryptfs_truncate(file->f_path.dentry,
+                                               end_of_prev_pg_pos);
+                        if (rc) {
+                                printk(KERN_ERR "Error on attempt to "
+                                       "truncate to (higher) offset [%lld];"
+                                       " rc = [%d]\n", end_of_prev_pg_pos, rc);
+                                goto out;
+                        }
                 }
+                if (end_of_prev_pg_pos + 1 > i_size_read(page->mapping->host))
+                        zero_user_page(page, 0, PAGE_CACHE_SIZE, KM_USER0);
         }
 out:
         return rc;
@@ -753,7 +760,7 @@ out:
 }
 
 /**
- * write_zeros
+ * ecryptfs_write_zeros
  * @file: The ecryptfs file
  * @index: The index in which we are writing
  * @start: The position after the last block of data
@@ -763,8 +770,8 @@ out:
  *
  * (start + num_zeros) must be less than or equal to PAGE_CACHE_SIZE
  */
-static
-int write_zeros(struct file *file, pgoff_t index, int start, int num_zeros)
+int
+ecryptfs_write_zeros(struct file *file, pgoff_t index, int start, int num_zeros)
 {
         int rc = 0;
         struct page *tmp_page;
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index c9fd8cf6eaa9..5de5061eb331 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1043,6 +1043,7 @@ static int ext2_remount (struct super_block * sb, int * flags, char * data)
 
         if ((ext2_use_xip(sb)) && (sb->s_blocksize != PAGE_SIZE)) {
                 printk("XIP: Unsupported blocksize\n");
+                err = -EINVAL;
                 goto restore_opts;
         }
 
diff --git a/fs/signalfd.c b/fs/signalfd.c
index f1da89203a9a..3b07f26d984d 100644
--- a/fs/signalfd.c
+++ b/fs/signalfd.c
@@ -133,7 +133,8 @@ static unsigned int signalfd_poll(struct file *file, poll_table *wait)
          * the peer disconnects.
          */
         if (signalfd_lock(ctx, &lk)) {
-                if (next_signal(&lk.tsk->pending, &ctx->sigmask) > 0 ||
+                if ((lk.tsk == current &&
+                     next_signal(&lk.tsk->pending, &ctx->sigmask) > 0) ||
                     next_signal(&lk.tsk->signal->shared_pending,
                                 &ctx->sigmask) > 0)
                         events |= POLLIN;
diff --git a/fs/sync.c b/fs/sync.c
index 2f97576355b8..7cd005ea7639 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -236,6 +236,14 @@ out:
         return ret;
 }
 
+/* It would be nice if people remember that not all the world's an i386
+   when they introduce new system calls */
+asmlinkage long sys_sync_file_range2(int fd, unsigned int flags,
+                                     loff_t offset, loff_t nbytes)
+{
+        return sys_sync_file_range(fd, offset, nbytes, flags);
+}
+
 /*
  * `endbyte' is inclusive
  */