ioctl.c 16.7 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 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
/*
 * 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>
#include <linux/smp_lock.h>	/* lock_kernel(), unlock_kernel() */
#include <linux/capability.h>	/* capable() */
#include <linux/uaccess.h>	/* copy_from_user(), copy_to_user() */
#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 *,
40
						   __u64 *, int,
K
Koji Sato 已提交
41 42 43
						   void *, size_t, size_t))
{
	void *buf;
44
	void __user *base = (void __user *)(unsigned long)argv->v_base;
45
	size_t maxmembs, total, n;
K
Koji Sato 已提交
46 47
	ssize_t nr;
	int ret, i;
48
	__u64 pos, ppos;
K
Koji Sato 已提交
49 50 51 52

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

53 54 55 56 57
	if (argv->v_size > PAGE_SIZE)
		return -EINVAL;

	buf = (void *)__get_free_pages(GFP_NOFS, 0);
	if (unlikely(!buf))
K
Koji Sato 已提交
58
		return -ENOMEM;
59
	maxmembs = PAGE_SIZE / argv->v_size;
K
Koji Sato 已提交
60 61 62

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

94
	free_pages((unsigned long)buf, 0);
K
Koji Sato 已提交
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
	return ret;
}

static int nilfs_ioctl_change_cpmode(struct inode *inode, struct file *filp,
				     unsigned int cmd, void __user *argp)
{
	struct inode *cpfile = NILFS_SB(inode->i_sb)->s_nilfs->ns_cpfile;
	struct nilfs_transaction_info ti;
	struct nilfs_cpmode cpmode;
	int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
	if (copy_from_user(&cpmode, argp, sizeof(cpmode)))
		return -EFAULT;

	nilfs_transaction_begin(inode->i_sb, &ti, 0);
	ret = nilfs_cpfile_change_cpmode(
		cpfile, cpmode.cm_cno, cpmode.cm_mode);
114 115 116 117 118
	if (unlikely(ret < 0)) {
		nilfs_transaction_abort(inode->i_sb);
		return ret;
	}
	nilfs_transaction_commit(inode->i_sb); /* never fails */
K
Koji Sato 已提交
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
	return ret;
}

static int
nilfs_ioctl_delete_checkpoint(struct inode *inode, struct file *filp,
			      unsigned int cmd, void __user *argp)
{
	struct inode *cpfile = NILFS_SB(inode->i_sb)->s_nilfs->ns_cpfile;
	struct nilfs_transaction_info ti;
	__u64 cno;
	int ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
	if (copy_from_user(&cno, argp, sizeof(cno)))
		return -EFAULT;

	nilfs_transaction_begin(inode->i_sb, &ti, 0);
	ret = nilfs_cpfile_delete_checkpoint(cpfile, cno);
138 139 140 141 142
	if (unlikely(ret < 0)) {
		nilfs_transaction_abort(inode->i_sb);
		return ret;
	}
	nilfs_transaction_commit(inode->i_sb); /* never fails */
K
Koji Sato 已提交
143 144 145 146
	return ret;
}

static ssize_t
147
nilfs_ioctl_do_get_cpinfo(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
148 149
			  void *buf, size_t size, size_t nmembs)
{
150
	return nilfs_cpfile_get_cpinfo(nilfs->ns_cpfile, posp, flags, buf,
K
Koji Sato 已提交
151 152 153 154 155 156 157 158 159 160 161 162 163
				       nmembs);
}

