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