LCOV - code coverage report
Current view: top level - fs - libfs.c (source / functions) Hit Total Coverage
Test: landlock.info Lines: 211 570 37.0 %
Date: 2021-04-22 12:43:58 Functions: 24 63 38.1 %

          Line data    Source code
       1             : // SPDX-License-Identifier: GPL-2.0-only
       2             : /*
       3             :  *      fs/libfs.c
       4             :  *      Library for filesystems writers.
       5             :  */
       6             : 
       7             : #include <linux/blkdev.h>
       8             : #include <linux/export.h>
       9             : #include <linux/pagemap.h>
      10             : #include <linux/slab.h>
      11             : #include <linux/cred.h>
      12             : #include <linux/mount.h>
      13             : #include <linux/vfs.h>
      14             : #include <linux/quotaops.h>
      15             : #include <linux/mutex.h>
      16             : #include <linux/namei.h>
      17             : #include <linux/exportfs.h>
      18             : #include <linux/writeback.h>
      19             : #include <linux/buffer_head.h> /* sync_mapping_buffers */
      20             : #include <linux/fs_context.h>
      21             : #include <linux/pseudo_fs.h>
      22             : #include <linux/fsnotify.h>
      23             : #include <linux/unicode.h>
      24             : #include <linux/fscrypt.h>
      25             : 
      26             : #include <linux/uaccess.h>
      27             : 
      28             : #include "internal.h"
      29             : 
      30           0 : int simple_getattr(struct user_namespace *mnt_userns, const struct path *path,
      31             :                    struct kstat *stat, u32 request_mask,
      32             :                    unsigned int query_flags)
      33             : {
      34           0 :         struct inode *inode = d_inode(path->dentry);
      35           0 :         generic_fillattr(&init_user_ns, inode, stat);
      36           0 :         stat->blocks = inode->i_mapping->nrpages << (PAGE_SHIFT - 9);
      37           0 :         return 0;
      38             : }
      39             : EXPORT_SYMBOL(simple_getattr);
      40             : 
      41          45 : int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
      42             : {
      43          45 :         buf->f_type = dentry->d_sb->s_magic;
      44          45 :         buf->f_bsize = PAGE_SIZE;
      45          45 :         buf->f_namelen = NAME_MAX;
      46          45 :         return 0;
      47             : }
      48             : EXPORT_SYMBOL(simple_statfs);
      49             : 
      50             : /*
      51             :  * Retaining negative dentries for an in-memory filesystem just wastes
      52             :  * memory and lookup time: arrange for them to be deleted immediately.
      53             :  */
      54        6994 : int always_delete_dentry(const struct dentry *dentry)
      55             : {
      56        6994 :         return 1;
      57             : }
      58             : EXPORT_SYMBOL(always_delete_dentry);
      59             : 
      60             : const struct dentry_operations simple_dentry_operations = {
      61             :         .d_delete = always_delete_dentry,
      62             : };
      63             : EXPORT_SYMBOL(simple_dentry_operations);
      64             : 
      65             : /*
      66             :  * Lookup the data. This is trivial - if the dentry didn't already
      67             :  * exist, we know it is negative.  Set d_op to delete negative dentries.
      68             :  */
      69       13440 : struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
      70             : {
      71       13440 :         if (dentry->d_name.len > NAME_MAX)
      72       13440 :                 return ERR_PTR(-ENAMETOOLONG);
      73       13440 :         if (!dentry->d_sb->s_d_op)
      74       11372 :                 d_set_d_op(dentry, &simple_dentry_operations);
      75       13440 :         d_add(dentry, NULL);
      76       13440 :         return NULL;
      77             : }
      78             : EXPORT_SYMBOL(simple_lookup);
      79             : 
      80         288 : int dcache_dir_open(struct inode *inode, struct file *file)
      81             : {
      82         288 :         file->private_data = d_alloc_cursor(file->f_path.dentry);
      83             : 
      84         288 :         return file->private_data ? 0 : -ENOMEM;
      85             : }
      86             : EXPORT_SYMBOL(dcache_dir_open);
      87             : 
      88         284 : int dcache_dir_close(struct inode *inode, struct file *file)
      89             : {
      90         284 :         dput(file->private_data);
      91         284 :         return 0;
      92             : }
      93             : EXPORT_SYMBOL(dcache_dir_close);
      94             : 
      95             : /* parent is locked at least shared */
      96             : /*
      97             :  * Returns an element of siblings' list.
      98             :  * We are looking for <count>th positive after <p>; if
      99             :  * found, dentry is grabbed and returned to caller.
     100             :  * If no such element exists, NULL is returned.
     101             :  */
     102        3233 : static struct dentry *scan_positives(struct dentry *cursor,
     103             :                                         struct list_head *p,
     104             :                                         loff_t count,
     105             :                                         struct dentry *last)
     106             : {
     107        3233 :         struct dentry *dentry = cursor->d_parent, *found = NULL;
     108             : 
     109        3233 :         spin_lock(&dentry->d_lock);
     110        3233 :         while ((p = p->next) != &dentry->d_subdirs) {
     111        3054 :                 struct dentry *d = list_entry(p, struct dentry, d_child);
     112             :                 // we must at least skip cursors, to avoid livelocks
     113        3054 :                 if (d->d_flags & DCACHE_DENTRY_CURSOR)
     114           0 :                         continue;
     115        6108 :                 if (simple_positive(d) && !--count) {
     116        3054 :                         spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
     117        3054 :                         if (simple_positive(d))
     118        3054 :                                 found = dget_dlock(d);
     119        3054 :                         spin_unlock(&d->d_lock);
     120        3054 :                         if (likely(found))
     121             :                                 break;
     122             :                         count = 1;
     123             :                 }
     124           0 :                 if (need_resched()) {
     125           0 :                         list_move(&cursor->d_child, p);
     126           0 :                         p = &cursor->d_child;
     127           0 :                         spin_unlock(&dentry->d_lock);
     128           0 :                         cond_resched();
     129        3233 :                         spin_lock(&dentry->d_lock);
     130             :                 }
     131             :         }
     132        3233 :         spin_unlock(&dentry->d_lock);
     133        3233 :         dput(last);
     134        3233 :         return found;
     135             : }
     136             : 
     137           0 : loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
     138             : {
     139           0 :         struct dentry *dentry = file->f_path.dentry;
     140           0 :         switch (whence) {
     141           0 :                 case 1:
     142           0 :                         offset += file->f_pos;
     143           0 :                         fallthrough;
     144           0 :                 case 0:
     145           0 :                         if (offset >= 0)
     146             :                                 break;
     147             :                         fallthrough;
     148             :                 default:
     149             :                         return -EINVAL;
     150             :         }
     151           0 :         if (offset != file->f_pos) {
     152           0 :                 struct dentry *cursor = file->private_data;
     153           0 :                 struct dentry *to = NULL;
     154             : 
     155           0 :                 inode_lock_shared(dentry->d_inode);
     156             : 
     157           0 :                 if (offset > 2)
     158           0 :                         to = scan_positives(cursor, &dentry->d_subdirs,
     159             :                                             offset - 2, NULL);
     160           0 :                 spin_lock(&dentry->d_lock);
     161           0 :                 if (to)
     162           0 :                         list_move(&cursor->d_child, &to->d_child);
     163             :                 else
     164           0 :                         list_del_init(&cursor->d_child);
     165           0 :                 spin_unlock(&dentry->d_lock);
     166           0 :                 dput(to);
     167             : 
     168           0 :                 file->f_pos = offset;
     169             : 
     170           0 :                 inode_unlock_shared(dentry->d_inode);
     171             :         }
     172             :         return offset;
     173             : }
     174             : EXPORT_SYMBOL(dcache_dir_lseek);
     175             : 
     176             : /* Relationship between i_mode and the DT_xxx types */
     177        3054 : static inline unsigned char dt_type(struct inode *inode)
     178             : {
     179        3054 :         return (inode->i_mode >> 12) & 15;
     180             : }
     181             : 
     182             : /*
     183             :  * Directory is locked and all positive dentries in it are safe, since
     184             :  * for ramfs-type trees they can't go away without unlink() or rmdir(),
     185             :  * both impossible due to the lock on directory.
     186             :  */
     187             : 
     188         334 : int dcache_readdir(struct file *file, struct dir_context *ctx)
     189             : {
     190         334 :         struct dentry *dentry = file->f_path.dentry;
     191         334 :         struct dentry *cursor = file->private_data;
     192         334 :         struct list_head *anchor = &dentry->d_subdirs;
     193         334 :         struct dentry *next = NULL;
     194         334 :         struct list_head *p;
     195             : 
     196         334 :         if (!dir_emit_dots(file, ctx))
     197             :                 return 0;
     198             : 
     199         334 :         if (ctx->pos == 2)
     200             :                 p = anchor;
     201         155 :         else if (!list_empty(&cursor->d_child))
     202             :                 p = &cursor->d_child;
     203             :         else
     204             :                 return 0;
     205             : 
     206        3233 :         while ((next = scan_positives(cursor, p, 1, next)) != NULL) {
     207        3054 :                 if (!dir_emit(ctx, next->d_name.name, next->d_name.len,
     208        3054 :                               d_inode(next)->i_ino, dt_type(d_inode(next))))
     209             :                         break;
     210        3054 :                 ctx->pos++;
     211        3054 :                 p = &next->d_child;
     212             :         }
     213         179 :         spin_lock(&dentry->d_lock);
     214         179 :         if (next)
     215           0 :                 list_move_tail(&cursor->d_child, &next->d_child);
     216             :         else
     217         179 :                 list_del_init(&cursor->d_child);
     218         179 :         spin_unlock(&dentry->d_lock);
     219         179 :         dput(next);
     220             : 
     221         179 :         return 0;
     222             : }
     223             : EXPORT_SYMBOL(dcache_readdir);
     224             : 
     225           0 : ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos)
     226             : {
     227           0 :         return -EISDIR;
     228             : }
     229             : EXPORT_SYMBOL(generic_read_dir);
     230             : 
     231             : const struct file_operations simple_dir_operations = {
     232             :         .open           = dcache_dir_open,
     233             :         .release        = dcache_dir_close,
     234             :         .llseek         = dcache_dir_lseek,
     235             :         .read           = generic_read_dir,
     236             :         .iterate_shared = dcache_readdir,
     237             :         .fsync          = noop_fsync,
     238             : };
     239             : EXPORT_SYMBOL(simple_dir_operations);
     240             : 
     241             : const struct inode_operations simple_dir_inode_operations = {
     242             :         .lookup         = simple_lookup,
     243             : };
     244             : EXPORT_SYMBOL(simple_dir_inode_operations);
     245             : 
     246           0 : static struct dentry *find_next_child(struct dentry *parent, struct dentry *prev)
     247             : {
     248           0 :         struct dentry *child = NULL;
     249           0 :         struct list_head *p = prev ? &prev->d_child : &parent->d_subdirs;
     250             : 
     251           0 :         spin_lock(&parent->d_lock);
     252           0 :         while ((p = p->next) != &parent->d_subdirs) {
     253           0 :                 struct dentry *d = container_of(p, struct dentry, d_child);
     254           0 :                 if (simple_positive(d)) {
     255           0 :                         spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
     256           0 :                         if (simple_positive(d))
     257           0 :                                 child = dget_dlock(d);
     258           0 :                         spin_unlock(&d->d_lock);
     259           0 :                         if (likely(child))
     260             :                                 break;
     261             :                 }
     262             :         }
     263           0 :         spin_unlock(&parent->d_lock);
     264           0 :         dput(prev);
     265           0 :         return child;
     266             : }
     267             : 
     268           0 : void simple_recursive_removal(struct dentry *dentry,
     269             :                               void (*callback)(struct dentry *))
     270             : {
     271           0 :         struct dentry *this = dget(dentry);
     272           0 :         while (true) {
     273           0 :                 struct dentry *victim = NULL, *child;
     274           0 :                 struct inode *inode = this->d_inode;
     275             : 
     276           0 :                 inode_lock(inode);
     277           0 :                 if (d_is_dir(this))
     278           0 :                         inode->i_flags |= S_DEAD;
     279           0 :                 while ((child = find_next_child(this, victim)) == NULL) {
     280             :                         // kill and ascend
     281             :                         // update metadata while it's still locked
     282           0 :                         inode->i_ctime = current_time(inode);
     283           0 :                         clear_nlink(inode);
     284           0 :                         inode_unlock(inode);
     285           0 :                         victim = this;
     286           0 :                         this = this->d_parent;
     287           0 :                         inode = this->d_inode;
     288           0 :                         inode_lock(inode);
     289           0 :                         if (simple_positive(victim)) {
     290           0 :                                 d_invalidate(victim);   // avoid lost mounts
     291           0 :                                 if (d_is_dir(victim))
     292           0 :                                         fsnotify_rmdir(inode, victim);
     293             :                                 else
     294           0 :                                         fsnotify_unlink(inode, victim);
     295           0 :                                 if (callback)
     296           0 :                                         callback(victim);
     297           0 :                                 dput(victim);           // unpin it
     298             :                         }
     299           0 :                         if (victim == dentry) {
     300           0 :                                 inode->i_ctime = inode->i_mtime =
     301           0 :                                         current_time(inode);
     302           0 :                                 if (d_is_dir(dentry))
     303           0 :                                         drop_nlink(inode);
     304           0 :                                 inode_unlock(inode);
     305           0 :                                 dput(dentry);
     306           0 :                                 return;
     307             :                         }
     308             :                 }
     309           0 :                 inode_unlock(inode);
     310           0 :                 this = child;
     311             :         }
     312             : }
     313             : EXPORT_SYMBOL(simple_recursive_removal);
     314             : 
     315             : static const struct super_operations simple_super_operations = {
     316             :         .statfs         = simple_statfs,
     317             : };
     318             : 
     319           6 : static int pseudo_fs_fill_super(struct super_block *s, struct fs_context *fc)
     320             : {
     321           6 :         struct pseudo_fs_context *ctx = fc->fs_private;
     322           6 :         struct inode *root;
     323             : 
     324           6 :         s->s_maxbytes = MAX_LFS_FILESIZE;
     325           6 :         s->s_blocksize = PAGE_SIZE;
     326           6 :         s->s_blocksize_bits = PAGE_SHIFT;
     327           6 :         s->s_magic = ctx->magic;
     328           6 :         s->s_op = ctx->ops ?: &simple_super_operations;
     329           6 :         s->s_xattr = ctx->xattr;
     330           6 :         s->s_time_gran = 1;
     331           6 :         root = new_inode(s);
     332           6 :         if (!root)
     333             :                 return -ENOMEM;
     334             : 
     335             :         /*
     336             :          * since this is the first inode, make it number 1. New inodes created
     337             :          * after this must take care not to collide with it (by passing
     338             :          * max_reserved of 1 to iunique).
     339             :          */
     340           6 :         root->i_ino = 1;
     341           6 :         root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
     342           6 :         root->i_atime = root->i_mtime = root->i_ctime = current_time(root);
     343           6 :         s->s_root = d_make_root(root);
     344           6 :         if (!s->s_root)
     345             :                 return -ENOMEM;
     346           6 :         s->s_d_op = ctx->dops;
     347           6 :         return 0;
     348             : }
     349             : 
     350           6 : static int pseudo_fs_get_tree(struct fs_context *fc)
     351             : {
     352           6 :         return get_tree_nodev(fc, pseudo_fs_fill_super);
     353             : }
     354             : 
     355           6 : static void pseudo_fs_free(struct fs_context *fc)
     356             : {
     357           6 :         kfree(fc->fs_private);
     358           6 : }
     359             : 
     360             : static const struct fs_context_operations pseudo_fs_context_ops = {
     361             :         .free           = pseudo_fs_free,
     362             :         .get_tree       = pseudo_fs_get_tree,
     363             : };
     364             : 
     365             : /*
     366             :  * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
     367             :  * will never be mountable)
     368             :  */
     369           6 : struct pseudo_fs_context *init_pseudo(struct fs_context *fc,
     370             :                                         unsigned long magic)
     371             : {
     372           6 :         struct pseudo_fs_context *ctx;
     373             : 
     374           6 :         ctx = kzalloc(sizeof(struct pseudo_fs_context), GFP_KERNEL);
     375           6 :         if (likely(ctx)) {
     376           6 :                 ctx->magic = magic;
     377           6 :                 fc->fs_private = ctx;
     378           6 :                 fc->ops = &pseudo_fs_context_ops;
     379           6 :                 fc->sb_flags |= SB_NOUSER;
     380           6 :                 fc->global = true;
     381             :         }
     382           6 :         return ctx;
     383             : }
     384             : EXPORT_SYMBOL(init_pseudo);
     385             : 
     386           0 : int simple_open(struct inode *inode, struct file *file)
     387             : {
     388           0 :         if (inode->i_private)
     389           0 :                 file->private_data = inode->i_private;
     390           0 :         return 0;
     391             : }
     392             : EXPORT_SYMBOL(simple_open);
     393             : 
     394           0 : int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
     395             : {
     396           0 :         struct inode *inode = d_inode(old_dentry);
     397             : 
     398           0 :         inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
     399           0 :         inc_nlink(inode);
     400           0 :         ihold(inode);
     401           0 :         dget(dentry);
     402           0 :         d_instantiate(dentry, inode);
     403           0 :         return 0;
     404             : }
     405             : EXPORT_SYMBOL(simple_link);
     406             : 
     407        1042 : int simple_empty(struct dentry *dentry)
     408             : {
     409        1042 :         struct dentry *child;
     410        1042 :         int ret = 0;
     411             : 
     412        1042 :         spin_lock(&dentry->d_lock);
     413        1071 :         list_for_each_entry(child, &dentry->d_subdirs, d_child) {
     414         361 :                 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
     415         361 :                 if (simple_positive(child)) {
     416         332 :                         spin_unlock(&child->d_lock);
     417         332 :                         goto out;
     418             :                 }
     419          29 :                 spin_unlock(&child->d_lock);
     420             :         }
     421             :         ret = 1;
     422        1042 : out:
     423        1042 :         spin_unlock(&dentry->d_lock);
     424        1042 :         return ret;
     425             : }
     426             : EXPORT_SYMBOL(simple_empty);
     427             : 
     428           0 : int simple_unlink(struct inode *dir, struct dentry *dentry)
     429             : {
     430           0 :         struct inode *inode = d_inode(dentry);
     431             : 
     432           0 :         inode->i_ctime = dir->i_ctime = dir->i_mtime = current_time(inode);
     433           0 :         drop_nlink(inode);
     434           0 :         dput(dentry);
     435           0 :         return 0;
     436             : }
     437             : EXPORT_SYMBOL(simple_unlink);
     438             : 
     439           0 : int simple_rmdir(struct inode *dir, struct dentry *dentry)
     440             : {
     441           0 :         if (!simple_empty(dentry))
     442             :                 return -ENOTEMPTY;
     443             : 
     444           0 :         drop_nlink(d_inode(dentry));
     445           0 :         simple_unlink(dir, dentry);
     446           0 :         drop_nlink(dir);
     447           0 :         return 0;
     448             : }
     449             : EXPORT_SYMBOL(simple_rmdir);
     450             : 
     451           0 : int simple_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
     452             :                   struct dentry *old_dentry, struct inode *new_dir,
     453             :                   struct dentry *new_dentry, unsigned int flags)
     454             : {
     455           0 :         struct inode *inode = d_inode(old_dentry);
     456           0 :         int they_are_dirs = d_is_dir(old_dentry);
     457             : 
     458           0 :         if (flags & ~RENAME_NOREPLACE)
     459             :                 return -EINVAL;
     460             : 
     461           0 :         if (!simple_empty(new_dentry))
     462             :                 return -ENOTEMPTY;
     463             : 
     464           0 :         if (d_really_is_positive(new_dentry)) {
     465           0 :                 simple_unlink(new_dir, new_dentry);
     466           0 :                 if (they_are_dirs) {
     467           0 :                         drop_nlink(d_inode(new_dentry));
     468           0 :                         drop_nlink(old_dir);
     469             :                 }
     470           0 :         } else if (they_are_dirs) {
     471           0 :                 drop_nlink(old_dir);
     472           0 :                 inc_nlink(new_dir);
     473             :         }
     474             : 
     475           0 :         old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime =
     476           0 :                 new_dir->i_mtime = inode->i_ctime = current_time(old_dir);
     477             : 
     478           0 :         return 0;
     479             : }
     480             : EXPORT_SYMBOL(simple_rename);
     481             : 
     482             : /**
     483             :  * simple_setattr - setattr for simple filesystem
     484             :  * @dentry: dentry
     485             :  * @iattr: iattr structure
     486             :  *
     487             :  * Returns 0 on success, -error on failure.
     488             :  *
     489             :  * simple_setattr is a simple ->setattr implementation without a proper
     490             :  * implementation of size changes.
     491             :  *
     492             :  * It can either be used for in-memory filesystems or special files
     493             :  * on simple regular filesystems.  Anything that needs to change on-disk
     494             :  * or wire state on size changes needs its own setattr method.
     495             :  */
     496         505 : int simple_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
     497             :                    struct iattr *iattr)
     498             : {
     499         505 :         struct inode *inode = d_inode(dentry);
     500         505 :         int error;
     501             : 
     502         505 :         error = setattr_prepare(mnt_userns, dentry, iattr);
     503         505 :         if (error)
     504             :                 return error;
     505             : 
     506         505 :         if (iattr->ia_valid & ATTR_SIZE)
     507           0 :                 truncate_setsize(inode, iattr->ia_size);
     508         505 :         setattr_copy(mnt_userns, inode, iattr);
     509         505 :         mark_inode_dirty(inode);
     510         505 :         return 0;
     511             : }
     512             : EXPORT_SYMBOL(simple_setattr);
     513             : 
     514           0 : int simple_readpage(struct file *file, struct page *page)
     515             : {
     516           0 :         clear_highpage(page);
     517           0 :         flush_dcache_page(page);
     518           0 :         SetPageUptodate(page);
     519           0 :         unlock_page(page);
     520           0 :         return 0;
     521             : }
     522             : EXPORT_SYMBOL(simple_readpage);
     523             : 
     524           0 : int simple_write_begin(struct file *file, struct address_space *mapping,
     525             :                         loff_t pos, unsigned len, unsigned flags,
     526             :                         struct page **pagep, void **fsdata)
     527             : {
     528           0 :         struct page *page;
     529           0 :         pgoff_t index;
     530             : 
     531           0 :         index = pos >> PAGE_SHIFT;
     532             : 
     533           0 :         page = grab_cache_page_write_begin(mapping, index, flags);
     534           0 :         if (!page)
     535             :                 return -ENOMEM;
     536             : 
     537           0 :         *pagep = page;
     538             : 
     539           0 :         if (!PageUptodate(page) && (len != PAGE_SIZE)) {
     540           0 :                 unsigned from = pos & (PAGE_SIZE - 1);
     541             : 
     542           0 :                 zero_user_segments(page, 0, from, from + len, PAGE_SIZE);
     543             :         }
     544             :         return 0;
     545             : }
     546             : EXPORT_SYMBOL(simple_write_begin);
     547             : 
     548             : /**
     549             :  * simple_write_end - .write_end helper for non-block-device FSes
     550             :  * @file: See .write_end of address_space_operations
     551             :  * @mapping:            "
     552             :  * @pos:                "
     553             :  * @len:                "
     554             :  * @copied:             "
     555             :  * @page:               "
     556             :  * @fsdata:             "
     557             :  *
     558             :  * simple_write_end does the minimum needed for updating a page after writing is
     559             :  * done. It has the same API signature as the .write_end of
     560             :  * address_space_operations vector. So it can just be set onto .write_end for
     561             :  * FSes that don't need any other processing. i_mutex is assumed to be held.
     562             :  * Block based filesystems should use generic_write_end().
     563             :  * NOTE: Even though i_size might get updated by this function, mark_inode_dirty
     564             :  * is not called, so a filesystem that actually does store data in .write_inode
     565             :  * should extend on what's done here with a call to mark_inode_dirty() in the
     566             :  * case that i_size has changed.
     567             :  *
     568             :  * Use *ONLY* with simple_readpage()
     569             :  */
     570           0 : int simple_write_end(struct file *file, struct address_space *mapping,
     571             :                         loff_t pos, unsigned len, unsigned copied,
     572             :                         struct page *page, void *fsdata)
     573             : {
     574           0 :         struct inode *inode = page->mapping->host;
     575           0 :         loff_t last_pos = pos + copied;
     576             : 
     577             :         /* zero the stale part of the page if we did a short copy */
     578           0 :         if (!PageUptodate(page)) {
     579           0 :                 if (copied < len) {
     580           0 :                         unsigned from = pos & (PAGE_SIZE - 1);
     581             : 
     582           0 :                         zero_user(page, from + copied, len - copied);
     583             :                 }
     584           0 :                 SetPageUptodate(page);
     585             :         }
     586             :         /*
     587             :          * No need to use i_size_read() here, the i_size
     588             :          * cannot change under us because we hold the i_mutex.
     589             :          */
     590           0 :         if (last_pos > inode->i_size)
     591           0 :                 i_size_write(inode, last_pos);
     592             : 
     593           0 :         set_page_dirty(page);
     594           0 :         unlock_page(page);
     595           0 :         put_page(page);
     596             : 
     597           0 :         return copied;
     598             : }
     599             : EXPORT_SYMBOL(simple_write_end);
     600             : 
     601             : /*
     602             :  * the inodes created here are not hashed. If you use iunique to generate
     603             :  * unique inode values later for this filesystem, then you must take care
     604             :  * to pass it an appropriate max_reserved value to avoid collisions.
     605             :  */
     606           2 : int simple_fill_super(struct super_block *s, unsigned long magic,
     607             :                       const struct tree_descr *files)
     608             : {
     609           2 :         struct inode *inode;
     610           2 :         struct dentry *root;
     611           2 :         struct dentry *dentry;
     612           2 :         int i;
     613             : 
     614           2 :         s->s_blocksize = PAGE_SIZE;
     615           2 :         s->s_blocksize_bits = PAGE_SHIFT;
     616           2 :         s->s_magic = magic;
     617           2 :         s->s_op = &simple_super_operations;
     618           2 :         s->s_time_gran = 1;
     619             : 
     620           2 :         inode = new_inode(s);
     621           2 :         if (!inode)
     622             :                 return -ENOMEM;
     623             :         /*
     624             :          * because the root inode is 1, the files array must not contain an
     625             :          * entry at index 1
     626             :          */
     627           2 :         inode->i_ino = 1;
     628           2 :         inode->i_mode = S_IFDIR | 0755;
     629           2 :         inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
     630           2 :         inode->i_op = &simple_dir_inode_operations;
     631           2 :         inode->i_fop = &simple_dir_operations;
     632           2 :         set_nlink(inode, 2);
     633           2 :         root = d_make_root(inode);
     634           2 :         if (!root)
     635             :                 return -ENOMEM;
     636           2 :         for (i = 0; !files->name || files->name[0]; i++, files++) {
     637           0 :                 if (!files->name)
     638           0 :                         continue;
     639             : 
     640             :                 /* warn if it tries to conflict with the root inode */
     641           0 :                 if (unlikely(i == 1))
     642           0 :                         printk(KERN_WARNING "%s: %s passed in a files array"
     643             :                                 "with an index of 1!\n", __func__,
     644           0 :                                 s->s_type->name);
     645             : 
     646           0 :                 dentry = d_alloc_name(root, files->name);
     647           0 :                 if (!dentry)
     648           0 :                         goto out;
     649           0 :                 inode = new_inode(s);
     650           0 :                 if (!inode) {
     651           0 :                         dput(dentry);
     652           0 :                         goto out;
     653             :                 }
     654           0 :                 inode->i_mode = S_IFREG | files->mode;
     655           0 :                 inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
     656           0 :                 inode->i_fop = files->ops;
     657           0 :                 inode->i_ino = i;
     658           0 :                 d_add(dentry, inode);
     659             :         }
     660           2 :         s->s_root = root;
     661           2 :         return 0;
     662           0 : out:
     663           0 :         d_genocide(root);
     664           0 :         shrink_dcache_parent(root);
     665           0 :         dput(root);
     666           0 :         return -ENOMEM;
     667             : }
     668             : EXPORT_SYMBOL(simple_fill_super);
     669             : 
     670             : static DEFINE_SPINLOCK(pin_fs_lock);
     671             : 
     672        5519 : int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
     673             : {
     674        5519 :         struct vfsmount *mnt = NULL;
     675        5519 :         spin_lock(&pin_fs_lock);
     676        5519 :         if (unlikely(!*mount)) {
     677           3 :                 spin_unlock(&pin_fs_lock);
     678           3 :                 mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, NULL);
     679           3 :                 if (IS_ERR(mnt))
     680           0 :                         return PTR_ERR(mnt);
     681           3 :                 spin_lock(&pin_fs_lock);
     682           3 :                 if (!*mount)
     683           3 :                         *mount = mnt;
     684             :         }
     685        5519 :         mntget(*mount);
     686        5519 :         ++*count;
     687        5519 :         spin_unlock(&pin_fs_lock);
     688        5519 :         mntput(mnt);
     689        5519 :         return 0;
     690             : }
     691             : EXPORT_SYMBOL(simple_pin_fs);
     692             : 
     693           0 : void simple_release_fs(struct vfsmount **mount, int *count)
     694             : {
     695           0 :         struct vfsmount *mnt;
     696           0 :         spin_lock(&pin_fs_lock);
     697           0 :         mnt = *mount;
     698           0 :         if (!--*count)
     699           0 :                 *mount = NULL;
     700           0 :         spin_unlock(&pin_fs_lock);
     701           0 :         mntput(mnt);
     702           0 : }
     703             : EXPORT_SYMBOL(simple_release_fs);
     704             : 
     705             : /**
     706             :  * simple_read_from_buffer - copy data from the buffer to user space
     707             :  * @to: the user space buffer to read to
     708             :  * @count: the maximum number of bytes to read
     709             :  * @ppos: the current position in the buffer
     710             :  * @from: the buffer to read from
     711             :  * @available: the size of the buffer
     712             :  *
     713             :  * The simple_read_from_buffer() function reads up to @count bytes from the
     714             :  * buffer @from at offset @ppos into the user space address starting at @to.
     715             :  *
     716             :  * On success, the number of bytes read is returned and the offset @ppos is
     717             :  * advanced by this number, or negative value is returned on error.
     718             :  **/
     719           3 : ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
     720             :                                 const void *from, size_t available)
     721             : {
     722           3 :         loff_t pos = *ppos;
     723           3 :         size_t ret;
     724             : 
     725           3 :         if (pos < 0)
     726             :                 return -EINVAL;
     727           3 :         if (pos >= available || !count)
     728             :                 return 0;
     729           2 :         if (count > available - pos)
     730             :                 count = available - pos;
     731           2 :         ret = copy_to_user(to, from + pos, count);
     732           2 :         if (ret == count)
     733             :                 return -EFAULT;
     734           2 :         count -= ret;
     735           2 :         *ppos = pos + count;
     736           2 :         return count;
     737             : }
     738             : EXPORT_SYMBOL(simple_read_from_buffer);
     739             : 
     740             : /**
     741             :  * simple_write_to_buffer - copy data from user space to the buffer
     742             :  * @to: the buffer to write to
     743             :  * @available: the size of the buffer
     744             :  * @ppos: the current position in the buffer
     745             :  * @from: the user space buffer to read from
     746             :  * @count: the maximum number of bytes to read
     747             :  *
     748             :  * The simple_write_to_buffer() function reads up to @count bytes from the user
     749             :  * space address starting at @from into the buffer @to at offset @ppos.
     750             :  *
     751             :  * On success, the number of bytes written is returned and the offset @ppos is
     752             :  * advanced by this number, or negative value is returned on error.
     753             :  **/
     754           0 : ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
     755             :                 const void __user *from, size_t count)
     756             : {
     757           0 :         loff_t pos = *ppos;
     758           0 :         size_t res;
     759             : 
     760           0 :         if (pos < 0)
     761             :                 return -EINVAL;
     762           0 :         if (pos >= available || !count)
     763             :                 return 0;
     764           0 :         if (count > available - pos)
     765             :                 count = available - pos;
     766           0 :         res = copy_from_user(to + pos, from, count);
     767           0 :         if (res == count)
     768             :                 return -EFAULT;
     769           0 :         count -= res;
     770           0 :         *ppos = pos + count;
     771           0 :         return count;
     772             : }
     773             : EXPORT_SYMBOL(simple_write_to_buffer);
     774             : 
     775             : /**
     776             :  * memory_read_from_buffer - copy data from the buffer
     777             :  * @to: the kernel space buffer to read to
     778             :  * @count: the maximum number of bytes to read
     779             :  * @ppos: the current position in the buffer
     780             :  * @from: the buffer to read from
     781             :  * @available: the size of the buffer
     782             :  *
     783             :  * The memory_read_from_buffer() function reads up to @count bytes from the
     784             :  * buffer @from at offset @ppos into the kernel space address starting at @to.
     785             :  *
     786             :  * On success, the number of bytes read is returned and the offset @ppos is
     787             :  * advanced by this number, or negative value is returned on error.
     788             :  **/
     789           0 : ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
     790             :                                 const void *from, size_t available)
     791             : {
     792           0 :         loff_t pos = *ppos;
     793             : 
     794           0 :         if (pos < 0)
     795             :                 return -EINVAL;
     796           0 :         if (pos >= available)
     797             :                 return 0;
     798           0 :         if (count > available - pos)
     799             :                 count = available - pos;
     800           0 :         memcpy(to, from + pos, count);
     801           0 :         *ppos = pos + count;
     802             : 
     803           0 :         return count;
     804             : }
     805             : EXPORT_SYMBOL(memory_read_from_buffer);
     806             : 
     807             : /*
     808             :  * Transaction based IO.
     809             :  * The file expects a single write which triggers the transaction, and then
     810             :  * possibly a read which collects the result - which is stored in a
     811             :  * file-local buffer.
     812             :  */
     813             : 
     814           0 : void simple_transaction_set(struct file *file, size_t n)
     815             : {
     816           0 :         struct simple_transaction_argresp *ar = file->private_data;
     817             : 
     818           0 :         BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
     819             : 
     820             :         /*
     821             :          * The barrier ensures that ar->size will really remain zero until
     822             :          * ar->data is ready for reading.
     823             :          */
     824           0 :         smp_mb();
     825           0 :         ar->size = n;
     826           0 : }
     827             : EXPORT_SYMBOL(simple_transaction_set);
     828             : 
     829           0 : char *simple_transaction_get(struct file *file, const char __user *buf, size_t size)
     830             : {
     831           0 :         struct simple_transaction_argresp *ar;
     832           0 :         static DEFINE_SPINLOCK(simple_transaction_lock);
     833             : 
     834           0 :         if (size > SIMPLE_TRANSACTION_LIMIT - 1)
     835           0 :                 return ERR_PTR(-EFBIG);
     836             : 
     837           0 :         ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL);
     838           0 :         if (!ar)
     839           0 :                 return ERR_PTR(-ENOMEM);
     840             : 
     841           0 :         spin_lock(&simple_transaction_lock);
     842             : 
     843             :         /* only one write allowed per open */
     844           0 :         if (file->private_data) {
     845           0 :                 spin_unlock(&simple_transaction_lock);
     846           0 :                 free_page((unsigned long)ar);
     847           0 :                 return ERR_PTR(-EBUSY);
     848             :         }
     849             : 
     850           0 :         file->private_data = ar;
     851             : 
     852           0 :         spin_unlock(&simple_transaction_lock);
     853             : 
     854           0 :         if (copy_from_user(ar->data, buf, size))
     855           0 :                 return ERR_PTR(-EFAULT);
     856             : 
     857             :         return ar->data;
     858             : }
     859             : EXPORT_SYMBOL(simple_transaction_get);
     860             : 
     861           0 : ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
     862             : {
     863           0 :         struct simple_transaction_argresp *ar = file->private_data;
     864             : 
     865           0 :         if (!ar)
     866             :                 return 0;
     867           0 :         return simple_read_from_buffer(buf, size, pos, ar->data, ar->size);
     868             : }
     869             : EXPORT_SYMBOL(simple_transaction_read);
     870             : 
     871           0 : int simple_transaction_release(struct inode *inode, struct file *file)
     872             : {
     873           0 :         free_page((unsigned long)file->private_data);
     874           0 :         return 0;
     875             : }
     876             : EXPORT_SYMBOL(simple_transaction_release);
     877             : 
     878             : /* Simple attribute files */
     879             : 
     880             : struct simple_attr {
     881             :         int (*get)(void *, u64 *);
     882             :         int (*set)(void *, u64);
     883             :         char get_buf[24];       /* enough to store a u64 and "\n\0" */
     884             :         char set_buf[24];
     885             :         void *data;
     886             :         const char *fmt;        /* format for read operation */
     887             :         struct mutex mutex;     /* protects access to these buffers */
     888             : };
     889             : 
     890             : /* simple_attr_open is called by an actual attribute open file operation
     891             :  * to set the attribute specific access operations. */
     892           0 : int simple_attr_open(struct inode *inode, struct file *file,
     893             :                      int (*get)(void *, u64 *), int (*set)(void *, u64),
     894             :                      const char *fmt)
     895             : {
     896           0 :         struct simple_attr *attr;
     897             : 
     898           0 :         attr = kzalloc(sizeof(*attr), GFP_KERNEL);
     899           0 :         if (!attr)
     900             :                 return -ENOMEM;
     901             : 
     902           0 :         attr->get = get;
     903           0 :         attr->set = set;
     904           0 :         attr->data = inode->i_private;
     905           0 :         attr->fmt = fmt;
     906           0 :         mutex_init(&attr->mutex);
     907             : 
     908           0 :         file->private_data = attr;
     909             : 
     910           0 :         return nonseekable_open(inode, file);
     911             : }
     912             : EXPORT_SYMBOL_GPL(simple_attr_open);
     913             : 
     914           0 : int simple_attr_release(struct inode *inode, struct file *file)
     915             : {
     916           0 :         kfree(file->private_data);
     917           0 :         return 0;
     918             : }
     919             : EXPORT_SYMBOL_GPL(simple_attr_release); /* GPL-only?  This?  Really? */
     920             : 
     921             : /* read from the buffer that is filled with the get function */
     922           0 : ssize_t simple_attr_read(struct file *file, char __user *buf,
     923             :                          size_t len, loff_t *ppos)
     924             : {
     925           0 :         struct simple_attr *attr;
     926           0 :         size_t size;
     927           0 :         ssize_t ret;
     928             : 
     929           0 :         attr = file->private_data;
     930             : 
     931           0 :         if (!attr->get)
     932             :                 return -EACCES;
     933             : 
     934           0 :         ret = mutex_lock_interruptible(&attr->mutex);
     935           0 :         if (ret)
     936             :                 return ret;
     937             : 
     938           0 :         if (*ppos && attr->get_buf[0]) {
     939             :                 /* continued read */
     940           0 :                 size = strlen(attr->get_buf);
     941             :         } else {
     942             :                 /* first read */
     943           0 :                 u64 val;
     944           0 :                 ret = attr->get(attr->data, &val);
     945           0 :                 if (ret)
     946           0 :                         goto out;
     947             : 
     948           0 :                 size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
     949             :                                  attr->fmt, (unsigned long long)val);
     950             :         }
     951             : 
     952           0 :         ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
     953           0 : out:
     954           0 :         mutex_unlock(&attr->mutex);
     955           0 :         return ret;
     956             : }
     957             : EXPORT_SYMBOL_GPL(simple_attr_read);
     958             : 
     959             : /* interpret the buffer as a number to call the set function with */
     960           0 : ssize_t simple_attr_write(struct file *file, const char __user *buf,
     961             :                           size_t len, loff_t *ppos)
     962             : {
     963           0 :         struct simple_attr *attr;
     964           0 :         unsigned long long val;
     965           0 :         size_t size;
     966           0 :         ssize_t ret;
     967             : 
     968           0 :         attr = file->private_data;
     969           0 :         if (!attr->set)
     970             :                 return -EACCES;
     971             : 
     972           0 :         ret = mutex_lock_interruptible(&attr->mutex);
     973           0 :         if (ret)
     974             :                 return ret;
     975             : 
     976           0 :         ret = -EFAULT;
     977           0 :         size = min(sizeof(attr->set_buf) - 1, len);
     978           0 :         if (copy_from_user(attr->set_buf, buf, size))
     979           0 :                 goto out;
     980             : 
     981           0 :         attr->set_buf[size] = '\0';
     982           0 :         ret = kstrtoull(attr->set_buf, 0, &val);
     983           0 :         if (ret)
     984           0 :                 goto out;
     985           0 :         ret = attr->set(attr->data, val);
     986           0 :         if (ret == 0)
     987           0 :                 ret = len; /* on success, claim we got the whole input */
     988           0 : out:
     989           0 :         mutex_unlock(&attr->mutex);
     990           0 :         return ret;
     991             : }
     992             : EXPORT_SYMBOL_GPL(simple_attr_write);
     993             : 
     994             : /**
     995             :  * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation
     996             :  * @sb:         filesystem to do the file handle conversion on
     997             :  * @fid:        file handle to convert
     998             :  * @fh_len:     length of the file handle in bytes
     999             :  * @fh_type:    type of file handle
    1000             :  * @get_inode:  filesystem callback to retrieve inode
    1001             :  *
    1002             :  * This function decodes @fid as long as it has one of the well-known
    1003             :  * Linux filehandle types and calls @get_inode on it to retrieve the
    1004             :  * inode for the object specified in the file handle.
    1005             :  */
    1006           0 : struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid,
    1007             :                 int fh_len, int fh_type, struct inode *(*get_inode)
    1008             :                         (struct super_block *sb, u64 ino, u32 gen))
    1009             : {
    1010           0 :         struct inode *inode = NULL;
    1011             : 
    1012           0 :         if (fh_len < 2)
    1013             :                 return NULL;
    1014             : 
    1015           0 :         switch (fh_type) {
    1016           0 :         case FILEID_INO32_GEN:
    1017             :         case FILEID_INO32_GEN_PARENT:
    1018           0 :                 inode = get_inode(sb, fid->i32.ino, fid->i32.gen);
    1019           0 :                 break;
    1020             :         }
    1021             : 
    1022           0 :         return d_obtain_alias(inode);
    1023             : }
    1024             : EXPORT_SYMBOL_GPL(generic_fh_to_dentry);
    1025             : 
    1026             : /**
    1027             :  * generic_fh_to_parent - generic helper for the fh_to_parent export operation
    1028             :  * @sb:         filesystem to do the file handle conversion on
    1029             :  * @fid:        file handle to convert
    1030             :  * @fh_len:     length of the file handle in bytes
    1031             :  * @fh_type:    type of file handle
    1032             :  * @get_inode:  filesystem callback to retrieve inode
    1033             :  *
    1034             :  * This function decodes @fid as long as it has one of the well-known
    1035             :  * Linux filehandle types and calls @get_inode on it to retrieve the
    1036             :  * inode for the _parent_ object specified in the file handle if it
    1037             :  * is specified in the file handle, or NULL otherwise.
    1038             :  */
    1039           0 : struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid,
    1040             :                 int fh_len, int fh_type, struct inode *(*get_inode)
    1041             :                         (struct super_block *sb, u64 ino, u32 gen))
    1042             : {
    1043           0 :         struct inode *inode = NULL;
    1044             : 
    1045           0 :         if (fh_len <= 2)
    1046             :                 return NULL;
    1047             : 
    1048           0 :         switch (fh_type) {
    1049           0 :         case FILEID_INO32_GEN_PARENT:
    1050           0 :                 inode = get_inode(sb, fid->i32.parent_ino,
    1051             :                                   (fh_len > 3 ? fid->i32.parent_gen : 0));
    1052           0 :                 break;
    1053             :         }
    1054             : 
    1055           0 :         return d_obtain_alias(inode);
    1056             : }
    1057             : EXPORT_SYMBOL_GPL(generic_fh_to_parent);
    1058             : 
    1059             : /**
    1060             :  * __generic_file_fsync - generic fsync implementation for simple filesystems
    1061             :  *
    1062             :  * @file:       file to synchronize
    1063             :  * @start:      start offset in bytes
    1064             :  * @end:        end offset in bytes (inclusive)
    1065             :  * @datasync:   only synchronize essential metadata if true
    1066             :  *
    1067             :  * This is a generic implementation of the fsync method for simple
    1068             :  * filesystems which track all non-inode metadata in the buffers list
    1069             :  * hanging off the address_space structure.
    1070             :  */
    1071           0 : int __generic_file_fsync(struct file *file, loff_t start, loff_t end,
    1072             :                                  int datasync)
    1073             : {
    1074           0 :         struct inode *inode = file->f_mapping->host;
    1075           0 :         int err;
    1076           0 :         int ret;
    1077             : 
    1078           0 :         err = file_write_and_wait_range(file, start, end);
    1079           0 :         if (err)
    1080             :                 return err;
    1081             : 
    1082           0 :         inode_lock(inode);
    1083           0 :         ret = sync_mapping_buffers(inode->i_mapping);
    1084           0 :         if (!(inode->i_state & I_DIRTY_ALL))
    1085           0 :                 goto out;
    1086           0 :         if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
    1087           0 :                 goto out;
    1088             : 
    1089           0 :         err = sync_inode_metadata(inode, 1);
    1090           0 :         if (ret == 0)
    1091           0 :                 ret = err;
    1092             : 
    1093           0 : out:
    1094           0 :         inode_unlock(inode);
    1095             :         /* check and advance again to catch errors after syncing out buffers */
    1096           0 :         err = file_check_and_advance_wb_err(file);
    1097           0 :         if (ret == 0)
    1098           0 :                 ret = err;
    1099             :         return ret;
    1100             : }
    1101             : EXPORT_SYMBOL(__generic_file_fsync);
    1102             : 
    1103             : /**
    1104             :  * generic_file_fsync - generic fsync implementation for simple filesystems
    1105             :  *                      with flush
    1106             :  * @file:       file to synchronize
    1107             :  * @start:      start offset in bytes
    1108             :  * @end:        end offset in bytes (inclusive)
    1109             :  * @datasync:   only synchronize essential metadata if true
    1110             :  *
    1111             :  */
    1112             : 
    1113           0 : int generic_file_fsync(struct file *file, loff_t start, loff_t end,
    1114             :                        int datasync)
    1115             : {
    1116           0 :         struct inode *inode = file->f_mapping->host;
    1117           0 :         int err;
    1118             : 
    1119           0 :         err = __generic_file_fsync(file, start, end, datasync);
    1120           0 :         if (err)
    1121             :                 return err;
    1122           0 :         return blkdev_issue_flush(inode->i_sb->s_bdev);
    1123             : }
    1124             : EXPORT_SYMBOL(generic_file_fsync);
    1125             : 
    1126             : /**
    1127             :  * generic_check_addressable - Check addressability of file system
    1128             :  * @blocksize_bits:     log of file system block size
    1129             :  * @num_blocks:         number of blocks in file system
    1130             :  *
    1131             :  * Determine whether a file system with @num_blocks blocks (and a
    1132             :  * block size of 2**@blocksize_bits) is addressable by the sector_t
    1133             :  * and page cache of the system.  Return 0 if so and -EFBIG otherwise.
    1134             :  */
    1135           1 : int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks)
    1136             : {
    1137           1 :         u64 last_fs_block = num_blocks - 1;
    1138           1 :         u64 last_fs_page =
    1139           1 :                 last_fs_block >> (PAGE_SHIFT - blocksize_bits);
    1140             : 
    1141           1 :         if (unlikely(num_blocks == 0))
    1142             :                 return 0;
    1143             : 
    1144           1 :         if ((blocksize_bits < 9) || (blocksize_bits > PAGE_SHIFT))
    1145             :                 return -EINVAL;
    1146             : 
    1147           1 :         if ((last_fs_block > (sector_t)(~0ULL) >> (blocksize_bits - 9)) ||
    1148             :             (last_fs_page > (pgoff_t)(~0ULL))) {
    1149           0 :                 return -EFBIG;
    1150             :         }
    1151             :         return 0;
    1152             : }
    1153             : EXPORT_SYMBOL(generic_check_addressable);
    1154             : 
    1155             : /*
    1156             :  * No-op implementation of ->fsync for in-memory filesystems.
    1157             :  */
    1158           3 : int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync)
    1159             : {
    1160           3 :         return 0;
    1161             : }
    1162             : EXPORT_SYMBOL(noop_fsync);
    1163             : 
    1164           0 : int noop_set_page_dirty(struct page *page)
    1165             : {
    1166             :         /*
    1167             :          * Unlike __set_page_dirty_no_writeback that handles dirty page
    1168             :          * tracking in the page object, dax does all dirty tracking in
    1169             :          * the inode address_space in response to mkwrite faults. In the
    1170             :          * dax case we only need to worry about potentially dirty CPU
    1171             :          * caches, not dirty page cache pages to write back.
    1172             :          *
    1173             :          * This callback is defined to prevent fallback to
    1174             :          * __set_page_dirty_buffers() in set_page_dirty().
    1175             :          */
    1176           0 :         return 0;
    1177             : }
    1178             : EXPORT_SYMBOL_GPL(noop_set_page_dirty);
    1179             : 
    1180           0 : void noop_invalidatepage(struct page *page, unsigned int offset,
    1181             :                 unsigned int length)
    1182             : {
    1183             :         /*
    1184             :          * There is no page cache to invalidate in the dax case, however
    1185             :          * we need this callback defined to prevent falling back to
    1186             :          * block_invalidatepage() in do_invalidatepage().
    1187             :          */
    1188           0 : }
    1189             : EXPORT_SYMBOL_GPL(noop_invalidatepage);
    1190             : 
    1191           0 : ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
    1192             : {
    1193             :         /*
    1194             :          * iomap based filesystems support direct I/O without need for
    1195             :          * this callback. However, it still needs to be set in
    1196             :          * inode->a_ops so that open/fcntl know that direct I/O is
    1197             :          * generally supported.
    1198             :          */
    1199           0 :         return -EINVAL;
    1200             : }
    1201             : EXPORT_SYMBOL_GPL(noop_direct_IO);
    1202             : 
    1203             : /* Because kfree isn't assignment-compatible with void(void*) ;-/ */
    1204        1729 : void kfree_link(void *p)
    1205             : {
    1206        1729 :         kfree(p);
    1207        1729 : }
    1208             : EXPORT_SYMBOL(kfree_link);
    1209             : 
    1210             : /*
    1211             :  * nop .set_page_dirty method so that people can use .page_mkwrite on
    1212             :  * anon inodes.
    1213             :  */
    1214           0 : static int anon_set_page_dirty(struct page *page)
    1215             : {
    1216           0 :         return 0;
    1217             : };
    1218             : 
    1219           2 : struct inode *alloc_anon_inode(struct super_block *s)
    1220             : {
    1221           2 :         static const struct address_space_operations anon_aops = {
    1222             :                 .set_page_dirty = anon_set_page_dirty,
    1223             :         };
    1224           2 :         struct inode *inode = new_inode_pseudo(s);
    1225             : 
    1226           2 :         if (!inode)
    1227           2 :                 return ERR_PTR(-ENOMEM);
    1228             : 
    1229           2 :         inode->i_ino = get_next_ino();
    1230           2 :         inode->i_mapping->a_ops = &anon_aops;
    1231             : 
    1232             :         /*
    1233             :          * Mark the inode dirty from the very beginning,
    1234             :          * that way it will never be moved to the dirty
    1235             :          * list because mark_inode_dirty() will think
    1236             :          * that it already _is_ on the dirty list.
    1237             :          */
    1238           2 :         inode->i_state = I_DIRTY;
    1239           2 :         inode->i_mode = S_IRUSR | S_IWUSR;
    1240           2 :         inode->i_uid = current_fsuid();
    1241           2 :         inode->i_gid = current_fsgid();
    1242           2 :         inode->i_flags |= S_PRIVATE;
    1243           2 :         inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
    1244           2 :         return inode;
    1245             : }
    1246             : EXPORT_SYMBOL(alloc_anon_inode);
    1247             : 
    1248             : /**
    1249             :  * simple_nosetlease - generic helper for prohibiting leases
    1250             :  * @filp: file pointer
    1251             :  * @arg: type of lease to obtain
    1252             :  * @flp: new lease supplied for insertion
    1253             :  * @priv: private data for lm_setup operation
    1254             :  *
    1255             :  * Generic helper for filesystems that do not wish to allow leases to be set.
    1256             :  * All arguments are ignored and it just returns -EINVAL.
    1257             :  */
    1258             : int
    1259           0 : simple_nosetlease(struct file *filp, long arg, struct file_lock **flp,
    1260             :                   void **priv)
    1261             : {
    1262           0 :         return -EINVAL;
    1263             : }
    1264             : EXPORT_SYMBOL(simple_nosetlease);
    1265             : 
    1266             : /**
    1267             :  * simple_get_link - generic helper to get the target of "fast" symlinks
    1268             :  * @dentry: not used here
    1269             :  * @inode: the symlink inode
    1270             :  * @done: not used here
    1271             :  *
    1272             :  * Generic helper for filesystems to use for symlink inodes where a pointer to
    1273             :  * the symlink target is stored in ->i_link.  NOTE: this isn't normally called,
    1274             :  * since as an optimization the path lookup code uses any non-NULL ->i_link
    1275             :  * directly, without calling ->get_link().  But ->get_link() still must be set,
    1276             :  * to mark the inode_operations as being for a symlink.
    1277             :  *
    1278             :  * Return: the symlink target
    1279             :  */
    1280           0 : const char *simple_get_link(struct dentry *dentry, struct inode *inode,
    1281             :                             struct delayed_call *done)
    1282             : {
    1283           0 :         return inode->i_link;
    1284             : }
    1285             : EXPORT_SYMBOL(simple_get_link);
    1286             : 
    1287             : const struct inode_operations simple_symlink_inode_operations = {
    1288             :         .get_link = simple_get_link,
    1289             : };
    1290             : EXPORT_SYMBOL(simple_symlink_inode_operations);
    1291             : 
    1292             : /*
    1293             :  * Operations for a permanently empty directory.
    1294             :  */
    1295           0 : static struct dentry *empty_dir_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
    1296             : {
    1297           0 :         return ERR_PTR(-ENOENT);
    1298             : }
    1299             : 
    1300           9 : static int empty_dir_getattr(struct user_namespace *mnt_userns,
    1301             :                              const struct path *path, struct kstat *stat,
    1302             :                              u32 request_mask, unsigned int query_flags)
    1303             : {
    1304           9 :         struct inode *inode = d_inode(path->dentry);
    1305           9 :         generic_fillattr(&init_user_ns, inode, stat);
    1306           9 :         return 0;
    1307             : }
    1308             : 
    1309           0 : static int empty_dir_setattr(struct user_namespace *mnt_userns,
    1310             :                              struct dentry *dentry, struct iattr *attr)
    1311             : {
    1312           0 :         return -EPERM;
    1313             : }
    1314             : 
    1315           0 : static ssize_t empty_dir_listxattr(struct dentry *dentry, char *list, size_t size)
    1316             : {
    1317           0 :         return -EOPNOTSUPP;
    1318             : }
    1319             : 
    1320             : static const struct inode_operations empty_dir_inode_operations = {
    1321             :         .lookup         = empty_dir_lookup,
    1322             :         .permission     = generic_permission,
    1323             :         .setattr        = empty_dir_setattr,
    1324             :         .getattr        = empty_dir_getattr,
    1325             :         .listxattr      = empty_dir_listxattr,
    1326             : };
    1327             : 
    1328           0 : static loff_t empty_dir_llseek(struct file *file, loff_t offset, int whence)
    1329             : {
    1330             :         /* An empty directory has two entries . and .. at offsets 0 and 1 */
    1331           0 :         return generic_file_llseek_size(file, offset, whence, 2, 2);
    1332             : }
    1333             : 
    1334           2 : static int empty_dir_readdir(struct file *file, struct dir_context *ctx)
    1335             : {
    1336           2 :         dir_emit_dots(file, ctx);
    1337           2 :         return 0;
    1338             : }
    1339             : 
    1340             : static const struct file_operations empty_dir_operations = {
    1341             :         .llseek         = empty_dir_llseek,
    1342             :         .read           = generic_read_dir,
    1343             :         .iterate_shared = empty_dir_readdir,
    1344             :         .fsync          = noop_fsync,
    1345             : };
    1346             : 
    1347             : 
    1348           4 : void make_empty_dir_inode(struct inode *inode)
    1349             : {
    1350           4 :         set_nlink(inode, 2);
    1351           4 :         inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
    1352           4 :         inode->i_uid = GLOBAL_ROOT_UID;
    1353           4 :         inode->i_gid = GLOBAL_ROOT_GID;
    1354           4 :         inode->i_rdev = 0;
    1355           4 :         inode->i_size = 0;
    1356           4 :         inode->i_blkbits = PAGE_SHIFT;
    1357           4 :         inode->i_blocks = 0;
    1358             : 
    1359           4 :         inode->i_op = &empty_dir_inode_operations;
    1360           4 :         inode->i_opflags &= ~IOP_XATTR;
    1361           4 :         inode->i_fop = &empty_dir_operations;
    1362           4 : }
    1363             : 
    1364           0 : bool is_empty_dir_inode(struct inode *inode)
    1365             : {
    1366           0 :         return (inode->i_fop == &empty_dir_operations) &&
    1367           0 :                 (inode->i_op == &empty_dir_inode_operations);
    1368             : }
    1369             : 
    1370             : #ifdef CONFIG_UNICODE
    1371             : /*
    1372             :  * Determine if the name of a dentry should be casefolded.
    1373             :  *
    1374             :  * Return: if names will need casefolding
    1375             :  */
    1376             : static bool needs_casefold(const struct inode *dir)
    1377             : {
    1378             :         return IS_CASEFOLDED(dir) && dir->i_sb->s_encoding;
    1379             : }
    1380             : 
    1381             : /**
    1382             :  * generic_ci_d_compare - generic d_compare implementation for casefolding filesystems
    1383             :  * @dentry:     dentry whose name we are checking against
    1384             :  * @len:        len of name of dentry
    1385             :  * @str:        str pointer to name of dentry
    1386             :  * @name:       Name to compare against
    1387             :  *
    1388             :  * Return: 0 if names match, 1 if mismatch, or -ERRNO
    1389             :  */
    1390             : static int generic_ci_d_compare(const struct dentry *dentry, unsigned int len,
    1391             :                                 const char *str, const struct qstr *name)
    1392             : {
    1393             :         const struct dentry *parent = READ_ONCE(dentry->d_parent);
    1394             :         const struct inode *dir = READ_ONCE(parent->d_inode);
    1395             :         const struct super_block *sb = dentry->d_sb;
    1396             :         const struct unicode_map *um = sb->s_encoding;
    1397             :         struct qstr qstr = QSTR_INIT(str, len);
    1398             :         char strbuf[DNAME_INLINE_LEN];
    1399             :         int ret;
    1400             : 
    1401             :         if (!dir || !needs_casefold(dir))
    1402             :                 goto fallback;
    1403             :         /*
    1404             :          * If the dentry name is stored in-line, then it may be concurrently
    1405             :          * modified by a rename.  If this happens, the VFS will eventually retry
    1406             :          * the lookup, so it doesn't matter what ->d_compare() returns.
    1407             :          * However, it's unsafe to call utf8_strncasecmp() with an unstable
    1408             :          * string.  Therefore, we have to copy the name into a temporary buffer.
    1409             :          */
    1410             :         if (len <= DNAME_INLINE_LEN - 1) {
    1411             :                 memcpy(strbuf, str, len);
    1412             :                 strbuf[len] = 0;
    1413             :                 qstr.name = strbuf;
    1414             :                 /* prevent compiler from optimizing out the temporary buffer */
    1415             :                 barrier();
    1416             :         }
    1417             :         ret = utf8_strncasecmp(um, name, &qstr);
    1418             :         if (ret >= 0)
    1419             :                 return ret;
    1420             : 
    1421             :         if (sb_has_strict_encoding(sb))
    1422             :                 return -EINVAL;
    1423             : fallback:
    1424             :         if (len != name->len)
    1425             :                 return 1;
    1426             :         return !!memcmp(str, name->name, len);
    1427             : }
    1428             : 
    1429             : /**
    1430             :  * generic_ci_d_hash - generic d_hash implementation for casefolding filesystems
    1431             :  * @dentry:     dentry of the parent directory
    1432             :  * @str:        qstr of name whose hash we should fill in
    1433             :  *
    1434             :  * Return: 0 if hash was successful or unchanged, and -EINVAL on error
    1435             :  */
    1436             : static int generic_ci_d_hash(const struct dentry *dentry, struct qstr *str)
    1437             : {
    1438             :         const struct inode *dir = READ_ONCE(dentry->d_inode);
    1439             :         struct super_block *sb = dentry->d_sb;
    1440             :         const struct unicode_map *um = sb->s_encoding;
    1441             :         int ret = 0;
    1442             : 
    1443             :         if (!dir || !needs_casefold(dir))
    1444             :                 return 0;
    1445             : 
    1446             :         ret = utf8_casefold_hash(um, dentry, str);
    1447             :         if (ret < 0 && sb_has_strict_encoding(sb))
    1448             :                 return -EINVAL;
    1449             :         return 0;
    1450             : }
    1451             : 
    1452             : static const struct dentry_operations generic_ci_dentry_ops = {
    1453             :         .d_hash = generic_ci_d_hash,
    1454             :         .d_compare = generic_ci_d_compare,
    1455             : };
    1456             : #endif
    1457             : 
    1458             : #ifdef CONFIG_FS_ENCRYPTION
    1459             : static const struct dentry_operations generic_encrypted_dentry_ops = {
    1460             :         .d_revalidate = fscrypt_d_revalidate,
    1461             : };
    1462             : #endif
    1463             : 
    1464             : #if defined(CONFIG_FS_ENCRYPTION) && defined(CONFIG_UNICODE)
    1465             : static const struct dentry_operations generic_encrypted_ci_dentry_ops = {
    1466             :         .d_hash = generic_ci_d_hash,
    1467             :         .d_compare = generic_ci_d_compare,
    1468             :         .d_revalidate = fscrypt_d_revalidate,
    1469             : };
    1470             : #endif
    1471             : 
    1472             : /**
    1473             :  * generic_set_encrypted_ci_d_ops - helper for setting d_ops for given dentry
    1474             :  * @dentry:     dentry to set ops on
    1475             :  *
    1476             :  * Casefolded directories need d_hash and d_compare set, so that the dentries
    1477             :  * contained in them are handled case-insensitively.  Note that these operations
    1478             :  * are needed on the parent directory rather than on the dentries in it, and
    1479             :  * while the casefolding flag can be toggled on and off on an empty directory,
    1480             :  * dentry_operations can't be changed later.  As a result, if the filesystem has
    1481             :  * casefolding support enabled at all, we have to give all dentries the
    1482             :  * casefolding operations even if their inode doesn't have the casefolding flag
    1483             :  * currently (and thus the casefolding ops would be no-ops for now).
    1484             :  *
    1485             :  * Encryption works differently in that the only dentry operation it needs is
    1486             :  * d_revalidate, which it only needs on dentries that have the no-key name flag.
    1487             :  * The no-key flag can't be set "later", so we don't have to worry about that.
    1488             :  *
    1489             :  * Finally, to maximize compatibility with overlayfs (which isn't compatible
    1490             :  * with certain dentry operations) and to avoid taking an unnecessary
    1491             :  * performance hit, we use custom dentry_operations for each possible
    1492             :  * combination rather than always installing all operations.
    1493             :  */
    1494        6930 : void generic_set_encrypted_ci_d_ops(struct dentry *dentry)
    1495             : {
    1496             : #ifdef CONFIG_FS_ENCRYPTION
    1497             :         bool needs_encrypt_ops = dentry->d_flags & DCACHE_NOKEY_NAME;
    1498             : #endif
    1499             : #ifdef CONFIG_UNICODE
    1500             :         bool needs_ci_ops = dentry->d_sb->s_encoding;
    1501             : #endif
    1502             : #if defined(CONFIG_FS_ENCRYPTION) && defined(CONFIG_UNICODE)
    1503             :         if (needs_encrypt_ops && needs_ci_ops) {
    1504             :                 d_set_d_op(dentry, &generic_encrypted_ci_dentry_ops);
    1505             :                 return;
    1506             :         }
    1507             : #endif
    1508             : #ifdef CONFIG_FS_ENCRYPTION
    1509             :         if (needs_encrypt_ops) {
    1510             :                 d_set_d_op(dentry, &generic_encrypted_dentry_ops);
    1511             :                 return;
    1512             :         }
    1513             : #endif
    1514             : #ifdef CONFIG_UNICODE
    1515             :         if (needs_ci_ops) {
    1516             :                 d_set_d_op(dentry, &generic_ci_dentry_ops);
    1517             :                 return;
    1518             :         }
    1519             : #endif
    1520        6930 : }
    1521             : EXPORT_SYMBOL(generic_set_encrypted_ci_d_ops);

Generated by: LCOV version 1.14