// SPDX-License-Identifier: GPL-2.0-only/* *	fs/libfs.c *	Library for filesystems writers. */ #include <linux/blkdev.h>#include <linux/export.h>#include <linux/pagemap.h>#include <linux/slab.h>#include <linux/cred.h>#include <linux/mount.h>#include <linux/vfs.h>#include <linux/quotaops.h>#include <linux/mutex.h>#include <linux/namei.h>#include <linux/exportfs.h>#include <linux/iversion.h>#include <linux/writeback.h>#include <linux/buffer_head.h> /* sync_mapping_buffers */#include <linux/fs_context.h>#include <linux/pseudo_fs.h>#include <linux/fsnotify.h>#include <linux/unicode.h>#include <linux/fscrypt.h>#include <linux/pidfs.h> #include <linux/uaccess.h> #include "internal.h" int simple_getattr(struct mnt_idmap *idmap, const struct path *path,		   struct kstat *stat, u32 request_mask,		   unsigned int query_flags){	struct inode *inode = d_inode(path->dentry);	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);	stat->blocks = inode->i_mapping->nrpages << (PAGE_SHIFT - 9);	return 0;}EXPORT_SYMBOL(simple_getattr); int simple_statfs(struct dentry *dentry, struct kstatfs *buf){	u64 id = huge_encode_dev(dentry->d_sb->s_dev); 	buf->f_fsid = u64_to_fsid(id);	buf->f_type = dentry->d_sb->s_magic;	buf->f_bsize = PAGE_SIZE;	buf->f_namelen = NAME_MAX;	return 0;}EXPORT_SYMBOL(simple_statfs); /* * Retaining negative dentries for an in-memory filesystem just wastes * memory and lookup time: arrange for them to be deleted immediately. */int always_delete_dentry(const struct dentry *dentry){	return 1;}EXPORT_SYMBOL(always_delete_dentry); const struct dentry_operations simple_dentry_operations = {	.d_delete = always_delete_dentry,};EXPORT_SYMBOL(simple_dentry_operations); /* * Lookup the data. This is trivial - if the dentry didn't already * exist, we know it is negative.  Set d_op to delete negative dentries. */struct dentry *simple_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags){	if (dentry->d_name.len > NAME_MAX)		return ERR_PTR(-ENAMETOOLONG);	if (!dentry->d_sb->s_d_op)		d_set_d_op(dentry, &simple_dentry_operations); 	if (IS_ENABLED(CONFIG_UNICODE) && IS_CASEFOLDED(dir))		return NULL; 	d_add(dentry, NULL);	return NULL;}EXPORT_SYMBOL(simple_lookup); int dcache_dir_open(struct inode *inode, struct file *file){	file->private_data = d_alloc_cursor(file->f_path.dentry); 	return file->private_data ? 0 : -ENOMEM;}EXPORT_SYMBOL(dcache_dir_open); int dcache_dir_close(struct inode *inode, struct file *file){	dput(file->private_data);	return 0;}EXPORT_SYMBOL(dcache_dir_close); /* parent is locked at least shared *//* * Returns an element of siblings' list. * We are looking for <count>th positive after <p>; if * found, dentry is grabbed and returned to caller. * If no such element exists, NULL is returned. */static struct dentry *scan_positives(struct dentry *cursor,					struct hlist_node **p,					loff_t count,					struct dentry *last){	struct dentry *dentry = cursor->d_parent, *found = NULL; 	spin_lock(&dentry->d_lock);	while (*p) {		struct dentry *d = hlist_entry(*p, struct dentry, d_sib);		p = &d->d_sib.next;		// we must at least skip cursors, to avoid livelocks		if (d->d_flags & DCACHE_DENTRY_CURSOR)			continue;		if (simple_positive(d) && !--count) {			spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);			if (simple_positive(d))				found = dget_dlock(d);			spin_unlock(&d->d_lock);			if (likely(found))				break;			count = 1;		}		if (need_resched()) {			if (!hlist_unhashed(&cursor->d_sib))				__hlist_del(&cursor->d_sib);			hlist_add_behind(&cursor->d_sib, &d->d_sib);			p = &cursor->d_sib.next;			spin_unlock(&dentry->d_lock);			cond_resched();			spin_lock(&dentry->d_lock);		}	}	spin_unlock(&dentry->d_lock);	dput(last);	return found;} loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence){	struct dentry *dentry = file->f_path.dentry;	switch (whence) {		case 1:			offset += file->f_pos;			fallthrough;		case 0:			if (offset >= 0)				break;			fallthrough;		default:			return -EINVAL;	}	if (offset != file->f_pos) {		struct dentry *cursor = file->private_data;		struct dentry *to = NULL; 		inode_lock_shared(dentry->d_inode); 		if (offset > 2)			to = scan_positives(cursor, &dentry->d_children.first,					    offset - 2, NULL);		spin_lock(&dentry->d_lock);		hlist_del_init(&cursor->d_sib);		if (to)			hlist_add_behind(&cursor->d_sib, &to->d_sib);		spin_unlock(&dentry->d_lock);		dput(to); 		file->f_pos = offset; 		inode_unlock_shared(dentry->d_inode);	}	return offset;}EXPORT_SYMBOL(dcache_dir_lseek); /* * Directory is locked and all positive dentries in it are safe, since * for ramfs-type trees they can't go away without unlink() or rmdir(), * both impossible due to the lock on directory. */ int dcache_readdir(struct file *file, struct dir_context *ctx){	struct dentry *dentry = file->f_path.dentry;	struct dentry *cursor = file->private_data;	struct dentry *next = NULL;	struct hlist_node **p; 	if (!dir_emit_dots(file, ctx))		return 0; 	if (ctx->pos == 2)		p = &dentry->d_children.first;	else		p = &cursor->d_sib.next; 	while ((next = scan_positives(cursor, p, 1, next)) != NULL) {		if (!dir_emit(ctx, next->d_name.name, next->d_name.len,			      d_inode(next)->i_ino,			      fs_umode_to_dtype(d_inode(next)->i_mode)))			break;		ctx->pos++;		p = &next->d_sib.next;	}	spin_lock(&dentry->d_lock);	hlist_del_init(&cursor->d_sib);	if (next)		hlist_add_before(&cursor->d_sib, &next->d_sib);	spin_unlock(&dentry->d_lock);	dput(next); 	return 0;}EXPORT_SYMBOL(dcache_readdir); ssize_t generic_read_dir(struct file *filp, char __user *buf, size_t siz, loff_t *ppos){	return -EISDIR;}EXPORT_SYMBOL(generic_read_dir); const struct file_operations simple_dir_operations = {	.open		= dcache_dir_open,	.release	= dcache_dir_close,	.llseek		= dcache_dir_lseek,	.read		= generic_read_dir,	.iterate_shared	= dcache_readdir,	.fsync		= noop_fsync,};EXPORT_SYMBOL(simple_dir_operations); const struct inode_operations simple_dir_inode_operations = {	.lookup		= simple_lookup,};EXPORT_SYMBOL(simple_dir_inode_operations); /* 0 is '.', 1 is '..', so always start with offset 2 or more */enum {	DIR_OFFSET_MIN	= 2,}; static void offset_set(struct dentry *dentry, long offset){	dentry->d_fsdata = (void *)offset;} static long dentry2offset(struct dentry *dentry){	return (long)dentry->d_fsdata;} static struct lock_class_key simple_offset_lock_class; /** * simple_offset_init - initialize an offset_ctx * @octx: directory offset map to be initialized * */void simple_offset_init(struct offset_ctx *octx){	mt_init_flags(&octx->mt, MT_FLAGS_ALLOC_RANGE);	lockdep_set_class(&octx->mt.ma_lock, &simple_offset_lock_class);	octx->next_offset = DIR_OFFSET_MIN;} /** * simple_offset_add - Add an entry to a directory's offset map * @octx: directory offset ctx to be updated * @dentry: new dentry being added * * Returns zero on success. @octx and the dentry's offset are updated. * Otherwise, a negative errno value is returned. */int simple_offset_add(struct offset_ctx *octx, struct dentry *dentry){	unsigned long offset;	int ret; 	if (dentry2offset(dentry) != 0)		return -EBUSY; 	ret = mtree_alloc_cyclic(&octx->mt, &offset, dentry, DIR_OFFSET_MIN,				 LONG_MAX, &octx->next_offset, GFP_KERNEL);	if (ret < 0)		return ret; 	offset_set(dentry, offset);	return 0;} static int simple_offset_replace(struct offset_ctx *octx, struct dentry *dentry,				 long offset){	int ret; 	ret = mtree_store(&octx->mt, offset, dentry, GFP_KERNEL);	if (ret)		return ret;	offset_set(dentry, offset);	return 0;} /** * simple_offset_remove - Remove an entry to a directory's offset map * @octx: directory offset ctx to be updated * @dentry: dentry being removed * */void simple_offset_remove(struct offset_ctx *octx, struct dentry *dentry){	long offset; 	offset = dentry2offset(dentry);	if (offset == 0)		return; 	mtree_erase(&octx->mt, offset);	offset_set(dentry, 0);} /** * simple_offset_empty - Check if a dentry can be unlinked * @dentry: dentry to be tested * * Returns 0 if @dentry is a non-empty directory; otherwise returns 1. */int simple_offset_empty(struct dentry *dentry){	struct inode *inode = d_inode(dentry);	struct offset_ctx *octx;	struct dentry *child;	unsigned long index;	int ret = 1; 	if (!inode || !S_ISDIR(inode->i_mode))		return ret; 	index = DIR_OFFSET_MIN;	octx = inode->i_op->get_offset_ctx(inode);	mt_for_each(&octx->mt, child, index, LONG_MAX) {		spin_lock(&child->d_lock);		if (simple_positive(child)) {			spin_unlock(&child->d_lock);			ret = 0;			break;		}		spin_unlock(&child->d_lock);	} 	return ret;} /** * simple_offset_rename - handle directory offsets for rename * @old_dir: parent directory of source entry * @old_dentry: dentry of source entry * @new_dir: parent_directory of destination entry * @new_dentry: dentry of destination * * Caller provides appropriate serialization. * * User space expects the directory offset value of the replaced * (new) directory entry to be unchanged after a rename. * * Returns zero on success, a negative errno value on failure. */int simple_offset_rename(struct inode *old_dir, struct dentry *old_dentry,			 struct inode *new_dir, struct dentry *new_dentry){	struct offset_ctx *old_ctx = old_dir->i_op->get_offset_ctx(old_dir);	struct offset_ctx *new_ctx = new_dir->i_op->get_offset_ctx(new_dir);	long new_offset = dentry2offset(new_dentry); 	simple_offset_remove(old_ctx, old_dentry); 	if (new_offset) {		offset_set(new_dentry, 0);		return simple_offset_replace(new_ctx, old_dentry, new_offset);	}	return simple_offset_add(new_ctx, old_dentry);} /** * simple_offset_rename_exchange - exchange rename with directory offsets * @old_dir: parent of dentry being moved * @old_dentry: dentry being moved * @new_dir: destination parent * @new_dentry: destination dentry * * This API preserves the directory offset values. Caller provides * appropriate serialization. * * Returns zero on success. Otherwise a negative errno is returned and the * rename is rolled back. */int simple_offset_rename_exchange(struct inode *old_dir,				  struct dentry *old_dentry,				  struct inode *new_dir,				  struct dentry *new_dentry){	struct offset_ctx *old_ctx = old_dir->i_op->get_offset_ctx(old_dir);	struct offset_ctx *new_ctx = new_dir->i_op->get_offset_ctx(new_dir);	long old_index = dentry2offset(old_dentry);	long new_index = dentry2offset(new_dentry);	int ret; 	simple_offset_remove(old_ctx, old_dentry);	simple_offset_remove(new_ctx, new_dentry); 	ret = simple_offset_replace(new_ctx, old_dentry, new_index);	if (ret)		goto out_restore; 	ret = simple_offset_replace(old_ctx, new_dentry, old_index);	if (ret) {		simple_offset_remove(new_ctx, old_dentry);		goto out_restore;	} 	ret = simple_rename_exchange(old_dir, old_dentry, new_dir, new_dentry);	if (ret) {		simple_offset_remove(new_ctx, old_dentry);		simple_offset_remove(old_ctx, new_dentry);		goto out_restore;	}	return 0; out_restore:	(void)simple_offset_replace(old_ctx, old_dentry, old_index);	(void)simple_offset_replace(new_ctx, new_dentry, new_index);	return ret;} /** * simple_offset_destroy - Release offset map * @octx: directory offset ctx that is about to be destroyed * * During fs teardown (eg. umount), a directory's offset map might still * contain entries. xa_destroy() cleans out anything that remains. */void simple_offset_destroy(struct offset_ctx *octx){	mtree_destroy(&octx->mt);} static int offset_dir_open(struct inode *inode, struct file *file){	struct offset_ctx *ctx = inode->i_op->get_offset_ctx(inode); 	file->private_data = (void *)ctx->next_offset;	return 0;} /** * offset_dir_llseek - Advance the read position of a directory descriptor * @file: an open directory whose position is to be updated * @offset: a byte offset * @whence: enumerator describing the starting position for this update * * SEEK_END, SEEK_DATA, and SEEK_HOLE are not supported for directories. * * Returns the updated read position if successful; otherwise a * negative errno is returned and the read position remains unchanged. */static loff_t offset_dir_llseek(struct file *file, loff_t offset, int whence){	struct inode *inode = file->f_inode;	struct offset_ctx *ctx = inode->i_op->get_offset_ctx(inode); 	switch (whence) {	case SEEK_CUR:		offset += file->f_pos;		fallthrough;	case SEEK_SET:		if (offset >= 0)			break;		fallthrough;	default:		return -EINVAL;	} 	/* In this case, ->private_data is protected by f_pos_lock */	if (!offset)		file->private_data = (void *)ctx->next_offset;	return vfs_setpos(file, offset, LONG_MAX);} static struct dentry *offset_find_next(struct offset_ctx *octx, loff_t offset){

Lines 1–500 of 2264. Load more