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_readlink(struct dentry *dentry, char __user *buffer,
 228                int buflen)
 229{
 230        return -EIO;
 231}
 232
 233static int bad_inode_permission(struct inode *inode, int mask)
 234{
 235        return -EIO;
 236}
 237
 238static int bad_inode_getattr(struct vfsmount *mnt, struct dentry *dentry,
 239                        struct kstat *stat)
 240{
 241        return -EIO;
 242}
 243
 244static int bad_inode_setattr(struct dentry *direntry, struct iattr *attrs)
 245{
 246        return -EIO;
 247}
 248
 249static int bad_inode_setxattr(struct dentry *dentry, const char *name,
 250                const void *value, size_t size, int flags)
 251{
 252        return -EIO;
 253}
 254
 255static ssize_t bad_inode_getxattr(struct dentry *dentry, const char *name,
 256                        void *buffer, size_t size)
 257{
 258        return -EIO;
 259}
 260
 261static ssize_t bad_inode_listxattr(struct dentry *dentry, char *buffer,
 262                        size_t buffer_size)
 263{
 264        return -EIO;
 265}
 266
 267static int bad_inode_removexattr(struct dentry *dentry, const char *name)
 268{
 269        return -EIO;
 270}
 271
 272static const struct inode_operations bad_inode_ops =
 273{
 274        .create         = bad_inode_create,
 275        .lookup         = bad_inode_lookup,
 276        .link           = bad_inode_link,
 277        .unlink         = bad_inode_unlink,
 278        .symlink        = bad_inode_symlink,
 279        .mkdir          = bad_inode_mkdir,
 280        .rmdir          = bad_inode_rmdir,
 281        .mknod          = bad_inode_mknod,
 282        .rename         = bad_inode_rename,
 283        .readlink       = bad_inode_readlink,
 284        /* follow_link must be no-op, otherwise unmounting this inode
 285           won't work */
 286        /* put_link returns void */
 287        /* truncate returns void */
 288        .permission     = bad_inode_permission,
 289        .getattr        = bad_inode_getattr,
 290        .setattr        = bad_inode_setattr,
 291        .setxattr       = bad_inode_setxattr,
 292        .getxattr       = bad_inode_getxattr,
 293        .listxattr      = bad_inode_listxattr,
 294        .removexattr    = bad_inode_removexattr,
 295};
 296
 297
 298/*
 299 * When a filesystem is unable to read an inode due to an I/O error in
 300 * its read_inode() function, it can call make_bad_inode() to return a
 301 * set of stubs which will return EIO errors as required. 
 302 *
 303 * We only need to do limited initialisation: all other fields are
 304 * preinitialised to zero automatically.
 305 */
 306 
 307/**
 308 *      make_bad_inode - mark an inode bad due to an I/O error
 309 *      @inode: Inode to mark bad
 310 *
 311 *      When an inode cannot be read due to a media or remote network
 312 *      failure this function makes the inode "bad" and causes I/O operations
 313 *      on it to fail from this point on.
 314 */
 315 
 316void make_bad_inode(struct inode *inode)
 317{
 318        remove_inode_hash(inode);
 319
 320        inode->i_mode = S_IFREG;
 321        inode->i_atime = inode->i_mtime = inode->i_ctime =
 322                current_fs_time(inode->i_sb);
 323        inode->i_op = &bad_inode_ops;   
 324        inode->i_fop = &bad_file_ops;   
 325}
 326EXPORT_SYMBOL(make_bad_inode);
 327
 328/*
 329 * This tests whether an inode has been flagged as bad. The test uses
 330 * &bad_inode_ops to cover the case of invalidated inodes as well as
 331 * those created by make_bad_inode() above.
 332 */
 333 
 334/**
 335 *      is_bad_inode - is an inode errored
 336 *      @inode: inode to test
 337 *
 338 *      Returns true if the inode in question has been marked as bad.
 339 */
 340 
 341int is_bad_inode(struct inode *inode)
 342{
 343        return (inode->i_op == &bad_inode_ops); 
 344}
 345
 346EXPORT_SYMBOL(is_bad_inode);
 347
 348/**
 349 * iget_failed - Mark an under-construction inode as dead and release it
 350 * @inode: The inode to discard
 351 *
 352 * Mark an under-construction inode as dead and release it.
 353 */
 354void iget_failed(struct inode *inode)
 355{
 356        make_bad_inode(inode);
 357        unlock_new_inode(inode);
 358        iput(inode);
 359}
 360EXPORT_SYMBOL(iget_failed);
 361
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.