ioctl.c 21.1 KB
Newer Older
K
Koji Sato 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * ioctl.c - NILFS ioctl operations.
 *
 * Copyright (C) 2007, 2008 Nippon Telegraph and Telephone Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Written by Koji Sato <koji@osrg.net>.
 */

#include <linux/fs.h>
#include <linux/wait.h>
25
#include <linux/slab.h>
K
Koji Sato 已提交
26 27
#include <linux/capability.h>	/* capable() */
#include <linux/uaccess.h>	/* copy_from_user(), copy_to_user() */
28
#include <linux/vmalloc.h>
R
Ryusuke Konishi 已提交
29
#include <linux/compat.h>	/* compat_ptr() */
A
Al Viro 已提交
30
#include <linux/mount.h>	/* mnt_want_write_file(), mnt_drop_write_file() */
31
#include <linux/buffer_head.h>
K
Koji Sato 已提交
32 33 34 35 36 37 38 39 40 41 42 43
#include <linux/nilfs2_fs.h>
#include "nilfs.h"
#include "segment.h"
#include "bmap.h"
#include "cpfile.h"
#include "sufile.h"
#include "dat.h"


static int nilfs_ioctl_wrap_copy(struct the_nilfs *nilfs,
				 struct nilfs_argv *argv, int dir,
				 ssize_t (*dofunc)(struct the_nilfs *,
44
						   __u64 *, int,
K
Koji Sato 已提交
45 46 47
						   void *, size_t, size_t))
{
	void *buf;
48
	void __user *base = (void __user *)(unsigned long)argv->v_base;
49
	size_t maxmembs, total, n;
K
Koji Sato 已提交
50 51
	ssize_t nr;
	int ret, i;
52
	__u64 pos, ppos;
K
Koji Sato 已提交
53 54 55 56

	if (argv->v_nmembs == 0)
		return 0;

57 58 59 60 61
	if (argv->v_size > PAGE_SIZE)
		return -EINVAL;

	buf = (void *)__get_free_pages(GFP_NOFS, 0);
	if (unlikely(!buf))
K
Koji Sato 已提交
62
		return -ENOMEM;
63
	maxmembs = PAGE_SIZE / argv->v_size;
K
Koji Sato 已提交
64 65 66

	ret = 0;
	total = 0;
67
	pos = argv->v_index;
K
Koji Sato 已提交
68 69 70 71
	for (i = 0; i < argv->v_nmembs; i += n) {
		n = (argv->v_nmembs - i < maxmembs) ?
			argv->v_nmembs - i : maxmembs;
		if ((dir & _IOC_WRITE) &&
72 73
		    copy_from_user(buf, base + argv->v_size * i,
				   argv->v_size * n)) {
K
Koji Sato 已提交
74 75 76
			ret = -EFAULT;
			break;
		}
77
		ppos = pos;
78
		nr = dofunc(nilfs, &pos, argv->v_flags, buf, argv->v_size,
79
			       n);
K
Koji Sato 已提交
80 81 82 83 84
		if (nr < 0) {
			ret = nr;
			break;
		}
		if ((dir & _IOC_READ) &&
85 86
		    copy_to_user(base + argv->v_size * i, buf,
				 argv->v_size * nr)) {
K
Koji Sato 已提交
87 88 89 90
			ret = -EFAULT;
			break;
		}
		total += nr;
91 92 93 94
		if ((size_t)nr < n)
			break;
		if (pos == ppos)
			pos += n;
K
Koji Sato 已提交
95 96 97
	}
	argv->v_nmembs = total;

98
	free_pages((unsigned long)buf, 0);
K
Koji Sato 已提交
99 100 101
	return ret;
}

102 103 104 105 106 107 108 109 110 111 112 113 114 115
static int nilfs_ioctl_getflags(struct inode *inode, void __user *argp)
{
	unsigned int flags = NILFS_I(inode)->i_flags & FS_FL_USER_VISIBLE;

	return put_user(flags, (int __user *)argp);
}

