fs/nilfs2/ioctl.c

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