LXR linux-bk/fs/bad

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