static int nilfs_ioctl_setflags(struct inode *inode, struct file *filp,
				void __user *argp)
{
	struct nilfs_transaction_info ti;
	unsigned int flags, oldflags;
	int ret;

116
	if (!inode_owner_or_capable(inode))
117 118 119 120 121
		return -EACCES;

	if (get_user(flags, (int __user *)argp))
		return -EFAULT;

122
	ret = mnt_want_write_file(filp);
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
	if (ret)
		return ret;

	flags = nilfs_mask_flags(inode->i_mode, flags);

	mutex_lock(&inode->i_mutex);

	oldflags = NILFS_I(inode)->i_flags;

	/*
	 * The IMMUTABLE and APPEND_ONLY flags can only be changed by the
	 * relevant capability.
	 */
	ret = -EPERM;
	if (((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) &&
	    !capable(CAP_LINUX_IMMUTABLE))
		goto out;

	ret = nilfs_transaction_begin(inode->i_sb, &ti, 0);
	if (ret)
		goto out;

	NILFS_I(inode)->i_flags = (oldflags & ~FS_FL_USER_MODIFIABLE) |
		(flags & FS_FL_USER_MODIFIABLE);

	nilfs_set_inode_flags(inode);
	inode->i_ctime = CURRENT_TIME;
	if (IS_SYNC(inode))
		nilfs_set_transaction_flag(NILFS_TI_SYNC);

	nilfs_mark_inode_dirty(inode);
	ret = nilfs_transaction_commit(inode->i_sb);
out:
	mutex_unlock(&inode->i_mutex);
A
Al Viro 已提交
157
	mnt_drop_write_file(filp);
158 159 160 161 162 163 164 165
	return ret;
}

static int nilfs_ioctl_getversion(struct inode *inode, void __user *argp)
{
	return put_user(inode->i_generation, (int __user *)argp);
}

K
Koji Sato 已提交
166 167 168
static int nilfs_ioctl_change_cpmode(struct inode *inode, struct file *filp,
				     unsigned int cmd, void __user *argp)
{
169
	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
K
Koji Sato 已提交
170 171 172 173 174 175
	struct nilfs_transaction_info ti;
	struct nilfs_cpmode cpmode;
	int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
176

177
	ret = mnt_want_write_file(filp);
178 179 180 181
	if (ret)
		return ret;

	ret = -EFAULT;
K
Koji Sato 已提交
182
	if (copy_from_user(&cpmode, argp, sizeof(cpmode)))
183
		goto out;
K
Koji Sato 已提交
184

185
	down_read(&inode->i_sb->s_umount);
186

K
Koji Sato 已提交
187 188
	nilfs_transaction_begin(inode->i_sb, &ti, 0);
	ret = nilfs_cpfile_change_cpmode(
189
		nilfs->ns_cpfile, cpmode.cm_cno, cpmode.cm_mode);
190
	if (unlikely(ret < 0))
191
		nilfs_transaction_abort(inode->i_sb);
192 193 194
	else
		nilfs_transaction_commit(inode->i_sb); /* never fails */

195
	up_read(&inode->i_sb->s_umount);
196
out:
A
Al Viro 已提交
197
	mnt_drop_write_file(filp);
K
Koji Sato 已提交
198 199 200 201 202 203 204
	return ret;
}

static int
nilfs_ioctl_delete_checkpoint(struct inode *inode, struct file *filp,
			      unsigned int cmd, void __user *argp)
{
205
	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
K
Koji Sato 已提交
206 207 208 209 210 211
	struct nilfs_transaction_info ti;
	__u64 cno;
	int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
212

213
	ret = mnt_want_write_file(filp);
214 215 216 217
	if (ret)
		return ret;

	ret = -EFAULT;
K
Koji Sato 已提交
218
	if (copy_from_user(&cno, argp, sizeof(cno)))
219
		goto out;
K
Koji Sato 已提交
220 221

	nilfs_transaction_begin(inode->i_sb, &ti, 0);
222
	ret = nilfs_cpfile_delete_checkpoint(nilfs->ns_cpfile, cno);
223
	if (unlikely(ret < 0))
224
		nilfs_transaction_abort(inode->i_sb);
225 226 227
	else
		nilfs_transaction_commit(inode->i_sb); /* never fails */
out:
A
Al Viro 已提交
228
	mnt_drop_write_file(filp);
K
Koji Sato 已提交
229 230 231 232
	return ret;
}

static ssize_t
233
nilfs_ioctl_do_get_cpinfo(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
234 235 236 237
			  void *buf, size_t size, size_t nmembs)
{
	int ret;

238
	down_read(&nilfs->ns_segctor_sem);
239
	ret = nilfs_cpfile_get_cpinfo(nilfs->ns_cpfile, posp, flags, buf,
240
				      size, nmembs);
241
	up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
242 243 244 245 246 247
	return ret;
}

static int nilfs_ioctl_get_cpstat(struct inode *inode, struct file *filp,
				  unsigned int cmd, void __user *argp)
{
248
	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
K
Koji Sato 已提交
249 250 251
	struct nilfs_cpstat cpstat;
	int ret;

252 253 254
	down_read(&nilfs->ns_segctor_sem);
	ret = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat);
	up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
255 256 257 258 259 260 261 262 263
	if (ret < 0)
		return ret;

	if (copy_to_user(argp, &cpstat, sizeof(cpstat)))
		ret = -EFAULT;
	return ret;
}

