fs/bad_inode.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/bad_inode.c
   4  *
   5  *  Copyright (C) 1997, Stephen Tweedie
   6  *
   7  *  Provide stub functions for unreadable inodes
   8  *
   9  *  Fabian Frederick : August 2003 - All file operations assigned to EIO
  10  */
  11
  12 #include <linux/fs.h>
  13 #include <linux/export.h>
  14 #include <linux/stat.h>
  15 #include <linux/time.h>
  16 #include <linux/namei.h>
  17 #include <linux/poll.h>
  18 #include <linux/fiemap.h>
  19
  20 static int bad_file_open(struct inode *inode, struct file *filp)
  21 {
  22         return -EIO;
  23 }
  24
  25 static const struct file_operations bad_file_ops =
  26 {
  27         .open           = bad_file_open,
  28 };
  29
  30 static int bad_inode_create(struct user_namespace *mnt_userns,
  31                             struct inode *dir, struct dentry *dentry,
  32                             umode_t mode, bool excl)
  33 {
  34         return -EIO;
  35 }
  36
  37 static struct dentry *bad_inode_lookup(struct inode *dir,
  38                         struct dentry *dentry, unsigned int flags)
  39 {
  40         return ERR_PTR(-EIO);
  41 }
  42
  43 static int bad_inode_link (struct dentry *old_dentry, struct inode *dir,
  44                 struct dentry *dentry)
  45 {
  46         return -EIO;
  47 }
  48
  49 static int bad_inode_unlink(struct inode *dir, struct dentry *dentry)
  50 {
  51         return -EIO;
  52 }
  53
  54 static int bad_inode_symlink(struct user_namespace *mnt_userns,
  55                              struct inode *dir, struct dentry *dentry,
  56                              const char *symname)
  57 {
  58         return -EIO;
  59 }
  60
  61 static int bad_inode_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
  62                            struct dentry *dentry, umode_t mode)
  63 {
  64         return -EIO;
  65 }
  66
  67 static int bad_inode_rmdir (struct inode *dir, struct dentry *dentry)
  68 {
  69         return -EIO;
  70 }
  71
  72 static int bad_inode_mknod(struct user_namespace *mnt_userns, struct inode *dir,
  73                            struct dentry *dentry, umode_t mode, dev_t rdev)
  74 {
  75         return -EIO;
  76 }
  77
  78 static int bad_inode_rename2(struct user_namespace *mnt_userns,
  79                              struct inode *old_dir, struct dentry *old_dentry,
  80                              struct inode *new_dir, struct dentry *new_dentry,
  81                              unsigned int flags)
  82 {
  83         return -EIO;
  84 }
  85
  86 static int bad_inode_readlink(struct dentry *dentry, char __user *buffer,
  87                 int buflen)
  88 {
  89         return -EIO;
  90 }
  91
  92 static int bad_inode_permission(struct user_namespace *mnt_userns,
  93                                 struct inode *inode, int mask)
  94 {
  95         return -EIO;
  96 }
  97
  98 static int bad_inode_getattr(struct user_namespace *mnt_userns,
  99                              const struct path *path, struct kstat *stat,
 100                              u32 request_mask, unsigned int query_flags)
 101 {
 102         return -EIO;
 103 }
 104
 105 static int bad_inode_setattr(struct user_namespace *mnt_userns,
 106                              struct dentry *direntry, struct iattr *attrs)
 107 {
 108         return -EIO;
 109 }
 110
 111 static ssize_t bad_inode_listxattr(struct dentry *dentry, char *buffer,
 112                         size_t buffer_size)
 113 {
 114         return -EIO;
 115 }
 116
 117 static const char *bad_inode_get_link(struct dentry *dentry,
 118                                       struct inode *inode,
 119                                       struct delayed_call *done)
 120 {
 121         return ERR_PTR(-EIO);
 122 }
 123
 124 static struct posix_acl *bad_inode_get_acl(struct inode *inode, int type, bool rcu)
 125 {
 126         return ERR_PTR(-EIO);
 127 }
 128
 129 static int bad_inode_fiemap(struct inode *inode,
 130                             struct fiemap_extent_info *fieinfo, u64 start,
 131                             u64 len)
 132 {
 133         return -EIO;
 134 }
 135
 136 static int bad_inode_update_time(struct inode *inode, struct timespec64 *time,
 137                                  int flags)
 138 {
 139         return -EIO;
 140 }
 141
 142 static int bad_inode_atomic_open(struct inode *inode, struct dentry *dentry,
 143                                  struct file *file, unsigned int open_flag,
 144                                  umode_t create_mode)
 145 {
 146         return -EIO;
 147 }
 148
 149 static int bad_inode_tmpfile(struct user_namespace *mnt_userns,
 150                              struct inode *inode, struct file *file,
 151                              umode_t mode)
 152 {
 153         return -EIO;
 154 }
 155
 156 static int bad_inode_set_acl(struct user_namespace *mnt_userns,
 157                              struct inode *inode, struct posix_acl *acl,
 158                              int type)
 159 {
 160         return -EIO;
 161 }
 162
 163 static const struct inode_operations bad_inode_ops =
 164 {
 165         .create         = bad_inode_create,
 166         .lookup         = bad_inode_lookup,
 167         .link           = bad_inode_link,
 168         .unlink         = bad_inode_unlink,
 169         .symlink        = bad_inode_symlink,
 170         .mkdir          = bad_inode_mkdir,
 171         .rmdir          = bad_inode_rmdir,
 172         .mknod          = bad_inode_mknod,
 173         .rename         = bad_inode_rename2,
 174         .readlink       = bad_inode_readlink,
 175         .permission     = bad_inode_permission,
 176         .getattr        = bad_inode_getattr,
 177         .setattr        = bad_inode_setattr,
 178         .listxattr      = bad_inode_listxattr,
 179         .get_link       = bad_inode_get_link,
 180         .get_acl        = bad_inode_get_acl,
 181         .fiemap         = bad_inode_fiemap,
 182         .update_time    = bad_inode_update_time,
 183         .atomic_open    = bad_inode_atomic_open,
 184         .tmpfile        = bad_inode_tmpfile,
 185         .set_acl        = bad_inode_set_acl,
 186 };
 187
 188
 189 /*
 190  * When a filesystem is unable to read an inode due to an I/O error in
 191  * its read_inode() function, it can call make_bad_inode() to return a
 192  * set of stubs which will return EIO errors as required.
 193  *
 194  * We only need to do limited initialisation: all other fields are
 195  * preinitialised to zero automatically.
 196  */
 197
 198 /**
 199  *      make_bad_inode - mark an inode bad due to an I/O error
 200  *      @inode: Inode to mark bad
 201  *
 202  *      When an inode cannot be read due to a media or remote network
 203  *      failure this function makes the inode "bad" and causes I/O operations
 204  *      on it to fail from this point on.
 205  */
 206
 207 void make_bad_inode(struct inode *inode)
 208 {
 209         remove_inode_hash(inode);
 210
 211         inode->i_mode = S_IFREG;
 212         inode->i_atime = inode->i_mtime = inode->i_ctime =
 213                 current_time(inode);
 214         inode->i_op = &bad_inode_ops;
 215         inode->i_opflags &= ~IOP_XATTR;
 216         inode->i_fop = &bad_file_ops;
 217 }
 218 EXPORT_SYMBOL(make_bad_inode);
 219
 220 /*
 221  * This tests whether an inode has been flagged as bad. The test uses
 222  * &bad_inode_ops to cover the case of invalidated inodes as well as
 223  * those created by make_bad_inode() above.
 224  */
 225
 226 /**
 227  *      is_bad_inode - is an inode errored
 228  *      @inode: inode to test
 229  *
 230  *      Returns true if the inode in question has been marked as bad.
 231  */
 232
 233 bool is_bad_inode(struct inode *inode)
 234 {
 235         return (inode->i_op == &bad_inode_ops);
 236 }
 237
 238 EXPORT_SYMBOL(is_bad_inode);
 239
 240 /**
 241  * iget_failed - Mark an under-construction inode as dead and release it
 242  * @inode: The inode to discard
 243  *
 244  * Mark an under-construction inode as dead and release it.
 245  */
 246 void iget_failed(struct inode *inode)
 247 {
 248         make_bad_inode(inode);
 249         unlock_new_inode(inode);
 250         iput(inode);
 251 }
 252 EXPORT_SYMBOL(iget_failed);