drm/i915: Fix ADL+ tiled plane stride when the POT stride is smaller than the original
[platform/kernel/linux-starfive.git] / fs / libfs.c
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/iversion.h>
19 #include <linux/writeback.h>
20 #include <linux/buffer_head.h> /* sync_mapping_buffers */
21 #include <linux/fs_context.h>
22 #include <linux/pseudo_fs.h>
23 #include <linux/fsnotify.h>
24 #include <linux/unicode.h>
25 #include <linux/fscrypt.h>
26
27 #include <linux/uaccess.h>
28
29 #include "internal.h"
30
31 int simple_getattr(struct mnt_idmap *idmap, const struct path *path,
32                    struct kstat *stat, u32 request_mask,
33                    unsigned int query_flags)
34 {
35         struct inode *inode = d_inode(path->dentry);
36         generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
37         stat->blocks = inode->i_mapping->nrpages << (PAGE_SHIFT - 9);
38         return 0;
39 }
40 EXPORT_SYMBOL(simple_getattr);
41
42 int simple_statfs(struct dentry *dentry, struct kstatfs *buf)
43 {
44         buf->f_type = dentry->d_sb->s_magic;
45         buf->f_bsize = PAGE_SIZE;
46         buf->f_namelen = NAME_MAX;
47         return 0;
48 }
49 EXPORT_SYMBOL(simple_statfs);
50
51 /*
52  * Retaining negative dentries for an in-memory filesystem just wastes
53  * memory and lookup time: arrange for them to be deleted immediately.
54  */
55 int always_delete_dentry(const struct dentry *dentry)
56 {
57         return 1;
58 }
59 EXPORT_SYMBOL(always_delete_dentry);
60
61 const struct dentry_operations simple_dentry_operations = {
62         .d_delete = always_delete_dentry,
63 };
64 EXPORT_SYMBOL(simple_dentry_operations);
65
66 /*
67  * Lookup the data. This is trivial - if the dentry didn't already
68  * exist, we know it is negative.  Set d_op to delete negative dentries.
69  */
70 struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
71 {
72         if (dentry->d_name.len > NAME_MAX)
73                 return ERR_PTR(-ENAMETOOLONG);
74         if (!dentry->d_sb->s_d_op)
75                 d_set_d_op(dentry, &simple_dentry_operations);
76         d_add(dentry, NULL);
77         return NULL;
78 }
79 EXPORT_SYMBOL(simple_lookup);
80
81 int dcache_dir_open(struct inode *inode, struct file *file)
82 {
83         file->private_data = d_alloc_cursor(file->f_path.dentry);
84
85         return file->private_data ? 0 : -ENOMEM;
86 }
87 EXPORT_SYMBOL(dcache_dir_open);
88
89 int dcache_dir_close(struct inode *inode, struct file *file)
90 {
91         dput(file->private_data);
92         return 0;
93 }
94 EXPORT_SYMBOL(dcache_dir_close);
95
96 /* parent is locked at least shared */
97 /*
98  * Returns an element of siblings' list.
99  * We are looking for <count>th positive after <p>; if
100  * found, dentry is grabbed and returned to caller.
101  * If no such element exists, NULL is returned.
102  */
103 static struct dentry *scan_positives(struct dentry *cursor,
104                                         struct list_head *p,
105                                         loff_t count,
106                                         struct dentry *last)
107 {
108         struct dentry *dentry = cursor->d_parent, *found = NULL;
109
110         spin_lock(&dentry->d_lock);
111         while ((p = p->next) != &dentry->d_subdirs) {
112                 struct dentry *d = list_entry(p, struct dentry, d_child);
113                 // we must at least skip cursors, to avoid livelocks
114                 if (d->d_flags & DCACHE_DENTRY_CURSOR)
115                         continue;
116                 if (simple_positive(d) && !--count) {
117                         spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
118                         if (simple_positive(d))
119                                 found = dget_dlock(d);
120                         spin_unlock(&d->d_lock);
121                         if (likely(found))
122                                 break;
123                         count = 1;
124                 }
125                 if (need_resched()) {
126                         list_move(&cursor->d_child, p);
127                         p = &cursor->d_child;
128                         spin_unlock(&dentry->d_lock);
129                         cond_resched();
130                         spin_lock(&dentry->d_lock);
131                 }
132         }
133         spin_unlock(&dentry->d_lock);
134         dput(last);
135         return found;
136 }
137
138 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence)
139 {
140         struct dentry *dentry = file->f_path.dentry;
141         switch (whence) {
142                 case 1:
143                         offset += file->f_pos;
144                         fallthrough;
145                 case 0:
146                         if (offset >= 0)
147                                 break;
148                         fallthrough;
149                 default:
150                         return -EINVAL;
151         }
152         if (offset != file->f_pos) {
153                 struct dentry *cursor = file->private_data;
154                 struct dentry *to = NULL;
155
156                 inode_lock_shared(dentry->d_inode);
157
158                 if (offset > 2)
159                         to = scan_positives(cursor, &dentry->d_subdirs,
160                                             offset - 2, NULL);
161                 spin_lock(&dentry->d_lock);
162                 if (to)
163                         list_move(&cursor->d_child, &to->d_child);
164                 else
165                         list_del_init(&cursor->d_child);
166                 spin_unlock(&dentry->d_lock);
167                 dput(to);
168
169                 file->f_pos = offset;
170
171                 inode_unlock_shared(dentry->d_inode);
172         }
173         return offset;
174 }
175 EXPORT_SYMBOL(dcache_dir_lseek);
176
177 /*
178  * Directory is locked and all positive dentries in it are safe, since
179  * for ramfs-type trees they can't go away without unlink() or rmdir(),
180  * both impossible due to the lock on directory.
181  */
182
183 int dcache_readdir(struct file *file, struct dir_context *ctx)
184 {
185         struct dentry *dentry = file->f_path.dentry;
186         struct dentry *cursor = file->private_data;
187         struct list_head *anchor = &dentry->d_subdirs;
188         struct dentry *next = NULL;
189         struct list_head *p;
190
191         if (!dir_emit_dots(file, ctx))
192                 return 0;
193
194         if (ctx->pos == 2)
195                 p = anchor;
196         else if (!list_empty(&cursor->d_child))
197                 p = &cursor->d_child;
198         else
199                 return 0;
200
201         while ((next = scan_positives(cursor, p, 1, next)) != NULL) {
202                 if (!dir_emit(ctx, next->d_name.name, next->d_name.len,
203                               d_inode(next)->i_ino,
204                               fs_umode_to_dtype(d_inode(next)->i_mode)))
205                         break;
206                 ctx->pos++;
207                 p = &next->d_child;
208         }
209         spin_lock(&dentry->d_lock);
210         if (next)
211                 list_move_tail(&cursor->d_child, &next->d_child);
212         else
213                 list_del_init(&cursor->d_child);
214         spin_unlock(&dentry->d_lock);
215         dput(next);
216
217         return 0;
218 }
219 EXPORT_SYMBOL(dcache_readdir);
220
221 ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos)
222 {
223         return -EISDIR;
224 }
225 EXPORT_SYMBOL(generic_read_dir);
226
227 const struct file_operations simple_dir_operations = {
228         .open           = dcache_dir_open,
229         .release        = dcache_dir_close,
230         .llseek         = dcache_dir_lseek,
231         .read           = generic_read_dir,
232         .iterate_shared = dcache_readdir,
233         .fsync          = noop_fsync,
234 };
235 EXPORT_SYMBOL(simple_dir_operations);
236
237 const struct inode_operations simple_dir_inode_operations = {
238         .lookup         = simple_lookup,
239 };
240 EXPORT_SYMBOL(simple_dir_inode_operations);
241
242 static void offset_set(struct dentry *dentry, u32 offset)
243 {
244         dentry->d_fsdata = (void *)((uintptr_t)(offset));
245 }
246
247 static u32 dentry2offset(struct dentry *dentry)
248 {
249         return (u32)((uintptr_t)(dentry->d_fsdata));
250 }
251
252 static struct lock_class_key simple_offset_xa_lock;
253
254 /**
255  * simple_offset_init - initialize an offset_ctx
256  * @octx: directory offset map to be initialized
257  *
258  */
259 void simple_offset_init(struct offset_ctx *octx)
260 {
261         xa_init_flags(&octx->xa, XA_FLAGS_ALLOC1);
262         lockdep_set_class(&octx->xa.xa_lock, &simple_offset_xa_lock);
263
264         /* 0 is '.', 1 is '..', so always start with offset 2 */
265         octx->next_offset = 2;
266 }
267
268 /**
269  * simple_offset_add - Add an entry to a directory's offset map
270  * @octx: directory offset ctx to be updated
271  * @dentry: new dentry being added
272  *
273  * Returns zero on success. @so_ctx and the dentry offset are updated.
274  * Otherwise, a negative errno value is returned.
275  */
276 int simple_offset_add(struct offset_ctx *octx, struct dentry *dentry)
277 {
278         static const struct xa_limit limit = XA_LIMIT(2, U32_MAX);
279         u32 offset;
280         int ret;
281
282         if (dentry2offset(dentry) != 0)
283                 return -EBUSY;
284
285         ret = xa_alloc_cyclic(&octx->xa, &offset, dentry, limit,
286                               &octx->next_offset, GFP_KERNEL);
287         if (ret < 0)
288                 return ret;
289
290         offset_set(dentry, offset);
291         return 0;
292 }
293
294 /**
295  * simple_offset_remove - Remove an entry to a directory's offset map
296  * @octx: directory offset ctx to be updated
297  * @dentry: dentry being removed
298  *
299  */
300 void simple_offset_remove(struct offset_ctx *octx, struct dentry *dentry)
301 {
302         u32 offset;
303
304         offset = dentry2offset(dentry);
305         if (offset == 0)
306                 return;
307
308         xa_erase(&octx->xa, offset);
309         offset_set(dentry, 0);
310 }
311
312 /**
313  * simple_offset_rename_exchange - exchange rename with directory offsets
314  * @old_dir: parent of dentry being moved
315  * @old_dentry: dentry being moved
316  * @new_dir: destination parent
317  * @new_dentry: destination dentry
318  *
319  * Returns zero on success. Otherwise a negative errno is returned and the
320  * rename is rolled back.
321  */
322 int simple_offset_rename_exchange(struct inode *old_dir,
323                                   struct dentry *old_dentry,
324                                   struct inode *new_dir,
325                                   struct dentry *new_dentry)
326 {
327         struct offset_ctx *old_ctx = old_dir->i_op->get_offset_ctx(old_dir);
328         struct offset_ctx *new_ctx = new_dir->i_op->get_offset_ctx(new_dir);
329         u32 old_index = dentry2offset(old_dentry);
330         u32 new_index = dentry2offset(new_dentry);
331         int ret;
332
333         simple_offset_remove(old_ctx, old_dentry);
334         simple_offset_remove(new_ctx, new_dentry);
335
336         ret = simple_offset_add(new_ctx, old_dentry);
337         if (ret)
338                 goto out_restore;
339
340         ret = simple_offset_add(old_ctx, new_dentry);
341         if (ret) {
342                 simple_offset_remove(new_ctx, old_dentry);
343                 goto out_restore;
344         }
345
346         ret = simple_rename_exchange(old_dir, old_dentry, new_dir, new_dentry);
347         if (ret) {
348                 simple_offset_remove(new_ctx, old_dentry);
349                 simple_offset_remove(old_ctx, new_dentry);
350                 goto out_restore;
351         }
352         return 0;
353
354 out_restore:
355         offset_set(old_dentry, old_index);
356         xa_store(&old_ctx->xa, old_index, old_dentry, GFP_KERNEL);
357         offset_set(new_dentry, new_index);
358         xa_store(&new_ctx->xa, new_index, new_dentry, GFP_KERNEL);
359         return ret;
360 }
361
362 /**
363  * simple_offset_destroy - Release offset map
364  * @octx: directory offset ctx that is about to be destroyed
365  *
366  * During fs teardown (eg. umount), a directory's offset map might still
367  * contain entries. xa_destroy() cleans out anything that remains.
368  */
369 void simple_offset_destroy(struct offset_ctx *octx)
370 {
371         xa_destroy(&octx->xa);
372 }
373
374 /**
375  * offset_dir_llseek - Advance the read position of a directory descriptor
376  * @file: an open directory whose position is to be updated
377  * @offset: a byte offset
378  * @whence: enumerator describing the starting position for this update
379  *
380  * SEEK_END, SEEK_DATA, and SEEK_HOLE are not supported for directories.
381  *
382  * Returns the updated read position if successful; otherwise a
383  * negative errno is returned and the read position remains unchanged.
384  */
385 static loff_t offset_dir_llseek(struct file *file, loff_t offset, int whence)
386 {
387         switch (whence) {
388         case SEEK_CUR:
389                 offset += file->f_pos;
390                 fallthrough;
391         case SEEK_SET:
392                 if (offset >= 0)
393                         break;
394                 fallthrough;
395         default:
396                 return -EINVAL;
397         }
398
399         /* In this case, ->private_data is protected by f_pos_lock */
400         file->private_data = NULL;
401         return vfs_setpos(file, offset, U32_MAX);
402 }
403
404 static struct dentry *offset_find_next(struct xa_state *xas)
405 {
406         struct dentry *child, *found = NULL;
407
408         rcu_read_lock();
409         child = xas_next_entry(xas, U32_MAX);
410         if (!child)
411                 goto out;
412         spin_lock(&child->d_lock);
413         if (simple_positive(child))
414                 found = dget_dlock(child);
415         spin_unlock(&child->d_lock);
416 out:
417         rcu_read_unlock();
418         return found;
419 }
420
421 static bool offset_dir_emit(struct dir_context *ctx, struct dentry *dentry)
422 {
423         u32 offset = dentry2offset(dentry);
424         struct inode *inode = d_inode(dentry);
425
426         return ctx->actor(ctx, dentry->d_name.name, dentry->d_name.len, offset,
427                           inode->i_ino, fs_umode_to_dtype(inode->i_mode));
428 }
429
430 static void *offset_iterate_dir(struct inode *inode, struct dir_context *ctx)
431 {
432         struct offset_ctx *so_ctx = inode->i_op->get_offset_ctx(inode);
433         XA_STATE(xas, &so_ctx->xa, ctx->pos);
434         struct dentry *dentry;
435
436         while (true) {
437                 dentry = offset_find_next(&xas);
438                 if (!dentry)
439                         return ERR_PTR(-ENOENT);
440
441                 if (!offset_dir_emit(ctx, dentry)) {
442                         dput(dentry);
443                         break;
444                 }
445
446                 dput(dentry);
447                 ctx->pos = xas.xa_index + 1;
448         }
449         return NULL;
450 }
451
452 /**
453  * offset_readdir - Emit entries starting at offset @ctx->pos
454  * @file: an open directory to iterate over
455  * @ctx: directory iteration context
456  *
457  * Caller must hold @file's i_rwsem to prevent insertion or removal of
458  * entries during this call.
459  *
460  * On entry, @ctx->pos contains an offset that represents the first entry
461  * to be read from the directory.
462  *
463  * The operation continues until there are no more entries to read, or
464  * until the ctx->actor indicates there is no more space in the caller's
465  * output buffer.
466  *
467  * On return, @ctx->pos contains an offset that will read the next entry
468  * in this directory when offset_readdir() is called again with @ctx.
469  *
470  * Return values:
471  *   %0 - Complete
472  */
473 static int offset_readdir(struct file *file, struct dir_context *ctx)
474 {
475         struct dentry *dir = file->f_path.dentry;
476
477         lockdep_assert_held(&d_inode(dir)->i_rwsem);
478
479         if (!dir_emit_dots(file, ctx))
480                 return 0;
481
482         /* In this case, ->private_data is protected by f_pos_lock */
483         if (ctx->pos == 2)
484                 file->private_data = NULL;
485         else if (file->private_data == ERR_PTR(-ENOENT))
486                 return 0;
487         file->private_data = offset_iterate_dir(d_inode(dir), ctx);
488         return 0;
489 }
490
491 const struct file_operations simple_offset_dir_operations = {
492         .llseek         = offset_dir_llseek,
493         .iterate_shared = offset_readdir,
494         .read           = generic_read_dir,
495         .fsync          = noop_fsync,
496 };
497
498 static struct dentry *find_next_child(struct dentry *parent, struct dentry *prev)
499 {
500         struct dentry *child = NULL;
501         struct list_head *p = prev ? &prev->d_child : &parent->d_subdirs;
502
503         spin_lock(&parent->d_lock);
504         while ((p = p->next) != &parent->d_subdirs) {
505                 struct dentry *d = container_of(p, struct dentry, d_child);
506                 if (simple_positive(d)) {
507                         spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
508                         if (simple_positive(d))
509                                 child = dget_dlock(d);
510                         spin_unlock(&d->d_lock);
511                         if (likely(child))
512                                 break;
513                 }
514         }
515         spin_unlock(&parent->d_lock);
516         dput(prev);
517         return child;
518 }
519
520 void simple_recursive_removal(struct dentry *dentry,
521                               void (*callback)(struct dentry *))
522 {
523         struct dentry *this = dget(dentry);
524         while (true) {
525                 struct dentry *victim = NULL, *child;
526                 struct inode *inode = this->d_inode;
527
528                 inode_lock(inode);
529                 if (d_is_dir(this))
530                         inode->i_flags |= S_DEAD;
531                 while ((child = find_next_child(this, victim)) == NULL) {
532                         // kill and ascend
533                         // update metadata while it's still locked
534                         inode_set_ctime_current(inode);
535                         clear_nlink(inode);
536                         inode_unlock(inode);
537                         victim = this;
538                         this = this->d_parent;
539                         inode = this->d_inode;
540                         inode_lock(inode);
541                         if (simple_positive(victim)) {
542                                 d_invalidate(victim);   // avoid lost mounts
543                                 if (d_is_dir(victim))
544                                         fsnotify_rmdir(inode, victim);
545                                 else
546                                         fsnotify_unlink(inode, victim);
547                                 if (callback)
548                                         callback(victim);
549                                 dput(victim);           // unpin it
550                         }
551                         if (victim == dentry) {
552                                 inode->i_mtime = inode_set_ctime_current(inode);
553                                 if (d_is_dir(dentry))
554                                         drop_nlink(inode);
555                                 inode_unlock(inode);
556                                 dput(dentry);
557                                 return;
558                         }
559                 }
560                 inode_unlock(inode);
561                 this = child;
562         }
563 }
564 EXPORT_SYMBOL(simple_recursive_removal);
565
566 static const struct super_operations simple_super_operations = {
567         .statfs         = simple_statfs,
568 };
569
570 static int pseudo_fs_fill_super(struct super_block *s, struct fs_context *fc)
571 {
572         struct pseudo_fs_context *ctx = fc->fs_private;
573         struct inode *root;
574
575         s->s_maxbytes = MAX_LFS_FILESIZE;
576         s->s_blocksize = PAGE_SIZE;
577         s->s_blocksize_bits = PAGE_SHIFT;
578         s->s_magic = ctx->magic;
579         s->s_op = ctx->ops ?: &simple_super_operations;
580         s->s_xattr = ctx->xattr;
581         s->s_time_gran = 1;
582         root = new_inode(s);
583         if (!root)
584                 return -ENOMEM;
585
586         /*
587          * since this is the first inode, make it number 1. New inodes created
588          * after this must take care not to collide with it (by passing
589          * max_reserved of 1 to iunique).
590          */
591         root->i_ino = 1;
592         root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
593         root->i_atime = root->i_mtime = inode_set_ctime_current(root);
594         s->s_root = d_make_root(root);
595         if (!s->s_root)
596                 return -ENOMEM;
597         s->s_d_op = ctx->dops;
598         return 0;
599 }
600
601 static int pseudo_fs_get_tree(struct fs_context *fc)
602 {
603         return get_tree_nodev(fc, pseudo_fs_fill_super);
604 }
605
606 static void pseudo_fs_free(struct fs_context *fc)
607 {
608         kfree(fc->fs_private);
609 }
610
611 static const struct fs_context_operations pseudo_fs_context_ops = {
612         .free           = pseudo_fs_free,
613         .get_tree       = pseudo_fs_get_tree,
614 };
615
616 /*
617  * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
618  * will never be mountable)
619  */
620 struct pseudo_fs_context *init_pseudo(struct fs_context *fc,
621                                         unsigned long magic)
622 {
623         struct pseudo_fs_context *ctx;
624
625         ctx = kzalloc(sizeof(struct pseudo_fs_context), GFP_KERNEL);
626         if (likely(ctx)) {
627                 ctx->magic = magic;
628                 fc->fs_private = ctx;
629                 fc->ops = &pseudo_fs_context_ops;
630                 fc->sb_flags |= SB_NOUSER;
631                 fc->global = true;
632         }
633         return ctx;
634 }
635 EXPORT_SYMBOL(init_pseudo);
636
637 int simple_open(struct inode *inode, struct file *file)
638 {
639         if (inode->i_private)
640                 file->private_data = inode->i_private;
641         return 0;
642 }
643 EXPORT_SYMBOL(simple_open);
644
645 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
646 {
647         struct inode *inode = d_inode(old_dentry);
648
649         dir->i_mtime = inode_set_ctime_to_ts(dir,
650                                              inode_set_ctime_current(inode));
651         inc_nlink(inode);
652         ihold(inode);
653         dget(dentry);
654         d_instantiate(dentry, inode);
655         return 0;
656 }
657 EXPORT_SYMBOL(simple_link);
658
659 int simple_empty(struct dentry *dentry)
660 {
661         struct dentry *child;
662         int ret = 0;
663
664         spin_lock(&dentry->d_lock);
665         list_for_each_entry(child, &dentry->d_subdirs, d_child) {
666                 spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
667                 if (simple_positive(child)) {
668                         spin_unlock(&child->d_lock);
669                         goto out;
670                 }
671                 spin_unlock(&child->d_lock);
672         }
673         ret = 1;
674 out:
675         spin_unlock(&dentry->d_lock);
676         return ret;
677 }
678 EXPORT_SYMBOL(simple_empty);
679
680 int simple_unlink(struct inode *dir, struct dentry *dentry)
681 {
682         struct inode *inode = d_inode(dentry);
683
684         dir->i_mtime = inode_set_ctime_to_ts(dir,
685                                              inode_set_ctime_current(inode));
686         drop_nlink(inode);
687         dput(dentry);
688         return 0;
689 }
690 EXPORT_SYMBOL(simple_unlink);
691
692 int simple_rmdir(struct inode *dir, struct dentry *dentry)
693 {
694         if (!simple_empty(dentry))
695                 return -ENOTEMPTY;
696
697         drop_nlink(d_inode(dentry));
698         simple_unlink(dir, dentry);
699         drop_nlink(dir);
700         return 0;
701 }
702 EXPORT_SYMBOL(simple_rmdir);
703
704 /**
705  * simple_rename_timestamp - update the various inode timestamps for rename
706  * @old_dir: old parent directory
707  * @old_dentry: dentry that is being renamed
708  * @new_dir: new parent directory
709  * @new_dentry: target for rename
710  *
711  * POSIX mandates that the old and new parent directories have their ctime and
712  * mtime updated, and that inodes of @old_dentry and @new_dentry (if any), have
713  * their ctime updated.
714  */
715 void simple_rename_timestamp(struct inode *old_dir, struct dentry *old_dentry,
716                              struct inode *new_dir, struct dentry *new_dentry)
717 {
718         struct inode *newino = d_inode(new_dentry);
719
720         old_dir->i_mtime = inode_set_ctime_current(old_dir);
721         if (new_dir != old_dir)
722                 new_dir->i_mtime = inode_set_ctime_current(new_dir);
723         inode_set_ctime_current(d_inode(old_dentry));
724         if (newino)
725                 inode_set_ctime_current(newino);
726 }
727 EXPORT_SYMBOL_GPL(simple_rename_timestamp);
728
729 int simple_rename_exchange(struct inode *old_dir, struct dentry *old_dentry,
730                            struct inode *new_dir, struct dentry *new_dentry)
731 {
732         bool old_is_dir = d_is_dir(old_dentry);
733         bool new_is_dir = d_is_dir(new_dentry);
734
735         if (old_dir != new_dir && old_is_dir != new_is_dir) {
736                 if (old_is_dir) {
737                         drop_nlink(old_dir);
738                         inc_nlink(new_dir);
739                 } else {
740                         drop_nlink(new_dir);
741                         inc_nlink(old_dir);
742                 }
743         }
744         simple_rename_timestamp(old_dir, old_dentry, new_dir, new_dentry);
745         return 0;
746 }
747 EXPORT_SYMBOL_GPL(simple_rename_exchange);
748
749 int simple_rename(struct mnt_idmap *idmap, struct inode *old_dir,
750                   struct dentry *old_dentry, struct inode *new_dir,
751                   struct dentry *new_dentry, unsigned int flags)
752 {
753         int they_are_dirs = d_is_dir(old_dentry);
754
755         if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
756                 return -EINVAL;
757
758         if (flags & RENAME_EXCHANGE)
759                 return simple_rename_exchange(old_dir, old_dentry, new_dir, new_dentry);
760
761         if (!simple_empty(new_dentry))
762                 return -ENOTEMPTY;
763
764         if (d_really_is_positive(new_dentry)) {
765                 simple_unlink(new_dir, new_dentry);
766                 if (they_are_dirs) {
767                         drop_nlink(d_inode(new_dentry));
768                         drop_nlink(old_dir);
769                 }
770         } else if (they_are_dirs) {
771                 drop_nlink(old_dir);
772                 inc_nlink(new_dir);
773         }
774
775         simple_rename_timestamp(old_dir, old_dentry, new_dir, new_dentry);
776         return 0;
777 }
778 EXPORT_SYMBOL(simple_rename);
779
780 /**
781  * simple_setattr - setattr for simple filesystem
782  * @idmap: idmap of the target mount
783  * @dentry: dentry
784  * @iattr: iattr structure
785  *
786  * Returns 0 on success, -error on failure.
787  *
788  * simple_setattr is a simple ->setattr implementation without a proper
789  * implementation of size changes.
790  *
791  * It can either be used for in-memory filesystems or special files
792  * on simple regular filesystems.  Anything that needs to change on-disk
793  * or wire state on size changes needs its own setattr method.
794  */
795 int simple_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
796                    struct iattr *iattr)
797 {
798         struct inode *inode = d_inode(dentry);
799         int error;
800
801         error = setattr_prepare(idmap, dentry, iattr);
802         if (error)
803                 return error;
804
805         if (iattr->ia_valid & ATTR_SIZE)
806                 truncate_setsize(inode, iattr->ia_size);
807         setattr_copy(idmap, inode, iattr);
808         mark_inode_dirty(inode);
809         return 0;
810 }
811 EXPORT_SYMBOL(simple_setattr);
812
813 static int simple_read_folio(struct file *file, struct folio *folio)
814 {
815         folio_zero_range(folio, 0, folio_size(folio));
816         flush_dcache_folio(folio);
817         folio_mark_uptodate(folio);
818         folio_unlock(folio);
819         return 0;
820 }
821
822 int simple_write_begin(struct file *file, struct address_space *mapping,
823                         loff_t pos, unsigned len,
824                         struct page **pagep, void **fsdata)
825 {
826         struct folio *folio;
827
828         folio = __filemap_get_folio(mapping, pos / PAGE_SIZE, FGP_WRITEBEGIN,
829                         mapping_gfp_mask(mapping));
830         if (IS_ERR(folio))
831                 return PTR_ERR(folio);
832
833         *pagep = &folio->page;
834
835         if (!folio_test_uptodate(folio) && (len != folio_size(folio))) {
836                 size_t from = offset_in_folio(folio, pos);
837
838                 folio_zero_segments(folio, 0, from,
839                                 from + len, folio_size(folio));
840         }
841         return 0;
842 }
843 EXPORT_SYMBOL(simple_write_begin);
844
845 /**
846  * simple_write_end - .write_end helper for non-block-device FSes
847  * @file: See .write_end of address_space_operations
848  * @mapping:            "
849  * @pos:                "
850  * @len:                "
851  * @copied:             "
852  * @page:               "
853  * @fsdata:             "
854  *
855  * simple_write_end does the minimum needed for updating a page after writing is
856  * done. It has the same API signature as the .write_end of
857  * address_space_operations vector. So it can just be set onto .write_end for
858  * FSes that don't need any other processing. i_mutex is assumed to be held.
859  * Block based filesystems should use generic_write_end().
860  * NOTE: Even though i_size might get updated by this function, mark_inode_dirty
861  * is not called, so a filesystem that actually does store data in .write_inode
862  * should extend on what's done here with a call to mark_inode_dirty() in the
863  * case that i_size has changed.
864  *
865  * Use *ONLY* with simple_read_folio()
866  */
867 static int simple_write_end(struct file *file, struct address_space *mapping,
868                         loff_t pos, unsigned len, unsigned copied,
869                         struct page *page, void *fsdata)
870 {
871         struct folio *folio = page_folio(page);
872         struct inode *inode = folio->mapping->host;
873         loff_t last_pos = pos + copied;
874
875         /* zero the stale part of the folio if we did a short copy */
876         if (!folio_test_uptodate(folio)) {
877                 if (copied < len) {
878                         size_t from = offset_in_folio(folio, pos);
879
880                         folio_zero_range(folio, from + copied, len - copied);
881                 }
882                 folio_mark_uptodate(folio);
883         }
884         /*
885          * No need to use i_size_read() here, the i_size
886          * cannot change under us because we hold the i_mutex.
887          */
888         if (last_pos > inode->i_size)
889                 i_size_write(inode, last_pos);
890
891         folio_mark_dirty(folio);
892         folio_unlock(folio);
893         folio_put(folio);
894
895         return copied;
896 }
897
898 /*
899  * Provides ramfs-style behavior: data in the pagecache, but no writeback.
900  */
901 const struct address_space_operations ram_aops = {
902         .read_folio     = simple_read_folio,
903         .write_begin    = simple_write_begin,
904         .write_end      = simple_write_end,
905         .dirty_folio    = noop_dirty_folio,
906 };
907 EXPORT_SYMBOL(ram_aops);
908
909 /*
910  * the inodes created here are not hashed. If you use iunique to generate
911  * unique inode values later for this filesystem, then you must take care
912  * to pass it an appropriate max_reserved value to avoid collisions.
913  */
914 int simple_fill_super(struct super_block *s, unsigned long magic,
915                       const struct tree_descr *files)
916 {
917         struct inode *inode;
918         struct dentry *root;
919         struct dentry *dentry;
920         int i;
921
922         s->s_blocksize = PAGE_SIZE;
923         s->s_blocksize_bits = PAGE_SHIFT;
924         s->s_magic = magic;
925         s->s_op = &simple_super_operations;
926         s->s_time_gran = 1;
927
928         inode = new_inode(s);
929         if (!inode)
930                 return -ENOMEM;
931         /*
932          * because the root inode is 1, the files array must not contain an
933          * entry at index 1
934          */
935         inode->i_ino = 1;
936         inode->i_mode = S_IFDIR | 0755;
937         inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode);
938         inode->i_op = &simple_dir_inode_operations;
939         inode->i_fop = &simple_dir_operations;
940         set_nlink(inode, 2);
941         root = d_make_root(inode);
942         if (!root)
943                 return -ENOMEM;
944         for (i = 0; !files->name || files->name[0]; i++, files++) {
945                 if (!files->name)
946                         continue;
947
948                 /* warn if it tries to conflict with the root inode */
949                 if (unlikely(i == 1))
950                         printk(KERN_WARNING "%s: %s passed in a files array"
951                                 "with an index of 1!\n", __func__,
952                                 s->s_type->name);
953
954                 dentry = d_alloc_name(root, files->name);
955                 if (!dentry)
956                         goto out;
957                 inode = new_inode(s);
958                 if (!inode) {
959                         dput(dentry);
960                         goto out;
961                 }
962                 inode->i_mode = S_IFREG | files->mode;
963                 inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode);
964                 inode->i_fop = files->ops;
965                 inode->i_ino = i;
966                 d_add(dentry, inode);
967         }
968         s->s_root = root;
969         return 0;
970 out:
971         d_genocide(root);
972         shrink_dcache_parent(root);
973         dput(root);
974         return -ENOMEM;
975 }
976 EXPORT_SYMBOL(simple_fill_super);
977
978 static DEFINE_SPINLOCK(pin_fs_lock);
979
980 int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
981 {
982         struct vfsmount *mnt = NULL;
983         spin_lock(&pin_fs_lock);
984         if (unlikely(!*mount)) {
985                 spin_unlock(&pin_fs_lock);
986                 mnt = vfs_kern_mount(type, SB_KERNMOUNT, type->name, NULL);
987                 if (IS_ERR(mnt))
988                         return PTR_ERR(mnt);
989                 spin_lock(&pin_fs_lock);
990                 if (!*mount)
991                         *mount = mnt;
992         }
993         mntget(*mount);
994         ++*count;
995         spin_unlock(&pin_fs_lock);
996         mntput(mnt);
997         return 0;
998 }
999 EXPORT_SYMBOL(simple_pin_fs);
1000
1001 void simple_release_fs(struct vfsmount **mount, int *count)
1002 {
1003         struct vfsmount *mnt;
1004         spin_lock(&pin_fs_lock);
1005         mnt = *mount;
1006         if (!--*count)
1007                 *mount = NULL;
1008         spin_unlock(&pin_fs_lock);
1009         mntput(mnt);
1010 }
1011 EXPORT_SYMBOL(simple_release_fs);
1012
1013 /**
1014  * simple_read_from_buffer - copy data from the buffer to user space
1015  * @to: the user space buffer to read to
1016  * @count: the maximum number of bytes to read
1017  * @ppos: the current position in the buffer
1018  * @from: the buffer to read from
1019  * @available: the size of the buffer
1020  *
1021  * The simple_read_from_buffer() function reads up to @count bytes from the
1022  * buffer @from at offset @ppos into the user space address starting at @to.
1023  *
1024  * On success, the number of bytes read is returned and the offset @ppos is
1025  * advanced by this number, or negative value is returned on error.
1026  **/
1027 ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
1028                                 const void *from, size_t available)
1029 {
1030         loff_t pos = *ppos;
1031         size_t ret;
1032
1033         if (pos < 0)
1034                 return -EINVAL;
1035         if (pos >= available || !count)
1036                 return 0;
1037         if (count > available - pos)
1038                 count = available - pos;
1039         ret = copy_to_user(to, from + pos, count);
1040         if (ret == count)
1041                 return -EFAULT;
1042         count -= ret;
1043         *ppos = pos + count;
1044         return count;
1045 }
1046 EXPORT_SYMBOL(simple_read_from_buffer);
1047
1048 /**
1049  * simple_write_to_buffer - copy data from user space to the buffer
1050  * @to: the buffer to write to
1051  * @available: the size of the buffer
1052  * @ppos: the current position in the buffer
1053  * @from: the user space buffer to read from
1054  * @count: the maximum number of bytes to read
1055  *
1056  * The simple_write_to_buffer() function reads up to @count bytes from the user
1057  * space address starting at @from into the buffer @to at offset @ppos.
1058  *
1059  * On success, the number of bytes written is returned and the offset @ppos is
1060  * advanced by this number, or negative value is returned on error.
1061  **/
1062 ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
1063                 const void __user *from, size_t count)
1064 {
1065         loff_t pos = *ppos;
1066         size_t res;
1067
1068         if (pos < 0)
1069                 return -EINVAL;
1070         if (pos >= available || !count)
1071                 return 0;
1072         if (count > available - pos)
1073                 count = available - pos;
1074         res = copy_from_user(to + pos, from, count);
1075         if (res == count)
1076                 return -EFAULT;
1077         count -= res;
1078         *ppos = pos + count;
1079         return count;
1080 }
1081 EXPORT_SYMBOL(simple_write_to_buffer);
1082
1083 /**
1084  * memory_read_from_buffer - copy data from the buffer
1085  * @to: the kernel space buffer to read to
1086  * @count: the maximum number of bytes to read
1087  * @ppos: the current position in the buffer
1088  * @from: the buffer to read from
1089  * @available: the size of the buffer
1090  *
1091  * The memory_read_from_buffer() function reads up to @count bytes from the
1092  * buffer @from at offset @ppos into the kernel space address starting at @to.
1093  *
1094  * On success, the number of bytes read is returned and the offset @ppos is
1095  * advanced by this number, or negative value is returned on error.
1096  **/
1097 ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
1098                                 const void *from, size_t available)
1099 {
1100         loff_t pos = *ppos;
1101
1102         if (pos < 0)
1103                 return -EINVAL;
1104         if (pos >= available)
1105                 return 0;
1106         if (count > available - pos)
1107                 count = available - pos;
1108         memcpy(to, from + pos, count);
1109         *ppos = pos + count;
1110
1111         return count;
1112 }
1113 EXPORT_SYMBOL(memory_read_from_buffer);
1114
1115 /*
1116  * Transaction based IO.
1117  * The file expects a single write which triggers the transaction, and then
1118  * possibly a read which collects the result - which is stored in a
1119  * file-local buffer.
1120  */
1121
1122 void simple_transaction_set(struct file *file, size_t n)
1123 {
1124         struct simple_transaction_argresp *ar = file->private_data;
1125
1126         BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
1127
1128         /*
1129          * The barrier ensures that ar->size will really remain zero until
1130          * ar->data is ready for reading.
1131          */
1132         smp_mb();
1133         ar->size = n;
1134 }
1135 EXPORT_SYMBOL(simple_transaction_set);
1136
1137 char *simple_transaction_get(struct file *file, const char __user *buf, size_t size)
1138 {
1139         struct simple_transaction_argresp *ar;
1140         static DEFINE_SPINLOCK(simple_transaction_lock);
1141
1142         if (size > SIMPLE_TRANSACTION_LIMIT - 1)
1143                 return ERR_PTR(-EFBIG);
1144
1145         ar = (struct simple_transaction_argresp *)get_zeroed_page(GFP_KERNEL);
1146         if (!ar)
1147                 return ERR_PTR(-ENOMEM);
1148
1149         spin_lock(&simple_transaction_lock);
1150
1151         /* only one write allowed per open */
1152         if (file->private_data) {
1153                 spin_unlock(&simple_transaction_lock);
1154                 free_page((unsigned long)ar);
1155                 return ERR_PTR(-EBUSY);
1156         }
1157
1158         file->private_data = ar;
1159
1160         spin_unlock(&simple_transaction_lock);
1161
1162         if (copy_from_user(ar->data, buf, size))
1163                 return ERR_PTR(-EFAULT);
1164
1165         return ar->data;
1166 }
1167 EXPORT_SYMBOL(simple_transaction_get);
1168
1169 ssize_t simple_transaction_read(struct file *file, char __user *buf, size_t size, loff_t *pos)
1170 {
1171         struct simple_transaction_argresp *ar = file->private_data;
1172
1173         if (!ar)
1174                 return 0;
1175         return simple_read_from_buffer(buf, size, pos, ar->data, ar->size);
1176 }
1177 EXPORT_SYMBOL(simple_transaction_read);
1178
1179 int simple_transaction_release(struct inode *inode, struct file *file)
1180 {
1181         free_page((unsigned long)file->private_data);
1182         return 0;
1183 }
1184 EXPORT_SYMBOL(simple_transaction_release);
1185
1186 /* Simple attribute files */
1187
1188 struct simple_attr {
1189         int (*get)(void *, u64 *);
1190         int (*set)(void *, u64);
1191         char get_buf[24];       /* enough to store a u64 and "\n\0" */
1192         char set_buf[24];
1193         void *data;
1194         const char *fmt;        /* format for read operation */
1195         struct mutex mutex;     /* protects access to these buffers */
1196 };
1197
1198 /* simple_attr_open is called by an actual attribute open file operation
1199  * to set the attribute specific access operations. */
1200 int simple_attr_open(struct inode *inode, struct file *file,
1201                      int (*get)(void *, u64 *), int (*set)(void *, u64),
1202                      const char *fmt)
1203 {
1204         struct simple_attr *attr;
1205
1206         attr = kzalloc(sizeof(*attr), GFP_KERNEL);
1207         if (!attr)
1208                 return -ENOMEM;
1209
1210         attr->get = get;
1211         attr->set = set;
1212         attr->data = inode->i_private;
1213         attr->fmt = fmt;
1214         mutex_init(&attr->mutex);
1215
1216         file->private_data = attr;
1217
1218         return nonseekable_open(inode, file);
1219 }
1220 EXPORT_SYMBOL_GPL(simple_attr_open);
1221
1222 int simple_attr_release(struct inode *inode, struct file *file)
1223 {
1224         kfree(file->private_data);
1225         return 0;
1226 }
1227 EXPORT_SYMBOL_GPL(simple_attr_release); /* GPL-only?  This?  Really? */
1228
1229 /* read from the buffer that is filled with the get function */
1230 ssize_t simple_attr_read(struct file *file, char __user *buf,
1231                          size_t len, loff_t *ppos)
1232 {
1233         struct simple_attr *attr;
1234         size_t size;
1235         ssize_t ret;
1236
1237         attr = file->private_data;
1238
1239         if (!attr->get)
1240                 return -EACCES;
1241
1242         ret = mutex_lock_interruptible(&attr->mutex);
1243         if (ret)
1244                 return ret;
1245
1246         if (*ppos && attr->get_buf[0]) {
1247                 /* continued read */
1248                 size = strlen(attr->get_buf);
1249         } else {
1250                 /* first read */
1251                 u64 val;
1252                 ret = attr->get(attr->data, &val);
1253                 if (ret)
1254                         goto out;
1255
1256                 size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
1257                                  attr->fmt, (unsigned long long)val);
1258         }
1259
1260         ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
1261 out:
1262         mutex_unlock(&attr->mutex);
1263         return ret;
1264 }
1265 EXPORT_SYMBOL_GPL(simple_attr_read);
1266
1267 /* interpret the buffer as a number to call the set function with */
1268 static ssize_t simple_attr_write_xsigned(struct file *file, const char __user *buf,
1269                           size_t len, loff_t *ppos, bool is_signed)
1270 {
1271         struct simple_attr *attr;
1272         unsigned long long val;
1273         size_t size;
1274         ssize_t ret;
1275
1276         attr = file->private_data;
1277         if (!attr->set)
1278                 return -EACCES;
1279
1280         ret = mutex_lock_interruptible(&attr->mutex);
1281         if (ret)
1282                 return ret;
1283
1284         ret = -EFAULT;
1285         size = min(sizeof(attr->set_buf) - 1, len);
1286         if (copy_from_user(attr->set_buf, buf, size))
1287                 goto out;
1288
1289         attr->set_buf[size] = '\0';
1290         if (is_signed)
1291                 ret = kstrtoll(attr->set_buf, 0, &val);
1292         else
1293                 ret = kstrtoull(attr->set_buf, 0, &val);
1294         if (ret)
1295                 goto out;
1296         ret = attr->set(attr->data, val);
1297         if (ret == 0)
1298                 ret = len; /* on success, claim we got the whole input */
1299 out:
1300         mutex_unlock(&attr->mutex);
1301         return ret;
1302 }
1303
1304 ssize_t simple_attr_write(struct file *file, const char __user *buf,
1305                           size_t len, loff_t *ppos)
1306 {
1307         return simple_attr_write_xsigned(file, buf, len, ppos, false);
1308 }
1309 EXPORT_SYMBOL_GPL(simple_attr_write);
1310
1311 ssize_t simple_attr_write_signed(struct file *file, const char __user *buf,
1312                           size_t len, loff_t *ppos)
1313 {
1314         return simple_attr_write_xsigned(file, buf, len, ppos, true);
1315 }
1316 EXPORT_SYMBOL_GPL(simple_attr_write_signed);
1317
1318 /**
1319  * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation
1320  * @sb:         filesystem to do the file handle conversion on
1321  * @fid:        file handle to convert
1322  * @fh_len:     length of the file handle in bytes
1323  * @fh_type:    type of file handle
1324  * @get_inode:  filesystem callback to retrieve inode
1325  *
1326  * This function decodes @fid as long as it has one of the well-known
1327  * Linux filehandle types and calls @get_inode on it to retrieve the
1328  * inode for the object specified in the file handle.
1329  */
1330 struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid,
1331                 int fh_len, int fh_type, struct inode *(*get_inode)
1332                         (struct super_block *sb, u64 ino, u32 gen))
1333 {
1334         struct inode *inode = NULL;
1335
1336         if (fh_len < 2)
1337                 return NULL;
1338
1339         switch (fh_type) {
1340         case FILEID_INO32_GEN:
1341         case FILEID_INO32_GEN_PARENT:
1342                 inode = get_inode(sb, fid->i32.ino, fid->i32.gen);
1343                 break;
1344         }
1345
1346         return d_obtain_alias(inode);
1347 }
1348 EXPORT_SYMBOL_GPL(generic_fh_to_dentry);
1349
1350 /**
1351  * generic_fh_to_parent - generic helper for the fh_to_parent export operation
1352  * @sb:         filesystem to do the file handle conversion on
1353  * @fid:        file handle to convert
1354  * @fh_len:     length of the file handle in bytes
1355  * @fh_type:    type of file handle
1356  * @get_inode:  filesystem callback to retrieve inode
1357  *
1358  * This function decodes @fid as long as it has one of the well-known
1359  * Linux filehandle types and calls @get_inode on it to retrieve the
1360  * inode for the _parent_ object specified in the file handle if it
1361  * is specified in the file handle, or NULL otherwise.
1362  */
1363 struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid,
1364                 int fh_len, int fh_type, struct inode *(*get_inode)
1365                         (struct super_block *sb, u64 ino, u32 gen))
1366 {
1367         struct inode *inode = NULL;
1368
1369         if (fh_len <= 2)
1370                 return NULL;
1371
1372         switch (fh_type) {
1373         case FILEID_INO32_GEN_PARENT:
1374                 inode = get_inode(sb, fid->i32.parent_ino,
1375                                   (fh_len > 3 ? fid->i32.parent_gen : 0));
1376                 break;
1377         }
1378
1379         return d_obtain_alias(inode);
1380 }
1381 EXPORT_SYMBOL_GPL(generic_fh_to_parent);
1382
1383 /**
1384  * __generic_file_fsync - generic fsync implementation for simple filesystems
1385  *
1386  * @file:       file to synchronize
1387  * @start:      start offset in bytes
1388  * @end:        end offset in bytes (inclusive)
1389  * @datasync:   only synchronize essential metadata if true
1390  *
1391  * This is a generic implementation of the fsync method for simple
1392  * filesystems which track all non-inode metadata in the buffers list
1393  * hanging off the address_space structure.
1394  */
1395 int __generic_file_fsync(struct file *file, loff_t start, loff_t end,
1396                                  int datasync)
1397 {
1398         struct inode *inode = file->f_mapping->host;
1399         int err;
1400         int ret;
1401
1402         err = file_write_and_wait_range(file, start, end);
1403         if (err)
1404                 return err;
1405
1406         inode_lock(inode);
1407         ret = sync_mapping_buffers(inode->i_mapping);
1408         if (!(inode->i_state & I_DIRTY_ALL))
1409                 goto out;
1410         if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
1411                 goto out;
1412
1413         err = sync_inode_metadata(inode, 1);
1414         if (ret == 0)
1415                 ret = err;
1416
1417 out:
1418         inode_unlock(inode);
1419         /* check and advance again to catch errors after syncing out buffers */
1420         err = file_check_and_advance_wb_err(file);
1421         if (ret == 0)
1422                 ret = err;
1423         return ret;
1424 }
1425 EXPORT_SYMBOL(__generic_file_fsync);
1426
1427 /**
1428  * generic_file_fsync - generic fsync implementation for simple filesystems
1429  *                      with flush
1430  * @file:       file to synchronize
1431  * @start:      start offset in bytes
1432  * @end:        end offset in bytes (inclusive)
1433  * @datasync:   only synchronize essential metadata if true
1434  *
1435  */
1436
1437 int generic_file_fsync(struct file *file, loff_t start, loff_t end,
1438                        int datasync)
1439 {
1440         struct inode *inode = file->f_mapping->host;
1441         int err;
1442
1443         err = __generic_file_fsync(file, start, end, datasync);
1444         if (err)
1445                 return err;
1446         return blkdev_issue_flush(inode->i_sb->s_bdev);
1447 }
1448 EXPORT_SYMBOL(generic_file_fsync);
1449
1450 /**
1451  * generic_check_addressable - Check addressability of file system
1452  * @blocksize_bits:     log of file system block size
1453  * @num_blocks:         number of blocks in file system
1454  *
1455  * Determine whether a file system with @num_blocks blocks (and a
1456  * block size of 2**@blocksize_bits) is addressable by the sector_t
1457  * and page cache of the system.  Return 0 if so and -EFBIG otherwise.
1458  */
1459 int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks)
1460 {
1461         u64 last_fs_block = num_blocks - 1;
1462         u64 last_fs_page =
1463                 last_fs_block >> (PAGE_SHIFT - blocksize_bits);
1464
1465         if (unlikely(num_blocks == 0))
1466                 return 0;
1467
1468         if ((blocksize_bits < 9) || (blocksize_bits > PAGE_SHIFT))
1469                 return -EINVAL;
1470
1471         if ((last_fs_block > (sector_t)(~0ULL) >> (blocksize_bits - 9)) ||
1472             (last_fs_page > (pgoff_t)(~0ULL))) {
1473                 return -EFBIG;
1474         }
1475         return 0;
1476 }
1477 EXPORT_SYMBOL(generic_check_addressable);
1478
1479 /*
1480  * No-op implementation of ->fsync for in-memory filesystems.
1481  */
1482 int noop_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1483 {
1484         return 0;
1485 }
1486 EXPORT_SYMBOL(noop_fsync);
1487
1488 ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
1489 {
1490         /*
1491          * iomap based filesystems support direct I/O without need for
1492          * this callback. However, it still needs to be set in
1493          * inode->a_ops so that open/fcntl know that direct I/O is
1494          * generally supported.
1495          */
1496         return -EINVAL;
1497 }
1498 EXPORT_SYMBOL_GPL(noop_direct_IO);
1499
1500 /* Because kfree isn't assignment-compatible with void(void*) ;-/ */
1501 void kfree_link(void *p)
1502 {
1503         kfree(p);
1504 }
1505 EXPORT_SYMBOL(kfree_link);
1506
1507 struct inode *alloc_anon_inode(struct super_block *s)
1508 {
1509         static const struct address_space_operations anon_aops = {
1510                 .dirty_folio    = noop_dirty_folio,
1511         };
1512         struct inode *inode = new_inode_pseudo(s);
1513
1514         if (!inode)
1515                 return ERR_PTR(-ENOMEM);
1516
1517         inode->i_ino = get_next_ino();
1518         inode->i_mapping->a_ops = &anon_aops;
1519
1520         /*
1521          * Mark the inode dirty from the very beginning,
1522          * that way it will never be moved to the dirty
1523          * list because mark_inode_dirty() will think
1524          * that it already _is_ on the dirty list.
1525          */
1526         inode->i_state = I_DIRTY;
1527         inode->i_mode = S_IRUSR | S_IWUSR;
1528         inode->i_uid = current_fsuid();
1529         inode->i_gid = current_fsgid();
1530         inode->i_flags |= S_PRIVATE;
1531         inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode);
1532         return inode;
1533 }
1534 EXPORT_SYMBOL(alloc_anon_inode);
1535
1536 /**
1537  * simple_nosetlease - generic helper for prohibiting leases
1538  * @filp: file pointer
1539  * @arg: type of lease to obtain
1540  * @flp: new lease supplied for insertion
1541  * @priv: private data for lm_setup operation
1542  *
1543  * Generic helper for filesystems that do not wish to allow leases to be set.
1544  * All arguments are ignored and it just returns -EINVAL.
1545  */
1546 int
1547 simple_nosetlease(struct file *filp, int arg, struct file_lock **flp,
1548                   void **priv)
1549 {
1550         return -EINVAL;
1551 }
1552 EXPORT_SYMBOL(simple_nosetlease);
1553
1554 /**
1555  * simple_get_link - generic helper to get the target of "fast" symlinks
1556  * @dentry: not used here
1557  * @inode: the symlink inode
1558  * @done: not used here
1559  *
1560  * Generic helper for filesystems to use for symlink inodes where a pointer to
1561  * the symlink target is stored in ->i_link.  NOTE: this isn't normally called,
1562  * since as an optimization the path lookup code uses any non-NULL ->i_link
1563  * directly, without calling ->get_link().  But ->get_link() still must be set,
1564  * to mark the inode_operations as being for a symlink.
1565  *
1566  * Return: the symlink target
1567  */
1568 const char *simple_get_link(struct dentry *dentry, struct inode *inode,
1569                             struct delayed_call *done)
1570 {
1571         return inode->i_link;
1572 }
1573 EXPORT_SYMBOL(simple_get_link);
1574
1575 const struct inode_operations simple_symlink_inode_operations = {
1576         .get_link = simple_get_link,
1577 };
1578 EXPORT_SYMBOL(simple_symlink_inode_operations);
1579
1580 /*
1581  * Operations for a permanently empty directory.
1582  */
1583 static struct dentry *empty_dir_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
1584 {
1585         return ERR_PTR(-ENOENT);
1586 }
1587
1588 static int empty_dir_getattr(struct mnt_idmap *idmap,
1589                              const struct path *path, struct kstat *stat,
1590                              u32 request_mask, unsigned int query_flags)
1591 {
1592         struct inode *inode = d_inode(path->dentry);
1593         generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
1594         return 0;
1595 }
1596
1597 static int empty_dir_setattr(struct mnt_idmap *idmap,
1598                              struct dentry *dentry, struct iattr *attr)
1599 {
1600         return -EPERM;
1601 }
1602
1603 static ssize_t empty_dir_listxattr(struct dentry *dentry, char *list, size_t size)
1604 {
1605         return -EOPNOTSUPP;
1606 }
1607
1608 static const struct inode_operations empty_dir_inode_operations = {
1609         .lookup         = empty_dir_lookup,
1610         .permission     = generic_permission,
1611         .setattr        = empty_dir_setattr,
1612         .getattr        = empty_dir_getattr,
1613         .listxattr      = empty_dir_listxattr,
1614 };
1615
1616 static loff_t empty_dir_llseek(struct file *file, loff_t offset, int whence)
1617 {
1618         /* An empty directory has two entries . and .. at offsets 0 and 1 */
1619         return generic_file_llseek_size(file, offset, whence, 2, 2);
1620 }
1621
1622 static int empty_dir_readdir(struct file *file, struct dir_context *ctx)
1623 {
1624         dir_emit_dots(file, ctx);
1625         return 0;
1626 }
1627
1628 static const struct file_operations empty_dir_operations = {
1629         .llseek         = empty_dir_llseek,
1630         .read           = generic_read_dir,
1631         .iterate_shared = empty_dir_readdir,
1632         .fsync          = noop_fsync,
1633 };
1634
1635
1636 void make_empty_dir_inode(struct inode *inode)
1637 {
1638         set_nlink(inode, 2);
1639         inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO;
1640         inode->i_uid = GLOBAL_ROOT_UID;
1641         inode->i_gid = GLOBAL_ROOT_GID;
1642         inode->i_rdev = 0;
1643         inode->i_size = 0;
1644         inode->i_blkbits = PAGE_SHIFT;
1645         inode->i_blocks = 0;
1646
1647         inode->i_op = &empty_dir_inode_operations;
1648         inode->i_opflags &= ~IOP_XATTR;
1649         inode->i_fop = &empty_dir_operations;
1650 }
1651
1652 bool is_empty_dir_inode(struct inode *inode)
1653 {
1654         return (inode->i_fop == &empty_dir_operations) &&
1655                 (inode->i_op == &empty_dir_inode_operations);
1656 }
1657
1658 #if IS_ENABLED(CONFIG_UNICODE)
1659 /**
1660  * generic_ci_d_compare - generic d_compare implementation for casefolding filesystems
1661  * @dentry:     dentry whose name we are checking against
1662  * @len:        len of name of dentry
1663  * @str:        str pointer to name of dentry
1664  * @name:       Name to compare against
1665  *
1666  * Return: 0 if names match, 1 if mismatch, or -ERRNO
1667  */
1668 static int generic_ci_d_compare(const struct dentry *dentry, unsigned int len,
1669                                 const char *str, const struct qstr *name)
1670 {
1671         const struct dentry *parent = READ_ONCE(dentry->d_parent);
1672         const struct inode *dir = READ_ONCE(parent->d_inode);
1673         const struct super_block *sb = dentry->d_sb;
1674         const struct unicode_map *um = sb->s_encoding;
1675         struct qstr qstr = QSTR_INIT(str, len);
1676         char strbuf[DNAME_INLINE_LEN];
1677         int ret;
1678
1679         if (!dir || !IS_CASEFOLDED(dir))
1680                 goto fallback;
1681         /*
1682          * If the dentry name is stored in-line, then it may be concurrently
1683          * modified by a rename.  If this happens, the VFS will eventually retry
1684          * the lookup, so it doesn't matter what ->d_compare() returns.
1685          * However, it's unsafe to call utf8_strncasecmp() with an unstable
1686          * string.  Therefore, we have to copy the name into a temporary buffer.
1687          */
1688         if (len <= DNAME_INLINE_LEN - 1) {
1689                 memcpy(strbuf, str, len);
1690                 strbuf[len] = 0;
1691                 qstr.name = strbuf;
1692                 /* prevent compiler from optimizing out the temporary buffer */
1693                 barrier();
1694         }
1695         ret = utf8_strncasecmp(um, name, &qstr);
1696         if (ret >= 0)
1697                 return ret;
1698
1699         if (sb_has_strict_encoding(sb))
1700                 return -EINVAL;
1701 fallback:
1702         if (len != name->len)
1703                 return 1;
1704         return !!memcmp(str, name->name, len);
1705 }
1706
1707 /**
1708  * generic_ci_d_hash - generic d_hash implementation for casefolding filesystems
1709  * @dentry:     dentry of the parent directory
1710  * @str:        qstr of name whose hash we should fill in
1711  *
1712  * Return: 0 if hash was successful or unchanged, and -EINVAL on error
1713  */
1714 static int generic_ci_d_hash(const struct dentry *dentry, struct qstr *str)
1715 {
1716         const struct inode *dir = READ_ONCE(dentry->d_inode);
1717         struct super_block *sb = dentry->d_sb;
1718         const struct unicode_map *um = sb->s_encoding;
1719         int ret = 0;
1720
1721         if (!dir || !IS_CASEFOLDED(dir))
1722                 return 0;
1723
1724         ret = utf8_casefold_hash(um, dentry, str);
1725         if (ret < 0 && sb_has_strict_encoding(sb))
1726                 return -EINVAL;
1727         return 0;
1728 }
1729
1730 static const struct dentry_operations generic_ci_dentry_ops = {
1731         .d_hash = generic_ci_d_hash,
1732         .d_compare = generic_ci_d_compare,
1733 };
1734 #endif
1735
1736 #ifdef CONFIG_FS_ENCRYPTION
1737 static const struct dentry_operations generic_encrypted_dentry_ops = {
1738         .d_revalidate = fscrypt_d_revalidate,
1739 };
1740 #endif
1741
1742 #if defined(CONFIG_FS_ENCRYPTION) && IS_ENABLED(CONFIG_UNICODE)
1743 static const struct dentry_operations generic_encrypted_ci_dentry_ops = {
1744         .d_hash = generic_ci_d_hash,
1745         .d_compare = generic_ci_d_compare,
1746         .d_revalidate = fscrypt_d_revalidate,
1747 };
1748 #endif
1749
1750 /**
1751  * generic_set_encrypted_ci_d_ops - helper for setting d_ops for given dentry
1752  * @dentry:     dentry to set ops on
1753  *
1754  * Casefolded directories need d_hash and d_compare set, so that the dentries
1755  * contained in them are handled case-insensitively.  Note that these operations
1756  * are needed on the parent directory rather than on the dentries in it, and
1757  * while the casefolding flag can be toggled on and off on an empty directory,
1758  * dentry_operations can't be changed later.  As a result, if the filesystem has
1759  * casefolding support enabled at all, we have to give all dentries the
1760  * casefolding operations even if their inode doesn't have the casefolding flag
1761  * currently (and thus the casefolding ops would be no-ops for now).
1762  *
1763  * Encryption works differently in that the only dentry operation it needs is
1764  * d_revalidate, which it only needs on dentries that have the no-key name flag.
1765  * The no-key flag can't be set "later", so we don't have to worry about that.
1766  *
1767  * Finally, to maximize compatibility with overlayfs (which isn't compatible
1768  * with certain dentry operations) and to avoid taking an unnecessary
1769  * performance hit, we use custom dentry_operations for each possible
1770  * combination rather than always installing all operations.
1771  */
1772 void generic_set_encrypted_ci_d_ops(struct dentry *dentry)
1773 {
1774 #ifdef CONFIG_FS_ENCRYPTION
1775         bool needs_encrypt_ops = dentry->d_flags & DCACHE_NOKEY_NAME;
1776 #endif
1777 #if IS_ENABLED(CONFIG_UNICODE)
1778         bool needs_ci_ops = dentry->d_sb->s_encoding;
1779 #endif
1780 #if defined(CONFIG_FS_ENCRYPTION) && IS_ENABLED(CONFIG_UNICODE)
1781         if (needs_encrypt_ops && needs_ci_ops) {
1782                 d_set_d_op(dentry, &generic_encrypted_ci_dentry_ops);
1783                 return;
1784         }
1785 #endif
1786 #ifdef CONFIG_FS_ENCRYPTION
1787         if (needs_encrypt_ops) {
1788                 d_set_d_op(dentry, &generic_encrypted_dentry_ops);
1789                 return;
1790         }
1791 #endif
1792 #if IS_ENABLED(CONFIG_UNICODE)
1793         if (needs_ci_ops) {
1794                 d_set_d_op(dentry, &generic_ci_dentry_ops);
1795                 return;
1796         }
1797 #endif
1798 }
1799 EXPORT_SYMBOL(generic_set_encrypted_ci_d_ops);
1800
1801 /**
1802  * inode_maybe_inc_iversion - increments i_version
1803  * @inode: inode with the i_version that should be updated
1804  * @force: increment the counter even if it's not necessary?
1805  *
1806  * Every time the inode is modified, the i_version field must be seen to have
1807  * changed by any observer.
1808  *
1809  * If "force" is set or the QUERIED flag is set, then ensure that we increment
1810  * the value, and clear the queried flag.
1811  *
1812  * In the common case where neither is set, then we can return "false" without
1813  * updating i_version.
1814  *
1815  * If this function returns false, and no other metadata has changed, then we
1816  * can avoid logging the metadata.
1817  */
1818 bool inode_maybe_inc_iversion(struct inode *inode, bool force)
1819 {
1820         u64 cur, new;
1821
1822         /*
1823          * The i_version field is not strictly ordered with any other inode
1824          * information, but the legacy inode_inc_iversion code used a spinlock
1825          * to serialize increments.
1826          *
1827          * Here, we add full memory barriers to ensure that any de-facto
1828          * ordering with other info is preserved.
1829          *
1830          * This barrier pairs with the barrier in inode_query_iversion()
1831          */
1832         smp_mb();
1833         cur = inode_peek_iversion_raw(inode);
1834         do {
1835                 /* If flag is clear then we needn't do anything */
1836                 if (!force && !(cur & I_VERSION_QUERIED))
1837                         return false;
1838
1839                 /* Since lowest bit is flag, add 2 to avoid it */
1840                 new = (cur & ~I_VERSION_QUERIED) + I_VERSION_INCREMENT;
1841         } while (!atomic64_try_cmpxchg(&inode->i_version, &cur, new));
1842         return true;
1843 }
1844 EXPORT_SYMBOL(inode_maybe_inc_iversion);
1845
1846 /**
1847  * inode_query_iversion - read i_version for later use
1848  * @inode: inode from which i_version should be read
1849  *
1850  * Read the inode i_version counter. This should be used by callers that wish
1851  * to store the returned i_version for later comparison. This will guarantee
1852  * that a later query of the i_version will result in a different value if
1853  * anything has changed.
1854  *
1855  * In this implementation, we fetch the current value, set the QUERIED flag and
1856  * then try to swap it into place with a cmpxchg, if it wasn't already set. If
1857  * that fails, we try again with the newly fetched value from the cmpxchg.
1858  */
1859 u64 inode_query_iversion(struct inode *inode)
1860 {
1861         u64 cur, new;
1862
1863         cur = inode_peek_iversion_raw(inode);
1864         do {
1865                 /* If flag is already set, then no need to swap */
1866                 if (cur & I_VERSION_QUERIED) {
1867                         /*
1868                          * This barrier (and the implicit barrier in the
1869                          * cmpxchg below) pairs with the barrier in
1870                          * inode_maybe_inc_iversion().
1871                          */
1872                         smp_mb();
1873                         break;
1874                 }
1875
1876                 new = cur | I_VERSION_QUERIED;
1877         } while (!atomic64_try_cmpxchg(&inode->i_version, &cur, new));
1878         return cur >> I_VERSION_QUERIED_SHIFT;
1879 }
1880 EXPORT_SYMBOL(inode_query_iversion);
1881
1882 ssize_t direct_write_fallback(struct kiocb *iocb, struct iov_iter *iter,
1883                 ssize_t direct_written, ssize_t buffered_written)
1884 {
1885         struct address_space *mapping = iocb->ki_filp->f_mapping;
1886         loff_t pos = iocb->ki_pos - buffered_written;
1887         loff_t end = iocb->ki_pos - 1;
1888         int err;
1889
1890         /*
1891          * If the buffered write fallback returned an error, we want to return
1892          * the number of bytes which were written by direct I/O, or the error
1893          * code if that was zero.
1894          *
1895          * Note that this differs from normal direct-io semantics, which will
1896          * return -EFOO even if some bytes were written.
1897          */
1898         if (unlikely(buffered_written < 0)) {
1899                 if (direct_written)
1900                         return direct_written;
1901                 return buffered_written;
1902         }
1903
1904         /*
1905          * We need to ensure that the page cache pages are written to disk and
1906          * invalidated to preserve the expected O_DIRECT semantics.
1907          */
1908         err = filemap_write_and_wait_range(mapping, pos, end);
1909         if (err < 0) {
1910                 /*
1911                  * We don't know how much we wrote, so just return the number of
1912                  * bytes which were direct-written
1913                  */
1914                 iocb->ki_pos -= buffered_written;
1915                 if (direct_written)
1916                         return direct_written;
1917                 return err;
1918         }
1919         invalidate_mapping_pages(mapping, pos >> PAGE_SHIFT, end >> PAGE_SHIFT);
1920         return direct_written + buffered_written;
1921 }
1922 EXPORT_SYMBOL_GPL(direct_write_fallback);