static ssize_t
264
nilfs_ioctl_do_get_suinfo(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
265 266 267 268
			  void *buf, size_t size, size_t nmembs)
{
	int ret;

269
	down_read(&nilfs->ns_segctor_sem);
270 271
	ret = nilfs_sufile_get_suinfo(nilfs->ns_sufile, *posp, buf, size,
				      nmembs);
272
	up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
273 274 275 276 277 278
	return ret;
}

static int nilfs_ioctl_get_sustat(struct inode *inode, struct file *filp,
				  unsigned int cmd, void __user *argp)
{
279
	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
K
Koji Sato 已提交
280 281 282
	struct nilfs_sustat sustat;
	int ret;

283 284 285
	down_read(&nilfs->ns_segctor_sem);
	ret = nilfs_sufile_get_stat(nilfs->ns_sufile, &sustat);
	up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
286 287 288 289 290 291 292 293 294
	if (ret < 0)
		return ret;

	if (copy_to_user(argp, &sustat, sizeof(sustat)))
		ret = -EFAULT;
	return ret;
}

static ssize_t
295
nilfs_ioctl_do_get_vinfo(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
296 297 298 299
			 void *buf, size_t size, size_t nmembs)
{
	int ret;

300
	down_read(&nilfs->ns_segctor_sem);
301
	ret = nilfs_dat_get_vinfo(nilfs->ns_dat, buf, size, nmembs);
302
	up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
303 304 305 306
	return ret;
}

static ssize_t
307
nilfs_ioctl_do_get_bdescs(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
308 309
			  void *buf, size_t size, size_t nmembs)
{
310
	struct nilfs_bmap *bmap = NILFS_I(nilfs->ns_dat)->i_bmap;
K
Koji Sato 已提交
311 312 313
	struct nilfs_bdesc *bdescs = buf;
	int ret, i;

314
	down_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
315 316 317 318 319 320
	for (i = 0; i < nmembs; i++) {
		ret = nilfs_bmap_lookup_at_level(bmap,
						 bdescs[i].bd_offset,
						 bdescs[i].bd_level + 1,
						 &bdescs[i].bd_blocknr);
		if (ret < 0) {
321 322
			if (ret != -ENOENT) {
				up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
323
				return ret;
324
			}
K
Koji Sato 已提交
325 326 327
			bdescs[i].bd_blocknr = 0;
		}
	}
328
	up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
329 330 331 332 333 334
	return nmembs;
}

static int nilfs_ioctl_get_bdescs(struct inode *inode, struct file *filp,
				  unsigned int cmd, void __user *argp)
{
335
	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
K
Koji Sato 已提交
336 337 338 339 340 341
	struct nilfs_argv argv;
	int ret;

	if (copy_from_user(&argv, argp, sizeof(argv)))
		return -EFAULT;

342 343 344
	if (argv.v_size != sizeof(struct nilfs_bdesc))
		return -EINVAL;

K
Koji Sato 已提交
345 346
	ret = nilfs_ioctl_wrap_copy(nilfs, &argv, _IOC_DIR(cmd),
				    nilfs_ioctl_do_get_bdescs);
347 348
	if (ret < 0)
		return ret;
K
Koji Sato 已提交
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383

	if (copy_to_user(argp, &argv, sizeof(argv)))
		ret = -EFAULT;
	return ret;
}

static int nilfs_ioctl_move_inode_block(struct inode *inode,
					struct nilfs_vdesc *vdesc,
					struct list_head *buffers)
{
	struct buffer_head *bh;
	int ret;

