Branch data Line data Source code
1 : : /*
2 : : * fs/libfs.c
3 : : * Library for filesystems writers.
4 : : */
5 : :
6 : : #include <linux/export.h>
7 : : #include <linux/pagemap.h>
8 : : #include <linux/slab.h>
9 : : #include <linux/mount.h>
10 : : #include <linux/vfs.h>
11 : : #include <linux/quotaops.h>
12 : : #include <linux/mutex.h>
13 : : #include <linux/namei.h>
14 : : #include <linux/exportfs.h>
15 : : #include <linux/writeback.h>
16 : : #include <linux/buffer_head.h> /* sync_mapping_buffers */
17 : :
18 : : #include <asm/uaccess.h>
19 : :
20 : : #include "internal.h"
21 : :
22 : : static inline int simple_positive(struct dentry *dentry)
23 : : {
24 [ + - ][ - + ]: 10626 : return dentry->d_inode && !d_unhashed(dentry);
[ + - ][ - + ]
[ # # ][ # # ]
25 : : }
26 : :
27 : 0 : int simple_getattr(struct vfsmount *mnt, struct dentry *dentry,
28 : : struct kstat *stat)
29 : : {
30 : 0 : struct inode *inode = dentry->d_inode;
31 : 0 : generic_fillattr(inode, stat);
32 : 0 : stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9);
33 : 0 : return 0;
34 : : }
35 : : EXPORT_SYMBOL(simple_getattr);
36 : :
37 : 0 : int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
38 : : {
39 : 2 : buf->f_type = dentry->d_sb->s_magic;
40 : 2 : buf->f_bsize = PAGE_CACHE_SIZE;
41 : 2 : buf->f_namelen = NAME_MAX;
42 : 2 : return 0;
43 : : }
44 : : EXPORT_SYMBOL(simple_statfs);
45 : :
46 : : /*
47 : : * Retaining negative dentries for an in-memory filesystem just wastes
48 : : * memory and lookup time: arrange for them to be deleted immediately.
49 : : */
50 : 0 : int always_delete_dentry(const struct dentry *dentry)
51 : : {
52 : 553513 : return 1;
53 : : }
54 : : EXPORT_SYMBOL(always_delete_dentry);
55 : :
56 : : const struct dentry_operations simple_dentry_operations = {
57 : : .d_delete = always_delete_dentry,
58 : : };
59 : : EXPORT_SYMBOL(simple_dentry_operations);
60 : :
61 : : /*
62 : : * Lookup the data. This is trivial - if the dentry didn't already
63 : : * exist, we know it is negative. Set d_op to delete negative dentries.
64 : : */
65 : 0 : struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
66 : : {
67 [ + + ]: 542993 : if (dentry->d_name.len > NAME_MAX)
68 : : return ERR_PTR(-ENAMETOOLONG);
69 [ + + ]: 542992 : if (!dentry->d_sb->s_d_op)
70 : 542964 : d_set_d_op(dentry, &simple_dentry_operations);
71 : : d_add(dentry, NULL);
72 : 542992 : return NULL;
73 : : }
74 : : EXPORT_SYMBOL(simple_lookup);
75 : :
76 : 0 : int dcache_dir_open(struct inode *inode, struct file *file)
77 : : {
78 : : static struct qstr cursor_name = QSTR_INIT(".", 1);
79 : :
80 : 481 : file->private_data = d_alloc(file->f_path.dentry, &cursor_name);
81 : :
82 [ - + ]: 481 : return file->private_data ? 0 : -ENOMEM;
83 : : }
84 : : EXPORT_SYMBOL(dcache_dir_open);
85 : :
86 : 0 : int dcache_dir_close(struct inode *inode, struct file *file)
87 : : {
88 : 481 : dput(file->private_data);
89 : 481 : return 0;
90 : : }
91 : : EXPORT_SYMBOL(dcache_dir_close);
92 : :
93 : 0 : loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
94 : : {
95 : 0 : struct dentry *dentry = file->f_path.dentry;
96 : 0 : mutex_lock(&dentry->d_inode->i_mutex);
97 [ # # # ]: 0 : switch (whence) {
98 : : case 1:
99 : 0 : offset += file->f_pos;
100 : : case 0:
101 [ # # ]: 0 : if (offset >= 0)
102 : : break;
103 : : default:
104 : 0 : mutex_unlock(&dentry->d_inode->i_mutex);
105 : 0 : return -EINVAL;
106 : : }
107 [ # # ]: 0 : if (offset != file->f_pos) {
108 : 0 : file->f_pos = offset;
109 [ # # ]: 0 : if (file->f_pos >= 2) {
110 : : struct list_head *p;
111 : 0 : struct dentry *cursor = file->private_data;
112 : 0 : loff_t n = file->f_pos - 2;
113 : :
114 : : spin_lock(&dentry->d_lock);
115 : : /* d_lock not required for cursor */
116 : : list_del(&cursor->d_u.d_child);
117 : 0 : p = dentry->d_subdirs.next;
118 [ # # ][ # # ]: 0 : while (n && p != &dentry->d_subdirs) {
119 : : struct dentry *next;
120 : : next = list_entry(p, struct dentry, d_u.d_child);
121 : 0 : spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
122 [ # # ]: 0 : if (simple_positive(next))
123 : 0 : n--;
124 : : spin_unlock(&next->d_lock);
125 : 0 : p = p->next;
126 : : }
127 : 0 : list_add_tail(&cursor->d_u.d_child, p);
128 : : spin_unlock(&dentry->d_lock);
129 : : }
130 : : }
131 : 0 : mutex_unlock(&dentry->d_inode->i_mutex);
132 : 0 : return offset;
133 : : }
134 : : EXPORT_SYMBOL(dcache_dir_lseek);
135 : :
136 : : /* Relationship between i_mode and the DT_xxx types */
137 : : static inline unsigned char dt_type(struct inode *inode)
138 : : {
139 : 10588 : return (inode->i_mode >> 12) & 15;
140 : : }
141 : :
142 : : /*
143 : : * Directory is locked and all positive dentries in it are safe, since
144 : : * for ramfs-type trees they can't go away without unlink() or rmdir(),
145 : : * both impossible due to the lock on directory.
146 : : */
147 : :
148 : 0 : int dcache_readdir(struct file *file, struct dir_context *ctx)
149 : : {
150 : 962 : struct dentry *dentry = file->f_path.dentry;
151 : 962 : struct dentry *cursor = file->private_data;
152 : 962 : struct list_head *p, *q = &cursor->d_u.d_child;
153 : :
154 [ + - ]: 962 : if (!dir_emit_dots(file, ctx))
155 : : return 0;
156 : : spin_lock(&dentry->d_lock);
157 [ + + ]: 962 : if (ctx->pos == 2)
158 : 481 : list_move(q, &dentry->d_subdirs);
159 : :
160 [ + + ]: 11550 : for (p = q->next; p != &dentry->d_subdirs; p = p->next) {
161 : : struct dentry *next = list_entry(p, struct dentry, d_u.d_child);
162 : 10588 : spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
163 [ - + ]: 10588 : if (!simple_positive(next)) {
164 : : spin_unlock(&next->d_lock);
165 : 0 : continue;
166 : : }
167 : :
168 : : spin_unlock(&next->d_lock);
169 : : spin_unlock(&dentry->d_lock);
170 [ + - ]: 10588 : if (!dir_emit(ctx, next->d_name.name, next->d_name.len,
171 : 21176 : next->d_inode->i_ino, dt_type(next->d_inode)))
172 : : return 0;
173 : : spin_lock(&dentry->d_lock);
174 : 10588 : spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
175 : : /* next is still alive */
176 : : list_move(q, p);
177 : : spin_unlock(&next->d_lock);
178 : : p = q;
179 : 10588 : ctx->pos++;
180 : : }
181 : : spin_unlock(&dentry->d_lock);
182 : 962 : return 0;
183 : : }
184 : : EXPORT_SYMBOL(dcache_readdir);
185 : :
186 : 0 : ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos)
187 : : {
188 : 37 : return -EISDIR;
189 : : }
190 : : EXPORT_SYMBOL(generic_read_dir);
191 : :
192 : : const struct file_operations simple_dir_operations = {
193 : : .open = dcache_dir_open,
194 : : .release = dcache_dir_close,
195 : : .llseek = dcache_dir_lseek,
196 : : .read = generic_read_dir,
197 : : .iterate = dcache_readdir,
198 : : .fsync = noop_fsync,
199 : : };
200 : : EXPORT_SYMBOL(simple_dir_operations);
201 : :
202 : : const struct inode_operations simple_dir_inode_operations = {
203 : : .lookup = simple_lookup,
204 : : };
205 : : EXPORT_SYMBOL(simple_dir_inode_operations);
206 : :
207 : : static const struct super_operations simple_super_operations = {
208 : : .statfs = simple_statfs,
209 : : };
210 : :
211 : : /*
212 : : * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
213 : : * will never be mountable)
214 : : */
215 : 0 : struct dentry *mount_pseudo(struct file_system_type *fs_type, char *name,
216 : : const struct super_operations *ops,
217 : : const struct dentry_operations *dops, unsigned long magic)
218 : : {
219 : : struct super_block *s;
220 : : struct dentry *dentry;
221 : : struct inode *root;
222 : 0 : struct qstr d_name = QSTR_INIT(name, strlen(name));
223 : :
224 : 0 : s = sget(fs_type, NULL, set_anon_super, MS_NOUSER, NULL);
225 [ # # ]: 0 : if (IS_ERR(s))
226 : : return ERR_CAST(s);
227 : :
228 : 0 : s->s_maxbytes = MAX_LFS_FILESIZE;
229 : 0 : s->s_blocksize = PAGE_SIZE;
230 : 0 : s->s_blocksize_bits = PAGE_SHIFT;
231 : 0 : s->s_magic = magic;
232 [ # # ]: 0 : s->s_op = ops ? ops : &simple_super_operations;
233 : 0 : s->s_time_gran = 1;
234 : 0 : root = new_inode(s);
235 [ # # ]: 0 : if (!root)
236 : : goto Enomem;
237 : : /*
238 : : * since this is the first inode, make it number 1. New inodes created
239 : : * after this must take care not to collide with it (by passing
240 : : * max_reserved of 1 to iunique).
241 : : */
242 : 0 : root->i_ino = 1;
243 : 0 : root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
244 : 0 : root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;
245 : 0 : dentry = __d_alloc(s, &d_name);
246 [ # # ]: 0 : if (!dentry) {
247 : 0 : iput(root);
248 : 0 : goto Enomem;
249 : : }
250 : 0 : d_instantiate(dentry, root);
251 : 0 : s->s_root = dentry;
252 : 0 : s->s_d_op = dops;
253 : 0 : s->s_flags |= MS_ACTIVE;
254 : 0 : return dget(s->s_root);
255 : :
256 : : Enomem:
257 : 0 : deactivate_locked_super(s);
258 : 0 : return ERR_PTR(-ENOMEM);
259 : : }
260 : : EXPORT_SYMBOL(mount_pseudo);
261 : :
262 : 0 : int simple_open(struct inode *inode, struct file *file)
263 : : {
264 [ # # ]: 0 : if (inode->i_private)
265 : 0 : file->private_data = inode->i_private;
266 : 0 : return 0;
267 : : }
268 : : EXPORT_SYMBOL(simple_open);
269 : :
270 : 0 : int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
271 : : {
272 : 0 : struct inode *inode = old_dentry->d_inode;
273 : :
274 : 0 : inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
275 : 0 : inc_nlink(inode);
276 : 0 : ihold(inode);
277 : : dget(dentry);
278 : 0 : d_instantiate(dentry, inode);
279 : 0 : return 0;
280 : : }
281 : : EXPORT_SYMBOL(simple_link);
282 : :
283 : 0 : int simple_empty(struct dentry *dentry)
284 : : {
285 : : struct dentry *child;
286 : : int ret = 0;
287 : :
288 : : spin_lock(&dentry->d_lock);
289 [ + + ]: 509 : list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) {
290 : 38 : spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
291 [ + - ]: 38 : if (simple_positive(child)) {
292 : : spin_unlock(&child->d_lock);
293 : : goto out;
294 : : }
295 : : spin_unlock(&child->d_lock);
296 : : }
297 : : ret = 1;
298 : : out:
299 : : spin_unlock(&dentry->d_lock);
300 : 509 : return ret;
301 : : }
302 : : EXPORT_SYMBOL(simple_empty);
303 : :
304 : 0 : int simple_unlink(struct inode *dir, struct dentry *dentry)
305 : : {
306 : 16 : struct inode *inode = dentry->d_inode;
307 : :
308 : 16 : inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
309 : 16 : drop_nlink(inode);
310 : 16 : dput(dentry);
311 : 16 : return 0;
312 : : }
313 : : EXPORT_SYMBOL(simple_unlink);
314 : :
315 : 0 : int simple_rmdir(struct inode *dir, struct dentry *dentry)
316 : : {
317 [ + - ]: 4 : if (!simple_empty(dentry))
318 : : return -ENOTEMPTY;
319 : :
320 : 4 : drop_nlink(dentry->d_inode);
321 : 4 : simple_unlink(dir, dentry);
322 : 4 : drop_nlink(dir);
323 : 4 : return 0;
324 : : }
325 : : EXPORT_SYMBOL(simple_rmdir);
326 : :
327 : 0 : int simple_rename(struct inode *old_dir, struct dentry *old_dentry,
328 : : struct inode *new_dir, struct dentry *new_dentry)
329 : : {
330 : 0 : struct inode *inode = old_dentry->d_inode;
331 : 0 : int they_are_dirs = S_ISDIR(old_dentry->d_inode->i_mode);
332 : :
333 [ # # ]: 0 : if (!simple_empty(new_dentry))
334 : : return -ENOTEMPTY;
335 : :
336 [ # # ]: 0 : if (new_dentry->d_inode) {
337 : 0 : simple_unlink(new_dir, new_dentry);
338 [ # # ]: 0 : if (they_are_dirs) {
339 : 0 : drop_nlink(new_dentry->d_inode);
340 : 0 : drop_nlink(old_dir);
341 : : }
342 [ # # ]: 0 : } else if (they_are_dirs) {
343 : 0 : drop_nlink(old_dir);
344 : 0 : inc_nlink(new_dir);
345 : : }
346 : :
347 : 0 : old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime =
348 : 0 : new_dir->i_mtime = inode->i_ctime = CURRENT_TIME;
349 : :
350 : 0 : return 0;
351 : : }
352 : : EXPORT_SYMBOL(simple_rename);
353 : :
354 : : /**
355 : : * simple_setattr - setattr for simple filesystem
356 : : * @dentry: dentry
357 : : * @iattr: iattr structure
358 : : *
359 : : * Returns 0 on success, -error on failure.
360 : : *
361 : : * simple_setattr is a simple ->setattr implementation without a proper
362 : : * implementation of size changes.
363 : : *
364 : : * It can either be used for in-memory filesystems or special files
365 : : * on simple regular filesystems. Anything that needs to change on-disk
366 : : * or wire state on size changes needs its own setattr method.
367 : : */
368 : 0 : int simple_setattr(struct dentry *dentry, struct iattr *iattr)
369 : : {
370 : 214 : struct inode *inode = dentry->d_inode;
371 : : int error;
372 : :
373 : 214 : error = inode_change_ok(inode, iattr);
374 [ + - ]: 214 : if (error)
375 : : return error;
376 : :
377 [ + + ]: 214 : if (iattr->ia_valid & ATTR_SIZE)
378 : 2 : truncate_setsize(inode, iattr->ia_size);
379 : 214 : setattr_copy(inode, iattr);
380 : : mark_inode_dirty(inode);
381 : 214 : return 0;
382 : : }
383 : : EXPORT_SYMBOL(simple_setattr);
384 : :
385 : 0 : int simple_readpage(struct file *file, struct page *page)
386 : : {
387 : : clear_highpage(page);
388 : 0 : flush_dcache_page(page);
389 : : SetPageUptodate(page);
390 : 0 : unlock_page(page);
391 : 0 : return 0;
392 : : }
393 : : EXPORT_SYMBOL(simple_readpage);
394 : :
395 : 0 : int simple_write_begin(struct file *file, struct address_space *mapping,
396 : : loff_t pos, unsigned len, unsigned flags,
397 : : struct page **pagep, void **fsdata)
398 : : {
399 : : struct page *page;
400 : : pgoff_t index;
401 : :
402 : 0 : index = pos >> PAGE_CACHE_SHIFT;
403 : :
404 : 0 : page = grab_cache_page_write_begin(mapping, index, flags);
405 [ # # ]: 0 : if (!page)
406 : : return -ENOMEM;
407 : :
408 : 0 : *pagep = page;
409 : :
410 [ # # ][ # # ]: 0 : if (!PageUptodate(page) && (len != PAGE_CACHE_SIZE)) {
411 : 0 : unsigned from = pos & (PAGE_CACHE_SIZE - 1);
412 : :
413 : 0 : zero_user_segments(page, 0, from, from + len, PAGE_CACHE_SIZE);
414 : : }
415 : : return 0;
416 : : }
417 : : EXPORT_SYMBOL(simple_write_begin);
418 : :
419 : : /**
420 : : * simple_write_end - .write_end helper for non-block-device FSes
421 : : * @available: See .write_end of address_space_operations
422 : : * @file: "
423 : : * @mapping: "
424 : : * @pos: "
425 : : * @len: "
426 : : * @copied: "
427 : : * @page: "
428 : : * @fsdata: "
429 : : *
430 : : * simple_write_end does the minimum needed for updating a page after writing is
431 : : * done. It has the same API signature as the .write_end of
432 : : * address_space_operations vector. So it can just be set onto .write_end for
433 : : * FSes that don't need any other processing. i_mutex is assumed to be held.
434 : : * Block based filesystems should use generic_write_end().
435 : : * NOTE: Even though i_size might get updated by this function, mark_inode_dirty
436 : : * is not called, so a filesystem that actually does store data in .write_inode
437 : : * should extend on what's done here with a call to mark_inode_dirty() in the
438 : : * case that i_size has changed.
439 : : */
440 : 0 : int simple_write_end(struct file *file, struct address_space *mapping,
441 : : loff_t pos, unsigned len, unsigned copied,
442 : : struct page *page, void *fsdata)
443 : : {
444 : 0 : struct inode *inode = page->mapping->host;
445 : 0 : loff_t last_pos = pos + copied;
446 : :
447 : : /* zero the stale part of the page if we did a short copy */
448 [ # # ]: 0 : if (copied < len) {
449 : 0 : unsigned from = pos & (PAGE_CACHE_SIZE - 1);
450 : :
451 : 0 : zero_user(page, from + copied, len - copied);
452 : : }
453 : :
454 [ # # ]: 0 : if (!PageUptodate(page))
455 : : SetPageUptodate(page);
456 : : /*
457 : : * No need to use i_size_read() here, the i_size
458 : : * cannot change under us because we hold the i_mutex.
459 : : */
460 [ # # ]: 0 : if (last_pos > inode->i_size)
461 : : i_size_write(inode, last_pos);
462 : :
463 : 0 : set_page_dirty(page);
464 : 0 : unlock_page(page);
465 : 0 : page_cache_release(page);
466 : :
467 : 0 : return copied;
468 : : }
469 : : EXPORT_SYMBOL(simple_write_end);
470 : :
471 : : /*
472 : : * the inodes created here are not hashed. If you use iunique to generate
473 : : * unique inode values later for this filesystem, then you must take care
474 : : * to pass it an appropriate max_reserved value to avoid collisions.
475 : : */
476 : 0 : int simple_fill_super(struct super_block *s, unsigned long magic,
477 : : struct tree_descr *files)
478 : : {
479 : : struct inode *inode;
480 : : struct dentry *root;
481 : : struct dentry *dentry;
482 : : int i;
483 : :
484 : 0 : s->s_blocksize = PAGE_CACHE_SIZE;
485 : 0 : s->s_blocksize_bits = PAGE_CACHE_SHIFT;
486 : 0 : s->s_magic = magic;
487 : 0 : s->s_op = &simple_super_operations;
488 : 0 : s->s_time_gran = 1;
489 : :
490 : 0 : inode = new_inode(s);
491 [ # # ]: 0 : if (!inode)
492 : : return -ENOMEM;
493 : : /*
494 : : * because the root inode is 1, the files array must not contain an
495 : : * entry at index 1
496 : : */
497 : 0 : inode->i_ino = 1;
498 : 0 : inode->i_mode = S_IFDIR | 0755;
499 : 0 : inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
500 : 0 : inode->i_op = &simple_dir_inode_operations;
501 : 0 : inode->i_fop = &simple_dir_operations;
502 : 0 : set_nlink(inode, 2);
503 : 0 : root = d_make_root(inode);
504 [ # # ]: 0 : if (!root)
505 : : return -ENOMEM;
506 [ # # ][ # # ]: 0 : for (i = 0; !files->name || files->name[0]; i++, files++) {
507 [ # # ]: 0 : if (!files->name)
508 : 0 : continue;
509 : :
510 : : /* warn if it tries to conflict with the root inode */
511 [ # # ]: 0 : if (unlikely(i == 1))
512 : 0 : printk(KERN_WARNING "%s: %s passed in a files array"
513 : : "with an index of 1!\n", __func__,
514 : 0 : s->s_type->name);
515 : :
516 : 0 : dentry = d_alloc_name(root, files->name);
517 [ # # ]: 0 : if (!dentry)
518 : : goto out;
519 : 0 : inode = new_inode(s);
520 [ # # ]: 0 : if (!inode) {
521 : 0 : dput(dentry);
522 : 0 : goto out;
523 : : }
524 : 0 : inode->i_mode = S_IFREG | files->mode;
525 : 0 : inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
526 : 0 : inode->i_fop = files->ops;
527 : 0 : inode->i_ino = i;
528 : : d_add(dentry, inode);
529 : : }
530 : 0 : s->s_root = root;
531 : 0 : return 0;
532 : : out:
533 : 0 : d_genocide(root);
534 : 0 : shrink_dcache_parent(root);
535 : 0 : dput(root);
536 : 0 : return -ENOMEM;
537 : : }
538 : : EXPORT_SYMBOL(simple_fill_super);
539 : :
540 : : static DEFINE_SPINLOCK(pin_fs_lock);
541 : :
542 : 0 : int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
543 : : {
544 : : struct vfsmount *mnt = NULL;
545 : : spin_lock(&pin_fs_lock);
546 [ - + ]: 6 : if (unlikely(!*mount)) {
547 : : spin_unlock(&pin_fs_lock);
548 : 0 : mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, NULL);
549 [ # # ]: 0 : if (IS_ERR(mnt))
550 : 0 : return PTR_ERR(mnt);
551 : : spin_lock(&pin_fs_lock);
552 [ # # ]: 0 : if (!*mount)
553 : 0 : *mount = mnt;
554 : : }
555 : 6 : mntget(*mount);
556 : 6 : ++*count;
557 : : spin_unlock(&pin_fs_lock);
558 : 6 : mntput(mnt);
559 : 6 : return 0;
560 : : }
561 : : EXPORT_SYMBOL(simple_pin_fs);
562 : :
563 : 0 : void simple_release_fs(struct vfsmount **mount, int *count)
564 : : {
565 : : struct vfsmount *mnt;
566 : : spin_lock(&pin_fs_lock);
567 : 6 : mnt = *mount;
568 [ - + ]: 6 : if (!--*count)
569 : 0 : *mount = NULL;
570 : : spin_unlock(&pin_fs_lock);
571 : 6 : mntput(mnt);
572 : 6 : }
573 : : EXPORT_SYMBOL(simple_release_fs);
574 : :
575 : : /**
576 : : * simple_read_from_buffer - copy data from the buffer to user space
577 : : * @to: the user space buffer to read to
578 : : * @count: the maximum number of bytes to read
579 : : * @ppos: the current position in the buffer
580 : : * @from: the buffer to read from
581 : : * @available: the size of the buffer
582 : : *
583 : : * The simple_read_from_buffer() function reads up to @count bytes from the
584 : : * buffer @from at offset @ppos into the user space address starting at @to.
585 : : *
586 : : * On success, the number of bytes read is returned and the offset @ppos is
587 : : * advanced by this number, or negative value is returned on error.
588 : : **/
589 : 0 : ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
590 : : const void *from, size_t available)
591 : : {
592 : 304 : loff_t pos = *ppos;
593 : : size_t ret;
594 : :
595 [ + - ]: 304 : if (pos < 0)
596 : : return -EINVAL;
597 [ + + ][ + - ]: 304 : if (pos >= available || !count)
598 : : return 0;
599 [ + + ]: 169 : if (count > available - pos)
600 : 93 : count = available - pos;
601 : 169 : ret = copy_to_user(to, from + pos, count);
602 [ + - ]: 473 : if (ret == count)
603 : : return -EFAULT;
604 : 169 : count -= ret;
605 : 169 : *ppos = pos + count;
606 : 169 : return count;
607 : : }
608 : : EXPORT_SYMBOL(simple_read_from_buffer);
609 : :
610 : : /**
611 : : * simple_write_to_buffer - copy data from user space to the buffer
612 : : * @to: the buffer to write to
613 : : * @available: the size of the buffer
614 : : * @ppos: the current position in the buffer
615 : : * @from: the user space buffer to read from
616 : : * @count: the maximum number of bytes to read
617 : : *
618 : : * The simple_write_to_buffer() function reads up to @count bytes from the user
619 : : * space address starting at @from into the buffer @to at offset @ppos.
620 : : *
621 : : * On success, the number of bytes written is returned and the offset @ppos is
622 : : * advanced by this number, or negative value is returned on error.
623 : : **/
624 : 0 : ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
625 : : const void __user *from, size_t count)
626 : : {
627 : 0 : loff_t pos = *ppos;
628 : : size_t res;
629 : :
630 [ # # ]: 0 : if (pos < 0)
631 : : return -EINVAL;
632 [ # # ][ # # ]: 0 : if (pos >= available || !count)
633 : : return 0;
634 [ # # ]: 0 : if (count > available - pos)
635 : 0 : count = available - pos;
636 : 0 : res = copy_from_user(to + pos, from, count);
637 [ # # ]: 0 : if (res == count)
638 : : return -EFAULT;
639 : 0 : count -= res;
640 : 0 : *ppos = pos + count;
641 : 0 : return count;
642 : : }
643 : : EXPORT_SYMBOL(simple_write_to_buffer);
644 : :
645 : : /**
646 : : * memory_read_from_buffer - copy data from the buffer
647 : : * @to: the kernel space buffer to read to
648 : : * @count: the maximum number of bytes to read
649 : : * @ppos: the current position in the buffer
650 : : * @from: the buffer to read from
651 : : * @available: the size of the buffer
652 : : *
653 : : * The memory_read_from_buffer() function reads up to @count bytes from the
654 : : * buffer @from at offset @ppos into the kernel space address starting at @to.
655 : : *
656 : : * On success, the number of bytes read is returned and the offset @ppos is
657 : : * advanced by this number, or negative value is returned on error.
658 : : **/
659 : 0 : ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
660 : : const void *from, size_t available)
661 : : {
662 : 0 : loff_t pos = *ppos;
663 : :
664 [ # # ]: 0 : if (pos < 0)
665 : : return -EINVAL;
666 [ # # ]: 0 : if (pos >= available)
667 : : return 0;
668 [ # # ]: 0 : if (count > available - pos)
669 : 0 : count = available - pos;
670 : 0 : memcpy(to, from + pos, count);
671 : 0 : *ppos = pos + count;
672 : :
673 : 0 : return count;
674 : : }
675 : : EXPORT_SYMBOL(memory_read_from_buffer);
676 : :
677 : : /*
678 : : * Transaction based IO.
679 : : * The file expects a single write which triggers the transaction, and then
680 : : * possibly a read which collects the result - which is stored in a
681 : : * file-local buffer.
682 : : */
683 : :
684 : 0 : void simple_transaction_set(struct file *file, size_t n)
685 : : {
686 : 0 : struct simple_transaction_argresp *ar = file->private_data;
687 : :
688 [ # # ]: 0 : BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
689 : :
690 : : /*
691 : : * The barrier ensures that ar->size will really remain zero until
692 : : * ar->data is ready for reading.
693 : : */
694 : 0 : smp_mb();
695 : 0 : ar->size = n;
696 : 0 : }
697 : : EXPORT_SYMBOL(simple_transaction_set);
698 : :
699 : 0 : char *simple_transaction_get(struct file *file, const char __user *buf, size_t size)
700 : : {
701 : : struct simple_transaction_argresp *ar;
702 : : static DEFINE_SPINLOCK(simple_transaction_lock);
703 : :
704 [ # # ]: 0 : if (size > SIMPLE_TRANSACTION_LIMIT - 1)
705 : : return ERR_PTR(-EFBIG);
706 : :
707 : 0 : ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL);
708 [ # # ]: 0 : if (!ar)
709 : : return ERR_PTR(-ENOMEM);
710 : :
711 : : spin_lock(&simple_transaction_lock);
712 : :
713 : : /* only one write allowed per open */
714 [ # # ]: 0 : if (file->private_data) {
715 : : spin_unlock(&simple_transaction_lock);
716 : 0 : free_page((unsigned long)ar);
717 : 0 : return ERR_PTR(-EBUSY);
718 : : }
719 : :
720 : 0 : file->private_data = ar;
721 : :
722 : : spin_unlock(&simple_transaction_lock);
723 : :
724 [ # # ]: 0 : if (copy_from_user(ar->data, buf, size))
725 : : return ERR_PTR(-EFAULT);
726 : :
727 : 0 : return ar->data;
728 : : }
729 : : EXPORT_SYMBOL(simple_transaction_get);
730 : :
731 : 0 : ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
732 : : {
733 : 0 : struct simple_transaction_argresp *ar = file->private_data;
734 : :
735 [ # # ]: 0 : if (!ar)
736 : : return 0;
737 : 0 : return simple_read_from_buffer(buf, size, pos, ar->data, ar->size);
738 : : }
739 : : EXPORT_SYMBOL(simple_transaction_read);
740 : :
741 : 0 : int simple_transaction_release(struct inode *inode, struct file *file)
742 : : {
743 : 0 : free_page((unsigned long)file->private_data);
744 : 0 : return 0;
745 : : }
746 : : EXPORT_SYMBOL(simple_transaction_release);
747 : :
748 : : /* Simple attribute files */
749 : :
750 : : struct simple_attr {
751 : : int (*get)(void *, u64 *);
752 : : int (*set)(void *, u64);
753 : : char get_buf[24]; /* enough to store a u64 and "\n\0" */
754 : : char set_buf[24];
755 : : void *data;
756 : : const char *fmt; /* format for read operation */
757 : : struct mutex mutex; /* protects access to these buffers */
758 : : };
759 : :
760 : : /* simple_attr_open is called by an actual attribute open file operation
761 : : * to set the attribute specific access operations. */
762 : 0 : int simple_attr_open(struct inode *inode, struct file *file,
763 : : int (*get)(void *, u64 *), int (*set)(void *, u64),
764 : : const char *fmt)
765 : : {
766 : : struct simple_attr *attr;
767 : :
768 : : attr = kmalloc(sizeof(*attr), GFP_KERNEL);
769 [ # # ]: 0 : if (!attr)
770 : : return -ENOMEM;
771 : :
772 : 0 : attr->get = get;
773 : 0 : attr->set = set;
774 : 0 : attr->data = inode->i_private;
775 : 0 : attr->fmt = fmt;
776 : 0 : mutex_init(&attr->mutex);
777 : :
778 : 0 : file->private_data = attr;
779 : :
780 : 0 : return nonseekable_open(inode, file);
781 : : }
782 : : EXPORT_SYMBOL_GPL(simple_attr_open);
783 : :
784 : 0 : int simple_attr_release(struct inode *inode, struct file *file)
785 : : {
786 : 0 : kfree(file->private_data);
787 : 0 : return 0;
788 : : }
789 : : EXPORT_SYMBOL_GPL(simple_attr_release); /* GPL-only? This? Really? */
790 : :
791 : : /* read from the buffer that is filled with the get function */
792 : 0 : ssize_t simple_attr_read(struct file *file, char __user *buf,
793 : : size_t len, loff_t *ppos)
794 : : {
795 : : struct simple_attr *attr;
796 : : size_t size;
797 : : ssize_t ret;
798 : :
799 : 0 : attr = file->private_data;
800 : :
801 [ # # ]: 0 : if (!attr->get)
802 : : return -EACCES;
803 : :
804 : 0 : ret = mutex_lock_interruptible(&attr->mutex);
805 [ # # ]: 0 : if (ret)
806 : : return ret;
807 : :
808 [ # # ]: 0 : if (*ppos) { /* continued read */
809 : 0 : size = strlen(attr->get_buf);
810 : : } else { /* first read */
811 : : u64 val;
812 : 0 : ret = attr->get(attr->data, &val);
813 [ # # ]: 0 : if (ret)
814 : : goto out;
815 : :
816 : 0 : size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
817 : : attr->fmt, (unsigned long long)val);
818 : : }
819 : :
820 : 0 : ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
821 : : out:
822 : 0 : mutex_unlock(&attr->mutex);
823 : 0 : return ret;
824 : : }
825 : : EXPORT_SYMBOL_GPL(simple_attr_read);
826 : :
827 : : /* interpret the buffer as a number to call the set function with */
828 : 0 : ssize_t simple_attr_write(struct file *file, const char __user *buf,
829 : : size_t len, loff_t *ppos)
830 : : {
831 : : struct simple_attr *attr;
832 : : u64 val;
833 : : size_t size;
834 : : ssize_t ret;
835 : :
836 : 0 : attr = file->private_data;
837 [ # # ]: 0 : if (!attr->set)
838 : : return -EACCES;
839 : :
840 : 0 : ret = mutex_lock_interruptible(&attr->mutex);
841 [ # # ]: 0 : if (ret)
842 : : return ret;
843 : :
844 : : ret = -EFAULT;
845 : 0 : size = min(sizeof(attr->set_buf) - 1, len);
846 [ # # ]: 0 : if (copy_from_user(attr->set_buf, buf, size))
847 : : goto out;
848 : :
849 : 0 : attr->set_buf[size] = '\0';
850 : 0 : val = simple_strtoll(attr->set_buf, NULL, 0);
851 : 0 : ret = attr->set(attr->data, val);
852 [ # # ]: 0 : if (ret == 0)
853 : 0 : ret = len; /* on success, claim we got the whole input */
854 : : out:
855 : 0 : mutex_unlock(&attr->mutex);
856 : 0 : return ret;
857 : : }
858 : : EXPORT_SYMBOL_GPL(simple_attr_write);
859 : :
860 : : /**
861 : : * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation
862 : : * @sb: filesystem to do the file handle conversion on
863 : : * @fid: file handle to convert
864 : : * @fh_len: length of the file handle in bytes
865 : : * @fh_type: type of file handle
866 : : * @get_inode: filesystem callback to retrieve inode
867 : : *
868 : : * This function decodes @fid as long as it has one of the well-known
869 : : * Linux filehandle types and calls @get_inode on it to retrieve the
870 : : * inode for the object specified in the file handle.
871 : : */
872 : 0 : struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid,
873 : : int fh_len, int fh_type, struct inode *(*get_inode)
874 : : (struct super_block *sb, u64 ino, u32 gen))
875 : : {
876 : : struct inode *inode = NULL;
877 : :
878 [ # # ]: 0 : if (fh_len < 2)
879 : : return NULL;
880 : :
881 [ # # ]: 0 : switch (fh_type) {
882 : : case FILEID_INO32_GEN:
883 : : case FILEID_INO32_GEN_PARENT:
884 : 0 : inode = get_inode(sb, fid->i32.ino, fid->i32.gen);
885 : 0 : break;
886 : : }
887 : :
888 : 0 : return d_obtain_alias(inode);
889 : : }
890 : : EXPORT_SYMBOL_GPL(generic_fh_to_dentry);
891 : :
892 : : /**
893 : : * generic_fh_to_parent - generic helper for the fh_to_parent export operation
894 : : * @sb: filesystem to do the file handle conversion on
895 : : * @fid: file handle to convert
896 : : * @fh_len: length of the file handle in bytes
897 : : * @fh_type: type of file handle
898 : : * @get_inode: filesystem callback to retrieve inode
899 : : *
900 : : * This function decodes @fid as long as it has one of the well-known
901 : : * Linux filehandle types and calls @get_inode on it to retrieve the
902 : : * inode for the _parent_ object specified in the file handle if it
903 : : * is specified in the file handle, or NULL otherwise.
904 : : */
905 : 0 : struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid,
906 : : int fh_len, int fh_type, struct inode *(*get_inode)
907 : : (struct super_block *sb, u64 ino, u32 gen))
908 : : {
909 : : struct inode *inode = NULL;
910 : :
911 [ # # ]: 0 : if (fh_len <= 2)
912 : : return NULL;
913 : :
914 [ # # ]: 0 : switch (fh_type) {
915 : : case FILEID_INO32_GEN_PARENT:
916 [ # # ]: 0 : inode = get_inode(sb, fid->i32.parent_ino,
917 : : (fh_len > 3 ? fid->i32.parent_gen : 0));
918 : 0 : break;
919 : : }
920 : :
921 : 0 : return d_obtain_alias(inode);
922 : : }
923 : : EXPORT_SYMBOL_GPL(generic_fh_to_parent);
924 : :
925 : : /**
926 : : * generic_file_fsync - generic fsync implementation for simple filesystems
927 : : * @file: file to synchronize
928 : : * @datasync: only synchronize essential metadata if true
929 : : *
930 : : * This is a generic implementation of the fsync method for simple
931 : : * filesystems which track all non-inode metadata in the buffers list
932 : : * hanging off the address_space structure.
933 : : */
934 : 0 : int generic_file_fsync(struct file *file, loff_t start, loff_t end,
935 : : int datasync)
936 : : {
937 : 1 : struct inode *inode = file->f_mapping->host;
938 : : int err;
939 : : int ret;
940 : :
941 : 1 : err = filemap_write_and_wait_range(inode->i_mapping, start, end);
942 [ + - ]: 1 : if (err)
943 : : return err;
944 : :
945 : 1 : mutex_lock(&inode->i_mutex);
946 : 1 : ret = sync_mapping_buffers(inode->i_mapping);
947 [ + - ]: 1 : if (!(inode->i_state & I_DIRTY))
948 : : goto out;
949 [ + - ][ + - ]: 1 : if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
950 : : goto out;
951 : :
952 : 1 : err = sync_inode_metadata(inode, 1);
953 [ + - ]: 1 : if (ret == 0)
954 : : ret = err;
955 : : out:
956 : 1 : mutex_unlock(&inode->i_mutex);
957 : 1 : return ret;
958 : : }
959 : : EXPORT_SYMBOL(generic_file_fsync);
960 : :
961 : : /**
962 : : * generic_check_addressable - Check addressability of file system
963 : : * @blocksize_bits: log of file system block size
964 : : * @num_blocks: number of blocks in file system
965 : : *
966 : : * Determine whether a file system with @num_blocks blocks (and a
967 : : * block size of 2**@blocksize_bits) is addressable by the sector_t
968 : : * and page cache of the system. Return 0 if so and -EFBIG otherwise.
969 : : */
970 : 0 : int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks)
971 : : {
972 : 2 : u64 last_fs_block = num_blocks - 1;
973 : 2 : u64 last_fs_page =
974 : 2 : last_fs_block >> (PAGE_CACHE_SHIFT - blocksize_bits);
975 : :
976 [ + - ]: 2 : if (unlikely(num_blocks == 0))
977 : : return 0;
978 : :
979 [ + - ]: 2 : if ((blocksize_bits < 9) || (blocksize_bits > PAGE_CACHE_SHIFT))
980 : : return -EINVAL;
981 : :
982 [ + - ][ + - ]: 2 : if ((last_fs_block > (sector_t)(~0ULL) >> (blocksize_bits - 9)) ||
983 : : (last_fs_page > (pgoff_t)(~0ULL))) {
984 : : return -EFBIG;
985 : : }
986 : 2 : return 0;
987 : : }
988 : : EXPORT_SYMBOL(generic_check_addressable);
989 : :
990 : : /*
991 : : * No-op implementation of ->fsync for in-memory filesystems.
992 : : */
993 : 0 : int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync)
994 : : {
995 : 0 : return 0;
996 : : }
997 : : EXPORT_SYMBOL(noop_fsync);
998 : :
999 : 0 : void kfree_put_link(struct dentry *dentry, struct nameidata *nd,
1000 : : void *cookie)
1001 : : {
1002 : : char *s = nd_get_link(nd);
1003 [ + - ]: 4057 : if (!IS_ERR(s))
1004 : 4057 : kfree(s);
1005 : 0 : }
1006 : : EXPORT_SYMBOL(kfree_put_link);
1007 : :
1008 : : /*
1009 : : * nop .set_page_dirty method so that people can use .page_mkwrite on
1010 : : * anon inodes.
1011 : : */
1012 : 0 : static int anon_set_page_dirty(struct page *page)
1013 : : {
1014 : 0 : return 0;
1015 : : };
1016 : :
1017 : : /*
1018 : : * A single inode exists for all anon_inode files. Contrary to pipes,
1019 : : * anon_inode inodes have no associated per-instance data, so we need
1020 : : * only allocate one of them.
1021 : : */
1022 : 0 : struct inode *alloc_anon_inode(struct super_block *s)
1023 : : {
1024 : : static const struct address_space_operations anon_aops = {
1025 : : .set_page_dirty = anon_set_page_dirty,
1026 : : };
1027 : 0 : struct inode *inode = new_inode_pseudo(s);
1028 : :
1029 [ # # ]: 0 : if (!inode)
1030 : : return ERR_PTR(-ENOMEM);
1031 : :
1032 : 0 : inode->i_ino = get_next_ino();
1033 : 0 : inode->i_mapping->a_ops = &anon_aops;
1034 : :
1035 : : /*
1036 : : * Mark the inode dirty from the very beginning,
1037 : : * that way it will never be moved to the dirty
1038 : : * list because mark_inode_dirty() will think
1039 : : * that it already _is_ on the dirty list.
1040 : : */
1041 : 0 : inode->i_state = I_DIRTY;
1042 : 0 : inode->i_mode = S_IRUSR | S_IWUSR;
1043 : 0 : inode->i_uid = current_fsuid();
1044 : 0 : inode->i_gid = current_fsgid();
1045 : 0 : inode->i_flags |= S_PRIVATE;
1046 : 0 : inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
1047 : 0 : return inode;
1048 : : }
1049 : : EXPORT_SYMBOL(alloc_anon_inode);
|