static int nilfs_ioctl_get_cpinfo(struct inode *inode, struct file *filp,
				  unsigned int cmd, void __user *argp)
{
	struct the_nilfs *nilfs = NILFS_SB(inode->i_sb)->s_nilfs;
	struct nilfs_argv argv;
	int ret;

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

164
	down_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
165 166
	ret = nilfs_ioctl_wrap_copy(nilfs, &argv, _IOC_DIR(cmd),
				    nilfs_ioctl_do_get_cpinfo);
167 168 169
	up_read(&nilfs->ns_segctor_sem);
	if (ret < 0)
		return ret;
K
Koji Sato 已提交
170 171 172 173 174 175 176 177 178

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

static int nilfs_ioctl_get_cpstat(struct inode *inode, struct file *filp,
				  unsigned int cmd, void __user *argp)
{
179
	struct the_nilfs *nilfs = NILFS_SB(inode->i_sb)->s_nilfs;
K
Koji Sato 已提交
180 181 182
	struct nilfs_cpstat cpstat;
	int ret;

183 184 185
	down_read(&nilfs->ns_segctor_sem);
	ret = nilfs_cpfile_get_stat(nilfs->ns_cpfile, &cpstat);
	up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
186 187 188 189 190 191 192 193 194
	if (ret < 0)
		return ret;

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

static ssize_t
195
nilfs_ioctl_do_get_suinfo(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
196 197
			  void *buf, size_t size, size_t nmembs)
{
198
	return nilfs_sufile_get_suinfo(nilfs->ns_sufile, *posp, buf, nmembs);
K
Koji Sato 已提交
199 200 201 202 203 204 205 206 207 208 209 210
}

static int nilfs_ioctl_get_suinfo(struct inode *inode, struct file *filp,
				  unsigned int cmd, void __user *argp)
{
	struct the_nilfs *nilfs = NILFS_SB(inode->i_sb)->s_nilfs;
	struct nilfs_argv argv;
	int ret;

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

211
	down_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
212 213
	ret = nilfs_ioctl_wrap_copy(nilfs, &argv, _IOC_DIR(cmd),
				    nilfs_ioctl_do_get_suinfo);
214 215 216
	up_read(&nilfs->ns_segctor_sem);
	if (ret < 0)
		return ret;
K
Koji Sato 已提交
217 218 219 220 221 222 223 224 225

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

static int nilfs_ioctl_get_sustat(struct inode *inode, struct file *filp,
				  unsigned int cmd, void __user *argp)
{
226
	struct the_nilfs *nilfs = NILFS_SB(inode->i_sb)->s_nilfs;
K
Koji Sato 已提交
227 228 229
	struct nilfs_sustat sustat;
	int ret;

230 231 232
	down_read(&nilfs->ns_segctor_sem);
	ret = nilfs_sufile_get_stat(nilfs->ns_sufile, &sustat);
	up_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
233 234 235 236 237 238 239 240 241
	if (ret < 0)
		return ret;

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

static ssize_t
242
nilfs_ioctl_do_get_vinfo(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
			 void *buf, size_t size, size_t nmembs)
{
	return nilfs_dat_get_vinfo(nilfs_dat_inode(nilfs), buf, nmembs);
}

static int nilfs_ioctl_get_vinfo(struct inode *inode, struct file *filp,
				 unsigned int cmd, void __user *argp)
{
	struct the_nilfs *nilfs = NILFS_SB(inode->i_sb)->s_nilfs;
	struct nilfs_argv argv;
	int ret;

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

258
	down_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
259 260
	ret = nilfs_ioctl_wrap_copy(nilfs, &argv, _IOC_DIR(cmd),
				    nilfs_ioctl_do_get_vinfo);
261 262 263
	up_read(&nilfs->ns_segctor_sem);
	if (ret < 0)
		return ret;
K
Koji Sato 已提交
264 265 266 267 268 269 270

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

static ssize_t
271
nilfs_ioctl_do_get_bdescs(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
			  void *buf, size_t size, size_t nmembs)
{
	struct inode *dat = nilfs_dat_inode(nilfs);
	struct nilfs_bmap *bmap = NILFS_I(dat)->i_bmap;
	struct nilfs_bdesc *bdescs = buf;
	int ret, i;

	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) {
			if (ret != -ENOENT)
				return ret;
			bdescs[i].bd_blocknr = 0;
		}
	}
	return nmembs;
}

static int nilfs_ioctl_get_bdescs(struct inode *inode, struct file *filp,
				  unsigned int cmd, void __user *argp)
{
	struct the_nilfs *nilfs = NILFS_SB(inode->i_sb)->s_nilfs;
	struct nilfs_argv argv;
	int ret;

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

303
	down_read(&nilfs->ns_segctor_sem);
K
Koji Sato 已提交
304 305
	ret = nilfs_ioctl_wrap_copy(nilfs, &argv, _IOC_DIR(cmd),
				    nilfs_ioctl_do_get_bdescs);
306 307 308
	up_read(&nilfs->ns_segctor_sem);
	if (ret < 0)
		return ret;
K
Koji Sato 已提交
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349

	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;
	}
	bh->b_private = vdesc;
	list_add_tail(&bh->b_assoc_buffers, buffers);
	return 0;
}

static ssize_t
350
nilfs_ioctl_do_move_blocks(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
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 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
			   void *buf, size_t size, size_t nmembs)
{
	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;
		inode = nilfs_gc_iget(nilfs, ino, cno);
		if (unlikely(inode == NULL)) {
			ret = -ENOMEM;
			goto failed;
		}
		do {
			ret = nilfs_ioctl_move_inode_block(inode, vdesc,
							   &buffers);
			if (unlikely(ret < 0))
				goto failed;
			vdesc++;
		} while (++i < nmembs &&
			 vdesc->vd_ino == ino && vdesc->vd_cno == cno);
	}

	list_for_each_entry_safe(bh, n, &buffers, b_assoc_buffers) {
		ret = nilfs_gccache_wait_and_mark_dirty(bh);
		if (unlikely(ret < 0)) {
			if (ret == -EEXIST) {
				vdesc = bh->b_private;
				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);
			}
			goto failed;
		}
		list_del_init(&bh->b_assoc_buffers);
		bh->b_private = NULL;
		brelse(bh);
	}
	return nmembs;

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

static inline int nilfs_ioctl_move_blocks(struct the_nilfs *nilfs,
					  struct nilfs_argv *argv,
					  int dir)
{
	return nilfs_ioctl_wrap_copy(nilfs, argv, dir,
				     nilfs_ioctl_do_move_blocks);
}

static ssize_t
422
nilfs_ioctl_do_delete_checkpoints(struct the_nilfs *nilfs, __u64 *posp,
K
Koji Sato 已提交
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
				  int flags, void *buf, size_t size,
				  size_t nmembs)
{
	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;
}

static inline int nilfs_ioctl_delete_checkpoints(struct the_nilfs *nilfs,
						 struct nilfs_argv *argv,
						 int dir)
{
	return nilfs_ioctl_wrap_copy(nilfs, argv, dir,
				     nilfs_ioctl_do_delete_checkpoints);
}

static ssize_t
448
nilfs_ioctl_do_free_vblocknrs(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
			      void *buf, size_t size, size_t nmembs)
{
	int ret = nilfs_dat_freev(nilfs_dat_inode(nilfs), buf, nmembs);

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

static inline int nilfs_ioctl_free_vblocknrs(struct the_nilfs *nilfs,
					     struct nilfs_argv *argv,
					     int dir)
{
	return nilfs_ioctl_wrap_copy(nilfs, argv, dir,
				     nilfs_ioctl_do_free_vblocknrs);
}

static ssize_t
465 466 467
nilfs_ioctl_do_mark_blocks_dirty(struct the_nilfs *nilfs, __u64 *posp,
				 int flags, void *buf, size_t size,
				 size_t nmembs)
K
Koji Sato 已提交
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
{
	struct inode *dat = nilfs_dat_inode(nilfs);
	struct nilfs_bmap *bmap = NILFS_I(dat)->i_bmap;
	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) {
			ret = nilfs_mdt_mark_block_dirty(dat,
							 bdescs[i].bd_offset);
			if (ret < 0) {
492
				WARN_ON(ret == -ENOENT);
K
Koji Sato 已提交
493 494 495 496 497 498
				return ret;
			}
		} else {
			ret = nilfs_bmap_mark(bmap, bdescs[i].bd_offset,
					      bdescs[i].bd_level);
			if (ret < 0) {
499
				WARN_ON(ret == -ENOENT);
K
Koji Sato 已提交
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
				return ret;
			}
		}
	}
	return nmembs;
}