	if (vdesc->vd_flags == 0)
		ret = nilfs_gccache_submit_read_data(
			inode, vdesc->vd_offset, vdesc->vd_blocknr,
			vdesc->vd_vblocknr, &bh);
	else
		ret = nilfs_gccache_submit_read_node(
			inode, vdesc->vd_blocknr, vdesc->vd_vblocknr, &bh);

	if (unlikely(ret < 0)) {
		if (ret == -ENOENT)
			printk(KERN_CRIT
			       "%s: invalid virtual block address (%s): "
			       "ino=%llu, cno=%llu, offset=%llu, "
			       "blocknr=%llu, vblocknr=%llu\n",
			       __func__, vdesc->vd_flags ? "node" : "data",
			       (unsigned long long)vdesc->vd_ino,
			       (unsigned long long)vdesc->vd_cno,
			       (unsigned long long)vdesc->vd_offset,
			       (unsigned long long)vdesc->vd_blocknr,
			       (unsigned long long)vdesc->vd_vblocknr);
		return ret;
	}
384 385 386 387 388 389 390 391 392 393 394 395
	if (unlikely(!list_empty(&bh->b_assoc_buffers))) {
		printk(KERN_CRIT "%s: conflicting %s buffer: ino=%llu, "
		       "cno=%llu, offset=%llu, blocknr=%llu, vblocknr=%llu\n",
		       __func__, vdesc->vd_flags ? "node" : "data",
		       (unsigned long long)vdesc->vd_ino,
		       (unsigned long long)vdesc->vd_cno,
		       (unsigned long long)vdesc->vd_offset,
		       (unsigned long long)vdesc->vd_blocknr,
		       (unsigned long long)vdesc->vd_vblocknr);
		brelse(bh);
		return -EEXIST;
	}
K
Koji Sato 已提交
396 397 398 399
	list_add_tail(&bh->b_assoc_buffers, buffers);
	return 0;
}

400
static int nilfs_ioctl_move_blocks(struct super_block *sb,
401
				   struct nilfs_argv *argv, void *buf)
K
Koji Sato 已提交
402
{
403
	size_t nmembs = argv->v_nmembs;
404
	struct the_nilfs *nilfs = sb->s_fs_info;
K
Koji Sato 已提交
405 406 407 408 409 410 411 412 413 414 415
	struct inode *inode;
	struct nilfs_vdesc *vdesc;
	struct buffer_head *bh, *n;
	LIST_HEAD(buffers);
	ino_t ino;
	__u64 cno;
	int i, ret;

	for (i = 0, vdesc = buf; i < nmembs; ) {
		ino = vdesc->vd_ino;
		cno = vdesc->vd_cno;
416
		inode = nilfs_iget_for_gc(sb, ino, cno);
417 418
		if (IS_ERR(inode)) {
			ret = PTR_ERR(inode);
K
Koji Sato 已提交
419 420
			goto failed;
		}
421 422 423 424 425 426 427 428 429 430 431
		if (list_empty(&NILFS_I(inode)->i_dirty)) {
			/*
			 * Add the inode to GC inode list. Garbage Collection
			 * is serialized and no two processes manipulate the
			 * list simultaneously.
			 */
			igrab(inode);
			list_add(&NILFS_I(inode)->i_dirty,
				 &nilfs->ns_gc_inodes);
		}

K
Koji Sato 已提交
432 433 434
		do {
			ret = nilfs_ioctl_move_inode_block(inode, vdesc,
							   &buffers);
435 436
			if (unlikely(ret < 0)) {
				iput(inode);
K
Koji Sato 已提交
437
				goto failed;
438
			}
K
Koji Sato 已提交
439 440 441
			vdesc++;
		} while (++i < nmembs &&
			 vdesc->vd_ino == ino && vdesc->vd_cno == cno);
442 443

		iput(inode); /* The inode still remains in GC inode list */
K
Koji Sato 已提交
444 445 446 447 448
	}

	list_for_each_entry_safe(bh, n, &buffers, b_assoc_buffers) {
		ret = nilfs_gccache_wait_and_mark_dirty(bh);
		if (unlikely(ret < 0)) {
449
			WARN_ON(ret == -EEXIST);
K
Koji Sato 已提交
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
			goto failed;
		}
		list_del_init(&bh->b_assoc_buffers);
		brelse(bh);
	}
	return nmembs;

 failed:
	list_for_each_entry_safe(bh, n, &buffers, b_assoc_buffers) {
		list_del_init(&bh->b_assoc_buffers);
		brelse(bh);
	}
	return ret;
}

