file->f_op is never NULL...

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

diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index bdc1d15369f844bfce700a9794b4f8eb558fa921..d1c7de92cfdf0c4eeaeed8cd9532c020e534889e 100644 (file)
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -575,7 +575,7 @@ static int alloc_device(struct nandsim *ns)
                cfile = filp_open(cache_file, O_CREAT | O_RDWR | O_LARGEFILE, 0600);
                if (IS_ERR(cfile))
                        return PTR_ERR(cfile);
-               if (!cfile->f_op || (!cfile->f_op->read && !cfile->f_op->aio_read)) {
+               if (!cfile->f_op->read && !cfile->f_op->aio_read) {
                        NS_ERR("alloc_device: cache file not readable\n");
                        err = -EINVAL;
                        goto err_close;

diff --git a/drivers/staging/comedi/comedi_compat32.c b/drivers/staging/comedi/comedi_compat32.c
index 2dfb06aedb153cfd91040e4c3df570c8e74cc6e5..1e9da405d8332364c8984a0a7fa9008b965d442a 100644 (file)
--- a/drivers/staging/comedi/comedi_compat32.c
+++ b/drivers/staging/comedi/comedi_compat32.c
@@ -86,9 +86,6 @@ struct comedi32_insnlist_struct {
 static int translated_ioctl(struct file *file, unsigned int cmd,
                            unsigned long arg)
 {
-       if (!file->f_op)
-               return -ENOTTY;
-
        if (file->f_op->unlocked_ioctl)
                return file->f_op->unlocked_ioctl(file, cmd, arg);
 

diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index 3f1128b37e462cd3ef65560137e2194fe816990e..ebab147e970038aace85ad1095220dbc6784f5df 100644 (file)
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -271,7 +271,7 @@ void autofs4_clean_ino(struct autofs_info *);
 
 static inline int autofs_prepare_pipe(struct file *pipe)
 {
-       if (!pipe->f_op || !pipe->f_op->write)
+       if (!pipe->f_op->write)
                return -EINVAL;
        if (!S_ISFIFO(file_inode(pipe)->i_mode))
                return -EINVAL;

diff --git a/fs/autofs4/dev-ioctl.c b/fs/autofs4/dev-ioctl.c
index 0f00da329e718ab465ddb1488dda626db71cca23..1818ce7f5a06049178e968d978733fe29c920e1f 100644 (file)
--- a/fs/autofs4/dev-ioctl.c
+++ b/fs/autofs4/dev-ioctl.c
@@ -658,12 +658,6 @@ static int _autofs_dev_ioctl(unsigned int command, struct autofs_dev_ioctl __use
                        goto out;
                }
 
-               if (!fp->f_op) {
-                       err = -ENOTTY;
-                       fput(fp);
-                       goto out;
-               }
-
                sbi = autofs_dev_ioctl_sbi(fp);
                if (!sbi || sbi->magic != AUTOFS_SBI_MAGIC) {
                        err = -EINVAL;

diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index 89dec7f789a44335c500e8a2d89fc3f13dac6c5e..faaa819f70faeb8b7f508a5ff0ea56e20a892c6d 100644 (file)
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -221,7 +221,7 @@ static int load_aout_binary(struct linux_binprm * bprm)
         * Requires a mmap handler. This prevents people from using a.out
         * as part of an exploit attack against /proc-related vulnerabilities.
         */
-       if (!bprm->file->f_op || !bprm->file->f_op->mmap)
+       if (!bprm->file->f_op->mmap)
                return -ENOEXEC;
 
        fd_offset = N_TXTOFF(ex);
@@ -374,7 +374,7 @@ static int load_aout_library(struct file *file)
         * Requires a mmap handler. This prevents people from using a.out
         * as part of an exploit attack against /proc-related vulnerabilities.
         */
-       if (!file->f_op || !file->f_op->mmap)
+       if (!file->f_op->mmap)
                goto out;
 
        if (N_FLAGS(ex))

diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 4c94a79991bb6d8ae0d2e12ae8c647e2fe22f7fe..501c8a4d6eb1cb1bb3753da7f3aa0ae41a0ef36a 100644 (file)
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -406,7 +406,7 @@ static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
                goto out;
        if (!elf_check_arch(interp_elf_ex))
                goto out;
-       if (!interpreter->f_op || !interpreter->f_op->mmap)
+       if (!interpreter->f_op->mmap)
                goto out;
 
        /*
@@ -607,7 +607,7 @@ static int load_elf_binary(struct linux_binprm *bprm)
                goto out;
        if (!elf_check_arch(&loc->elf_ex))
                goto out;
-       if (!bprm->file->f_op || !bprm->file->f_op->mmap)
+       if (!bprm->file->f_op->mmap)
                goto out;
 
        /* Now read in all of the header information */
@@ -1028,7 +1028,7 @@ static int load_elf_library(struct file *file)
 
        /* First of all, some simple consistency checks */
        if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
-           !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
+           !elf_check_arch(&elf_ex) || !file->f_op->mmap)
                goto out;
 
        /* Now read in all of the header information */

diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index c166f325a1839b1ecf83ae0b068f13e8a26495c2..ea4c6273b4a5b02406fc7e7b457c676f30724a78 100644 (file)
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -111,7 +111,7 @@ static int is_elf_fdpic(struct elfhdr *hdr, struct file *file)
                return 0;
        if (!elf_check_arch(hdr) || !elf_check_fdpic(hdr))
                return 0;
-       if (!file->f_op || !file->f_op->mmap)
+       if (!file->f_op->mmap)
                return 0;
        return 1;
 }

diff --git a/fs/binfmt_em86.c b/fs/binfmt_em86.c
index 037a3e2b045b07b27fc1f1fde0a0b3f2e1a541df..f37b08cea1f760a061d7a5d49bf8dcaeda385ab8 100644 (file)
--- a/fs/binfmt_em86.c
+++ b/fs/binfmt_em86.c
@@ -38,7 +38,7 @@ static int load_em86(struct linux_binprm *bprm)
        /* First of all, some simple consistency checks */
        if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
                (!((elf_ex.e_machine == EM_386) || (elf_ex.e_machine == EM_486))) ||
-               (!bprm->file->f_op || !bprm->file->f_op->mmap)) {
+               !bprm->file->f_op->mmap) {
                        return -ENOEXEC;
        }
 

diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 190effc6a6fae2e09f0826979c201c532003b1b8..8c8d469c9283f93ed49f2ee3ec47cdf9ebfb18e4 100644 (file)
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -387,9 +387,6 @@ static int coda_readdir(struct file *coda_file, struct dir_context *ctx)
        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
 
-       if (!host_file->f_op)
-               return -ENOTDIR;
-
        if (host_file->f_op->iterate) {
                struct inode *host_inode = file_inode(host_file);
                mutex_lock(&host_inode->i_mutex);

diff --git a/fs/coda/file.c b/fs/coda/file.c
index 380b798f8443360a9788a13b7de4ad4ea16fd255..9e83b77902126a011e1505104bd707dbe89f809d 100644 (file)
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -36,7 +36,7 @@ coda_file_read(struct file *coda_file, char __user *buf, size_t count, loff_t *p
        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
 
-       if (!host_file->f_op || !host_file->f_op->read)
+       if (!host_file->f_op->read)
                return -EINVAL;
 
        return host_file->f_op->read(host_file, buf, count, ppos);
@@ -75,7 +75,7 @@ coda_file_write(struct file *coda_file, const char __user *buf, size_t count, lo
        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
 
-       if (!host_file->f_op || !host_file->f_op->write)
+       if (!host_file->f_op->write)
                return -EINVAL;
 
        host_inode = file_inode(host_file);
@@ -105,7 +105,7 @@ coda_file_mmap(struct file *coda_file, struct vm_area_struct *vma)
        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
 
-       if (!host_file->f_op || !host_file->f_op->mmap)
+       if (!host_file->f_op->mmap)
                return -ENODEV;
 
        coda_inode = file_inode(coda_file);

diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index 5d19acfa7c6c652a6b8134ec79507457be463216..dc52e13d58e021ac5cf7951d44c66c8e8d9a4993 100644 (file)
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -1583,13 +1583,13 @@ asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
                /*FALL THROUGH*/
 
        default:
-               if (f.file->f_op && f.file->f_op->compat_ioctl) {
+               if (f.file->f_op->compat_ioctl) {
                        error = f.file->f_op->compat_ioctl(f.file, cmd, arg);
                        if (error != -ENOIOCTLCMD)
                                goto out_fput;
                }
 
-               if (!f.file->f_op || !f.file->f_op->unlocked_ioctl)
+               if (!f.file->f_op->unlocked_ioctl)
                        goto do_ioctl;
                break;
        }

diff --git a/fs/coredump.c b/fs/coredump.c
index 9bdeca12ae0e388ecda010964c5209313cb363a9..42c3b842366980bcdb12dae8eace880464c50cd4 100644 (file)
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@ -645,7 +645,7 @@ void do_coredump(siginfo_t *siginfo)
                 */
                if (!uid_eq(inode->i_uid, current_fsuid()))
                        goto close_fail;
-               if (!cprm.file->f_op || !cprm.file->f_op->write)
+               if (!cprm.file->f_op->write)
                        goto close_fail;
                if (do_truncate(cprm.file->f_path.dentry, 0, 0, cprm.file))
                        goto close_fail;

diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index 992cf95830b5792a5d510f7d588049d27c139a94..6b1cd2b0c75179f822319c6ae7a28c06fb108b53 100644 (file)
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -271,7 +271,7 @@ static int ecryptfs_flush(struct file *file, fl_owner_t td)
 {
        struct file *lower_file = ecryptfs_file_to_lower(file);
 
-       if (lower_file->f_op && lower_file->f_op->flush) {
+       if (lower_file->f_op->flush) {
                filemap_write_and_wait(file->f_mapping);
                return lower_file->f_op->flush(lower_file, td);
        }
@@ -305,7 +305,7 @@ static int ecryptfs_fasync(int fd, struct file *file, int flag)
        struct file *lower_file = NULL;
 
        lower_file = ecryptfs_file_to_lower(file);
-       if (lower_file->f_op && lower_file->f_op->fasync)
+       if (lower_file->f_op->fasync)
                rc = lower_file->f_op->fasync(fd, lower_file, flag);
        return rc;
 }
@@ -318,7 +318,7 @@ ecryptfs_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
        if (ecryptfs_file_to_private(file))
                lower_file = ecryptfs_file_to_lower(file);
-       if (lower_file && lower_file->f_op && lower_file->f_op->unlocked_ioctl)
+       if (lower_file->f_op && lower_file->f_op->unlocked_ioctl)
                rc = lower_file->f_op->unlocked_ioctl(lower_file, cmd, arg);
        return rc;
 }
@@ -332,7 +332,7 @@ ecryptfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
        if (ecryptfs_file_to_private(file))
                lower_file = ecryptfs_file_to_lower(file);
-       if (lower_file && lower_file->f_op && lower_file->f_op->compat_ioctl)
+       if (lower_file->f_op && lower_file->f_op->compat_ioctl)
                rc = lower_file->f_op->compat_ioctl(lower_file, cmd, arg);
        return rc;
 }

diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 473e09da7d02d3396273221f3094824c91f3b030..31fd77cd81eb6b9df7ee1f480886afd090cf51c4 100644 (file)
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -1816,7 +1816,7 @@ SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
 
        /* The target file descriptor must support poll */
        error = -EPERM;
-       if (!tf.file->f_op || !tf.file->f_op->poll)
+       if (!tf.file->f_op->poll)
                goto error_tgt_fput;
 
        /* Check if EPOLLWAKEUP is allowed */

diff --git a/fs/exec.c b/fs/exec.c
index 8875dd10ae7ac77444db95e33c9fde83dde67512..351440fbf1ee3c975a1baa8850d2af5151facad9 100644 (file)
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -106,6 +106,7 @@ static inline void put_binfmt(struct linux_binfmt * fmt)
  */
 SYSCALL_DEFINE1(uselib, const char __user *, library)
 {
+       struct linux_binfmt *fmt;
        struct file *file;
        struct filename *tmp = getname(library);
        int error = PTR_ERR(tmp);
@@ -136,24 +137,21 @@ SYSCALL_DEFINE1(uselib, const char __user *, library)
        fsnotify_open(file);
 
        error = -ENOEXEC;
-       if(file->f_op) {
-               struct linux_binfmt * fmt;
 
-               read_lock(&binfmt_lock);
-               list_for_each_entry(fmt, &formats, lh) {
-                       if (!fmt->load_shlib)
-                               continue;
-                       if (!try_module_get(fmt->module))
-                               continue;
-                       read_unlock(&binfmt_lock);
-                       error = fmt->load_shlib(file);
-                       read_lock(&binfmt_lock);
-                       put_binfmt(fmt);
-                       if (error != -ENOEXEC)
-                               break;
-               }
+       read_lock(&binfmt_lock);
+       list_for_each_entry(fmt, &formats, lh) {
+               if (!fmt->load_shlib)
+                       continue;
+               if (!try_module_get(fmt->module))
+                       continue;
                read_unlock(&binfmt_lock);
+               error = fmt->load_shlib(file);
+               read_lock(&binfmt_lock);
+               put_binfmt(fmt);
+               if (error != -ENOEXEC)
+                       break;
        }
+       read_unlock(&binfmt_lock);
 exit:
        fput(file);
 out:
@@ -1277,13 +1275,10 @@ static int check_unsafe_exec(struct linux_binprm *bprm)
  */
 int prepare_binprm(struct linux_binprm *bprm)
 {
-       umode_t mode;
-       struct inode * inode = file_inode(bprm->file);
+       struct inode *inode = file_inode(bprm->file);
+       umode_t mode = inode->i_mode;
        int retval;
 
-       mode = inode->i_mode;
-       if (bprm->file->f_op == NULL)
-               return -EACCES;
 
        /* clear any previous set[ug]id data from a previous binary */
        bprm->cred->euid = current_euid();

diff --git a/fs/fcntl.c b/fs/fcntl.c
index 65343c3741ff86876418deb9d18e3f72f5872898..ef6866592a0f68c390f2ecededd785fb21e4a659 100644 (file)
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -56,7 +56,7 @@ static int setfl(int fd, struct file * filp, unsigned long arg)
                                return -EINVAL;
        }
 
-       if (filp->f_op && filp->f_op->check_flags)
+       if (filp->f_op->check_flags)
                error = filp->f_op->check_flags(arg);
        if (error)
                return error;
@@ -64,8 +64,7 @@ static int setfl(int fd, struct file * filp, unsigned long arg)
        /*
         * ->fasync() is responsible for setting the FASYNC bit.
         */
-       if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op &&
-                       filp->f_op->fasync) {
+       if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op->fasync) {
                error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
                if (error < 0)
                        goto out;

diff --git a/fs/file_table.c b/fs/file_table.c
index abdd15ad13c9c52bf672465787e3811c06ef7224..e61e5529fa9d07364a1ec5a37c977bb4e83271bf 100644 (file)
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -240,11 +240,11 @@ static void __fput(struct file *file)
        locks_remove_flock(file);
 
        if (unlikely(file->f_flags & FASYNC)) {
-               if (file->f_op && file->f_op->fasync)
+               if (file->f_op->fasync)
                        file->f_op->fasync(-1, file, 0);
        }
        ima_file_free(file);
-       if (file->f_op && file->f_op->release)
+       if (file->f_op->release)
                file->f_op->release(inode, file);
        security_file_free(file);
        if (unlikely(S_ISCHR(inode->i_mode) && inode->i_cdev != NULL &&

diff --git a/fs/ioctl.c b/fs/ioctl.c
index fd507fb460f823f624062e84828bd6bf6437f848..8ac3fad36192fb153b93e1be8c5d0e0ee110b463 100644 (file)
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -37,7 +37,7 @@ static long vfs_ioctl(struct file *filp, unsigned int cmd,
 {
        int error = -ENOTTY;
 
-       if (!filp->f_op || !filp->f_op->unlocked_ioctl)
+       if (!filp->f_op->unlocked_ioctl)
                goto out;
 
        error = filp->f_op->unlocked_ioctl(filp, cmd, arg);
@@ -501,7 +501,7 @@ static int ioctl_fioasync(unsigned int fd, struct file *filp,
 
        /* Did FASYNC state change ? */
        if ((flag ^ filp->f_flags) & FASYNC) {
-               if (filp->f_op && filp->f_op->fasync)
+               if (filp->f_op->fasync)
                        /* fasync() adjusts filp->f_flags */
                        error = filp->f_op->fasync(fd, filp, on);
                else

diff --git a/fs/locks.c b/fs/locks.c
index b27a3005d78df9fccd74343bd4a9f93f9f6753b1..f155ffd648bb413428cc705dcec369e67a34997c 100644 (file)
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1579,7 +1579,7 @@ EXPORT_SYMBOL(generic_setlease);
 
 static int __vfs_setlease(struct file *filp, long arg, struct file_lock **lease)
 {
-       if (filp->f_op && filp->f_op->setlease)
+       if (filp->f_op->setlease)
                return filp->f_op->setlease(filp, arg, lease);
        else
                return generic_setlease(filp, arg, lease);
@@ -1771,7 +1771,7 @@ SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
        if (error)
                goto out_free;
 
-       if (f.file->f_op && f.file->f_op->flock)
+       if (f.file->f_op->flock)
                error = f.file->f_op->flock(f.file,
                                          (can_sleep) ? F_SETLKW : F_SETLK,
                                          lock);
@@ -1797,7 +1797,7 @@ SYSCALL_DEFINE2(flock, unsigned int, fd, unsigned int, cmd)
  */
 int vfs_test_lock(struct file *filp, struct file_lock *fl)
 {
-       if (filp->f_op && filp->f_op->lock)
+       if (filp->f_op->lock)
                return filp->f_op->lock(filp, F_GETLK, fl);
        posix_test_lock(filp, fl);
        return 0;
@@ -1909,7 +1909,7 @@ out:
  */
 int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)
 {
-       if (filp->f_op && filp->f_op->lock)
+       if (filp->f_op->lock)
                return filp->f_op->lock(filp, cmd, fl);
        else
                return posix_lock_file(filp, fl, conf);
@@ -2182,7 +2182,7 @@ void locks_remove_flock(struct file *filp)
        if (!inode->i_flock)
                return;
 
-       if (filp->f_op && filp->f_op->flock) {
+       if (filp->f_op->flock) {
                struct file_lock fl = {
                        .fl_pid = current->tgid,
                        .fl_file = filp,
@@ -2246,7 +2246,7 @@ EXPORT_SYMBOL(posix_unblock_lock);
  */
 int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
 {
-       if (filp->f_op && filp->f_op->lock)
+       if (filp->f_op->lock)
                return filp->f_op->lock(filp, F_CANCELLK, fl);
        return 0;
 }

diff --git a/fs/open.c b/fs/open.c
index d420331ca32a20b20b00c1da468a9af516e6a037..a1465b1ec8c72d067a30ec3d5e5237ded26b441a 100644 (file)
--- a/fs/open.c
+++ b/fs/open.c
@@ -693,6 +693,10 @@ static int do_dentry_open(struct file *f,
        }
 
        f->f_op = fops_get(inode->i_fop);
+       if (unlikely(WARN_ON(!f->f_op))) {
+               error = -ENODEV;
+               goto cleanup_all;
+       }
 
        error = security_file_open(f, cred);
        if (error)
@@ -702,7 +706,7 @@ static int do_dentry_open(struct file *f,
        if (error)
                goto cleanup_all;
 
-       if (!open && f->f_op)
+       if (!open)
                open = f->f_op->open;
        if (open) {
                error = open(inode, f);
@@ -1023,7 +1027,7 @@ int filp_close(struct file *filp, fl_owner_t id)
                return 0;
        }
 
-       if (filp->f_op && filp->f_op->flush)
+       if (filp->f_op->flush)
                retval = filp->f_op->flush(filp, id);
 
        if (likely(!(filp->f_mode & FMODE_PATH))) {

diff --git a/fs/read_write.c b/fs/read_write.c
index e3cd280b158c1132a98c1b53ab2ab8bcdb14de02..58e440df1bc687e3dd3eea50fe38f018a6cc192b 100644 (file)
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -257,7 +257,7 @@ loff_t vfs_llseek(struct file *file, loff_t offset, int whence)
 
        fn = no_llseek;
        if (file->f_mode & FMODE_LSEEK) {
-               if (file->f_op && file->f_op->llseek)
+               if (file->f_op->llseek)
                        fn = file->f_op->llseek;
        }
        return fn(file, offset, whence);
@@ -384,7 +384,7 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
 
        if (!(file->f_mode & FMODE_READ))
                return -EBADF;
-       if (!file->f_op || (!file->f_op->read && !file->f_op->aio_read))
+       if (!file->f_op->read && !file->f_op->aio_read)
                return -EINVAL;
        if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
                return -EFAULT;
@@ -433,7 +433,7 @@ ssize_t __kernel_write(struct file *file, const char *buf, size_t count, loff_t
        const char __user *p;
        ssize_t ret;
 
-       if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))
+       if (!file->f_op->write && !file->f_op->aio_write)
                return -EINVAL;
 
        old_fs = get_fs();
@@ -460,7 +460,7 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_
 
        if (!(file->f_mode & FMODE_WRITE))
                return -EBADF;
-       if (!file->f_op || (!file->f_op->write && !file->f_op->aio_write))
+       if (!file->f_op->write && !file->f_op->aio_write)
                return -EINVAL;
        if (unlikely(!access_ok(VERIFY_READ, buf, count)))
                return -EFAULT;
@@ -727,11 +727,6 @@ static ssize_t do_readv_writev(int type, struct file *file,
        io_fn_t fn;
        iov_fn_t fnv;
 
-       if (!file->f_op) {
-               ret = -EINVAL;
-               goto out;
-       }
-
        ret = rw_copy_check_uvector(type, uvector, nr_segs,
                                    ARRAY_SIZE(iovstack), iovstack, &iov);
        if (ret <= 0)
@@ -778,7 +773,7 @@ ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
 {
        if (!(file->f_mode & FMODE_READ))
                return -EBADF;
-       if (!file->f_op || (!file->f_op->aio_read && !file->f_op->read))
+       if (!file->f_op->aio_read && !file->f_op->read)
                return -EINVAL;
 
        return do_readv_writev(READ, file, vec, vlen, pos);
@@ -791,7 +786,7 @@ ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
 {
        if (!(file->f_mode & FMODE_WRITE))
                return -EBADF;
-       if (!file->f_op || (!file->f_op->aio_write && !file->f_op->write))
+       if (!file->f_op->aio_write && !file->f_op->write)
                return -EINVAL;
 
        return do_readv_writev(WRITE, file, vec, vlen, pos);
@@ -906,10 +901,6 @@ static ssize_t compat_do_readv_writev(int type, struct file *file,
        io_fn_t fn;
        iov_fn_t fnv;
 
-       ret = -EINVAL;
-       if (!file->f_op)
-               goto out;
-
        ret = -EFAULT;
        if (!access_ok(VERIFY_READ, uvector, nr_segs*sizeof(*uvector)))
                goto out;
@@ -965,7 +956,7 @@ static size_t compat_readv(struct file *file,
                goto out;
 
        ret = -EINVAL;
-       if (!file->f_op || (!file->f_op->aio_read && !file->f_op->read))
+       if (!file->f_op->aio_read && !file->f_op->read)
                goto out;
 
        ret = compat_do_readv_writev(READ, file, vec, vlen, pos);
@@ -1032,7 +1023,7 @@ static size_t compat_writev(struct file *file,
                goto out;
 
        ret = -EINVAL;
-       if (!file->f_op || (!file->f_op->aio_write && !file->f_op->write))
+       if (!file->f_op->aio_write && !file->f_op->write)
                goto out;
 
        ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos);

diff --git a/fs/readdir.c b/fs/readdir.c
index 93d71e57431076f5773e335a3777e18ac3a90108..5b53d995cae6a06a4b7087ab5850d020490114a3 100644 (file)
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -24,7 +24,7 @@ int iterate_dir(struct file *file, struct dir_context *ctx)
 {
        struct inode *inode = file_inode(file);
        int res = -ENOTDIR;
-       if (!file->f_op || !file->f_op->iterate)
+       if (!file->f_op->iterate)
                goto out;
 
        res = security_file_permission(file, MAY_READ);

diff --git a/fs/select.c b/fs/select.c
index 35d4adc749d9616f4bb2a7cd6d952eb18b5579b4..55278a36a6582802edfd91600d311def49de17c0 100644 (file)
--- a/fs/select.c
+++ b/fs/select.c
@@ -455,7 +455,7 @@ int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
                                        const struct file_operations *f_op;
                                        f_op = f.file->f_op;
                                        mask = DEFAULT_POLLMASK;
-                                       if (f_op && f_op->poll) {
+                                       if (f_op->poll) {
                                                wait_key_set(wait, in, out,
                                                             bit, busy_flag);
                                                mask = (*f_op->poll)(f.file, wait);
@@ -762,7 +762,7 @@ static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait,
                mask = POLLNVAL;
                if (f.file) {
                        mask = DEFAULT_POLLMASK;
-                       if (f.file->f_op && f.file->f_op->poll) {
+                       if (f.file->f_op->poll) {
                                pwait->_key = pollfd->events|POLLERR|POLLHUP;
                                pwait->_key |= busy_flag;
                                mask = f.file->f_op->poll(f.file, pwait);

diff --git a/fs/splice.c b/fs/splice.c
index 3b7ee656f3aaeacd719955b2bba80fd5d8d43b0a..46a08f772d7dbf5db1c931d479ad86e8405d323a 100644 (file)
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -695,7 +695,7 @@ static int pipe_to_sendpage(struct pipe_inode_info *pipe,
        loff_t pos = sd->pos;
        int more;
 
-       if (!likely(file->f_op && file->f_op->sendpage))
+       if (!likely(file->f_op->sendpage))
                return -EINVAL;
 
        more = (sd->flags & SPLICE_F_MORE) ? MSG_MORE : 0;
@@ -1099,7 +1099,7 @@ static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
        ssize_t (*splice_write)(struct pipe_inode_info *, struct file *,
                                loff_t *, size_t, unsigned int);
 
-       if (out->f_op && out->f_op->splice_write)
+       if (out->f_op->splice_write)
                splice_write = out->f_op->splice_write;
        else
                splice_write = default_file_splice_write;
@@ -1125,7 +1125,7 @@ static long do_splice_to(struct file *in, loff_t *ppos,
        if (unlikely(ret < 0))
                return ret;
 
-       if (in->f_op && in->f_op->splice_read)
+       if (in->f_op->splice_read)
                splice_read = in->f_op->splice_read;
        else
                splice_read = default_file_splice_read;

diff --git a/fs/sync.c b/fs/sync.c
index 905f3f6b3d8567032b9d5ad6044a184cb6ac3151..6c0ca3b75758dac589160158968a14518231810a 100644 (file)
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -177,7 +177,7 @@ SYSCALL_DEFINE1(syncfs, int, fd)
  */
 int vfs_fsync_range(struct file *file, loff_t start, loff_t end, int datasync)
 {
-       if (!file->f_op || !file->f_op->fsync)
+       if (!file->f_op->fsync)
                return -EINVAL;
        return file->f_op->fsync(file, start, end, datasync);
 }

diff --git a/mm/memory.c b/mm/memory.c
index ca00039471152eae75bb8321a129a4edfc6f580e..e2bbba42604ce877f8b8efe76251ea4ed6f51e1f 100644 (file)
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -681,7 +681,7 @@ static void print_bad_pte(struct vm_area_struct *vma, unsigned long addr,
        if (vma->vm_ops)
                printk(KERN_ALERT "vma->vm_ops->fault: %pSR\n",
                       vma->vm_ops->fault);
-       if (vma->vm_file && vma->vm_file->f_op)
+       if (vma->vm_file)
                printk(KERN_ALERT "vma->vm_file->f_op->mmap: %pSR\n",
                       vma->vm_file->f_op->mmap);
        dump_stack();

diff --git a/mm/mmap.c b/mm/mmap.c
index 9d548512ff8a30498ce07f2e536f765e8bd54cca..ab199dfc9e26889fbba305ba09b2ab517dd591f7 100644 (file)
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -1299,7 +1299,7 @@ unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
                                vm_flags &= ~VM_MAYEXEC;
                        }
 
-                       if (!file->f_op || !file->f_op->mmap)
+                       if (!file->f_op->mmap)
                                return -ENODEV;
                        if (vm_flags & (VM_GROWSDOWN|VM_GROWSUP))
                                return -EINVAL;
@@ -1951,7 +1951,7 @@ get_unmapped_area(struct file *file, unsigned long addr, unsigned long len,
                return -ENOMEM;
 
        get_area = current->mm->get_unmapped_area;
-       if (file && file->f_op && file->f_op->get_unmapped_area)
+       if (file && file->f_op->get_unmapped_area)
                get_area = file->f_op->get_unmapped_area;
        addr = get_area(file, addr, len, pgoff, flags);
        if (IS_ERR_VALUE(addr))

diff --git a/mm/nommu.c b/mm/nommu.c
index ecd1f158548e95a51cf004ad3f4d4ff7acb87a88..9e6cb02cba644c4ec357775e2acb22c5451f2ee7 100644 (file)
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -937,7 +937,7 @@ static int validate_mmap_request(struct file *file,
                struct address_space *mapping;
 
                /* files must support mmap */
-               if (!file->f_op || !file->f_op->mmap)
+               if (!file->f_op->mmap)
                        return -ENODEV;
 
                /* work out if what we've got could possibly be shared

diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c
index 3ffda1b3799b54340a0ba7851fa0f1c3cea6710c..9321a77630675dacbca66949e7e2e0f75d25deed 100644 (file)
--- a/net/9p/trans_fd.c
+++ b/net/9p/trans_fd.c
@@ -244,10 +244,10 @@ p9_fd_poll(struct p9_client *client, struct poll_table_struct *pt)
        if (!ts)
                return -EREMOTEIO;
 
-       if (!ts->rd->f_op || !ts->rd->f_op->poll)
+       if (!ts->rd->f_op->poll)
                return -EIO;
 
-       if (!ts->wr->f_op || !ts->wr->f_op->poll)
+       if (!ts->wr->f_op->poll)
                return -EIO;
 
        ret = ts->rd->f_op->poll(ts->rd, pt);