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