fs/nilfs2/ioctl.c

   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  */
  47 static 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  */
 119 int 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  */
 131 int 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  */
 163 static 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  */
 187 static 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);
 217 out:
 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  */
 241 static int
 242 nilfs_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 */
 267 out:
 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  */
 287 static ssize_t
 288 nilfs_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  */
 321 static 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  */
 354 static ssize_t
 355 nilfs_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  */
 388 static 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  */
 421 static ssize_t
 422 nilfs_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  */
 448 static ssize_t
 449 nilfs_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  */
 497 static 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  */
 540 static 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  */
 596 static 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  */
 680 static 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  */
 715 static 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  */
 744 static 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
 790 int 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  */
 843 static 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
 944 out_free:
 945         while (--n >= 0)
 946                 vfree(kbufs[n]);
 947         kfree(kbufs[4]);
 948 out:
 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  */
 980 static 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  */
1014 static 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
1033 out_drop_write:
1034         mnt_drop_write_file(filp);
1035 out:
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  */
1050 static 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  */
1092 static 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         minseg = div64_ul(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         maxseg = div64_ul(maxseg, segbytes);
1124         maxseg--;
1125
1126         ret = nilfs_sufile_set_alloc_range(nilfs->ns_sufile, minseg, maxseg);
1127 out:
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  */
1153 static 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  */
1204 static 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
1262 out_free:
1263         vfree(kbuf);
1264 out:
1265         mnt_drop_write_file(filp);
1266         return ret;
1267 }
1268
1269 long 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
1317 long 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