static inline int nilfs_ioctl_mark_blocks_dirty(struct the_nilfs *nilfs,
						struct nilfs_argv *argv,
						int dir)
{
	return nilfs_ioctl_wrap_copy(nilfs, argv, dir,
				     nilfs_ioctl_do_mark_blocks_dirty);
}

static ssize_t
516
nilfs_ioctl_do_free_segments(struct the_nilfs *nilfs, __u64 *posp, int flags,
K
Koji Sato 已提交
517 518 519 520 521
			     void *buf, size_t size, size_t nmembs)
{
	struct nilfs_sb_info *sbi = nilfs_get_writer(nilfs);
	int ret;

522 523
	if (unlikely(!sbi))
		return -EROFS;
K
Koji Sato 已提交
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
	ret = nilfs_segctor_add_segments_to_be_freed(
		NILFS_SC(sbi), buf, nmembs);
	nilfs_put_writer(nilfs);

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

static inline int nilfs_ioctl_free_segments(struct the_nilfs *nilfs,
					     struct nilfs_argv *argv,
					     int dir)
{
	return nilfs_ioctl_wrap_copy(nilfs, argv, dir,
				     nilfs_ioctl_do_free_segments);
}

int nilfs_ioctl_prepare_clean_segments(struct the_nilfs *nilfs,
				       void __user *argp)
{
	struct nilfs_argv argv[5];
543
	const char *msg;
K
Koji Sato 已提交
544 545 546 547 548 549 550
	int dir, ret;

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

	dir = _IOC_WRITE;
	ret = nilfs_ioctl_move_blocks(nilfs, &argv[0], dir);
551 552 553 554
	if (ret < 0) {
		msg = "cannot read source blocks";
		goto failed;
	}
K
Koji Sato 已提交
555
	ret = nilfs_ioctl_delete_checkpoints(nilfs, &argv[1], dir);
556 557 558 559 560 561 562 563
	if (ret < 0) {
		/*
		 * can safely abort because checkpoints can be removed
		 * independently.
		 */
		msg = "cannot delete checkpoints";
		goto failed;
	}
K
Koji Sato 已提交
564
	ret = nilfs_ioctl_free_vblocknrs(nilfs, &argv[2], dir);
565 566 567 568 569 570 571 572
	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;
	}
K
Koji Sato 已提交
573
	ret = nilfs_ioctl_mark_blocks_dirty(nilfs, &argv[3], dir);
574 575 576 577 578 579 580
	if (ret < 0) {
		/*
		 * can safely abort because the operation is nondestructive.
		 */
		msg = "cannot mark copying blocks dirty";
		goto failed;
	}
K
Koji Sato 已提交
581
	ret = nilfs_ioctl_free_segments(nilfs, &argv[4], dir);
582 583 584 585 586 587 588
	if (ret < 0) {
		/*
		 * can safely abort because this operation is atomic.
		 */
		msg = "cannot set segments to be freed";
		goto failed;
	}
K
Koji Sato 已提交
589 590
	return 0;

591
 failed:
K
Koji Sato 已提交
592
	nilfs_remove_all_gcinode(nilfs);
593 594
	printk(KERN_ERR "NILFS: GC failed during preparation: %s: err=%d\n",
	       msg, ret);
K
Koji Sato 已提交
595 596 597 598 599 600 601 602
	return ret;
}