465 466
static int nilfs_ioctl_delete_checkpoints(struct the_nilfs *nilfs,
					  struct nilfs_argv *argv, void *buf)
K
Koji Sato 已提交
467
{
468
	size_t nmembs = argv->v_nmembs;
K
Koji Sato 已提交
469 470 471 472 473 474 475 476 477 478 479 480 481
	struct inode *cpfile = nilfs->ns_cpfile;
	struct nilfs_period *periods = buf;
	int ret, i;

	for (i = 0; i < nmembs; i++) {
		ret = nilfs_cpfile_delete_checkpoints(
			cpfile, periods[i].p_start, periods[i].p_end);
		if (ret < 0)
			return ret;
	}
	return nmembs;
}

482 483
static int nilfs_ioctl_free_vblocknrs(struct the_nilfs *nilfs,
				      struct nilfs_argv *argv, void *buf)
K
Koji Sato 已提交
484
{
485 486
	size_t nmembs = argv->v_nmembs;
	int ret;
K
Koji Sato 已提交
487

488
	ret = nilfs_dat_freev(nilfs->ns_dat, buf, nmembs);
K
Koji Sato 已提交
489 490 491 492

	return (ret < 0) ? ret : nmembs;
}

493 494
static int nilfs_ioctl_mark_blocks_dirty(struct the_nilfs *nilfs,
					 struct nilfs_argv *argv, void *buf)
K
Koji Sato 已提交
495
{
496
	size_t nmembs = argv->v_nmembs;
497
	struct nilfs_bmap *bmap = NILFS_I(nilfs->ns_dat)->i_bmap;
K
Koji Sato 已提交
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
	struct nilfs_bdesc *bdescs = buf;
	int ret, i;

	for (i = 0; i < nmembs; i++) {
		/* XXX: use macro or inline func to check liveness */
		ret = nilfs_bmap_lookup_at_level(bmap,
						 bdescs[i].bd_offset,
						 bdescs[i].bd_level + 1,
						 &bdescs[i].bd_blocknr);
		if (ret < 0) {
			if (ret != -ENOENT)
				return ret;
			bdescs[i].bd_blocknr = 0;
		}
		if (bdescs[i].bd_blocknr != bdescs[i].bd_oblocknr)
			/* skip dead block */
			continue;
		if (bdescs[i].bd_level == 0) {
516
			ret = nilfs_mdt_mark_block_dirty(nilfs->ns_dat,
K
Koji Sato 已提交
517 518
							 bdescs[i].bd_offset);
			if (ret < 0) {
519
				WARN_ON(ret == -ENOENT);
K
Koji Sato 已提交
520 521 522 523 524 525
				return ret;
			}
		} else {
			ret = nilfs_bmap_mark(bmap, bdescs[i].bd_offset,
					      bdescs[i].bd_level);
			if (ret < 0) {
526
				WARN_ON(ret == -ENOENT);
K
Koji Sato 已提交
527 528 529 530 531 532 533 534
				return ret;
			}
		}
	}
	return nmembs;
}

int nilfs_ioctl_prepare_clean_segments(struct the_nilfs *nilfs,
535
				       struct nilfs_argv *argv, void **kbufs)
K
Koji Sato 已提交
536
{
537
	const char *msg;
538
	int ret;
K
Koji Sato 已提交
539

540
	ret = nilfs_ioctl_delete_checkpoints(nilfs, &argv[1], kbufs[1]);
541 542 543 544 545 546 547 548
	if (ret < 0) {
		/*
		 * can safely abort because checkpoints can be removed
		 * independently.
		 */
		msg = "cannot delete checkpoints";
		goto failed;
	}
549
	ret = nilfs_ioctl_free_vblocknrs(nilfs, &argv[2], kbufs[2]);
550 551 552 553 554 555 556 557
	if (ret < 0) {
		/*
		 * can safely abort because DAT file is updated atomically
		 * using a copy-on-write technique.
		 */
		msg = "cannot delete virtual blocks from DAT file";
		goto failed;
	}
558
	ret = nilfs_ioctl_mark_blocks_dirty(nilfs, &argv[3], kbufs[3]);
559 560 561 562 563 564 565
	if (ret < 0) {
		/*
		 * can safely abort because the operation is nondestructive.
		 */
		msg = "cannot mark copying blocks dirty";
		goto failed;
	}
K
Koji Sato 已提交
566 567
	return 0;

568 569 570
 failed:
	printk(KERN_ERR "NILFS: GC failed during preparation: %s: err=%d\n",
	       msg, ret);
K
Koji Sato 已提交
571 572 573 574 575 576
	return ret;
}

static int nilfs_ioctl_clean_segments(struct inode *inode, struct file *filp,
				      unsigned int cmd, void __user *argp)
{
577
	struct nilfs_argv argv[5];
578
	static const size_t argsz[5] = {
579 580 581 582 583 584 585 586 587 588 589 590
		sizeof(struct nilfs_vdesc),
		sizeof(struct nilfs_period),
		sizeof(__u64),
		sizeof(struct nilfs_bdesc),
		sizeof(__u64),
	};
	void __user *base;
	void *kbufs[5];
	struct the_nilfs *nilfs;
	size_t len, nsegs;
	int n, ret;

K
Koji Sato 已提交
591 592
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
593

594
	ret = mnt_want_write_file(filp);
595 596 597 598
	if (ret)
		return ret;

	ret = -EFAULT;
599
	if (copy_from_user(argv, argp, sizeof(argv)))
600
		goto out;
601

602
	ret = -EINVAL;
603 604
	nsegs = argv[4].v_nmembs;
	if (argv[4].v_size != argsz[4])
605
		goto out;
606 607
	if (nsegs > UINT_MAX / sizeof(__u64))
		goto out;
608

609 610 611 612 613 614 615
	/*
	 * argv[4] points to segment numbers this ioctl cleans.  We
	 * use kmalloc() for its buffer because memory used for the
	 * segment numbers is enough small.
	 */
	kbufs[4] = memdup_user((void __user *)(unsigned long)argv[4].v_base,
			       nsegs * sizeof(__u64));
616 617 618 619
	if (IS_ERR(kbufs[4])) {
		ret = PTR_ERR(kbufs[4]);
		goto out;
	}
620
	nilfs = inode->i_sb->s_fs_info;
621 622 623 624 625 626 627 628 629

	for (n = 0; n < 4; n++) {
		ret = -EINVAL;
		if (argv[n].v_size != argsz[n])
			goto out_free;

		if (argv[n].v_nmembs > nsegs * nilfs->ns_blocks_per_segment)
			goto out_free;

630 631 632
		if (argv[n].v_nmembs >= UINT_MAX / argv[n].v_size)
			goto out_free;

633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651
		len = argv[n].v_size * argv[n].v_nmembs;
		base = (void __user *)(unsigned long)argv[n].v_base;
		if (len == 0) {
			kbufs[n] = NULL;
			continue;
		}

		kbufs[n] = vmalloc(len);
		if (!kbufs[n]) {
			ret = -ENOMEM;
			goto out_free;
		}
		if (copy_from_user(kbufs[n], base, len)) {
			ret = -EFAULT;
			vfree(kbufs[n]);
			goto out_free;
		}
	}

652
	/*
653
	 * nilfs_ioctl_move_blocks() will call nilfs_iget_for_gc(),
654 655 656 657 658 659 660 661 662
	 * which will operates an inode list without blocking.
	 * To protect the list from concurrent operations,
	 * nilfs_ioctl_move_blocks should be atomic operation.
	 */
	if (test_and_set_bit(THE_NILFS_GC_RUNNING, &nilfs->ns_flags)) {
		ret = -EBUSY;
		goto out_free;
	}

663 664
	vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);

665
	ret = nilfs_ioctl_move_blocks(inode->i_sb, &argv[0], kbufs[0]);
666 667 668 669 670 671
	if (ret < 0)
		printk(KERN_ERR "NILFS: GC failed during preparation: "
			"cannot read source blocks: err=%d\n", ret);
	else
		ret = nilfs_clean_segments(inode->i_sb, argv, kbufs);

672
	nilfs_remove_all_gcinodes(nilfs);
