generic_write_checks(): drop isblk argument

all remaining callers are passing 0; some just obscure that fact.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index d7fcb775311e5a1697a2d8866a5a9f2bb25eb99a..b5b020ace1b3cddefc9490b2157d3c205fca83c2 100644 (file)
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -409,7 +409,7 @@ v9fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        size_t count = iov_iter_count(from);
        int err = 0;
 
-       retval = generic_write_checks(file, &origin, &count, 0);
+       retval = generic_write_checks(file, &origin, &count);
        if (retval)
                return retval;
 

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index cdc801c8510570a650a17212427b92d35823fab5..691a84a81e09149838c0a1b6b43006d70839a670 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1747,7 +1747,7 @@ static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
        mutex_lock(&inode->i_mutex);
 
        current->backing_dev_info = inode_to_bdi(inode);
-       err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
+       err = generic_write_checks(file, &pos, &count);
        if (err) {
                mutex_unlock(&inode->i_mutex);
                goto out;

diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 56237ea5fc227580580e8f27a308e97a7fb1c07b..761841903160223674df8b2a63464e39f9220988 100644 (file)
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -953,7 +953,7 @@ static ssize_t ceph_write_iter(struct kiocb *iocb, struct iov_iter *from)
        /* We can write back this queue in page reclaim */
        current->backing_dev_info = inode_to_bdi(inode);
 
-       err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
+       err = generic_write_checks(file, &pos, &count);
        if (err)
                goto out;
 

diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 3c5c9bc5cbafd94ac2fbe1cabf8b1091c0e40ff3..4202e74b2db5cdf15d878add2e8f2a95e9e52b7e 100644 (file)
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -2580,7 +2580,7 @@ ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
         */
 
        len = iov_iter_count(from);
-       rc = generic_write_checks(file, &iocb->ki_pos, &len, 0);
+       rc = generic_write_checks(file, &iocb->ki_pos, &len);
        if (rc)
                return rc;
 
@@ -2684,7 +2684,7 @@ cifs_writev(struct kiocb *iocb, struct iov_iter *from)
        mutex_lock(&inode->i_mutex);
 
        count = iov_iter_count(from);
-       rc = generic_write_checks(file, &iocb->ki_pos, &count, 0);
+       rc = generic_write_checks(file, &iocb->ki_pos, &count);
        if (rc)
                goto out;
 

diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index f7cca423ddedb8fd8329cf4357a47a556cc0c44c..1f0afc181b7b4fd0030a89f7d2a20513affa90d7 100644 (file)
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -171,7 +171,7 @@ ext4_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                }
        }
 
-       ret = generic_write_checks(file, &iocb->ki_pos, &length, 0);
+       ret = generic_write_checks(file, &iocb->ki_pos, &length);
        if (ret)
                goto out;
 

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 3d355e946991460b1c305d7f5982a54659ebb1f3..4c04a8144a755fd77f72db37e43207eb5b990800 100644 (file)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -1167,7 +1167,7 @@ static ssize_t fuse_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        /* We can write back this queue in page reclaim */
        current->backing_dev_info = inode_to_bdi(inode);
 
-       err = generic_write_checks(file, &pos, &count, S_ISBLK(inode->i_mode));
+       err = generic_write_checks(file, &pos, &count);
        if (err)
                goto out;
 
@@ -1420,7 +1420,7 @@ static ssize_t fuse_direct_write_iter(struct kiocb *iocb, struct iov_iter *from)
 
        /* Don't allow parallel writes to the same file */
        mutex_lock(&inode->i_mutex);
