1 // SPDX-License-Identifier: GPL-2.0-only
4 * Library for filesystems writers.
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>
26 #include <linux/uaccess.h>
30 int simple_getattr(struct user_namespace
*mnt_userns
, const struct path
*path
,
31 struct kstat
*stat
, u32 request_mask
,
32 unsigned int query_flags
)
34 struct inode
*inode
= d_inode(path
->dentry
);
35 generic_fillattr(&init_user_ns
, inode
, stat
);
36 stat
->blocks
= inode
->i_mapping
->nrpages
<< (PAGE_SHIFT
- 9);
39 EXPORT_SYMBOL(simple_getattr
);
41 int simple_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
43 buf
->f_type
= dentry
->d_sb
->s_magic
;
44 buf
->f_bsize
= PAGE_SIZE
;
45 buf
->f_namelen
= NAME_MAX
;
48 EXPORT_SYMBOL(simple_statfs
);
51 * Retaining negative dentries for an in-memory filesystem just wastes
52 * memory and lookup time: arrange for them to be deleted immediately.
54 int always_delete_dentry(const struct dentry
*dentry
)
58 EXPORT_SYMBOL(always_delete_dentry
);
60 const struct dentry_operations simple_dentry_operations
= {
61 .d_delete
= always_delete_dentry
,
63 EXPORT_SYMBOL(simple_dentry_operations
);
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.
69 struct dentry
*simple_lookup(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
71 if (dentry
->d_name
.len
> NAME_MAX
)
72 return ERR_PTR(-ENAMETOOLONG
);
73 if (!dentry
->d_sb
->s_d_op
)
74 d_set_d_op(dentry
, &simple_dentry_operations
);
78 EXPORT_SYMBOL(simple_lookup
);
80 int dcache_dir_open(struct inode
*inode
, struct file
*file
)
82 file
->private_data
= d_alloc_cursor(file
->f_path
.dentry
);
84 return file
->private_data
? 0 : -ENOMEM
;
86 EXPORT_SYMBOL(dcache_dir_open
);
88 int dcache_dir_close(struct inode
*inode
, struct file
*file
)
90 dput(file
->private_data
);
93 EXPORT_SYMBOL(dcache_dir_close
);
95 /* parent is locked at least shared */
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.
102 static struct dentry
*scan_positives(struct dentry
*cursor
,
107 struct dentry
*dentry
= cursor
->d_parent
, *found
= NULL
;
109 spin_lock(&dentry
->d_lock
);
110 while ((p
= p
->next
) != &dentry
->d_subdirs
) {
111 struct dentry
*d
= list_entry(p
, struct dentry
, d_child
);
112 // we must at least skip cursors, to avoid livelocks
113 if (d
->d_flags
& DCACHE_DENTRY_CURSOR
)
115 if (simple_positive(d
) && !--count
) {
116 spin_lock_nested(&d
->d_lock
, DENTRY_D_LOCK_NESTED
);
117 if (simple_positive(d
))
118 found
= dget_dlock(d
);
119 spin_unlock(&d
->d_lock
);
124 if (need_resched()) {
125 list_move(&cursor
->d_child
, p
);
126 p
= &cursor
->d_child
;
127 spin_unlock(&dentry
->d_lock
);
129 spin_lock(&dentry
->d_lock
);
132 spin_unlock(&dentry
->d_lock
);
137 loff_t
dcache_dir_lseek(struct file
*file
, loff_t offset
, int whence
)
139 struct dentry
*dentry
= file
->f_path
.dentry
;
142 offset
+= file
->f_pos
;
151 if (offset
!= file
->f_pos
) {
152 struct dentry
*cursor
= file
->private_data
;
153 struct dentry
*to
= NULL
;
155 inode_lock_shared(dentry
->d_inode
);
158 to
= scan_positives(cursor
, &dentry
->d_subdirs
,
160 spin_lock(&dentry
->d_lock
);
162 list_move(&cursor
->d_child
, &to
->d_child
);
164 list_del_init(&cursor
->d_child
);
165 spin_unlock(&dentry
->d_lock
);
168 file
->f_pos
= offset
;
170 inode_unlock_shared(dentry
->d_inode
);
174 EXPORT_SYMBOL(dcache_dir_lseek
);
176 /* Relationship between i_mode and the DT_xxx types */
177 static inline unsigned char dt_type(struct inode
*inode
)
179 return (inode
->i_mode
>> 12) & 15;
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.
188 int dcache_readdir(struct file
*file
, struct dir_context
*ctx
)
190 struct dentry
*dentry
= file
->f_path
.dentry
;
191 struct dentry
*cursor
= file
->private_data
;
192 struct list_head
*anchor
= &dentry
->d_subdirs
;
193 struct dentry
*next
= NULL
;
196 if (!dir_emit_dots(file
, ctx
))
201 else if (!list_empty(&cursor
->d_child
))
202 p
= &cursor
->d_child
;
206 while ((next
= scan_positives(cursor
, p
, 1, next
)) != NULL
) {
207 if (!dir_emit(ctx
, next
->d_name
.name
, next
->d_name
.len
,
208 d_inode(next
)->i_ino
, dt_type(d_inode(next
))))
213 spin_lock(&dentry
->d_lock
);
215 list_move_tail(&cursor
->d_child
, &next
->d_child
);
217 list_del_init(&cursor
->d_child
);
218 spin_unlock(&dentry
->d_lock
);
223 EXPORT_SYMBOL(dcache_readdir
);
225 ssize_t
generic_read_dir(struct file
*filp
, char __user
*buf
, size_t siz
, loff_t
*ppos
)
229 EXPORT_SYMBOL(generic_read_dir
);
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
,
239 EXPORT_SYMBOL(simple_dir_operations
);
241 const struct inode_operations simple_dir_inode_operations
= {
242 .lookup
= simple_lookup
,
244 EXPORT_SYMBOL(simple_dir_inode_operations
);
246 static struct dentry
*find_next_child(struct dentry
*parent
, struct dentry
*prev
)
248 struct dentry
*child
= NULL
;
249 struct list_head
*p
= prev
? &prev
->d_child
: &parent
->d_subdirs
;
251 spin_lock(&parent
->d_lock
);
252 while ((p
= p
->next
) != &parent
->d_subdirs
) {
253 struct dentry
*d
= container_of(p
, struct dentry
, d_child
);
254 if (simple_positive(d
)) {
255 spin_lock_nested(&d
->d_lock
, DENTRY_D_LOCK_NESTED
);
256 if (simple_positive(d
))
257 child
= dget_dlock(d
);
258 spin_unlock(&d
->d_lock
);
263 spin_unlock(&parent
->d_lock
);
268 void simple_recursive_removal(struct dentry
*dentry
,
269 void (*callback
)(struct dentry
*))
271 struct dentry
*this = dget(dentry
);
273 struct dentry
*victim
= NULL
, *child
;
274 struct inode
*inode
= this->d_inode
;
278 inode
->i_flags
|= S_DEAD
;
279 while ((child
= find_next_child(this, victim
)) == NULL
) {
281 // update metadata while it's still locked
282 inode
->i_ctime
= current_time(inode
);
286 this = this->d_parent
;
287 inode
= this->d_inode
;
289 if (simple_positive(victim
)) {
290 d_invalidate(victim
); // avoid lost mounts
291 if (d_is_dir(victim
))
292 fsnotify_rmdir(inode
, victim
);
294 fsnotify_unlink(inode
, victim
);
297 dput(victim
); // unpin it
299 if (victim
== dentry
) {
300 inode
->i_ctime
= inode
->i_mtime
=
302 if (d_is_dir(dentry
))
313 EXPORT_SYMBOL(simple_recursive_removal
);
315 static const struct super_operations simple_super_operations
= {
316 .statfs
= simple_statfs
,
319 static int pseudo_fs_fill_super(struct super_block
*s
, struct fs_context
*fc
)
321 struct pseudo_fs_context
*ctx
= fc
->fs_private
;
324 s
->s_maxbytes
= MAX_LFS_FILESIZE
;
325 s
->s_blocksize
= PAGE_SIZE
;
326 s
->s_blocksize_bits
= PAGE_SHIFT
;
327 s
->s_magic
= ctx
->magic
;
328 s
->s_op
= ctx
->ops
?: &simple_super_operations
;
329 s
->s_xattr
= ctx
->xattr
;
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).
341 root
->i_mode
= S_IFDIR
| S_IRUSR
| S_IWUSR
;
342 root
->i_atime
= root
->i_mtime
= root
->i_ctime
= current_time(root
);
343 s
->s_root
= d_make_root(root
);
346 s
->s_d_op
= ctx
->dops
;
350 static int pseudo_fs_get_tree(struct fs_context
*fc
)
352 return get_tree_nodev(fc
, pseudo_fs_fill_super
);
355 static void pseudo_fs_free(struct fs_context
*fc
)
357 kfree(fc
->fs_private
);
360 static const struct fs_context_operations pseudo_fs_context_ops
= {
361 .free
= pseudo_fs_free
,
362 .get_tree
= pseudo_fs_get_tree
,
366 * Common helper for pseudo-filesystems (sockfs, pipefs, bdev - stuff that
367 * will never be mountable)
369 struct pseudo_fs_context
*init_pseudo(struct fs_context
*fc
,
372 struct pseudo_fs_context
*ctx
;
374 ctx
= kzalloc(sizeof(struct pseudo_fs_context
), GFP_KERNEL
);
377 fc
->fs_private
= ctx
;
378 fc
->ops
= &pseudo_fs_context_ops
;
379 fc
->sb_flags
|= SB_NOUSER
;
384 EXPORT_SYMBOL(init_pseudo
);
386 int simple_open(struct inode
*inode
, struct file
*file
)
388 if (inode
->i_private
)
389 file
->private_data
= inode
->i_private
;
392 EXPORT_SYMBOL(simple_open
);
394 int simple_link(struct dentry
*old_dentry
, struct inode
*dir
, struct dentry
*dentry
)
396 struct inode
*inode
= d_inode(old_dentry
);
398 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= current_time(inode
);
402 d_instantiate(dentry
, inode
);
405 EXPORT_SYMBOL(simple_link
);
407 int simple_empty(struct dentry
*dentry
)
409 struct dentry
*child
;
412 spin_lock(&dentry
->d_lock
);
413 list_for_each_entry(child
, &dentry
->d_subdirs
, d_child
) {
414 spin_lock_nested(&child
->d_lock
, DENTRY_D_LOCK_NESTED
);
415 if (simple_positive(child
)) {
416 spin_unlock(&child
->d_lock
);
419 spin_unlock(&child
->d_lock
);
423 spin_unlock(&dentry
->d_lock
);
426 EXPORT_SYMBOL(simple_empty
);
428 int simple_unlink(struct inode
*dir
, struct dentry
*dentry
)
430 struct inode
*inode
= d_inode(dentry
);
432 inode
->i_ctime
= dir
->i_ctime
= dir
->i_mtime
= current_time(inode
);
437 EXPORT_SYMBOL(simple_unlink
);
439 int simple_rmdir(struct inode
*dir
, struct dentry
*dentry
)
441 if (!simple_empty(dentry
))
444 drop_nlink(d_inode(dentry
));
445 simple_unlink(dir
, dentry
);
449 EXPORT_SYMBOL(simple_rmdir
);
451 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
)
455 struct inode
*inode
= d_inode(old_dentry
);
456 int they_are_dirs
= d_is_dir(old_dentry
);
458 if (flags
& ~RENAME_NOREPLACE
)
461 if (!simple_empty(new_dentry
))
464 if (d_really_is_positive(new_dentry
)) {
465 simple_unlink(new_dir
, new_dentry
);
467 drop_nlink(d_inode(new_dentry
));
470 } else if (they_are_dirs
) {
475 old_dir
->i_ctime
= old_dir
->i_mtime
= new_dir
->i_ctime
=
476 new_dir
->i_mtime
= inode
->i_ctime
= current_time(old_dir
);
480 EXPORT_SYMBOL(simple_rename
);
483 * simple_setattr - setattr for simple filesystem
484 * @mnt_userns: user namespace of the target mount
486 * @iattr: iattr structure
488 * Returns 0 on success, -error on failure.
490 * simple_setattr is a simple ->setattr implementation without a proper
491 * implementation of size changes.
493 * It can either be used for in-memory filesystems or special files
494 * on simple regular filesystems. Anything that needs to change on-disk
495 * or wire state on size changes needs its own setattr method.
497 int simple_setattr(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
500 struct inode
*inode
= d_inode(dentry
);
503 error
= setattr_prepare(mnt_userns
, dentry
, iattr
);
507 if (iattr
->ia_valid
& ATTR_SIZE
)
508 truncate_setsize(inode
, iattr
->ia_size
);
509 setattr_copy(mnt_userns
, inode
, iattr
);
510 mark_inode_dirty(inode
);
513 EXPORT_SYMBOL(simple_setattr
);
515 static int simple_readpage(struct file
*file
, struct page
*page
)
517 clear_highpage(page
);
518 flush_dcache_page(page
);
519 SetPageUptodate(page
);
524 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
)
531 index
= pos
>> PAGE_SHIFT
;
533 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
539 if (!PageUptodate(page
) && (len
!= PAGE_SIZE
)) {
540 unsigned from
= pos
& (PAGE_SIZE
- 1);
542 zero_user_segments(page
, 0, from
, from
+ len
, PAGE_SIZE
);
546 EXPORT_SYMBOL(simple_write_begin
);
549 * simple_write_end - .write_end helper for non-block-device FSes
550 * @file: See .write_end of address_space_operations
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.
568 * Use *ONLY* with simple_readpage()
570 static 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
)
574 struct inode
*inode
= page
->mapping
->host
;
575 loff_t last_pos
= pos
+ copied
;
577 /* zero the stale part of the page if we did a short copy */
578 if (!PageUptodate(page
)) {
580 unsigned from
= pos
& (PAGE_SIZE
- 1);
582 zero_user(page
, from
+ copied
, len
- copied
);
584 SetPageUptodate(page
);
587 * No need to use i_size_read() here, the i_size
588 * cannot change under us because we hold the i_mutex.
590 if (last_pos
> inode
->i_size
)
591 i_size_write(inode
, last_pos
);
593 set_page_dirty(page
);
601 * Provides ramfs-style behavior: data in the pagecache, but no writeback.
603 const struct address_space_operations ram_aops
= {
604 .readpage
= simple_readpage
,
605 .write_begin
= simple_write_begin
,
606 .write_end
= simple_write_end
,
607 .set_page_dirty
= __set_page_dirty_no_writeback
,
609 EXPORT_SYMBOL(ram_aops
);
612 * the inodes created here are not hashed. If you use iunique to generate
613 * unique inode values later for this filesystem, then you must take care
614 * to pass it an appropriate max_reserved value to avoid collisions.
616 int simple_fill_super(struct super_block
*s
, unsigned long magic
,
617 const struct tree_descr
*files
)
621 struct dentry
*dentry
;
624 s
->s_blocksize
= PAGE_SIZE
;
625 s
->s_blocksize_bits
= PAGE_SHIFT
;
627 s
->s_op
= &simple_super_operations
;
630 inode
= new_inode(s
);
634 * because the root inode is 1, the files array must not contain an
638 inode
->i_mode
= S_IFDIR
| 0755;
639 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
640 inode
->i_op
= &simple_dir_inode_operations
;
641 inode
->i_fop
= &simple_dir_operations
;
643 root
= d_make_root(inode
);
646 for (i
= 0; !files
->name
|| files
->name
[0]; i
++, files
++) {
650 /* warn if it tries to conflict with the root inode */
651 if (unlikely(i
== 1))
652 printk(KERN_WARNING
"%s: %s passed in a files array"
653 "with an index of 1!\n", __func__
,
656 dentry
= d_alloc_name(root
, files
->name
);
659 inode
= new_inode(s
);
664 inode
->i_mode
= S_IFREG
| files
->mode
;
665 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
666 inode
->i_fop
= files
->ops
;
668 d_add(dentry
, inode
);
674 shrink_dcache_parent(root
);
678 EXPORT_SYMBOL(simple_fill_super
);
680 static DEFINE_SPINLOCK(pin_fs_lock
);
682 int simple_pin_fs(struct file_system_type
*type
, struct vfsmount
**mount
, int *count
)
684 struct vfsmount
*mnt
= NULL
;
685 spin_lock(&pin_fs_lock
);
686 if (unlikely(!*mount
)) {
687 spin_unlock(&pin_fs_lock
);
688 mnt
= vfs_kern_mount(type
, SB_KERNMOUNT
, type
->name
, NULL
);
691 spin_lock(&pin_fs_lock
);
697 spin_unlock(&pin_fs_lock
);
701 EXPORT_SYMBOL(simple_pin_fs
);
703 void simple_release_fs(struct vfsmount
**mount
, int *count
)
705 struct vfsmount
*mnt
;
706 spin_lock(&pin_fs_lock
);
710 spin_unlock(&pin_fs_lock
);
713 EXPORT_SYMBOL(simple_release_fs
);
716 * simple_read_from_buffer - copy data from the buffer to user space
717 * @to: the user space buffer to read to
718 * @count: the maximum number of bytes to read
719 * @ppos: the current position in the buffer
720 * @from: the buffer to read from
721 * @available: the size of the buffer
723 * The simple_read_from_buffer() function reads up to @count bytes from the
724 * buffer @from at offset @ppos into the user space address starting at @to.
726 * On success, the number of bytes read is returned and the offset @ppos is
727 * advanced by this number, or negative value is returned on error.
729 ssize_t
simple_read_from_buffer(void __user
*to
, size_t count
, loff_t
*ppos
,
730 const void *from
, size_t available
)
737 if (pos
>= available
|| !count
)
739 if (count
> available
- pos
)
740 count
= available
- pos
;
741 ret
= copy_to_user(to
, from
+ pos
, count
);
748 EXPORT_SYMBOL(simple_read_from_buffer
);
751 * simple_write_to_buffer - copy data from user space to the buffer
752 * @to: the buffer to write to
753 * @available: the size of the buffer
754 * @ppos: the current position in the buffer
755 * @from: the user space buffer to read from
756 * @count: the maximum number of bytes to read
758 * The simple_write_to_buffer() function reads up to @count bytes from the user
759 * space address starting at @from into the buffer @to at offset @ppos.
761 * On success, the number of bytes written is returned and the offset @ppos is
762 * advanced by this number, or negative value is returned on error.
764 ssize_t
simple_write_to_buffer(void *to
, size_t available
, loff_t
*ppos
,
765 const void __user
*from
, size_t count
)
772 if (pos
>= available
|| !count
)
774 if (count
> available
- pos
)
775 count
= available
- pos
;
776 res
= copy_from_user(to
+ pos
, from
, count
);
783 EXPORT_SYMBOL(simple_write_to_buffer
);
786 * memory_read_from_buffer - copy data from the buffer
787 * @to: the kernel space buffer to read to
788 * @count: the maximum number of bytes to read
789 * @ppos: the current position in the buffer
790 * @from: the buffer to read from
791 * @available: the size of the buffer
793 * The memory_read_from_buffer() function reads up to @count bytes from the
794 * buffer @from at offset @ppos into the kernel space address starting at @to.
796 * On success, the number of bytes read is returned and the offset @ppos is
797 * advanced by this number, or negative value is returned on error.
799 ssize_t
memory_read_from_buffer(void *to
, size_t count
, loff_t
*ppos
,
800 const void *from
, size_t available
)
806 if (pos
>= available
)
808 if (count
> available
- pos
)
809 count
= available
- pos
;
810 memcpy(to
, from
+ pos
, count
);
815 EXPORT_SYMBOL(memory_read_from_buffer
);
818 * Transaction based IO.
819 * The file expects a single write which triggers the transaction, and then
820 * possibly a read which collects the result - which is stored in a
824 void simple_transaction_set(struct file
*file
, size_t n
)
826 struct simple_transaction_argresp
*ar
= file
->private_data
;
828 BUG_ON(n
> SIMPLE_TRANSACTION_LIMIT
);
831 * The barrier ensures that ar->size will really remain zero until
832 * ar->data is ready for reading.
837 EXPORT_SYMBOL(simple_transaction_set
);
839 char *simple_transaction_get(struct file
*file
, const char __user
*buf
, size_t size
)
841 struct simple_transaction_argresp
*ar
;
842 static DEFINE_SPINLOCK(simple_transaction_lock
);
844 if (size
> SIMPLE_TRANSACTION_LIMIT
- 1)
845 return ERR_PTR(-EFBIG
);
847 ar
= (struct simple_transaction_argresp
*)get_zeroed_page(GFP_KERNEL
);
849 return ERR_PTR(-ENOMEM
);
851 spin_lock(&simple_transaction_lock
);
853 /* only one write allowed per open */
854 if (file
->private_data
) {
855 spin_unlock(&simple_transaction_lock
);
856 free_page((unsigned long)ar
);
857 return ERR_PTR(-EBUSY
);
860 file
->private_data
= ar
;
862 spin_unlock(&simple_transaction_lock
);
864 if (copy_from_user(ar
->data
, buf
, size
))
865 return ERR_PTR(-EFAULT
);
869 EXPORT_SYMBOL(simple_transaction_get
);
871 ssize_t
simple_transaction_read(struct file
*file
, char __user
*buf
, size_t size
, loff_t
*pos
)
873 struct simple_transaction_argresp
*ar
= file
->private_data
;
877 return simple_read_from_buffer(buf
, size
, pos
, ar
->data
, ar
->size
);
879 EXPORT_SYMBOL(simple_transaction_read
);
881 int simple_transaction_release(struct inode
*inode
, struct file
*file
)
883 free_page((unsigned long)file
->private_data
);
886 EXPORT_SYMBOL(simple_transaction_release
);
888 /* Simple attribute files */
891 int (*get
)(void *, u64
*);
892 int (*set
)(void *, u64
);
893 char get_buf
[24]; /* enough to store a u64 and "\n\0" */
896 const char *fmt
; /* format for read operation */
897 struct mutex mutex
; /* protects access to these buffers */
900 /* simple_attr_open is called by an actual attribute open file operation
901 * to set the attribute specific access operations. */
902 int simple_attr_open(struct inode
*inode
, struct file
*file
,
903 int (*get
)(void *, u64
*), int (*set
)(void *, u64
),
906 struct simple_attr
*attr
;
908 attr
= kzalloc(sizeof(*attr
), GFP_KERNEL
);
914 attr
->data
= inode
->i_private
;
916 mutex_init(&attr
->mutex
);
918 file
->private_data
= attr
;
920 return nonseekable_open(inode
, file
);
922 EXPORT_SYMBOL_GPL(simple_attr_open
);
924 int simple_attr_release(struct inode
*inode
, struct file
*file
)
926 kfree(file
->private_data
);
929 EXPORT_SYMBOL_GPL(simple_attr_release
); /* GPL-only? This? Really? */
931 /* read from the buffer that is filled with the get function */
932 ssize_t
simple_attr_read(struct file
*file
, char __user
*buf
,
933 size_t len
, loff_t
*ppos
)
935 struct simple_attr
*attr
;
939 attr
= file
->private_data
;
944 ret
= mutex_lock_interruptible(&attr
->mutex
);
948 if (*ppos
&& attr
->get_buf
[0]) {
950 size
= strlen(attr
->get_buf
);
954 ret
= attr
->get(attr
->data
, &val
);
958 size
= scnprintf(attr
->get_buf
, sizeof(attr
->get_buf
),
959 attr
->fmt
, (unsigned long long)val
);
962 ret
= simple_read_from_buffer(buf
, len
, ppos
, attr
->get_buf
, size
);
964 mutex_unlock(&attr
->mutex
);
967 EXPORT_SYMBOL_GPL(simple_attr_read
);
969 /* interpret the buffer as a number to call the set function with */
970 ssize_t
simple_attr_write(struct file
*file
, const char __user
*buf
,
971 size_t len
, loff_t
*ppos
)
973 struct simple_attr
*attr
;
974 unsigned long long val
;
978 attr
= file
->private_data
;
982 ret
= mutex_lock_interruptible(&attr
->mutex
);
987 size
= min(sizeof(attr
->set_buf
) - 1, len
);
988 if (copy_from_user(attr
->set_buf
, buf
, size
))
991 attr
->set_buf
[size
] = '\0';
992 ret
= kstrtoull(attr
->set_buf
, 0, &val
);
995 ret
= attr
->set(attr
->data
, val
);
997 ret
= len
; /* on success, claim we got the whole input */
999 mutex_unlock(&attr
->mutex
);
1002 EXPORT_SYMBOL_GPL(simple_attr_write
);
1005 * generic_fh_to_dentry - generic helper for the fh_to_dentry export operation
1006 * @sb: filesystem to do the file handle conversion on
1007 * @fid: file handle to convert
1008 * @fh_len: length of the file handle in bytes
1009 * @fh_type: type of file handle
1010 * @get_inode: filesystem callback to retrieve inode
1012 * This function decodes @fid as long as it has one of the well-known
1013 * Linux filehandle types and calls @get_inode on it to retrieve the
1014 * inode for the object specified in the file handle.
1016 struct dentry
*generic_fh_to_dentry(struct super_block
*sb
, struct fid
*fid
,
1017 int fh_len
, int fh_type
, struct inode
*(*get_inode
)
1018 (struct super_block
*sb
, u64 ino
, u32 gen
))
1020 struct inode
*inode
= NULL
;
1026 case FILEID_INO32_GEN
:
1027 case FILEID_INO32_GEN_PARENT
:
1028 inode
= get_inode(sb
, fid
->i32
.ino
, fid
->i32
.gen
);
1032 return d_obtain_alias(inode
);
1034 EXPORT_SYMBOL_GPL(generic_fh_to_dentry
);
1037 * generic_fh_to_parent - generic helper for the fh_to_parent export operation
1038 * @sb: filesystem to do the file handle conversion on
1039 * @fid: file handle to convert
1040 * @fh_len: length of the file handle in bytes
1041 * @fh_type: type of file handle
1042 * @get_inode: filesystem callback to retrieve inode
1044 * This function decodes @fid as long as it has one of the well-known
1045 * Linux filehandle types and calls @get_inode on it to retrieve the
1046 * inode for the _parent_ object specified in the file handle if it
1047 * is specified in the file handle, or NULL otherwise.
1049 struct dentry
*generic_fh_to_parent(struct super_block
*sb
, struct fid
*fid
,
1050 int fh_len
, int fh_type
, struct inode
*(*get_inode
)
1051 (struct super_block
*sb
, u64 ino
, u32 gen
))
1053 struct inode
*inode
= NULL
;
1059 case FILEID_INO32_GEN_PARENT
:
1060 inode
= get_inode(sb
, fid
->i32
.parent_ino
,
1061 (fh_len
> 3 ? fid
->i32
.parent_gen
: 0));
1065 return d_obtain_alias(inode
);
1067 EXPORT_SYMBOL_GPL(generic_fh_to_parent
);
1070 * __generic_file_fsync - generic fsync implementation for simple filesystems
1072 * @file: file to synchronize
1073 * @start: start offset in bytes
1074 * @end: end offset in bytes (inclusive)
1075 * @datasync: only synchronize essential metadata if true
1077 * This is a generic implementation of the fsync method for simple
1078 * filesystems which track all non-inode metadata in the buffers list
1079 * hanging off the address_space structure.
1081 int __generic_file_fsync(struct file
*file
, loff_t start
, loff_t end
,
1084 struct inode
*inode
= file
->f_mapping
->host
;
1088 err
= file_write_and_wait_range(file
, start
, end
);
1093 ret
= sync_mapping_buffers(inode
->i_mapping
);
1094 if (!(inode
->i_state
& I_DIRTY_ALL
))
1096 if (datasync
&& !(inode
->i_state
& I_DIRTY_DATASYNC
))
1099 err
= sync_inode_metadata(inode
, 1);
1104 inode_unlock(inode
);
1105 /* check and advance again to catch errors after syncing out buffers */
1106 err
= file_check_and_advance_wb_err(file
);
1111 EXPORT_SYMBOL(__generic_file_fsync
);
1114 * generic_file_fsync - generic fsync implementation for simple filesystems
1116 * @file: file to synchronize
1117 * @start: start offset in bytes
1118 * @end: end offset in bytes (inclusive)
1119 * @datasync: only synchronize essential metadata if true
1123 int generic_file_fsync(struct file
*file
, loff_t start
, loff_t end
,
1126 struct inode
*inode
= file
->f_mapping
->host
;
1129 err
= __generic_file_fsync(file
, start
, end
, datasync
);
1132 return blkdev_issue_flush(inode
->i_sb
->s_bdev
);
1134 EXPORT_SYMBOL(generic_file_fsync
);
1137 * generic_check_addressable - Check addressability of file system
1138 * @blocksize_bits: log of file system block size
1139 * @num_blocks: number of blocks in file system
1141 * Determine whether a file system with @num_blocks blocks (and a
1142 * block size of 2**@blocksize_bits) is addressable by the sector_t
1143 * and page cache of the system. Return 0 if so and -EFBIG otherwise.
1145 int generic_check_addressable(unsigned blocksize_bits
, u64 num_blocks
)
1147 u64 last_fs_block
= num_blocks
- 1;
1149 last_fs_block
>> (PAGE_SHIFT
- blocksize_bits
);
1151 if (unlikely(num_blocks
== 0))
1154 if ((blocksize_bits
< 9) || (blocksize_bits
> PAGE_SHIFT
))
1157 if ((last_fs_block
> (sector_t
)(~0ULL) >> (blocksize_bits
- 9)) ||
1158 (last_fs_page
> (pgoff_t
)(~0ULL))) {
1163 EXPORT_SYMBOL(generic_check_addressable
);
1166 * No-op implementation of ->fsync for in-memory filesystems.
1168 int noop_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
1172 EXPORT_SYMBOL(noop_fsync
);
1174 void noop_invalidatepage(struct page
*page
, unsigned int offset
,
1175 unsigned int length
)
1178 * There is no page cache to invalidate in the dax case, however
1179 * we need this callback defined to prevent falling back to
1180 * block_invalidatepage() in do_invalidatepage().
1183 EXPORT_SYMBOL_GPL(noop_invalidatepage
);
1185 ssize_t
noop_direct_IO(struct kiocb
*iocb
, struct iov_iter
*iter
)
1188 * iomap based filesystems support direct I/O without need for
1189 * this callback. However, it still needs to be set in
1190 * inode->a_ops so that open/fcntl know that direct I/O is
1191 * generally supported.
1195 EXPORT_SYMBOL_GPL(noop_direct_IO
);
1197 /* Because kfree isn't assignment-compatible with void(void*) ;-/ */
1198 void kfree_link(void *p
)
1202 EXPORT_SYMBOL(kfree_link
);
1204 struct inode
*alloc_anon_inode(struct super_block
*s
)
1206 static const struct address_space_operations anon_aops
= {
1207 .set_page_dirty
= __set_page_dirty_no_writeback
,
1209 struct inode
*inode
= new_inode_pseudo(s
);
1212 return ERR_PTR(-ENOMEM
);
1214 inode
->i_ino
= get_next_ino();
1215 inode
->i_mapping
->a_ops
= &anon_aops
;
1218 * Mark the inode dirty from the very beginning,
1219 * that way it will never be moved to the dirty
1220 * list because mark_inode_dirty() will think
1221 * that it already _is_ on the dirty list.
1223 inode
->i_state
= I_DIRTY
;
1224 inode
->i_mode
= S_IRUSR
| S_IWUSR
;
1225 inode
->i_uid
= current_fsuid();
1226 inode
->i_gid
= current_fsgid();
1227 inode
->i_flags
|= S_PRIVATE
;
1228 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
= current_time(inode
);
1231 EXPORT_SYMBOL(alloc_anon_inode
);
1234 * simple_nosetlease - generic helper for prohibiting leases
1235 * @filp: file pointer
1236 * @arg: type of lease to obtain
1237 * @flp: new lease supplied for insertion
1238 * @priv: private data for lm_setup operation
1240 * Generic helper for filesystems that do not wish to allow leases to be set.
1241 * All arguments are ignored and it just returns -EINVAL.
1244 simple_nosetlease(struct file
*filp
, long arg
, struct file_lock
**flp
,
1249 EXPORT_SYMBOL(simple_nosetlease
);
1252 * simple_get_link - generic helper to get the target of "fast" symlinks
1253 * @dentry: not used here
1254 * @inode: the symlink inode
1255 * @done: not used here
1257 * Generic helper for filesystems to use for symlink inodes where a pointer to
1258 * the symlink target is stored in ->i_link. NOTE: this isn't normally called,
1259 * since as an optimization the path lookup code uses any non-NULL ->i_link
1260 * directly, without calling ->get_link(). But ->get_link() still must be set,
1261 * to mark the inode_operations as being for a symlink.
1263 * Return: the symlink target
1265 const char *simple_get_link(struct dentry
*dentry
, struct inode
*inode
,
1266 struct delayed_call
*done
)
1268 return inode
->i_link
;
1270 EXPORT_SYMBOL(simple_get_link
);
1272 const struct inode_operations simple_symlink_inode_operations
= {
1273 .get_link
= simple_get_link
,
1275 EXPORT_SYMBOL(simple_symlink_inode_operations
);
1278 * Operations for a permanently empty directory.
1280 static struct dentry
*empty_dir_lookup(struct inode
*dir
, struct dentry
*dentry
, unsigned int flags
)
1282 return ERR_PTR(-ENOENT
);
1285 static int empty_dir_getattr(struct user_namespace
*mnt_userns
,
1286 const struct path
*path
, struct kstat
*stat
,
1287 u32 request_mask
, unsigned int query_flags
)
1289 struct inode
*inode
= d_inode(path
->dentry
);
1290 generic_fillattr(&init_user_ns
, inode
, stat
);
1294 static int empty_dir_setattr(struct user_namespace
*mnt_userns
,
1295 struct dentry
*dentry
, struct iattr
*attr
)
1300 static ssize_t
empty_dir_listxattr(struct dentry
*dentry
, char *list
, size_t size
)
1305 static const struct inode_operations empty_dir_inode_operations
= {
1306 .lookup
= empty_dir_lookup
,
1307 .permission
= generic_permission
,
1308 .setattr
= empty_dir_setattr
,
1309 .getattr
= empty_dir_getattr
,
1310 .listxattr
= empty_dir_listxattr
,
1313 static loff_t
empty_dir_llseek(struct file
*file
, loff_t offset
, int whence
)
1315 /* An empty directory has two entries . and .. at offsets 0 and 1 */
1316 return generic_file_llseek_size(file
, offset
, whence
, 2, 2);
1319 static int empty_dir_readdir(struct file
*file
, struct dir_context
*ctx
)
1321 dir_emit_dots(file
, ctx
);
1325 static const struct file_operations empty_dir_operations
= {
1326 .llseek
= empty_dir_llseek
,
1327 .read
= generic_read_dir
,
1328 .iterate_shared
= empty_dir_readdir
,
1329 .fsync
= noop_fsync
,
1333 void make_empty_dir_inode(struct inode
*inode
)
1335 set_nlink(inode
, 2);
1336 inode
->i_mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
1337 inode
->i_uid
= GLOBAL_ROOT_UID
;
1338 inode
->i_gid
= GLOBAL_ROOT_GID
;
1341 inode
->i_blkbits
= PAGE_SHIFT
;
1342 inode
->i_blocks
= 0;
1344 inode
->i_op
= &empty_dir_inode_operations
;
1345 inode
->i_opflags
&= ~IOP_XATTR
;
1346 inode
->i_fop
= &empty_dir_operations
;
1349 bool is_empty_dir_inode(struct inode
*inode
)
1351 return (inode
->i_fop
== &empty_dir_operations
) &&
1352 (inode
->i_op
== &empty_dir_inode_operations
);
1355 #ifdef CONFIG_UNICODE
1357 * Determine if the name of a dentry should be casefolded.
1359 * Return: if names will need casefolding
1361 static bool needs_casefold(const struct inode
*dir
)
1363 return IS_CASEFOLDED(dir
) && dir
->i_sb
->s_encoding
;
1367 * generic_ci_d_compare - generic d_compare implementation for casefolding filesystems
1368 * @dentry: dentry whose name we are checking against
1369 * @len: len of name of dentry
1370 * @str: str pointer to name of dentry
1371 * @name: Name to compare against
1373 * Return: 0 if names match, 1 if mismatch, or -ERRNO
1375 static int generic_ci_d_compare(const struct dentry
*dentry
, unsigned int len
,
1376 const char *str
, const struct qstr
*name
)
1378 const struct dentry
*parent
= READ_ONCE(dentry
->d_parent
);
1379 const struct inode
*dir
= READ_ONCE(parent
->d_inode
);
1380 const struct super_block
*sb
= dentry
->d_sb
;
1381 const struct unicode_map
*um
= sb
->s_encoding
;
1382 struct qstr qstr
= QSTR_INIT(str
, len
);
1383 char strbuf
[DNAME_INLINE_LEN
];
1386 if (!dir
|| !needs_casefold(dir
))
1389 * If the dentry name is stored in-line, then it may be concurrently
1390 * modified by a rename. If this happens, the VFS will eventually retry
1391 * the lookup, so it doesn't matter what ->d_compare() returns.
1392 * However, it's unsafe to call utf8_strncasecmp() with an unstable
1393 * string. Therefore, we have to copy the name into a temporary buffer.
1395 if (len
<= DNAME_INLINE_LEN
- 1) {
1396 memcpy(strbuf
, str
, len
);
1399 /* prevent compiler from optimizing out the temporary buffer */
1402 ret
= utf8_strncasecmp(um
, name
, &qstr
);
1406 if (sb_has_strict_encoding(sb
))
1409 if (len
!= name
->len
)
1411 return !!memcmp(str
, name
->name
, len
);
1415 * generic_ci_d_hash - generic d_hash implementation for casefolding filesystems
1416 * @dentry: dentry of the parent directory
1417 * @str: qstr of name whose hash we should fill in
1419 * Return: 0 if hash was successful or unchanged, and -EINVAL on error
1421 static int generic_ci_d_hash(const struct dentry
*dentry
, struct qstr
*str
)
1423 const struct inode
*dir
= READ_ONCE(dentry
->d_inode
);
1424 struct super_block
*sb
= dentry
->d_sb
;
1425 const struct unicode_map
*um
= sb
->s_encoding
;
1428 if (!dir
|| !needs_casefold(dir
))
1431 ret
= utf8_casefold_hash(um
, dentry
, str
);
1432 if (ret
< 0 && sb_has_strict_encoding(sb
))
1437 static const struct dentry_operations generic_ci_dentry_ops
= {
1438 .d_hash
= generic_ci_d_hash
,
1439 .d_compare
= generic_ci_d_compare
,
1443 #ifdef CONFIG_FS_ENCRYPTION
1444 static const struct dentry_operations generic_encrypted_dentry_ops
= {
1445 .d_revalidate
= fscrypt_d_revalidate
,
1449 #if defined(CONFIG_FS_ENCRYPTION) && defined(CONFIG_UNICODE)
1450 static const struct dentry_operations generic_encrypted_ci_dentry_ops
= {
1451 .d_hash
= generic_ci_d_hash
,
1452 .d_compare
= generic_ci_d_compare
,
1453 .d_revalidate
= fscrypt_d_revalidate
,
1458 * generic_set_encrypted_ci_d_ops - helper for setting d_ops for given dentry
1459 * @dentry: dentry to set ops on
1461 * Casefolded directories need d_hash and d_compare set, so that the dentries
1462 * contained in them are handled case-insensitively. Note that these operations
1463 * are needed on the parent directory rather than on the dentries in it, and
1464 * while the casefolding flag can be toggled on and off on an empty directory,
1465 * dentry_operations can't be changed later. As a result, if the filesystem has
1466 * casefolding support enabled at all, we have to give all dentries the
1467 * casefolding operations even if their inode doesn't have the casefolding flag
1468 * currently (and thus the casefolding ops would be no-ops for now).
1470 * Encryption works differently in that the only dentry operation it needs is
1471 * d_revalidate, which it only needs on dentries that have the no-key name flag.
1472 * The no-key flag can't be set "later", so we don't have to worry about that.
1474 * Finally, to maximize compatibility with overlayfs (which isn't compatible
1475 * with certain dentry operations) and to avoid taking an unnecessary
1476 * performance hit, we use custom dentry_operations for each possible
1477 * combination rather than always installing all operations.
1479 void generic_set_encrypted_ci_d_ops(struct dentry
*dentry
)
1481 #ifdef CONFIG_FS_ENCRYPTION
1482 bool needs_encrypt_ops
= dentry
->d_flags
& DCACHE_NOKEY_NAME
;
1484 #ifdef CONFIG_UNICODE
1485 bool needs_ci_ops
= dentry
->d_sb
->s_encoding
;
1487 #if defined(CONFIG_FS_ENCRYPTION) && defined(CONFIG_UNICODE)
1488 if (needs_encrypt_ops
&& needs_ci_ops
) {
1489 d_set_d_op(dentry
, &generic_encrypted_ci_dentry_ops
);
1493 #ifdef CONFIG_FS_ENCRYPTION
1494 if (needs_encrypt_ops
) {
1495 d_set_d_op(dentry
, &generic_encrypted_dentry_ops
);
1499 #ifdef CONFIG_UNICODE
1501 d_set_d_op(dentry
, &generic_ci_dentry_ops
);
1506 EXPORT_SYMBOL(generic_set_encrypted_ci_d_ops
);