673
	clear_nilfs_gc_running(nilfs);
674

675
out_free:
676
	while (--n >= 0)
677 678
		vfree(kbufs[n]);
	kfree(kbufs[4]);
679
out:
A
Al Viro 已提交
680
	mnt_drop_write_file(filp);
681
	return ret;
K
Koji Sato 已提交
682 683 684 685 686 687 688
}

static int nilfs_ioctl_sync(struct inode *inode, struct file *filp,
			    unsigned int cmd, void __user *argp)
{
	__u64 cno;
	int ret;
689
	struct the_nilfs *nilfs;
K
Koji Sato 已提交
690 691 692 693 694 695

	ret = nilfs_construct_segment(inode->i_sb);
	if (ret < 0)
		return ret;

	if (argp != NULL) {
696
		nilfs = inode->i_sb->s_fs_info;
697 698 699
		down_read(&nilfs->ns_segctor_sem);
		cno = nilfs->ns_cno - 1;
		up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
700 701 702 703 704 705
		if (copy_to_user(argp, &cno, sizeof(cno)))
			return -EFAULT;
	}
	return 0;
}

R
Ryusuke Konishi 已提交
706 707 708 709 710 711 712 713 714
static int nilfs_ioctl_resize(struct inode *inode, struct file *filp,
			      void __user *argp)
{
	__u64 newsize;
	int ret = -EPERM;

	if (!capable(CAP_SYS_ADMIN))
		goto out;

715
	ret = mnt_want_write_file(filp);
R
Ryusuke Konishi 已提交
716 717 718 719 720 721 722 723 724 725
	if (ret)
		goto out;

	ret = -EFAULT;
	if (copy_from_user(&newsize, argp, sizeof(newsize)))
		goto out_drop_write;

	ret = nilfs_resize_fs(inode->i_sb, newsize);

out_drop_write:
A
Al Viro 已提交
726
	mnt_drop_write_file(filp);
R
Ryusuke Konishi 已提交
727 728 729 730
out:
	return ret;
}

731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
static int nilfs_ioctl_set_alloc_range(struct inode *inode, void __user *argp)
{
	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
	__u64 range[2];
	__u64 minseg, maxseg;
	unsigned long segbytes;
	int ret = -EPERM;

	if (!capable(CAP_SYS_ADMIN))
		goto out;

	ret = -EFAULT;
	if (copy_from_user(range, argp, sizeof(__u64[2])))
		goto out;

	ret = -ERANGE;
	if (range[1] > i_size_read(inode->i_sb->s_bdev->bd_inode))
		goto out;

	segbytes = nilfs->ns_blocks_per_segment * nilfs->ns_blocksize;

	minseg = range[0] + segbytes - 1;
	do_div(minseg, segbytes);
	maxseg = NILFS_SB2_OFFSET_BYTES(range[1]);
	do_div(maxseg, segbytes);
	maxseg--;

	ret = nilfs_sufile_set_alloc_range(nilfs->ns_sufile, minseg, maxseg);
out:
	return ret;
}

763 764
static int nilfs_ioctl_get_info(struct inode *inode, struct file *filp,
				unsigned int cmd, void __user *argp,
765
				size_t membsz,
766 767 768 769 770
				ssize_t (*dofunc)(struct the_nilfs *,
						  __u64 *, int,
						  void *, size_t, size_t))

{
771
	struct the_nilfs *nilfs = inode->i_sb->s_fs_info;
772 773 774 775 776 777
	struct nilfs_argv argv;
	int ret;

	if (copy_from_user(&argv, argp, sizeof(argv)))
		return -EFAULT;

778
	if (argv.v_size < membsz)
779 780
		return -EINVAL;

781 782 783 784 785 786 787 788 789
	ret = nilfs_ioctl_wrap_copy(nilfs, &argv, _IOC_DIR(cmd), dofunc);
	if (ret < 0)
		return ret;

	if (copy_to_user(argp, &argv, sizeof(argv)))
		ret = -EFAULT;
	return ret;
}

