~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/libfs.c

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp