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