static int nilfs_ioctl_clean_segments(struct inode *inode, struct file *filp,
				      unsigned int cmd, void __user *argp)
{
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;
603
	return nilfs_clean_segments(inode->i_sb, argp);
K
Koji Sato 已提交
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623
}

static int nilfs_ioctl_sync(struct inode *inode, struct file *filp,
			    unsigned int cmd, void __user *argp)
{
	__u64 cno;
	int ret;

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

	if (argp != NULL) {
		cno = NILFS_SB(inode->i_sb)->s_nilfs->ns_cno - 1;
		if (copy_to_user(argp, &cno, sizeof(cno)))
			return -EFAULT;
	}
	return 0;
}

R
Ryusuke Konishi 已提交
624
long nilfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
K
Koji Sato 已提交
625
{
R
Ryusuke Konishi 已提交
626
	struct inode *inode = filp->f_dentry->d_inode;
K
Koji Sato 已提交
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
	void __user *argp = (void * __user *)arg;

	switch (cmd) {
	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:
		return nilfs_ioctl_get_cpinfo(inode, filp, cmd, argp);
	case NILFS_IOCTL_GET_CPSTAT:
		return nilfs_ioctl_get_cpstat(inode, filp, cmd, argp);
	case NILFS_IOCTL_GET_SUINFO:
		return nilfs_ioctl_get_suinfo(inode, filp, cmd, argp);
	case NILFS_IOCTL_GET_SUSTAT:
		return nilfs_ioctl_get_sustat(inode, filp, cmd, argp);
	case NILFS_IOCTL_GET_VINFO:
		/* XXX: rename to ??? */
		return nilfs_ioctl_get_vinfo(inode, filp, cmd, argp);
	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);
	default:
		return -ENOTTY;
	}
}