-       res = generic_write_checks(file, &iocb->ki_pos, &count, 0);
+       res = generic_write_checks(file, &iocb->ki_pos, &count);
        if (!res) {
                iov_iter_truncate(from, count);
                res = fuse_direct_io(&io, from, &iocb->ki_pos, FUSE_DIO_WRITE);
@@ -2841,7 +2841,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter, loff_t offset)
                io->done = &wait;
 
        if (iov_iter_rw(iter) == WRITE) {
-               ret = generic_write_checks(file, &pos, &count, 0);
+               ret = generic_write_checks(file, &pos, &count);
                if (!ret) {
                        iov_iter_truncate(iter, count);
                        ret = fuse_direct_io(io, iter, &pos, FUSE_DIO_WRITE);

diff --git a/fs/ncpfs/file.c b/fs/ncpfs/file.c
index 479bf8db264e0cd0f253093f957a2ea32f0012a2..ab6363b165565bd930e0edb84439eaf9b4cf9e5f 100644 (file)
--- a/fs/ncpfs/file.c
+++ b/fs/ncpfs/file.c
@@ -177,7 +177,7 @@ ncp_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        void *bouncebuffer;
 
        ncp_dbg(1, "enter %pD2\n", file);
-       errno = generic_write_checks(file, &pos, &count, 0);
+       errno = generic_write_checks(file, &pos, &count);
        if (errno)
                return errno;
        iov_iter_truncate(from, count);

diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 06503bc604e18228747016f313590bf279a7eb92..5ddd77acb3f7434b74b733887e617bee346ff66b 100644 (file)
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -977,7 +977,7 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter,
        dfprintk(FILE, "NFS: direct write(%pD2, %zd@%Ld)\n",
                file, count, (long long) pos);
 
-       result = generic_write_checks(file, &pos, &count, 0);
+       result = generic_write_checks(file, &pos, &count);
        if (result)
                goto out;
 

diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 77087d5ad45828558e06cb8ff7937134edeef647..cec4ec3c1ede2d343c6890c88eca19cd7e9babc8 100644 (file)
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -345,7 +345,7 @@ static ssize_t ntfs_prepare_file_for_write(struct kiocb *iocb,
                        "0x%llx, count 0x%zx.", vi->i_ino,
                        (unsigned)le32_to_cpu(ni->type),
                        (unsigned long long)iocb->ki_pos, count);
-       err = generic_write_checks(file, &iocb->ki_pos, &count, S_ISBLK(vi->i_mode));
+       err = generic_write_checks(file, &iocb->ki_pos, &count);
        if (unlikely(err))
                goto out;
        iov_iter_truncate(from, count);

diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 0a6ec7e6efd81b7d31b01d18797a9d6b703ecd59..1c11314946cb42bcde7b92b78e773d3ee67c78d1 100644 (file)
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -2374,8 +2374,7 @@ relock:
        /* communicate with ocfs2_dio_end_io */
        ocfs2_iocb_set_rw_locked(iocb, rw_level);
 
-       ret = generic_write_checks(file, ppos, &count,
-                                  S_ISBLK(inode->i_mode));
+       ret = generic_write_checks(file, ppos, &count);
        if (ret)
                goto out_dio;
 

diff --git a/fs/udf/file.c b/fs/udf/file.c
index 35e81ed9940543ad6241917a3adcf741d882a9ee..6834509a7e5a7e782b0f58abc74fcb2eff44dda8 100644 (file)
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -151,7 +151,7 @@ static ssize_t udf_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        } else
                up_write(&iinfo->i_data_sem);
 
-       retval = generic_write_checks(file, &iocb->ki_pos, &count, 0);
+       retval = generic_write_checks(file, &iocb->ki_pos, &count);
        if (retval)
                goto out;
 

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 44856c3b9617c6f658f6ab9b05b5f08be23f2a01..43c0e6686c47707ba7584fad63c9736ecfb0061d 100644 (file)
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -554,7 +554,7 @@ xfs_file_aio_write_checks(
        int                     error = 0;
 
 restart:
-       error = generic_write_checks(file, pos, count, S_ISBLK(inode->i_mode));
+       error = generic_write_checks(file, pos, count);
        if (error)
                return error;
 

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 72e3759de8c38b5b4b3d2e9228eaaff00261407e..492948ea4c9bdc426852b2461e7a10109e2699e3 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2566,7 +2566,7 @@ extern int sb_min_blocksize(struct super_block *, int);
 
 extern int generic_file_mmap(struct file *, struct vm_area_struct *);
 extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
-int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
+int generic_write_checks(struct file *file, loff_t *pos, size_t *count);
 extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
 extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
 extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);

diff --git a/mm/filemap.c b/mm/filemap.c
index a794a7f987435c07db26148ec076c35116b3d498..dfc573c6ec25d3530570752cc1062e42fd345752 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2260,7 +2260,7 @@ EXPORT_SYMBOL(read_cache_page_gfp);
  * Returns appropriate error code that caller should return or
  * zero in case that write should be allowed.
  */
-inline int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk)
+inline int generic_write_checks(struct file *file, loff_t *pos, size_t *count)
 {
        struct inode *inode = file->f_mapping->host;
        unsigned long limit = rlimit(RLIMIT_FSIZE);
@@ -2268,20 +2268,17 @@ inline int generic_write_checks(struct file *file, loff_t *pos, size_t *count, i
         if (unlikely(*pos < 0))
                 return -EINVAL;
 
-       if (!isblk) {
-               /* FIXME: this is for backwards compatibility with 2.4 */
-               if (file->f_flags & O_APPEND)
-                        *pos = i_size_read(inode);
+       /* FIXME: this is for backwards compatibility with 2.4 */
+       if (file->f_flags & O_APPEND)
+               *pos = i_size_read(inode);
 
-               if (limit != RLIM_INFINITY) {
-                       if (*pos >= limit) {
-                               send_sig(SIGXFSZ, current, 0);
-                               return -EFBIG;
-                       }
-                       if (*count > limit - (typeof(limit))*pos) {
-                               *count = limit - (typeof(limit))*pos;
-                       }
+       if (limit != RLIM_INFINITY) {
+               if (*pos >= limit) {
+                       send_sig(SIGXFSZ, current, 0);
+                       return -EFBIG;
                }
+               if (*count > limit - (typeof(limit))*pos)
+                       *count = limit - (typeof(limit))*pos;
        }
 
        /*
@@ -2289,12 +2286,10 @@ inline int generic_write_checks(struct file *file, loff_t *pos, size_t *count, i
         */
        if (unlikely(*pos + *count > MAX_NON_LFS &&
                                !(file->f_flags & O_LARGEFILE))) {
-               if (*pos >= MAX_NON_LFS) {
+               if (*pos >= MAX_NON_LFS)
                        return -EFBIG;
-               }
-               if (*count > MAX_NON_LFS - (unsigned long)*pos) {
+               if (*count > MAX_NON_LFS - (unsigned long)*pos)
                        *count = MAX_NON_LFS - (unsigned long)*pos;
-               }
        }
 
        /*
@@ -2304,33 +2299,15 @@ inline int generic_write_checks(struct file *file, loff_t *pos, size_t *count, i
         * exceeded without writing data we send a signal and return EFBIG.
         * Linus frestrict idea will clean these up nicely..
         */
-       if (likely(!isblk)) {
-               if (unlikely(*pos >= inode->i_sb->s_maxbytes)) {
-                       if (*count || *pos > inode->i_sb->s_maxbytes) {
-                               return -EFBIG;
-                       }
-                       /* zero-length writes at ->s_maxbytes are OK */
-               }
-
-               if (unlikely(*pos + *count > inode->i_sb->s_maxbytes))
-                       *count = inode->i_sb->s_maxbytes - *pos;
-       } else {
-#ifdef CONFIG_BLOCK
-               loff_t isize;
-               if (bdev_read_only(I_BDEV(inode)))
-                       return -EPERM;
-               isize = i_size_read(inode);
-               if (*pos >= isize) {
-                       if (*count || *pos > isize)
-                               return -ENOSPC;
+       if (unlikely(*pos >= inode->i_sb->s_maxbytes)) {
+               if (*count || *pos > inode->i_sb->s_maxbytes) {
+                       return -EFBIG;
                }
-
-               if (*pos + *count > isize)
-                       *count = isize - *pos;
-#else
-               return -EPERM;
-#endif
+               /* zero-length writes at ->s_maxbytes are OK */
        }
+
+       if (unlikely(*pos + *count > inode->i_sb->s_maxbytes))
+               *count = inode->i_sb->s_maxbytes - *pos;
        return 0;
 }
 EXPORT_SYMBOL(generic_write_checks);
@@ -2644,7 +2621,7 @@ ssize_t generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
        size_t count = iov_iter_count(from);
 
        mutex_lock(&inode->i_mutex);
-       ret = generic_write_checks(file, &iocb->ki_pos, &count, 0);
+       ret = generic_write_checks(file, &iocb->ki_pos, &count);
        if (!ret && count) {
                iov_iter_truncate(from, count);
                ret = __generic_file_write_iter(iocb, from);