11 files changed, 207 insertions, 73 deletions

diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c
index 452e98dd7560..1ee54ffd3a24 100644
--- a/fs/cachefiles/daemon.c
+++ b/fs/cachefiles/daemon.c
@@ -162,6 +162,8 @@ static ssize_t cachefiles_daemon_read(struct file *file, char __user *_buffer,
                                       size_t buflen, loff_t *pos)
 {
         struct cachefiles_cache *cache = file->private_data;
+        unsigned long long b_released;
+        unsigned f_released;
         char buffer[256];
         int n;
 
@@ -174,6 +176,8 @@ static ssize_t cachefiles_daemon_read(struct file *file, char __user *_buffer,
         cachefiles_has_space(cache, 0, 0);
 
         /* summarise */
+        f_released = atomic_xchg(&cache->f_released, 0);
+        b_released = atomic_long_xchg(&cache->b_released, 0);
         clear_bit(CACHEFILES_STATE_CHANGED, &cache->flags);
 
         n = snprintf(buffer, sizeof(buffer),
@@ -183,15 +187,18 @@ static ssize_t cachefiles_daemon_read(struct file *file, char __user *_buffer,
                      " fstop=%llx"
                      " brun=%llx"
                      " bcull=%llx"
-                     " bstop=%llx",
+                     " bstop=%llx"
+                     " freleased=%x"
+                     " breleased=%llx",
                      test_bit(CACHEFILES_CULLING, &cache->flags) ? '1' : '0',
                      (unsigned long long) cache->frun,
                      (unsigned long long) cache->fcull,
                      (unsigned long long) cache->fstop,
                      (unsigned long long) cache->brun,
                      (unsigned long long) cache->bcull,
-                     (unsigned long long) cache->bstop
-                     );
+                     (unsigned long long) cache->bstop,
+                     f_released,
+                     b_released);
 
         if (n > buflen)
                 return -EMSGSIZE;
diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index 675a3332d72f..861d611b8c05 100644
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -291,15 +291,8 @@ static void cachefiles_drop_object(struct fscache_object *_object)
         }
 
         /* note that the object is now inactive */
-        if (test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
-                write_lock(&cache->active_lock);
-                if (!test_and_clear_bit(CACHEFILES_OBJECT_ACTIVE,
-                                        &object->flags))
-                        BUG();
-                rb_erase(&object->active_node, &cache->active_nodes);
-                wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
-                write_unlock(&cache->active_lock);
-        }
+        if (test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags))
+                cachefiles_mark_object_inactive(cache, object);
 
         dput(object->dentry);
         object->dentry = NULL;
diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h
index 9c4b737a54df..2fcde1a34b7c 100644
--- a/fs/cachefiles/internal.h
+++ b/fs/cachefiles/internal.h
@@ -66,6 +66,8 @@ struct cachefiles_cache {
         struct rb_root                  active_nodes;   /* active nodes (can't be culled) */
         rwlock_t                        active_lock;    /* lock for active_nodes */
         atomic_t                        gravecounter;   /* graveyard uniquifier */
+        atomic_t                        f_released;     /* number of objects released lately */
+        atomic_long_t                   b_released;     /* number of blocks released lately */
         unsigned                        frun_percent;   /* when to stop culling (% files) */
         unsigned                        fcull_percent;  /* when to start culling (% files) */
         unsigned                        fstop_percent;  /* when to stop allocating (% files) */
@@ -157,6 +159,8 @@ extern char *cachefiles_cook_key(const u8 *raw, int keylen, uint8_t type);
 /*
  * namei.c
  */
+extern void cachefiles_mark_object_inactive(struct cachefiles_cache *cache,
+                                            struct cachefiles_object *object);
 extern int cachefiles_delete_object(struct cachefiles_cache *cache,
                                     struct cachefiles_object *object);
 extern int cachefiles_walk_to_object(struct cachefiles_object *parent,
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index 1c2334c163dd..4ae75006e73b 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -258,6 +258,28 @@ requeue:
 }
 
 /*
+ * Mark an object as being inactive.
+ */
+void cachefiles_mark_object_inactive(struct cachefiles_cache *cache,
+                                     struct cachefiles_object *object)
+{
+        write_lock(&cache->active_lock);
+        rb_erase(&object->active_node, &cache->active_nodes);
+        clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
+        write_unlock(&cache->active_lock);
+
+        wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
+
+        /* This object can now be culled, so we need to let the daemon know
+         * that there is something it can remove if it needs to.
+         */
+        atomic_long_add(d_backing_inode(object->dentry)->i_blocks,
+                        &cache->b_released);
+        if (atomic_inc_return(&cache->f_released))
+                cachefiles_state_changed(cache);
+}
+
+/*
  * delete an object representation from the cache
  * - file backed objects are unlinked
  * - directory backed objects are stuffed into the graveyard for userspace to
@@ -684,11 +706,7 @@ mark_active_timed_out:
 
 check_error:
         _debug("check error %d", ret);
-        write_lock(&cache->active_lock);
-        rb_erase(&object->active_node, &cache->active_nodes);
-        clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
-        wake_up_bit(&object->flags, CACHEFILES_OBJECT_ACTIVE);
-        write_unlock(&cache->active_lock);
+        cachefiles_mark_object_inactive(cache, object);
 release_dentry:
         dput(object->dentry);
         object->dentry = NULL;
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 1b2f7ffc8b84..85463171053b 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -445,7 +445,8 @@ static struct bio *dio_await_one(struct dio *dio)
                 __set_current_state(TASK_UNINTERRUPTIBLE);
                 dio->waiter = current;
                 spin_unlock_irqrestore(&dio->bio_lock, flags);
-                if (!blk_poll(bdev_get_queue(dio->bio_bdev), dio->bio_cookie))
+                if (!(dio->iocb->ki_flags & IOCB_HIPRI) ||
+                    !blk_poll(bdev_get_queue(dio->bio_bdev), dio->bio_cookie))
                         io_schedule();
                 /* wake up sets us TASK_RUNNING */
                 spin_lock_irqsave(&dio->bio_lock, flags);
diff --git a/fs/jffs2/dir.c b/fs/jffs2/dir.c
index d211b8e18566..30c4c9ebb693 100644
--- a/fs/jffs2/dir.c
+++ b/fs/jffs2/dir.c
@@ -843,9 +843,14 @@ static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
 
                 pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n",
                           __func__, ret);
-                /* Might as well let the VFS know */
-                d_instantiate(new_dentry, d_inode(old_dentry));
-                ihold(d_inode(old_dentry));
+                /*
+                 * We can't keep the target in dcache after that.
+                 * For one thing, we can't afford dentry aliases for directories.
+                 * For another, if there was a victim, we _can't_ set new inode
+                 * for that sucker and we have to trigger mount eviction - the
+                 * caller won't do it on its own since we are returning an error.
+                 */
+                d_invalidate(new_dentry);
                 new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now);
                 return ret;
         }
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index 26c2de2de13f..b7f8eaeea5d8 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -633,7 +633,7 @@ ncp_fill_cache(struct file *file, struct dir_context *ctx,
                                 d_rehash(newdent);
                 } else {
                         spin_lock(&dentry->d_lock);
-                        NCP_FINFO(inode)->flags &= ~NCPI_DIR_CACHE;
+                        NCP_FINFO(dir)->flags &= ~NCPI_DIR_CACHE;
                         spin_unlock(&dentry->d_lock);
                 }
         } else {
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 5d2a57e4c03a..d40010e4f1a9 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -870,7 +870,7 @@ __be32 nfsd_readv(struct file *file, loff_t offset, struct kvec *vec, int vlen,
 
         oldfs = get_fs();
         set_fs(KERNEL_DS);
-        host_err = vfs_readv(file, (struct iovec __user *)vec, vlen, &offset);
+        host_err = vfs_readv(file, (struct iovec __user *)vec, vlen, &offset, 0);
         set_fs(oldfs);
         return nfsd_finish_read(file, count, host_err);
 }
@@ -957,7 +957,7 @@ nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
 
         /* Write the data. */
         oldfs = get_fs(); set_fs(KERNEL_DS);
-        host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &pos);
+        host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &pos, 0);
         set_fs(oldfs);
         if (host_err < 0)
                 goto out_nfserr;
