linux/fs/bad_inode.c
<<
>>
Prefs
   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/export.h>
  13#include <linux/stat.h>
  14#include <linux/time.h>
  15#include <linux/namei.h>
  16#include <linux/poll.h>
  17
  18
  19static loff_t bad_file_llseek(struct file *file, loff_t offset, int whence)
  20{
  21        return -EIO;
  22}
  23
  24static ssize_t bad_file_read(struct file *filp, char __user *buf,
  25                        size_t size, loff_t *ppos)
  26{
  27        return -EIO;
  28}
  29
  30static ssize_t bad_file_write(struct file *filp, const char __user *buf,
  31                        size_t siz, loff_t *ppos)
  32{
  33        return -EIO;
  34}
  35
  36static ssize_t bad_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
  37                        unsigned long nr_segs, loff_t pos)
  38{
  39        return -EIO;
  40}
  41
  42static ssize_t bad_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
  43                        unsigned long nr_segs, loff_t pos)
  44{
  45        return -EIO;
  46}
  47
  48static int bad_file_readdir(struct file *filp, void *dirent, filldir_t filldir)
  49{
  50        return -EIO;
  51}
  52
  53static unsigned int bad_file_poll(struct file *filp, poll_table *wait)
  54{
  55        return POLLERR;
  56}
  57
  58static long bad_file_unlocked_ioctl(struct file *file, unsigned cmd,
  59                        unsigned long arg)
  60{
  61        return -EIO;
  62}
  63
  64static long bad_file_compat_ioctl(struct file *file, unsigned int cmd,
  65                        unsigned long arg)
  66{
  67        return -EIO;
  68}
  69
  70static int bad_file_mmap(struct file *file, struct vm_area_struct *vma)
  71{
  72        return -EIO;
  73}
  74
  75static int bad_file_open(struct inode *inode, struct file *filp)
  76{
  77        return -EIO;
  78}
  79
  80static int bad_file_flush(struct file *file, fl_owner_t id)
  81{
  82        return -EIO;
  83}
  84
  85static int bad_file_release(struct inode *inode, struct file *filp)
  86{
  87        return -EIO;
  88}
  89
  90static int bad_file_fsync(struct file *file, loff_t start, loff_t end,
  91                          int datasync)
  92{
  93        return -EIO;
  94}
  95
  96static int bad_file_aio_fsync(struct kiocb *iocb, int datasync)
  97{
  98        return -EIO;
  99}
 100
 101static int bad_file_fasync(int fd, struct file *filp, int on)
 102{
 103        return -EIO;
 104}
 105
 106static int bad_file_lock(struct file *file, int cmd, struct file_lock *fl)
 107{
 108        return -EIO;
 109}
 110
 111static ssize_t bad_file_sendpage(struct file *file, struct page *page,
 112                        int off, size_t len, loff_t *pos, int more)
 113{
 114        return -EIO;
 115}
 116
 117static unsigned long bad_file_get_unmapped_area(struct file *file,
 118                                unsigned long addr, unsigned long len,
 119                                unsigned long pgoff, unsigned long flags)
 120{
 121        return -EIO;
 122}
 123
 124static int bad_file_check_flags(int flags)
 125{
 126        return -EIO;
 127}
 128
 129static int bad_file_flock(struct file *filp, int cmd, struct file_lock *fl)
 130{
 131        return -EIO;
 132}
 133
 134static ssize_t bad_file_splice_write(struct pipe_inode_info *pipe,
 135                        struct file *out, loff_t *ppos, size_t len,
 136                        unsigned int flags)
 137{
 138        return -EIO;
 139}
 140
 141static ssize_t bad_file_splice_read(struct file *in, loff_t *ppos,
 142                        struct pipe_inode_info *pipe, size_t len,
 143                        unsigned int flags)
 144{
 145        return -EIO;
 146}
 147
 148static const struct file_operations bad_file_ops =
 149{
 150        .llseek         = bad_file_llseek,
 151        .read           = bad_file_read,
 152        .write          = bad_file_write,
 153        .aio_read       = bad_file_aio_read,
 154        .aio_write      = bad_file_aio_write,
 155        .readdir        = bad_file_readdir,
 156        .poll           = bad_file_poll,
 157        .unlocked_ioctl = bad_file_unlocked_ioctl,
 158        .compat_ioctl   = bad_file_compat_ioctl,
 159        .mmap           = bad_file_mmap,
 160        .open           = bad_file_open,
 161        .flush          = bad_file_flush,
 162        .release        = bad_file_release,
 163        .fsync          = bad_file_fsync,
 164        .aio_fsync      = bad_file_aio_fsync,
 165        .fasync         = bad_file_fasync,
 166        .lock           = bad_file_lock,
 167        .sendpage       = bad_file_sendpage,
 168        .get_unmapped_area = bad_file_get_unmapped_area,
 169        .check_flags    = bad_file_check_flags,
 170        .flock          = bad_file_flock,
 171        .splice_write   = bad_file_splice_write,
 172        .splice_read    = bad_file_splice_read,
 173};
 174
 175static int bad_inode_create (struct inode *dir, struct dentry *dentry,
 176                umode_t mode, bool excl)
 177{
 178        return -EIO;
 179}
 180
 181static struct dentry *bad_inode_lookup(struct inode *dir,
 182                        struct dentry *dentry, unsigned int flags)
 183{
 184        return ERR_PTR(-EIO);
 185}
 186
 187static int bad_inode_link (struct dentry *old_dentry, struct inode *dir,
 188                struct dentry *dentry)
 189{
 190        return -EIO;
 191}
 192
 193static int bad_inode_unlink(struct inode *dir, struct dentry *dentry)
 194{
 195        return -EIO;
 196}
 197
 198static int bad_inode_symlink (struct inode *dir, struct dentry *dentry,
 199                const char *symname)
 200{
 201        return -EIO;
 202}
 203
 204static int bad_inode_mkdir(struct inode *dir, struct dentry *dentry,
 205                        umode_t mode)
 206{
 207        return -EIO;
 208}
 209
 210static int bad_inode_rmdir (struct inode *dir, struct dentry *dentry)
 211{
 212        return -EIO;
 213}
 214
 215static int bad_inode_mknod (struct inode *dir, struct dentry *dentry,
 216                        umode_t mode, dev_t rdev)
 217{
 218        return -EIO;
 219}
 220
 221static int bad_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
 222                            struct inode *new_dir, struct dentry *new_dentry)
 223{
 224        return -EIO;
 225}
 226
 227static int bad_inode_rename2(struct inode *old_dir, struct dentry *old_dentry,
 228                             struct inode *new_dir, struct dentry *new_dentry,
 229                             unsigned int flags)
 230{
 231        return -EIO;
 232}
 233
 234static int bad_inode_readlink(struct dentry *dentry, char __user *buffer,
 235                int buflen)
 236{
 237        return -EIO;
 238}
 239
 240static int bad_inode_permission(struct inode *inode, int mask)
 241{
 242        return -EIO;
 243}
 244
 245static int bad_inode_getattr(struct vfsmount *mnt, struct dentry *dentry,
 246                        struct kstat *stat)
 247{
 248        return -EIO;
 249}
 250
 251static int bad_inode_setattr(struct dentry *direntry, struct iattr *attrs)
 252{
 253        return -EIO;
 254}
 255
 256static int bad_inode_setxattr(struct dentry *dentry, const char *name,
 257                const void *value, size_t size, int flags)
 258{
 259        return -EIO;
 260}
 261
 262static ssize_t bad_inode_getxattr(struct dentry *dentry, const char *name,
 263                        void *buffer, size_t size)
 264{
 265        return -EIO;
 266}
 267
 268static ssize_t bad_inode_listxattr(struct dentry *dentry, char *buffer,
 269                        size_t buffer_size)
 270{
 271        return -EIO;
 272}
 273
 274static int bad_inode_removexattr(struct dentry *dentry, const char *name)
 275{
 276        return -EIO;
 277}
 278
 279static const struct inode_operations_wrapper bad_inode_ops =
 280{
 281        .ops = {
 282        .create         = bad_inode_create,
 283        .lookup         = bad_inode_lookup,
 284        .link           = bad_inode_link,
 285        .unlink         = bad_inode_unlink,
 286        .symlink        = bad_inode_symlink,
 287        .mkdir          = bad_inode_mkdir,
 288        .rmdir          = bad_inode_rmdir,
 289        .mknod          = bad_inode_mknod,
 290        .rename         = bad_inode_rename,
 291        .readlink       = bad_inode_readlink,
 292        /* follow_link must be no-op, otherwise unmounting this inode
 293           won't work */
 294        /* put_link returns void */
 295        /* truncate returns void */
 296        .permission     = bad_inode_permission,
 297        .getattr        = bad_inode_getattr,
 298        .setattr        = bad_inode_setattr,
 299        .setxattr       = bad_inode_setxattr,
 300        .getxattr       = bad_inode_getxattr,
 301        .listxattr      = bad_inode_listxattr,
 302        .removexattr    = bad_inode_removexattr,
 303        },
 304        .rename2        = bad_inode_rename2,
 305};
 306
 307
 308/*
 309 * When a filesystem is unable to read an inode due to an I/O error in
 310 * its read_inode() function, it can call make_bad_inode() to return a
 311 * set of stubs which will return EIO errors as required. 
 312 *
 313 * We only need to do limited initialisation: all other fields are
 314 * preinitialised to zero automatically.
 315 */
 316 
 317/**
 318 *      make_bad_inode - mark an inode bad due to an I/O error
 319 *      @inode: Inode to mark bad
 320 *
 321 *      When an inode cannot be read due to a media or remote network
 322 *      failure this function makes the inode "bad" and causes I/O operations
 323 *      on it to fail from this point on.
 324 */
 325 
 326void make_bad_inode(struct inode *inode)
 327{
 328        remove_inode_hash(inode);
 329
 330        inode->i_mode = S_IFREG;
 331        inode->i_atime = inode->i_mtime = inode->i_ctime =
 332                current_fs_time(inode->i_sb);
 333        inode->i_op = &bad_inode_ops.ops;
 334        inode->i_fop = &bad_file_ops;
 335        inode->i_flags |= S_IOPS_WRAPPER;
 336}
 337EXPORT_SYMBOL(make_bad_inode);
 338
 339/*
 340 * This tests whether an inode has been flagged as bad. The test uses
 341 * &bad_inode_ops to cover the case of invalidated inodes as well as
 342 * those created by make_bad_inode() above.
 343 */
 344 
 345/**
 346 *      is_bad_inode - is an inode errored
 347 *      @inode: inode to test
 348 *
 349 *      Returns true if the inode in question has been marked as bad.
 350 */
 351 
 352int is_bad_inode(struct inode *inode)
 353{
 354        return (inode->i_op == &bad_inode_ops.ops);
 355}
 356
 357EXPORT_SYMBOL(is_bad_inode);
 358
 359/**
 360 * iget_failed - Mark an under-construction inode as dead and release it
 361 * @inode: The inode to discard
 362 *
 363 * Mark an under-construction inode as dead and release it.
 364 */
 365void iget_failed(struct inode *inode)
 366{
 367        make_bad_inode(inode);
 368        unlock_new_inode(inode);
 369        iput(inode);
 370}
 371EXPORT_SYMBOL(iget_failed);
 372