1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * NILFS ioctl operations.
   4 *
   5 * Copyright (C) 2007, 2008 Nippon Telegraph and Telephone Corporation.
   6 *
   7 * Written by Koji Sato.
   8 */
   9
  10#include <linux/fs.h>
  11#include <linux/wait.h>
  12#include <linux/slab.h>
  13#include <linux/capability.h>	/* capable() */
  14#include <linux/uaccess.h>	/* copy_from_user(), copy_to_user() */
  15#include <linux/vmalloc.h>
  16#include <linux/compat.h>	/* compat_ptr() */
  17#include <linux/mount.h>	/* mnt_want_write_file(), mnt_drop_write_file() */
  18#include <linux/buffer_head.h>
  19#include <linux/fileattr.h>
  20#include "nilfs.h"
  21#include "segment.h"
  22#include "bmap.h"
  23#include "cpfile.h"
  24#include "sufile.h"
  25#include "dat.h"
  26
  27/**
  28 * nilfs_ioctl_wrap_copy - wrapping function of get/set metadata info
  29 * @nilfs: nilfs object
  30 * @argv: vector of arguments from userspace
  31 * @dir: set of direction flags
  32 * @dofunc: concrete function of get/set metadata info
  33 *
  34 * Description: nilfs_ioctl_wrap_copy() gets/sets metadata info by means of
  35 * calling dofunc() function on the basis of @argv argument.
  36 *
  37 * Return Value: On success, 0 is returned and requested metadata info
  38 * is copied into userspace. On error, one of the following
  39 * negative error codes is returned.
  40 *
  41 * %-EINVAL - Invalid arguments from userspace.
  42 *
  43 * %-ENOMEM - Insufficient amount of memory available.
  44 *
  45 * %-EFAULT - Failure during execution of requested operation.
  46 */
  47static int nilfs_ioctl_wrap_copy(struct the_nilfs *nilfs,
  48				 struct nilfs_argv *argv, int dir,
  49				 ssize_t (*dofunc)(struct the_nilfs *,
  50						   __u64 *, int,
  51						   void *, size_t, size_t))
  52{
  53	void *buf;
  54	void __user *base = (void __user *)(unsigned long)argv->v_base;
  55	size_t maxmembs, total, n;
  56	ssize_t nr;
  57	int ret, i;
  58	__u64 pos, ppos;
  59
  60	if (argv->v_nmembs == 0)
  61		return 0;
  62
  63	if (argv->v_size > PAGE_SIZE)
  64		return -EINVAL;
  65
  66	/*
  67	 * Reject pairs of a start item position (argv->v_index) and a
  68	 * total count (argv->v_nmembs) which leads position 'pos' to
  69	 * overflow by the increment at the end of the loop.
  70	 */
  71	if (argv->v_index > ~(__u64)0 - argv->v_nmembs)
  72		return -EINVAL;
  73
  74	buf = (void *)get_zeroed_page(GFP_NOFS);
  75	if (unlikely(!buf))
  76		return -ENOMEM;
  77	maxmembs = PAGE_SIZE / argv->v_size;
  78
  79	ret = 0;
  80	total = 0;
  81	pos = argv->v_index;
  82	for (i = 0; i < argv->v_nmembs; i += n) {
  83		n = (argv->v_nmembs - i < maxmembs) ?
  84			argv->v_nmembs - i : maxmembs;
  85		if ((dir & _IOC_WRITE) &&
  86		    copy_from_user(buf, base + argv->v_size * i,
  87				   argv->v_size * n)) {
  88			ret = -EFAULT;
  89			break;
  90		}
  91		ppos = pos;
  92		nr = dofunc(nilfs, &pos, argv->v_flags, buf, argv->v_size,
  93			       n);
  94		if (nr < 0) {
  95			ret = nr;
  96			break;
  97		}
  98		if ((dir & _IOC_READ) &&
  99		    copy_to_user(base + argv->v_size * i, buf,
 100				 argv->v_size * nr)) {
 101			ret = -EFAULT;
 102			break;
 103		}
 104		total += nr;
 105		if ((size_t)nr < n)
 106			break;
 107		if (pos == ppos)
 108			pos += n;
 109	}
 110	argv->v_nmembs = total;
 111
 112	free_pages((unsigned long)buf, 0);
 113	return ret;
 114}
 115
 116/**
 117 * nilfs_fileattr_get - ioctl to support lsattr
 118 */
 119int nilfs_fileattr_get(struct dentry *dentry, struct fileattr *fa)
 120{
 121	struct inode *inode = d_inode(dentry);
 122
 123	fileattr_fill_flags(fa, NILFS_I(inode)->i_flags & FS_FL_USER_VISIBLE);
 124
 125	return 0;
 126}
 127
 128/**
 129 * nilfs_fileattr_set - ioctl to support chattr
 130 */
 131int nilfs_fileattr_set(struct mnt_idmap *idmap,
 132		       struct dentry *dentry, struct fileattr *fa)
 133{
 134	struct inode *inode = d_inode(dentry);
 135	struct nilfs_transaction_info ti;
 136	unsigned int flags, oldflags;
 137	int ret;
 138
 139	if (fileattr_has_fsx(fa))
 140		return -EOPNOTSUPP;
 141
 142	flags = nilfs_mask_flags(inode->i_mode, fa->flags);
 143
 144	ret = nilfs_transaction_begin(inode->i_sb, &ti, 0);
 145	if (ret)
 146		return ret;
 147
 148	oldflags = NILFS_I(inode)->i_flags & ~FS_FL_USER_MODIFIABLE;
 149	NILFS_I(inode)->i_flags = oldflags | (flags & FS_FL_USER_MODIFIABLE);
 150
 151	nilfs_set_inode_flags(inode);
 152	inode_set_ctime_current(inode);
 153	if (IS_SYNC(inode))
 154		nilfs_set_transaction_flag(NILFS_TI_SYNC);
 155
 156	nilfs_mark_inode_dirty(inode);
 157	return nilfs_transaction_commit(inode->i_sb);
 158}
 159
 160/**
 161 * nilfs_ioctl_getversion - get info about a file's version (generation number)
 162 */
 163static int nilfs_ioctl_getversion(struct inode *inode, void __user *argp)
 164{
 165	return put_user(inode->i_generation, (int __user *)argp);
 166}
 167
 168/**
 169 * nilfs_ioctl_change_cpmode - change checkpoint mode (checkpoint/snapshot)
 170 * @inode: inode object
 171 * @filp: file object
 172 * @cmd: ioctl's request code
 173 * @argp: pointer on argument from userspace
 174 *
 175 * Description: nilfs_ioctl_change_cpmode() function changes mode of
 176 * given checkpoint between checkpoint and snapshot state. This ioctl
 177 * is used in chcp and mkcp utilities.
 178 *
 179 * Return Value: On success, 0 is returned and mode of a checkpoint is
 180 * changed. On error, one of the following negative error codes
 181 * is returned.
 182 *
 183 * %-EPERM - Operation not permitted.
 184 *
 185 * %-EFAULT - Failure during checkpoint mode changing.
 186 */
 187static int nilfs_ioctl_change_cpmode(struct inode *inode, struct file *filp,
 188				     unsigned int cmd, void __user *argp)
 189{
 190	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
 191	struct nilfs_transaction_info ti;
 192	struct nilfs_cpmode cpmode;
 193	int ret;
 194
 195	if (!capable(CAP_SYS_ADMIN))
 196		return -EPERM;
 197
 198	ret = mnt_want_write_file(filp);
 199	if (ret)
 200		return ret;
 201
 202	ret = -EFAULT;
 203	if (copy_from_user(&cpmode, argp, sizeof(cpmode)))
 204		goto out;
 205
 206	mutex_lock(&nilfs->ns_snapshot_mount_mutex);
 207
 208	nilfs_transaction_begin(inode->i_sb, &ti, 0);
 209	ret = nilfs_cpfile_change_cpmode(
 210		nilfs->ns_cpfile, cpmode.cm_cno, cpmode.cm_mode);
 211	if (unlikely(ret < 0))
 212		nilfs_transaction_abort(inode->i_sb);
 213	else
 214		nilfs_transaction_commit(inode->i_sb); /* never fails */
 215
 216	mutex_unlock(&nilfs->ns_snapshot_mount_mutex);
 217out:
 218	mnt_drop_write_file(filp);
 219	return ret;
 220}
 221
 222/**
 223 * nilfs_ioctl_delete_checkpoint - remove checkpoint
 224 * @inode: inode object
 225 * @filp: file object
 226 * @cmd: ioctl's request code
 227 * @argp: pointer on argument from userspace
 228 *
 229 * Description: nilfs_ioctl_delete_checkpoint() function removes
 230 * checkpoint from NILFS2 file system. This ioctl is used in rmcp
 231 * utility.
 232 *
 233 * Return Value: On success, 0 is returned and a checkpoint is
 234 * removed. On error, one of the following negative error codes
 235 * is returned.
 236 *
 237 * %-EPERM - Operation not permitted.
 238 *
 239 * %-EFAULT - Failure during checkpoint removing.
 240 */
 241static int
 242nilfs_ioctl_delete_checkpoint(struct inode *inode, struct file *filp,
 243			      unsigned int cmd, void __user *argp)
 244{
 245	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
 246	struct nilfs_transaction_info ti;
 247	__u64 cno;
 248	int ret;
 249
 250	if (!capable(CAP_SYS_ADMIN))
 251		return -EPERM;
 252
 253	ret = mnt_want_write_file(filp);
 254	if (ret)
 255		return ret;
 256
 257	ret = -EFAULT;
 258	if (copy_from_user(&cno, argp, sizeof(cno)))
 259		goto out;
 260
 261	nilfs_transaction_begin(inode->i_sb, &ti, 0);
 262	ret = nilfs_cpfile_delete_checkpoint(nilfs->ns_cpfile, cno);
 263	if (unlikely(ret < 0))
 264		nilfs_transaction_abort(inode->i_sb);
 265	else
 266		nilfs_transaction_commit(inode->i_sb); /* never fails */
 267out:
 268	mnt_drop_write_file(filp);
 269	return ret;
 270}
 271
 272/**
 273 * nilfs_ioctl_do_get_cpinfo - callback method getting info about checkpoints
 274 * @nilfs: nilfs object
 275 * @posp: pointer on array of checkpoint's numbers
 276 * @flags: checkpoint mode (checkpoint or snapshot)
 277 * @buf: buffer for storing checkponts' info
 278 * @size: size in bytes of one checkpoint info item in array
 279 * @nmembs: number of checkpoints in array (numbers and infos)
 280 *
 281 * Description: nilfs_ioctl_do_get_cpinfo() function returns info about
 282 * requested checkpoints. The NILFS_IOCTL_GET_CPINFO ioctl is used in
 283 * lscp utility and by nilfs_cleanerd daemon.
 284 *
 285 * Return value: count of nilfs_cpinfo structures in output buffer.
 286 */
 287static ssize_t
 288nilfs_ioctl_do_get_cpinfo(struct the_nilfs *nilfs, __u64 *posp, int flags,
 289			  void *buf, size_t size, size_t nmembs)
 290{
 291	int ret;
 292
 293	down_read(&nilfs->ns_segctor_sem);
 294	ret = nilfs_cpfile_get_cpinfo(nilfs->ns_cpfile, posp, flags, buf,
 295				      size, nmembs);
 296	up_read(&nilfs->ns_segctor_sem);
 297	return ret;
 298}
 299
 300/**
 301 * nilfs_ioctl_get_cpstat - get checkpoints statistics
 302 * @inode: inode object
 303 * @filp: file object
 304 * @cmd: ioctl's request code
 305 * @argp: pointer on argument from userspace
 306 *
 307 * Description: nilfs_ioctl_get_cpstat() returns information about checkpoints.
 308 * The NILFS_IOCTL_GET_CPSTAT ioctl is used by lscp, rmcp utilities
 309 * and by nilfs_cleanerd daemon.
 310 *
 311 * Return Value: On success, 0 is returned, and checkpoints information is
 312 * copied into userspace pointer @argp. On error, one of the following
 313 * negative error codes is returned.
 314 *
 315 * %-EIO - I/O error.
 316 *
 317 * %-ENOMEM - Insufficient amount of memory available.
 318 *
 319 * %-EFAULT - Failure during getting checkpoints statistics.
 320 */
 321static int nilfs_ioctl_get_cpstat(struct inode *inode, struct file *filp,
 322				  unsigned int cmd, void __user *argp)
 323{
 324	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
 325	struct nilfs_cpstat cpstat;
 326	int ret;
 327
 328	down_read(&nilfs->ns_segctor_sem);
 329	ret = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat);
 330	up_read(&nilfs->ns_segctor_sem);
 331	if (ret < 0)
 332		return ret;
 333
 334	if (copy_to_user(argp, &cpstat, sizeof(cpstat)))
 335		ret = -EFAULT;
 336	return ret;
 337}
 338
 339/**
 340 * nilfs_ioctl_do_get_suinfo - callback method getting segment usage info
 341 * @nilfs: nilfs object
 342 * @posp: pointer on array of segment numbers
 343 * @flags: *not used*
 344 * @buf: buffer for storing suinfo array
 345 * @size: size in bytes of one suinfo item in array
 346 * @nmembs: count of segment numbers and suinfos in array
 347 *
 348 * Description: nilfs_ioctl_do_get_suinfo() function returns segment usage
 349 * info about requested segments. The NILFS_IOCTL_GET_SUINFO ioctl is used
 350 * in lssu, nilfs_resize utilities and by nilfs_cleanerd daemon.
 351 *
 352 * Return value: count of nilfs_suinfo structures in output buffer.
 353 */
 354static ssize_t
 355nilfs_ioctl_do_get_suinfo(struct the_nilfs *nilfs, __u64 *posp, int flags,
 356			  void *buf, size_t size, size_t nmembs)
 357{
 358	int ret;
 359
 360	down_read(&nilfs->ns_segctor_sem);
 361	ret = nilfs_sufile_get_suinfo(nilfs->ns_sufile, *posp, buf, size,
 362				      nmembs);
 363	up_read(&nilfs->ns_segctor_sem);
 364	return ret;
 365}
 366
 367/**
 368 * nilfs_ioctl_get_sustat - get segment usage statistics
 369 * @inode: inode object
 370 * @filp: file object
 371 * @cmd: ioctl's request code
 372 * @argp: pointer on argument from userspace
 373 *
 374 * Description: nilfs_ioctl_get_sustat() returns segment usage statistics.
 375 * The NILFS_IOCTL_GET_SUSTAT ioctl is used in lssu, nilfs_resize utilities
 376 * and by nilfs_cleanerd daemon.
 377 *
 378 * Return Value: On success, 0 is returned, and segment usage information is
 379 * copied into userspace pointer @argp. On error, one of the following
 380 * negative error codes is returned.
 381 *
 382 * %-EIO - I/O error.
 383 *
 384 * %-ENOMEM - Insufficient amount of memory available.
 385 *
 386 * %-EFAULT - Failure during getting segment usage statistics.
 387 */
 388static int nilfs_ioctl_get_sustat(struct inode *inode, struct file *filp,
 389				  unsigned int cmd, void __user *argp)
 390{
 391	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
 392	struct nilfs_sustat sustat;
 393	int ret;
 394
 395	down_read(&nilfs->ns_segctor_sem);
 396	ret = nilfs_sufile_get_stat(nilfs->ns_sufile, &sustat);
 397	up_read(&nilfs->ns_segctor_sem);
 398	if (ret < 0)
 399		return ret;
 400
 401	if (copy_to_user(argp, &sustat, sizeof(sustat)))
 402		ret = -EFAULT;
 403	return ret;
 404}
 405
 406/**
 407 * nilfs_ioctl_do_get_vinfo - callback method getting virtual blocks info
 408 * @nilfs: nilfs object
 409 * @posp: *not used*
 410 * @flags: *not used*
 411 * @buf: buffer for storing array of nilfs_vinfo structures
 412 * @size: size in bytes of one vinfo item in array
 413 * @nmembs: count of vinfos in array
 414 *
 415 * Description: nilfs_ioctl_do_get_vinfo() function returns information
 416 * on virtual block addresses. The NILFS_IOCTL_GET_VINFO ioctl is used
 417 * by nilfs_cleanerd daemon.
 418 *
 419 * Return value: count of nilfs_vinfo structures in output buffer.
 420 */
 421static ssize_t
 422nilfs_ioctl_do_get_vinfo(struct the_nilfs *nilfs, __u64 *posp, int flags,
 423			 void *buf, size_t size, size_t nmembs)
 424{
 425	int ret;
 426
 427	down_read(&nilfs->ns_segctor_sem);
 428	ret = nilfs_dat_get_vinfo(nilfs->ns_dat, buf, size, nmembs);
 429	up_read(&nilfs->ns_segctor_sem);
 430	return ret;
 431}
 432
 433/**
 434 * nilfs_ioctl_do_get_bdescs - callback method getting disk block descriptors
 435 * @nilfs: nilfs object
 436 * @posp: *not used*
 437 * @flags: *not used*
 438 * @buf: buffer for storing array of nilfs_bdesc structures
 439 * @size: size in bytes of one bdesc item in array
 440 * @nmembs: count of bdescs in array
 441 *
 442 * Description: nilfs_ioctl_do_get_bdescs() function returns information
 443 * about descriptors of disk block numbers. The NILFS_IOCTL_GET_BDESCS ioctl
 444 * is used by nilfs_cleanerd daemon.
 445 *
 446 * Return value: count of nilfs_bdescs structures in output buffer.
 447 */
 448static ssize_t
 449nilfs_ioctl_do_get_bdescs(struct the_nilfs *nilfs, __u64 *posp, int flags,
 450			  void *buf, size_t size, size_t nmembs)
 451{
 452	struct nilfs_bmap *bmap = NILFS_I(nilfs->ns_dat)->i_bmap;
 453	struct nilfs_bdesc *bdescs = buf;
 454	int ret, i;
 455
 456	down_read(&nilfs->ns_segctor_sem);
 457	for (i = 0; i < nmembs; i++) {
 458		ret = nilfs_bmap_lookup_at_level(bmap,
 459						 bdescs[i].bd_offset,
 460						 bdescs[i].bd_level + 1,
 461						 &bdescs[i].bd_blocknr);
 462		if (ret < 0) {
 463			if (ret != -ENOENT) {
 464				up_read(&nilfs->ns_segctor_sem);
 465				return ret;
 466			}
 467			bdescs[i].bd_blocknr = 0;
 468		}
 469	}
 470	up_read(&nilfs->ns_segctor_sem);
 471	return nmembs;
 472}
 473
 474/**
 475 * nilfs_ioctl_get_bdescs - get disk block descriptors
 476 * @inode: inode object
 477 * @filp: file object
 478 * @cmd: ioctl's request code
 479 * @argp: pointer on argument from userspace
 480 *
 481 * Description: nilfs_ioctl_do_get_bdescs() function returns information
 482 * about descriptors of disk block numbers. The NILFS_IOCTL_GET_BDESCS ioctl
 483 * is used by nilfs_cleanerd daemon.
 484 *
 485 * Return Value: On success, 0 is returned, and disk block descriptors are
 486 * copied into userspace pointer @argp. On error, one of the following
 487 * negative error codes is returned.
 488 *
 489 * %-EINVAL - Invalid arguments from userspace.
 490 *
 491 * %-EIO - I/O error.
 492 *
 493 * %-ENOMEM - Insufficient amount of memory available.
 494 *
 495 * %-EFAULT - Failure during getting disk block descriptors.
 496 */
 497static int nilfs_ioctl_get_bdescs(struct inode *inode, struct file *filp,
 498				  unsigned int cmd, void __user *argp)
 499{
 500	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
 501	struct nilfs_argv argv;
 502	int ret;
 503
 504	if (copy_from_user(&argv, argp, sizeof(argv)))
 505		return -EFAULT;
 506
 507	if (argv.v_size != sizeof(struct nilfs_bdesc))
 508		return -EINVAL;
 509
 510	ret = nilfs_ioctl_wrap_copy(nilfs, &argv, _IOC_DIR(cmd),
 511				    nilfs_ioctl_do_get_bdescs);
 512	if (ret < 0)
 513		return ret;
 514
 515	if (copy_to_user(argp, &argv, sizeof(argv)))
 516		ret = -EFAULT;
 517	return ret;
 518}
 519
 520/**
 521 * nilfs_ioctl_move_inode_block - prepare data/node block for moving by GC
 522 * @inode: inode object
 523 * @vdesc: descriptor of virtual block number
 524 * @buffers: list of moving buffers
 525 *
 526 * Description: nilfs_ioctl_move_inode_block() function registers data/node
 527 * buffer in the GC pagecache and submit read request.
 528 *
 529 * Return Value: On success, 0 is returned. On error, one of the following
 530 * negative error codes is returned.
 531 *
 532 * %-EIO - I/O error.
 533 *
 534 * %-ENOMEM - Insufficient amount of memory available.
 535 *
 536 * %-ENOENT - Requested block doesn't exist.
 537 *
 538 * %-EEXIST - Blocks conflict is detected.
 539 */
 540static int nilfs_ioctl_move_inode_block(struct inode *inode,
 541					struct nilfs_vdesc *vdesc,
 542					struct list_head *buffers)
 543{
 544	struct buffer_head *bh;
 545	int ret;
 546
 547	if (vdesc->vd_flags == 0)
 548		ret = nilfs_gccache_submit_read_data(
 549			inode, vdesc->vd_offset, vdesc->vd_blocknr,
 550			vdesc->vd_vblocknr, &bh);
 551	else
 552		ret = nilfs_gccache_submit_read_node(
 553			inode, vdesc->vd_blocknr, vdesc->vd_vblocknr, &bh);
 554
 555	if (unlikely(ret < 0)) {
 556		if (ret == -ENOENT)
 557			nilfs_crit(inode->i_sb,
 558				   "%s: invalid virtual block address (%s): ino=%llu, cno=%llu, offset=%llu, blocknr=%llu, vblocknr=%llu",
 559				   __func__, vdesc->vd_flags ? "node" : "data",
 560				   (unsigned long long)vdesc->vd_ino,
 561				   (unsigned long long)vdesc->vd_cno,
 562				   (unsigned long long)vdesc->vd_offset,
 563				   (unsigned long long)vdesc->vd_blocknr,
 564				   (unsigned long long)vdesc->vd_vblocknr);
 565		return ret;
 566	}
 567	if (unlikely(!list_empty(&bh->b_assoc_buffers))) {
 568		nilfs_crit(inode->i_sb,
 569			   "%s: conflicting %s buffer: ino=%llu, cno=%llu, offset=%llu, blocknr=%llu, vblocknr=%llu",
 570			   __func__, vdesc->vd_flags ? "node" : "data",
 571			   (unsigned long long)vdesc->vd_ino,
 572			   (unsigned long long)vdesc->vd_cno,
 573			   (unsigned long long)vdesc->vd_offset,
 574			   (unsigned long long)vdesc->vd_blocknr,
 575			   (unsigned long long)vdesc->vd_vblocknr);
 576		brelse(bh);
 577		return -EEXIST;
 578	}
 579	list_add_tail(&bh->b_assoc_buffers, buffers);
 580	return 0;
 581}
 582
 583/**
 584 * nilfs_ioctl_move_blocks - move valid inode's blocks during garbage collection
 585 * @sb: superblock object
 586 * @argv: vector of arguments from userspace
 587 * @buf: array of nilfs_vdesc structures
 588 *
 589 * Description: nilfs_ioctl_move_blocks() function reads valid data/node
 590 * blocks that garbage collector specified with the array of nilfs_vdesc
 591 * structures and stores them into page caches of GC inodes.
 592 *
 593 * Return Value: Number of processed nilfs_vdesc structures or
 594 * error code, otherwise.
 595 */
 596static int nilfs_ioctl_move_blocks(struct super_block *sb,
 597				   struct nilfs_argv *argv, void *buf)
 598{
 599	size_t nmembs = argv->v_nmembs;
 600	struct the_nilfs *nilfs = sb->s_fs_info;
 601	struct inode *inode;
 602	struct nilfs_vdesc *vdesc;
 603	struct buffer_head *bh, *n;
 604	LIST_HEAD(buffers);
 605	ino_t ino;
 606	__u64 cno;
 607	int i, ret;
 608
 609	for (i = 0, vdesc = buf; i < nmembs; ) {
 610		ino = vdesc->vd_ino;
 611		cno = vdesc->vd_cno;
 612		inode = nilfs_iget_for_gc(sb, ino, cno);
 613		if (IS_ERR(inode)) {
 614			ret = PTR_ERR(inode);
 615			goto failed;
 616		}
 617		if (list_empty(&NILFS_I(inode)->i_dirty)) {
 618			/*
 619			 * Add the inode to GC inode list. Garbage Collection
 620			 * is serialized and no two processes manipulate the
 621			 * list simultaneously.
 622			 */
 623			igrab(inode);
 624			list_add(&NILFS_I(inode)->i_dirty,
 625				 &nilfs->ns_gc_inodes);
 626		}
 627
 628		do {
 629			ret = nilfs_ioctl_move_inode_block(inode, vdesc,
 630							   &buffers);
 631			if (unlikely(ret < 0)) {
 632				iput(inode);
 633				goto failed;
 634			}
 635			vdesc++;
 636		} while (++i < nmembs &&
 637			 vdesc->vd_ino == ino && vdesc->vd_cno == cno);
 638
 639		iput(inode); /* The inode still remains in GC inode list */
 640	}
 641
 642	list_for_each_entry_safe(bh, n, &buffers, b_assoc_buffers) {
 643		ret = nilfs_gccache_wait_and_mark_dirty(bh);
 644		if (unlikely(ret < 0)) {
 645			WARN_ON(ret == -EEXIST);
 646			goto failed;
 647		}
 648		list_del_init(&bh->b_assoc_buffers);
 649		brelse(bh);
 650	}
 651	return nmembs;
 652
 653 failed:
 654	list_for_each_entry_safe(bh, n, &buffers, b_assoc_buffers) {
 655		list_del_init(&bh->b_assoc_buffers);
 656		brelse(bh);
 657	}
 658	return ret;
 659}
 660
 661/**
 662 * nilfs_ioctl_delete_checkpoints - delete checkpoints
 663 * @nilfs: nilfs object
 664 * @argv: vector of arguments from userspace
 665 * @buf: array of periods of checkpoints numbers
 666 *
 667 * Description: nilfs_ioctl_delete_checkpoints() function deletes checkpoints
 668 * in the period from p_start to p_end, excluding p_end itself. The checkpoints
 669 * which have been already deleted are ignored.
 670 *
 671 * Return Value: Number of processed nilfs_period structures or
 672 * error code, otherwise.
 673 *
 674 * %-EIO - I/O error.
 675 *
 676 * %-ENOMEM - Insufficient amount of memory available.
 677 *
 678 * %-EINVAL - invalid checkpoints.
 679 */
 680static int nilfs_ioctl_delete_checkpoints(struct the_nilfs *nilfs,
 681					  struct nilfs_argv *argv, void *buf)
 682{
 683	size_t nmembs = argv->v_nmembs;
 684	struct inode *cpfile = nilfs->ns_cpfile;
 685	struct nilfs_period *periods = buf;
 686	int ret, i;
 687
 688	for (i = 0; i < nmembs; i++) {
 689		ret = nilfs_cpfile_delete_checkpoints(
 690			cpfile, periods[i].p_start, periods[i].p_end);
 691		if (ret < 0)
 692			return ret;
 693	}
 694	return nmembs;
 695}
 696
 697/**
 698 * nilfs_ioctl_free_vblocknrs - free virtual block numbers
 699 * @nilfs: nilfs object
 700 * @argv: vector of arguments from userspace
 701 * @buf: array of virtual block numbers
 702 *
 703 * Description: nilfs_ioctl_free_vblocknrs() function frees
 704 * the virtual block numbers specified by @buf and @argv->v_nmembs.
 705 *
 706 * Return Value: Number of processed virtual block numbers or
 707 * error code, otherwise.
 708 *
 709 * %-EIO - I/O error.
 710 *
 711 * %-ENOMEM - Insufficient amount of memory available.
 712 *
 713 * %-ENOENT - The virtual block number have not been allocated.
 714 */
 715static int nilfs_ioctl_free_vblocknrs(struct the_nilfs *nilfs,
 716				      struct nilfs_argv *argv, void *buf)
 717{
 718	size_t nmembs = argv->v_nmembs;
 719	int ret;
 720
 721	ret = nilfs_dat_freev(nilfs->ns_dat, buf, nmembs);
 722
 723	return (ret < 0) ? ret : nmembs;
 724}
 725
 726/**
 727 * nilfs_ioctl_mark_blocks_dirty - mark blocks dirty
 728 * @nilfs: nilfs object
 729 * @argv: vector of arguments from userspace
 730 * @buf: array of block descriptors
 731 *
 732 * Description: nilfs_ioctl_mark_blocks_dirty() function marks
 733 * metadata file or data blocks as dirty.
 734 *
 735 * Return Value: Number of processed block descriptors or
 736 * error code, otherwise.
 737 *
 738 * %-ENOMEM - Insufficient memory available.
 739 *
 740 * %-EIO - I/O error
 741 *
 742 * %-ENOENT - the specified block does not exist (hole block)
 743 */
 744static int nilfs_ioctl_mark_blocks_dirty(struct the_nilfs *nilfs,
 745					 struct nilfs_argv *argv, void *buf)
 746{
 747	size_t nmembs = argv->v_nmembs;
 748	struct nilfs_bmap *bmap = NILFS_I(nilfs->ns_dat)->i_bmap;
 749	struct nilfs_bdesc *bdescs = buf;
 750	struct buffer_head *bh;
 751	int ret, i;
 752
 753	for (i = 0; i < nmembs; i++) {
 754		/* XXX: use macro or inline func to check liveness */
 755		ret = nilfs_bmap_lookup_at_level(bmap,
 756						 bdescs[i].bd_offset,
 757						 bdescs[i].bd_level + 1,
 758						 &bdescs[i].bd_blocknr);
 759		if (ret < 0) {
 760			if (ret != -ENOENT)
 761				return ret;
 762			bdescs[i].bd_blocknr = 0;
 763		}
 764		if (bdescs[i].bd_blocknr != bdescs[i].bd_oblocknr)
 765			/* skip dead block */
 766			continue;
 767		if (bdescs[i].bd_level == 0) {
 768			ret = nilfs_mdt_get_block(nilfs->ns_dat,
 769						  bdescs[i].bd_offset,
 770						  false, NULL, &bh);
 771			if (unlikely(ret)) {
 772				WARN_ON(ret == -ENOENT);
 773				return ret;
 774			}
 775			mark_buffer_dirty(bh);
 776			nilfs_mdt_mark_dirty(nilfs->ns_dat);
 777			put_bh(bh);
 778		} else {
 779			ret = nilfs_bmap_mark(bmap, bdescs[i].bd_offset,
 780					      bdescs[i].bd_level);
 781			if (ret < 0) {
 782				WARN_ON(ret == -ENOENT);
 783				return ret;
 784			}
 785		}
 786	}
 787	return nmembs;
 788}
 789
 790int nilfs_ioctl_prepare_clean_segments(struct the_nilfs *nilfs,
 791				       struct nilfs_argv *argv, void **kbufs)
 792{
 793	const char *msg;
 794	int ret;
 795
 796	ret = nilfs_ioctl_delete_checkpoints(nilfs, &argv[1], kbufs[1]);
 797	if (ret < 0) {
 798		/*
 799		 * can safely abort because checkpoints can be removed
 800		 * independently.
 801		 */
 802		msg = "cannot delete checkpoints";
 803		goto failed;
 804	}
 805	ret = nilfs_ioctl_free_vblocknrs(nilfs, &argv[2], kbufs[2]);
 806	if (ret < 0) {
 807		/*
 808		 * can safely abort because DAT file is updated atomically
 809		 * using a copy-on-write technique.
 810		 */
 811		msg = "cannot delete virtual blocks from DAT file";
 812		goto failed;
 813	}
 814	ret = nilfs_ioctl_mark_blocks_dirty(nilfs, &argv[3], kbufs[3]);
 815	if (ret < 0) {
 816		/*
 817		 * can safely abort because the operation is nondestructive.
 818		 */
 819		msg = "cannot mark copying blocks dirty";
 820		goto failed;
 821	}
 822	return 0;
 823
 824 failed:
 825	nilfs_err(nilfs->ns_sb, "error %d preparing GC: %s", ret, msg);
 826	return ret;
 827}
 828
 829/**
 830 * nilfs_ioctl_clean_segments - clean segments
 831 * @inode: inode object
 832 * @filp: file object
 833 * @cmd: ioctl's request code
 834 * @argp: pointer on argument from userspace
 835 *
 836 * Description: nilfs_ioctl_clean_segments() function makes garbage
 837 * collection operation in the environment of requested parameters
 838 * from userspace. The NILFS_IOCTL_CLEAN_SEGMENTS ioctl is used by
 839 * nilfs_cleanerd daemon.
 840 *
 841 * Return Value: On success, 0 is returned or error code, otherwise.
 842 */
 843static int nilfs_ioctl_clean_segments(struct inode *inode, struct file *filp,
 844				      unsigned int cmd, void __user *argp)
 845{
 846	struct nilfs_argv argv[5];
 847	static const size_t argsz[5] = {
 848		sizeof(struct nilfs_vdesc),
 849		sizeof(struct nilfs_period),
 850		sizeof(__u64),
 851		sizeof(struct nilfs_bdesc),
 852		sizeof(__u64),
 853	};
 854	void __user *base;
 855	void *kbufs[5];
 856	struct the_nilfs *nilfs;
 857	size_t len, nsegs;
 858	int n, ret;
 859
 860	if (!capable(CAP_SYS_ADMIN))
 861		return -EPERM;
 862
 863	ret = mnt_want_write_file(filp);
 864	if (ret)
 865		return ret;
 866
 867	ret = -EFAULT;
 868	if (copy_from_user(argv, argp, sizeof(argv)))
 869		goto out;
 870
 871	ret = -EINVAL;
 872	nsegs = argv[4].v_nmembs;
 873	if (argv[4].v_size != argsz[4])
 874		goto out;
 
 
 875
 876	/*
 877	 * argv[4] points to segment numbers this ioctl cleans.  We
 878	 * use kmalloc() for its buffer because the memory used for the
 879	 * segment numbers is small enough.
 880	 */
 881	kbufs[4] = memdup_array_user((void __user *)(unsigned long)argv[4].v_base,
 882				     nsegs, sizeof(__u64));
 883	if (IS_ERR(kbufs[4])) {
 884		ret = PTR_ERR(kbufs[4]);
 885		goto out;
 886	}
 887	nilfs = inode->i_sb->s_fs_info;
 888
 889	for (n = 0; n < 4; n++) {
 890		ret = -EINVAL;
 891		if (argv[n].v_size != argsz[n])
 892			goto out_free;
 893
 894		if (argv[n].v_nmembs > nsegs * nilfs->ns_blocks_per_segment)
 895			goto out_free;
 896
 897		if (argv[n].v_nmembs >= UINT_MAX / argv[n].v_size)
 898			goto out_free;
 899
 900		len = argv[n].v_size * argv[n].v_nmembs;
 901		base = (void __user *)(unsigned long)argv[n].v_base;
 902		if (len == 0) {
 903			kbufs[n] = NULL;
 904			continue;
 905		}
 906
 907		kbufs[n] = vmalloc(len);
 908		if (!kbufs[n]) {
 909			ret = -ENOMEM;
 910			goto out_free;
 911		}
 912		if (copy_from_user(kbufs[n], base, len)) {
 913			ret = -EFAULT;
 914			vfree(kbufs[n]);
 915			goto out_free;
 916		}
 917	}
 918
 919	/*
 920	 * nilfs_ioctl_move_blocks() will call nilfs_iget_for_gc(),
 921	 * which will operates an inode list without blocking.
 922	 * To protect the list from concurrent operations,
 923	 * nilfs_ioctl_move_blocks should be atomic operation.
 924	 */
 925	if (test_and_set_bit(THE_NILFS_GC_RUNNING, &nilfs->ns_flags)) {
 926		ret = -EBUSY;
 927		goto out_free;
 928	}
 929
 930	ret = nilfs_ioctl_move_blocks(inode->i_sb, &argv[0], kbufs[0]);
 931	if (ret < 0) {
 932		nilfs_err(inode->i_sb,
 933			  "error %d preparing GC: cannot read source blocks",
 934			  ret);
 935	} else {
 936		if (nilfs_sb_need_update(nilfs))
 937			set_nilfs_discontinued(nilfs);
 938		ret = nilfs_clean_segments(inode->i_sb, argv, kbufs);
 939	}
 940
 941	nilfs_remove_all_gcinodes(nilfs);
 942	clear_nilfs_gc_running(nilfs);
 943
 944out_free:
 945	while (--n >= 0)
 946		vfree(kbufs[n]);
 947	kfree(kbufs[4]);
 948out:
 949	mnt_drop_write_file(filp);
 950	return ret;
 951}
 952
 953/**
 954 * nilfs_ioctl_sync - make a checkpoint
 955 * @inode: inode object
 956 * @filp: file object
 957 * @cmd: ioctl's request code
 958 * @argp: pointer on argument from userspace
 959 *
 960 * Description: nilfs_ioctl_sync() function constructs a logical segment
 961 * for checkpointing.  This function guarantees that all modified data
 962 * and metadata are written out to the device when it successfully
 963 * returned.
 964 *
 965 * Return Value: On success, 0 is retured. On errors, one of the following
 966 * negative error code is returned.
 967 *
 968 * %-EROFS - Read only filesystem.
 969 *
 970 * %-EIO - I/O error
 971 *
 972 * %-ENOSPC - No space left on device (only in a panic state).
 973 *
 974 * %-ERESTARTSYS - Interrupted.
 975 *
 976 * %-ENOMEM - Insufficient memory available.
 977 *
 978 * %-EFAULT - Failure during execution of requested operation.
 979 */
 980static int nilfs_ioctl_sync(struct inode *inode, struct file *filp,
 981			    unsigned int cmd, void __user *argp)
 982{
 983	__u64 cno;
 984	int ret;
 985	struct the_nilfs *nilfs;
 986
 987	ret = nilfs_construct_segment(inode->i_sb);
 988	if (ret < 0)
 989		return ret;
 990
 991	nilfs = inode->i_sb->s_fs_info;
 992	ret = nilfs_flush_device(nilfs);
 993	if (ret < 0)
 994		return ret;
 995
 996	if (argp != NULL) {
 997		down_read(&nilfs->ns_segctor_sem);
 998		cno = nilfs->ns_cno - 1;
 999		up_read(&nilfs->ns_segctor_sem);
1000		if (copy_to_user(argp, &cno, sizeof(cno)))
1001			return -EFAULT;
1002	}
1003	return 0;
1004}
1005
1006/**
1007 * nilfs_ioctl_resize - resize NILFS2 volume
1008 * @inode: inode object
1009 * @filp: file object
1010 * @argp: pointer on argument from userspace
1011 *
1012 * Return Value: On success, 0 is returned or error code, otherwise.
1013 */
1014static int nilfs_ioctl_resize(struct inode *inode, struct file *filp,
1015			      void __user *argp)
1016{
1017	__u64 newsize;
1018	int ret = -EPERM;
1019
1020	if (!capable(CAP_SYS_ADMIN))
1021		goto out;
1022
1023	ret = mnt_want_write_file(filp);
1024	if (ret)
1025		goto out;
1026
1027	ret = -EFAULT;
1028	if (copy_from_user(&newsize, argp, sizeof(newsize)))
1029		goto out_drop_write;
1030
1031	ret = nilfs_resize_fs(inode->i_sb, newsize);
1032
1033out_drop_write:
1034	mnt_drop_write_file(filp);
1035out:
1036	return ret;
1037}
1038
1039/**
1040 * nilfs_ioctl_trim_fs() - trim ioctl handle function
1041 * @inode: inode object
1042 * @argp: pointer on argument from userspace
1043 *
1044 * Description: nilfs_ioctl_trim_fs is the FITRIM ioctl handle function. It
1045 * checks the arguments from userspace and calls nilfs_sufile_trim_fs, which
1046 * performs the actual trim operation.
1047 *
1048 * Return Value: On success, 0 is returned or negative error code, otherwise.
1049 */
1050static int nilfs_ioctl_trim_fs(struct inode *inode, void __user *argp)
1051{
1052	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
1053	struct fstrim_range range;
1054	int ret;
1055
1056	if (!capable(CAP_SYS_ADMIN))
1057		return -EPERM;
1058
1059	if (!bdev_max_discard_sectors(nilfs->ns_bdev))
1060		return -EOPNOTSUPP;
1061
1062	if (copy_from_user(&range, argp, sizeof(range)))
1063		return -EFAULT;
1064
1065	range.minlen = max_t(u64, range.minlen,
1066			     bdev_discard_granularity(nilfs->ns_bdev));
1067
1068	down_read(&nilfs->ns_segctor_sem);
1069	ret = nilfs_sufile_trim_fs(nilfs->ns_sufile, &range);
1070	up_read(&nilfs->ns_segctor_sem);
1071
1072	if (ret < 0)
1073		return ret;
1074
1075	if (copy_to_user(argp, &range, sizeof(range)))
1076		return -EFAULT;
1077
1078	return 0;
1079}
1080
1081/**
1082 * nilfs_ioctl_set_alloc_range - limit range of segments to be allocated
1083 * @inode: inode object
1084 * @argp: pointer on argument from userspace
1085 *
1086 * Description: nilfs_ioctl_set_alloc_range() function defines lower limit
1087 * of segments in bytes and upper limit of segments in bytes.
1088 * The NILFS_IOCTL_SET_ALLOC_RANGE is used by nilfs_resize utility.
1089 *
1090 * Return Value: On success, 0 is returned or error code, otherwise.
1091 */
1092static int nilfs_ioctl_set_alloc_range(struct inode *inode, void __user *argp)
1093{
1094	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
1095	__u64 range[2];
1096	__u64 minseg, maxseg;
1097	unsigned long segbytes;
1098	int ret = -EPERM;
1099
1100	if (!capable(CAP_SYS_ADMIN))
1101		goto out;
1102
1103	ret = -EFAULT;
1104	if (copy_from_user(range, argp, sizeof(__u64[2])))
1105		goto out;
1106
1107	ret = -ERANGE;
1108	if (range[1] > bdev_nr_bytes(inode->i_sb->s_bdev))
1109		goto out;
1110
1111	segbytes = nilfs->ns_blocks_per_segment * nilfs->ns_blocksize;
1112
1113	minseg = range[0] + segbytes - 1;
1114	do_div(minseg, segbytes);
1115
1116	if (range[1] < 4096)
1117		goto out;
1118
1119	maxseg = NILFS_SB2_OFFSET_BYTES(range[1]);
1120	if (maxseg < segbytes)
1121		goto out;
1122
1123	do_div(maxseg, segbytes);
1124	maxseg--;
1125
1126	ret = nilfs_sufile_set_alloc_range(nilfs->ns_sufile, minseg, maxseg);
1127out:
1128	return ret;
1129}
1130
1131/**
1132 * nilfs_ioctl_get_info - wrapping function of get metadata info
1133 * @inode: inode object
1134 * @filp: file object
1135 * @cmd: ioctl's request code
1136 * @argp: pointer on argument from userspace
1137 * @membsz: size of an item in bytes
1138 * @dofunc: concrete function of getting metadata info
1139 *
1140 * Description: nilfs_ioctl_get_info() gets metadata info by means of
1141 * calling dofunc() function.
1142 *
1143 * Return Value: On success, 0 is returned and requested metadata info
1144 * is copied into userspace. On error, one of the following
1145 * negative error codes is returned.
1146 *
1147 * %-EINVAL - Invalid arguments from userspace.
1148 *
1149 * %-ENOMEM - Insufficient amount of memory available.
1150 *
1151 * %-EFAULT - Failure during execution of requested operation.
1152 */
1153static int nilfs_ioctl_get_info(struct inode *inode, struct file *filp,
1154				unsigned int cmd, void __user *argp,
1155				size_t membsz,
1156				ssize_t (*dofunc)(struct the_nilfs *,
1157						  __u64 *, int,
1158						  void *, size_t, size_t))
1159
1160{
1161	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
1162	struct nilfs_argv argv;
1163	int ret;
1164
1165	if (copy_from_user(&argv, argp, sizeof(argv)))
1166		return -EFAULT;
1167
1168	if (argv.v_size < membsz)
1169		return -EINVAL;
1170
1171	ret = nilfs_ioctl_wrap_copy(nilfs, &argv, _IOC_DIR(cmd), dofunc);
1172	if (ret < 0)
1173		return ret;
1174
1175	if (copy_to_user(argp, &argv, sizeof(argv)))
1176		ret = -EFAULT;
1177	return ret;
1178}
1179
1180/**
1181 * nilfs_ioctl_set_suinfo - set segment usage info
1182 * @inode: inode object
1183 * @filp: file object
1184 * @cmd: ioctl's request code
1185 * @argp: pointer on argument from userspace
1186 *
1187 * Description: Expects an array of nilfs_suinfo_update structures
1188 * encapsulated in nilfs_argv and updates the segment usage info
1189 * according to the flags in nilfs_suinfo_update.
1190 *
1191 * Return Value: On success, 0 is returned. On error, one of the
1192 * following negative error codes is returned.
1193 *
1194 * %-EPERM - Not enough permissions
1195 *
1196 * %-EFAULT - Error copying input data
1197 *
1198 * %-EIO - I/O error.
1199 *
1200 * %-ENOMEM - Insufficient amount of memory available.
1201 *
1202 * %-EINVAL - Invalid values in input (segment number, flags or nblocks)
1203 */
1204static int nilfs_ioctl_set_suinfo(struct inode *inode, struct file *filp,
1205				unsigned int cmd, void __user *argp)
1206{
1207	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
1208	struct nilfs_transaction_info ti;
1209	struct nilfs_argv argv;
1210	size_t len;
1211	void __user *base;
1212	void *kbuf;
1213	int ret;
1214
1215	if (!capable(CAP_SYS_ADMIN))
1216		return -EPERM;
1217
1218	ret = mnt_want_write_file(filp);
1219	if (ret)
1220		return ret;
1221
1222	ret = -EFAULT;
1223	if (copy_from_user(&argv, argp, sizeof(argv)))
1224		goto out;
1225
1226	ret = -EINVAL;
1227	if (argv.v_size < sizeof(struct nilfs_suinfo_update))
1228		goto out;
1229
1230	if (argv.v_nmembs > nilfs->ns_nsegments)
1231		goto out;
1232
1233	if (argv.v_nmembs >= UINT_MAX / argv.v_size)
1234		goto out;
1235
1236	len = argv.v_size * argv.v_nmembs;
1237	if (!len) {
1238		ret = 0;
1239		goto out;
1240	}
1241
1242	base = (void __user *)(unsigned long)argv.v_base;
1243	kbuf = vmalloc(len);
1244	if (!kbuf) {
1245		ret = -ENOMEM;
1246		goto out;
1247	}
1248
1249	if (copy_from_user(kbuf, base, len)) {
1250		ret = -EFAULT;
1251		goto out_free;
1252	}
1253
1254	nilfs_transaction_begin(inode->i_sb, &ti, 0);
1255	ret = nilfs_sufile_set_suinfo(nilfs->ns_sufile, kbuf, argv.v_size,
1256			argv.v_nmembs);
1257	if (unlikely(ret < 0))
1258		nilfs_transaction_abort(inode->i_sb);
1259	else
1260		nilfs_transaction_commit(inode->i_sb); /* never fails */
1261
1262out_free:
1263	vfree(kbuf);
1264out:
1265	mnt_drop_write_file(filp);
1266	return ret;
1267}
1268
1269long nilfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1270{
1271	struct inode *inode = file_inode(filp);
1272	void __user *argp = (void __user *)arg;
1273
1274	switch (cmd) {
1275	case FS_IOC_GETVERSION:
1276		return nilfs_ioctl_getversion(inode, argp);
1277	case NILFS_IOCTL_CHANGE_CPMODE:
1278		return nilfs_ioctl_change_cpmode(inode, filp, cmd, argp);
1279	case NILFS_IOCTL_DELETE_CHECKPOINT:
1280		return nilfs_ioctl_delete_checkpoint(inode, filp, cmd, argp);
1281	case NILFS_IOCTL_GET_CPINFO:
1282		return nilfs_ioctl_get_info(inode, filp, cmd, argp,
1283					    sizeof(struct nilfs_cpinfo),
1284					    nilfs_ioctl_do_get_cpinfo);
1285	case NILFS_IOCTL_GET_CPSTAT:
1286		return nilfs_ioctl_get_cpstat(inode, filp, cmd, argp);
1287	case NILFS_IOCTL_GET_SUINFO:
1288		return nilfs_ioctl_get_info(inode, filp, cmd, argp,
1289					    sizeof(struct nilfs_suinfo),
1290					    nilfs_ioctl_do_get_suinfo);
1291	case NILFS_IOCTL_SET_SUINFO:
1292		return nilfs_ioctl_set_suinfo(inode, filp, cmd, argp);
1293	case NILFS_IOCTL_GET_SUSTAT:
1294		return nilfs_ioctl_get_sustat(inode, filp, cmd, argp);
1295	case NILFS_IOCTL_GET_VINFO:
1296		return nilfs_ioctl_get_info(inode, filp, cmd, argp,
1297					    sizeof(struct nilfs_vinfo),
1298					    nilfs_ioctl_do_get_vinfo);
1299	case NILFS_IOCTL_GET_BDESCS:
1300		return nilfs_ioctl_get_bdescs(inode, filp, cmd, argp);
1301	case NILFS_IOCTL_CLEAN_SEGMENTS:
1302		return nilfs_ioctl_clean_segments(inode, filp, cmd, argp);
1303	case NILFS_IOCTL_SYNC:
1304		return nilfs_ioctl_sync(inode, filp, cmd, argp);
1305	case NILFS_IOCTL_RESIZE:
1306		return nilfs_ioctl_resize(inode, filp, argp);
1307	case NILFS_IOCTL_SET_ALLOC_RANGE:
1308		return nilfs_ioctl_set_alloc_range(inode, argp);
1309	case FITRIM:
1310		return nilfs_ioctl_trim_fs(inode, argp);
1311	default:
1312		return -ENOTTY;
1313	}
1314}
1315
1316#ifdef CONFIG_COMPAT
1317long nilfs_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1318{
1319	switch (cmd) {
1320	case FS_IOC32_GETVERSION:
1321		cmd = FS_IOC_GETVERSION;
1322		break;
1323	case NILFS_IOCTL_CHANGE_CPMODE:
1324	case NILFS_IOCTL_DELETE_CHECKPOINT:
1325	case NILFS_IOCTL_GET_CPINFO:
1326	case NILFS_IOCTL_GET_CPSTAT:
1327	case NILFS_IOCTL_GET_SUINFO:
1328	case NILFS_IOCTL_SET_SUINFO:
1329	case NILFS_IOCTL_GET_SUSTAT:
1330	case NILFS_IOCTL_GET_VINFO:
1331	case NILFS_IOCTL_GET_BDESCS:
1332	case NILFS_IOCTL_CLEAN_SEGMENTS:
1333	case NILFS_IOCTL_SYNC:
1334	case NILFS_IOCTL_RESIZE:
1335	case NILFS_IOCTL_SET_ALLOC_RANGE:
1336	case FITRIM:
1337		break;
1338	default:
1339		return -ENOIOCTLCMD;
1340	}
1341	return nilfs_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
1342}
1343#endif