diff --git a/fs/proc_namespace.c b/fs/proc_namespace.c
index 2256e7e23e67..3f1190d18991 100644
--- a/fs/proc_namespace.c
+++ b/fs/proc_namespace.c
@@ -199,6 +199,8 @@ static int show_vfsstat(struct seq_file *m, struct vfsmount *mnt)
         if (sb->s_op->show_devname) {
                 seq_puts(m, "device ");
                 err = sb->s_op->show_devname(m, mnt_path.dentry);
+                if (err)
+                        goto out;
         } else {
                 if (r->mnt_devname) {
                         seq_puts(m, "device ");
diff --git a/fs/read_write.c b/fs/read_write.c
index dadf24e5c95b..cf377cf9dfe3 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -693,12 +693,17 @@ unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
 EXPORT_SYMBOL(iov_shorten);
 
 static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
-                loff_t *ppos, iter_fn_t fn)
+                loff_t *ppos, iter_fn_t fn, int flags)
 {
         struct kiocb kiocb;
         ssize_t ret;
 
+        if (flags & ~RWF_HIPRI)
+                return -EOPNOTSUPP;
+
         init_sync_kiocb(&kiocb, filp);
+        if (flags & RWF_HIPRI)
+                kiocb.ki_flags |= IOCB_HIPRI;
         kiocb.ki_pos = *ppos;
 
         ret = fn(&kiocb, iter);
@@ -709,10 +714,13 @@ static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
 
 /* Do it by hand, with file-ops */
 static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
-                loff_t *ppos, io_fn_t fn)
+                loff_t *ppos, io_fn_t fn, int flags)
 {
         ssize_t ret = 0;
 
+        if (flags & ~RWF_HIPRI)
+                return -EOPNOTSUPP;
+
         while (iov_iter_count(iter)) {
                 struct iovec iovec = iov_iter_iovec(iter);
                 ssize_t nr;
@@ -813,7 +821,8 @@ out:
 
 static ssize_t do_readv_writev(int type, struct file *file,
                                const struct iovec __user * uvector,
-                               unsigned long nr_segs, loff_t *pos)
+                               unsigned long nr_segs, loff_t *pos,
+                               int flags)
 {
         size_t tot_len;
         struct iovec iovstack[UIO_FASTIOV];
@@ -845,9 +854,9 @@ static ssize_t do_readv_writev(int type, struct file *file,
         }
 
         if (iter_fn)
-                ret = do_iter_readv_writev(file, &iter, pos, iter_fn);
+                ret = do_iter_readv_writev(file, &iter, pos, iter_fn, flags);
         else
-                ret = do_loop_readv_writev(file, &iter, pos, fn);
+                ret = do_loop_readv_writev(file, &iter, pos, fn, flags);
 
         if (type != READ)
                 file_end_write(file);
@@ -864,40 +873,40 @@ out:
 }
 
 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
-                  unsigned long vlen, loff_t *pos)
+                  unsigned long vlen, loff_t *pos, int flags)
 {
         if (!(file->f_mode & FMODE_READ))
                 return -EBADF;
         if (!(file->f_mode & FMODE_CAN_READ))
                 return -EINVAL;
 
-        return do_readv_writev(READ, file, vec, vlen, pos);
+        return do_readv_writev(READ, file, vec, vlen, pos, flags);
 }
 
 EXPORT_SYMBOL(vfs_readv);
 
 ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
-                   unsigned long vlen, loff_t *pos)
+                   unsigned long vlen, loff_t *pos, int flags)
 {
         if (!(file->f_mode & FMODE_WRITE))
                 return -EBADF;
         if (!(file->f_mode & FMODE_CAN_WRITE))
                 return -EINVAL;
 
-        return do_readv_writev(WRITE, file, vec, vlen, pos);
+        return do_readv_writev(WRITE, file, vec, vlen, pos, flags);
 }
 
 EXPORT_SYMBOL(vfs_writev);
 
-SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
-                unsigned long, vlen)
+static ssize_t do_readv(unsigned long fd, const struct iovec __user *vec,
+                        unsigned long vlen, int flags)
 {
         struct fd f = fdget_pos(fd);
         ssize_t ret = -EBADF;
 
         if (f.file) {
                 loff_t pos = file_pos_read(f.file);
-                ret = vfs_readv(f.file, vec, vlen, &pos);
+                ret = vfs_readv(f.file, vec, vlen, &pos, flags);
                 if (ret >= 0)
                         file_pos_write(f.file, pos);
                 fdput_pos(f);
@@ -909,15 +918,15 @@ SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
         return ret;
 }
 
-SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
-                unsigned long, vlen)
+static ssize_t do_writev(unsigned long fd, const struct iovec __user *vec,
+                         unsigned long vlen, int flags)
 {
         struct fd f = fdget_pos(fd);
         ssize_t ret = -EBADF;
 
         if (f.file) {
                 loff_t pos = file_pos_read(f.file);
-                ret = vfs_writev(f.file, vec, vlen, &pos);
+                ret = vfs_writev(f.file, vec, vlen, &pos, flags);
                 if (ret >= 0)
                         file_pos_write(f.file, pos);
                 fdput_pos(f);
@@ -935,10 +944,9 @@ static inline loff_t pos_from_hilo(unsigned long high, unsigned long low)
         return (((loff_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
 }
 
-SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
-                unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
+static ssize_t do_preadv(unsigned long fd, const struct iovec __user *vec,
+                         unsigned long vlen, loff_t pos, int flags)
 {
-        loff_t pos = pos_from_hilo(pos_h, pos_l);
         struct fd f;
         ssize_t ret = -EBADF;
 
@@ -949,7 +957,7 @@ SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
         if (f.file) {
                 ret = -ESPIPE;
                 if (f.file->f_mode & FMODE_PREAD)
-                        ret = vfs_readv(f.file, vec, vlen, &pos);
+                        ret = vfs_readv(f.file, vec, vlen, &pos, flags);
                 fdput(f);
         }
 
@@ -959,10 +967,9 @@ SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
         return ret;
 }
 
-SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
-                unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
+static ssize_t do_pwritev(unsigned long fd, const struct iovec __user *vec,
+                          unsigned long vlen, loff_t pos, int flags)
 {
-        loff_t pos = pos_from_hilo(pos_h, pos_l);
         struct fd f;
         ssize_t ret = -EBADF;
 
@@ -973,7 +980,7 @@ SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
         if (f.file) {
                 ret = -ESPIPE;
                 if (f.file->f_mode & FMODE_PWRITE)
-                        ret = vfs_writev(f.file, vec, vlen, &pos);
+                        ret = vfs_writev(f.file, vec, vlen, &pos, flags);
                 fdput(f);
         }
 
@@ -983,11 +990,64 @@ SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
         return ret;
 }
 
+SYSCALL_DEFINE3(readv, unsigned long, fd, const struct iovec __user *, vec,
+                unsigned long, vlen)
+{
+        return do_readv(fd, vec, vlen, 0);
+}
+
+SYSCALL_DEFINE3(writev, unsigned long, fd, const struct iovec __user *, vec,
+                unsigned long, vlen)
+{
+        return do_writev(fd, vec, vlen, 0);
+}
+
+SYSCALL_DEFINE5(preadv, unsigned long, fd, const struct iovec __user *, vec,
+                unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
+{
+        loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+        return do_preadv(fd, vec, vlen, pos, 0);
+}
+
+SYSCALL_DEFINE6(preadv2, unsigned long, fd, const struct iovec __user *, vec,
+                unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
+                int, flags)
+{
+        loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+        if (pos == -1)
+                return do_readv(fd, vec, vlen, flags);
+
+        return do_preadv(fd, vec, vlen, pos, flags);
+}
+
+SYSCALL_DEFINE5(pwritev, unsigned long, fd, const struct iovec __user *, vec,
+                unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h)
+{
+        loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+        return do_pwritev(fd, vec, vlen, pos, 0);
+}
+
+SYSCALL_DEFINE6(pwritev2, unsigned long, fd, const struct iovec __user *, vec,
+                unsigned long, vlen, unsigned long, pos_l, unsigned long, pos_h,
+                int, flags)
+{
+        loff_t pos = pos_from_hilo(pos_h, pos_l);
+
+        if (pos == -1)
+                return do_writev(fd, vec, vlen, flags);
+
+        return do_pwritev(fd, vec, vlen, pos, flags);
+}
+
 #ifdef CONFIG_COMPAT
 
 static ssize_t compat_do_readv_writev(int type, struct file *file,
                                const struct compat_iovec __user *uvector,
-                               unsigned long nr_segs, loff_t *pos)
+                               unsigned long nr_segs, loff_t *pos,
+                               int flags)
 {
         compat_ssize_t tot_len;
         struct iovec iovstack[UIO_FASTIOV];
@@ -1019,9 +1079,9 @@ static ssize_t compat_do_readv_writev(int type, struct file *file,
         }
 
         if (iter_fn)
-                ret = do_iter_readv_writev(file, &iter, pos, iter_fn);
+                ret = do_iter_readv_writev(file, &iter, pos, iter_fn, flags);
         else
-                ret = do_loop_readv_writev(file, &iter, pos, fn);
+                ret = do_loop_readv_writev(file, &iter, pos, fn, flags);
 
         if (type != READ)
                 file_end_write(file);
@@ -1039,7 +1099,7 @@ out:
 
 static size_t compat_readv(struct file *file,
                            const struct compat_iovec __user *vec,
-                           unsigned long vlen, loff_t *pos)
+                           unsigned long vlen, loff_t *pos, int flags)
 {
         ssize_t ret = -EBADF;
 
@@ -1050,7 +1110,7 @@ static size_t compat_readv(struct file *file,
         if (!(file->f_mode & FMODE_CAN_READ))
                 goto out;
 
-        ret = compat_do_readv_writev(READ, file, vec, vlen, pos);
+        ret = compat_do_readv_writev(READ, file, vec, vlen, pos, flags);
 
 out:
         if (ret > 0)
@@ -1059,9 +1119,9 @@ out:
         return ret;
 }
 
-COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
-                const struct compat_iovec __user *,vec,
-                compat_ulong_t, vlen)
+static size_t do_compat_readv(compat_ulong_t fd,
+                                 const struct compat_iovec __user *vec,
+                                 compat_ulong_t vlen, int flags)
 {
         struct fd f = fdget_pos(fd);
         ssize_t ret;
@@ -1070,16 +1130,24 @@ COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
         if (!f.file)
                 return -EBADF;
         pos = f.file->f_pos;
-        ret = compat_readv(f.file, vec, vlen, &pos);
+        ret = compat_readv(f.file, vec, vlen, &pos, flags);
         if (ret >= 0)
                 f.file->f_pos = pos;
         fdput_pos(f);
         return ret;
+
+}
+
+COMPAT_SYSCALL_DEFINE3(readv, compat_ulong_t, fd,
+                const struct compat_iovec __user *,vec,
+                compat_ulong_t, vlen)
+{
+        return do_compat_readv(fd, vec, vlen, 0);
 }
 
-static long __compat_sys_preadv64(unsigned long fd,
+static long do_compat_preadv64(unsigned long fd,
                                   const struct compat_iovec __user *vec,
-                                  unsigned long vlen, loff_t pos)
+                                  unsigned long vlen, loff_t pos, int flags)
 {
         struct fd f;
         ssize_t ret;
@@ -1091,7 +1159,7 @@ static long __compat_sys_preadv64(unsigned long fd,
                 return -EBADF;
         ret = -ESPIPE;
         if (f.file->f_mode & FMODE_PREAD)
-                ret = compat_readv(f.file, vec, vlen, &pos);
+                ret = compat_readv(f.file, vec, vlen, &pos, flags);
         fdput(f);
         return ret;
 }
@@ -1101,7 +1169,7 @@ COMPAT_SYSCALL_DEFINE4(preadv64, unsigned long, fd,
                 const struct compat_iovec __user *,vec,
                 unsigned long, vlen, loff_t, pos)
 {
-        return __compat_sys_preadv64(fd, vec, vlen, pos);
+        return do_compat_preadv64(fd, vec, vlen, pos, 0);
 }
 #endif
 
@@ -1111,12 +1179,25 @@ COMPAT_SYSCALL_DEFINE5(preadv, compat_ulong_t, fd,
 {
         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
 
-        return __compat_sys_preadv64(fd, vec, vlen, pos);
+        return do_compat_preadv64(fd, vec, vlen, pos, 0);
+}
+
+COMPAT_SYSCALL_DEFINE6(preadv2, compat_ulong_t, fd,
+                const struct compat_iovec __user *,vec,
+                compat_ulong_t, vlen, u32, pos_low, u32, pos_high,
+                int, flags)
+{
+        loff_t pos = ((loff_t)pos_high << 32) | pos_low;
+
+        if (pos == -1)
+                return do_compat_readv(fd, vec, vlen, flags);
+
+        return do_compat_preadv64(fd, vec, vlen, pos, flags);
 }
 
 static size_t compat_writev(struct file *file,
                             const struct compat_iovec __user *vec,
-                            unsigned long vlen, loff_t *pos)
+                            unsigned long vlen, loff_t *pos, int flags)
 {
         ssize_t ret = -EBADF;
 
@@ -1127,7 +1208,7 @@ static size_t compat_writev(struct file *file,
         if (!(file->f_mode & FMODE_CAN_WRITE))
                 goto out;
 
-        ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos);
+        ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos, 0);
 
 out:
         if (ret > 0)
@@ -1136,9 +1217,9 @@ out:
         return ret;
 }
 
-COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
-                const struct compat_iovec __user *, vec,
-                compat_ulong_t, vlen)
+static size_t do_compat_writev(compat_ulong_t fd,
+                                  const struct compat_iovec __user* vec,
+                                  compat_ulong_t vlen, int flags)
 {
         struct fd f = fdget_pos(fd);
         ssize_t ret;
@@ -1147,16 +1228,23 @@ COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
         if (!f.file)
                 return -EBADF;
         pos = f.file->f_pos;
-        ret = compat_writev(f.file, vec, vlen, &pos);
+        ret = compat_writev(f.file, vec, vlen, &pos, flags);
         if (ret >= 0)
                 f.file->f_pos = pos;
         fdput_pos(f);
         return ret;
 }
 
-static long __compat_sys_pwritev64(unsigned long fd,
+COMPAT_SYSCALL_DEFINE3(writev, compat_ulong_t, fd,
+                const struct compat_iovec __user *, vec,
+                compat_ulong_t, vlen)
+{
+        return do_compat_writev(fd, vec, vlen, 0);
+}
+
+static long do_compat_pwritev64(unsigned long fd,
                                    const struct compat_iovec __user *vec,
-                                   unsigned long vlen, loff_t pos)
+                                   unsigned long vlen, loff_t pos, int flags)
 {
         struct fd f;
         ssize_t ret;
@@ -1168,7 +1256,7 @@ static long __compat_sys_pwritev64(unsigned long fd,
                 return -EBADF;
         ret = -ESPIPE;
         if (f.file->f_mode & FMODE_PWRITE)
-                ret = compat_writev(f.file, vec, vlen, &pos);
+                ret = compat_writev(f.file, vec, vlen, &pos, flags);
         fdput(f);
         return ret;
 }
@@ -1178,7 +1266,7 @@ COMPAT_SYSCALL_DEFINE4(pwritev64, unsigned long, fd,
                 const struct compat_iovec __user *,vec,
                 unsigned long, vlen, loff_t, pos)
 {
-        return __compat_sys_pwritev64(fd, vec, vlen, pos);
+        return do_compat_pwritev64(fd, vec, vlen, pos, 0);
 }
 #endif
 
@@ -1188,8 +1276,21 @@ COMPAT_SYSCALL_DEFINE5(pwritev, compat_ulong_t, fd,
 {
         loff_t pos = ((loff_t)pos_high << 32) | pos_low;
 
-        return __compat_sys_pwritev64(fd, vec, vlen, pos);
+        return do_compat_pwritev64(fd, vec, vlen, pos, 0);
+}
+
+COMPAT_SYSCALL_DEFINE6(pwritev2, compat_ulong_t, fd,
+                const struct compat_iovec __user *,vec,
+                compat_ulong_t, vlen, u32, pos_low, u32, pos_high, int, flags)
+{
+        loff_t pos = ((loff_t)pos_high << 32) | pos_low;
+
+        if (pos == -1)
+                return do_compat_writev(fd, vec, vlen, flags);
+
+        return do_compat_pwritev64(fd, vec, vlen, pos, flags);
 }
+
 #endif
 
 static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
diff --git a/fs/splice.c b/fs/splice.c
index 82bc0d64fc38..9947b5c69664 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -185,6 +185,9 @@ ssize_t splice_to_pipe(struct pipe_inode_info *pipe,
         unsigned int spd_pages = spd->nr_pages;
         int ret, do_wakeup, page_nr;
 
+        if (!spd_pages)
+                return 0;
+
         ret = 0;
         do_wakeup = 0;
         page_nr = 0;
@@ -577,7 +580,7 @@ static ssize_t kernel_readv(struct file *file, const struct iovec *vec,
         old_fs = get_fs();
         set_fs(get_ds());
         /* The cast to a user pointer is valid due to the set_fs() */
-        res = vfs_readv(file, (const struct iovec __user *)vec, vlen, &pos);
+        res = vfs_readv(file, (const struct iovec __user *)vec, vlen, &pos, 0);
         set_fs(old_fs);
 
         return res;