~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nilfs2/ioctl.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp