fs/bad_inode.c

   1 /*
   2  *  linux/fs/bad_inode.c
   3  *
   4  *  Copyright (C) 1997, Stephen Tweedie
   5  *
   6  *  Provide stub functions for unreadable inodes
   7  */
   8
   9 #include <linux/fs.h>
  10 #include <linux/stat.h>
  11 #include <linux/sched.h>
  12
  13 /*
  14  * The follow_link operation is special: it must behave as a no-op
  15  * so that a bad root inode can at least be unmounted. To do this
  16  * we must dput() the base and return the dentry with a dget().
  17  */
  18 static int bad_follow_link(struct dentry *dent, struct nameidata *nd)
  19 {
  20         dput(nd->dentry);
  21         nd->dentry = dget(dent);
  22         return 0;
  23 }
  24
  25 static int return_EIO(void)
  26 {
  27         return -EIO;
  28 }
  29
  30 #define EIO_ERROR ((void *) (return_EIO))
  31
  32 static struct file_operations bad_file_ops =
  33 {
  34         llseek:         EIO_ERROR,
  35         read:           EIO_ERROR,
  36         write:          EIO_ERROR,
  37         readdir:        EIO_ERROR,
  38         poll:           EIO_ERROR,
  39         ioctl:          EIO_ERROR,
  40         mmap:           EIO_ERROR,
  41         open:           EIO_ERROR,
  42         flush:          EIO_ERROR,
  43         release:        EIO_ERROR,
  44         fsync:          EIO_ERROR,
  45         fasync:         EIO_ERROR,
  46         lock:           EIO_ERROR,
  47 };
  48
  49 struct inode_operations bad_inode_ops =
  50 {
  51         create:         EIO_ERROR,
  52         lookup:         EIO_ERROR,
  53         link:           EIO_ERROR,
  54         unlink:         EIO_ERROR,
  55         symlink:        EIO_ERROR,
  56         mkdir:          EIO_ERROR,
  57         rmdir:          EIO_ERROR,
  58         mknod:          EIO_ERROR,
  59         rename:         EIO_ERROR,
  60         readlink:       EIO_ERROR,
  61         follow_link:    bad_follow_link,
  62         truncate:       EIO_ERROR,
  63         permission:     EIO_ERROR,
  64         revalidate:     EIO_ERROR,
  65 };
  66
  67
  68 /*
  69  * When a filesystem is unable to read an inode due to an I/O error in
  70  * its read_inode() function, it can call make_bad_inode() to return a
  71  * set of stubs which will return EIO errors as required.
  72  *
  73  * We only need to do limited initialisation: all other fields are
  74  * preinitialised to zero automatically.
  75  */
  76
  77 /**
  78  *      make_bad_inode - mark an inode bad due to an I/O error
  79  *      @inode: Inode to mark bad
  80  *
  81  *      When an inode cannot be read due to a media or remote network
  82  *      failure this function makes the inode "bad" and causes I/O operations
  83  *      on it to fail from this point on.
  84  */
  85
  86 void make_bad_inode(struct inode * inode)
  87 {
  88         inode->i_mode = S_IFREG;
  89         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  90         inode->i_op = &bad_inode_ops;
  91         inode->i_fop = &bad_file_ops;
  92 }
  93
  94 /*
  95  * This tests whether an inode has been flagged as bad. The test uses
  96  * &bad_inode_ops to cover the case of invalidated inodes as well as
  97  * those created by make_bad_inode() above.
  98  */
  99
 100 /**
 101  *      is_bad_inode - is an inode errored
 102  *      @inode: inode to test
 103  *
 104  *      Returns true if the inode in question has been marked as bad.
 105  */
 106
 107 int is_bad_inode(struct inode * inode)
 108 {
 109         return (inode->i_op == &bad_inode_ops);
 110 }