R
Ryusuke Konishi 已提交
790
long nilfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
K
Koji Sato 已提交
791
{
R
Ryusuke Konishi 已提交
792
	struct inode *inode = filp->f_dentry->d_inode;
793
	void __user *argp = (void __user *)arg;
K
Koji Sato 已提交
794 795

	switch (cmd) {
796 797 798 799 800 801
	case FS_IOC_GETFLAGS:
		return nilfs_ioctl_getflags(inode, argp);
	case FS_IOC_SETFLAGS:
		return nilfs_ioctl_setflags(inode, filp, argp);
	case FS_IOC_GETVERSION:
		return nilfs_ioctl_getversion(inode, argp);
K
Koji Sato 已提交
802 803 804 805 806
	case NILFS_IOCTL_CHANGE_CPMODE:
		return nilfs_ioctl_change_cpmode(inode, filp, cmd, argp);
	case NILFS_IOCTL_DELETE_CHECKPOINT:
		return nilfs_ioctl_delete_checkpoint(inode, filp, cmd, argp);
	case NILFS_IOCTL_GET_CPINFO:
807
		return nilfs_ioctl_get_info(inode, filp, cmd, argp,
808
					    sizeof(struct nilfs_cpinfo),
809
					    nilfs_ioctl_do_get_cpinfo);
K
Koji Sato 已提交
810 811 812
	case NILFS_IOCTL_GET_CPSTAT:
		return nilfs_ioctl_get_cpstat(inode, filp, cmd, argp);
	case NILFS_IOCTL_GET_SUINFO:
813
		return nilfs_ioctl_get_info(inode, filp, cmd, argp,
814
					    sizeof(struct nilfs_suinfo),
815
					    nilfs_ioctl_do_get_suinfo);
K
Koji Sato 已提交
816 817 818
	case NILFS_IOCTL_GET_SUSTAT:
		return nilfs_ioctl_get_sustat(inode, filp, cmd, argp);
	case NILFS_IOCTL_GET_VINFO:
819
		return nilfs_ioctl_get_info(inode, filp, cmd, argp,
820
					    sizeof(struct nilfs_vinfo),
821
					    nilfs_ioctl_do_get_vinfo);
K
Koji Sato 已提交
822 823 824 825 826 827
	case NILFS_IOCTL_GET_BDESCS:
		return nilfs_ioctl_get_bdescs(inode, filp, cmd, argp);
	case NILFS_IOCTL_CLEAN_SEGMENTS:
		return nilfs_ioctl_clean_segments(inode, filp, cmd, argp);
	case NILFS_IOCTL_SYNC:
		return nilfs_ioctl_sync(inode, filp, cmd, argp);
R
Ryusuke Konishi 已提交
828 829
	case NILFS_IOCTL_RESIZE:
		return nilfs_ioctl_resize(inode, filp, argp);
830 831
	case NILFS_IOCTL_SET_ALLOC_RANGE:
		return nilfs_ioctl_set_alloc_range(inode, argp);
K
Koji Sato 已提交
832 833 834 835
	default:
		return -ENOTTY;
	}
}
R
Ryusuke Konishi 已提交
836 837 838 839 840 841 842 843 844 845 846 847 848 849

#ifdef CONFIG_COMPAT
long nilfs_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case FS_IOC32_GETFLAGS:
		cmd = FS_IOC_GETFLAGS;
		break;
	case FS_IOC32_SETFLAGS:
		cmd = FS_IOC_SETFLAGS;
		break;
	case FS_IOC32_GETVERSION:
		cmd = FS_IOC_GETVERSION;
		break;
T
Thomas Meyer 已提交
850 851 852 853 854 855 856 857 858 859 860 861 862
	case NILFS_IOCTL_CHANGE_CPMODE:
	case NILFS_IOCTL_DELETE_CHECKPOINT:
	case NILFS_IOCTL_GET_CPINFO:
	case NILFS_IOCTL_GET_CPSTAT:
	case NILFS_IOCTL_GET_SUINFO:
	case NILFS_IOCTL_GET_SUSTAT:
	case NILFS_IOCTL_GET_VINFO:
	case NILFS_IOCTL_GET_BDESCS:
	case NILFS_IOCTL_CLEAN_SEGMENTS:
	case NILFS_IOCTL_SYNC:
	case NILFS_IOCTL_RESIZE:
	case NILFS_IOCTL_SET_ALLOC_RANGE:
		break;
R
Ryusuke Konishi 已提交
863 864 865 866 867 868
	default:
		return -ENOIOCTLCMD;
	}
	return nilfs_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
}
#endif