original development tree for Linux kernel GTP module; now long in mainline.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

360 lines
7.7 KiB

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