xfs_ioctl.c 39.9 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
L
Linus Torvalds 已提交
4
 *
5 6
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
L
Linus Torvalds 已提交
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * This program is distributed in the hope that it would 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.
L
Linus Torvalds 已提交
13
 *
14 15 16
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
L
Linus Torvalds 已提交
17 18 19
 */
#include "xfs.h"
#include "xfs_fs.h"
20
#include "xfs_shared.h"
21 22 23
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
L
Linus Torvalds 已提交
24
#include "xfs_sb.h"
25
#include "xfs_ag.h"
L
Linus Torvalds 已提交
26 27
#include "xfs_mount.h"
#include "xfs_inode.h"
28
#include "xfs_ioctl.h"
29
#include "xfs_alloc.h"
L
Linus Torvalds 已提交
30 31
#include "xfs_rtalloc.h"
#include "xfs_itable.h"
32
#include "xfs_error.h"
L
Linus Torvalds 已提交
33
#include "xfs_attr.h"
34
#include "xfs_bmap.h"
D
Dave Chinner 已提交
35
#include "xfs_bmap_util.h"
L
Linus Torvalds 已提交
36
#include "xfs_fsops.h"
C
Christoph Hellwig 已提交
37
#include "xfs_discard.h"
38
#include "xfs_quota.h"
39
#include "xfs_export.h"
C
Christoph Hellwig 已提交
40
#include "xfs_trace.h"
41
#include "xfs_icache.h"
D
Dave Chinner 已提交
42
#include "xfs_symlink.h"
43 44
#include "xfs_dinode.h"
#include "xfs_trans.h"
L
Linus Torvalds 已提交
45

46
#include <linux/capability.h>
L
Linus Torvalds 已提交
47 48 49 50
#include <linux/dcache.h>
#include <linux/mount.h>
#include <linux/namei.h>
#include <linux/pagemap.h>
51
#include <linux/slab.h>
52
#include <linux/exportfs.h>
L
Linus Torvalds 已提交
53 54 55 56 57 58 59 60 61 62 63 64

/*
 * xfs_find_handle maps from userspace xfs_fsop_handlereq structure to
 * a file or fs handle.
 *
 * XFS_IOC_PATH_TO_FSHANDLE
 *    returns fs handle for a mount point or path within that mount point
 * XFS_IOC_FD_TO_HANDLE
 *    returns full handle for a FD opened in user space
 * XFS_IOC_PATH_TO_HANDLE
 *    returns full handle for a path
 */
65
int
L
Linus Torvalds 已提交
66 67
xfs_find_handle(
	unsigned int		cmd,
68
	xfs_fsop_handlereq_t	*hreq)
L
Linus Torvalds 已提交
69 70 71 72
{
	int			hsize;
	xfs_handle_t		handle;
	struct inode		*inode;
73
	struct fd		f = {NULL};
C
Christoph Hellwig 已提交
74
	struct path		path;
75
	int			error;
C
Christoph Hellwig 已提交
76
	struct xfs_inode	*ip;
L
Linus Torvalds 已提交
77

C
Christoph Hellwig 已提交
78
	if (cmd == XFS_IOC_FD_TO_HANDLE) {
79 80
		f = fdget(hreq->fd);
		if (!f.file)
C
Christoph Hellwig 已提交
81
			return -EBADF;
A
Al Viro 已提交
82
		inode = file_inode(f.file);
C
Christoph Hellwig 已提交
83 84 85 86 87
	} else {
		error = user_lpath((const char __user *)hreq->path, &path);
		if (error)
			return error;
		inode = path.dentry->d_inode;
L
Linus Torvalds 已提交
88
	}
C
Christoph Hellwig 已提交
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
	ip = XFS_I(inode);

	/*
	 * We can only generate handles for inodes residing on a XFS filesystem,
	 * and only for regular files, directories or symbolic links.
	 */
	error = -EINVAL;
	if (inode->i_sb->s_magic != XFS_SB_MAGIC)
		goto out_put;

	error = -EBADF;
	if (!S_ISREG(inode->i_mode) &&
	    !S_ISDIR(inode->i_mode) &&
	    !S_ISLNK(inode->i_mode))
		goto out_put;


	memcpy(&handle.ha_fsid, ip->i_mount->m_fixedfsid, sizeof(xfs_fsid_t));

	if (cmd == XFS_IOC_PATH_TO_FSHANDLE) {
		/*
		 * This handle only contains an fsid, zero the rest.
		 */
		memset(&handle.ha_fid, 0, sizeof(handle.ha_fid));
		hsize = sizeof(xfs_fsid_t);
	} else {
C
Christoph Hellwig 已提交
115 116 117 118 119
		handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
					sizeof(handle.ha_fid.fid_len);
		handle.ha_fid.fid_pad = 0;
		handle.ha_fid.fid_gen = ip->i_d.di_gen;
		handle.ha_fid.fid_ino = ip->i_ino;
L
Linus Torvalds 已提交
120 121 122 123

		hsize = XFS_HSIZE(handle);
	}

C
Christoph Hellwig 已提交
124
	error = -EFAULT;
125
	if (copy_to_user(hreq->ohandle, &handle, hsize) ||
C
Christoph Hellwig 已提交
126 127
	    copy_to_user(hreq->ohandlen, &hsize, sizeof(__s32)))
		goto out_put;
L
Linus Torvalds 已提交
128

C
Christoph Hellwig 已提交
129 130 131 132
	error = 0;

 out_put:
	if (cmd == XFS_IOC_FD_TO_HANDLE)
133
		fdput(f);
C
Christoph Hellwig 已提交
134 135 136
	else
		path_put(&path);
	return error;
L
Linus Torvalds 已提交
137 138 139
}

/*
140 141
 * No need to do permission checks on the various pathname components
 * as the handle operations are privileged.
L
Linus Torvalds 已提交
142 143
 */
STATIC int
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
xfs_handle_acceptable(
	void			*context,
	struct dentry		*dentry)
{
	return 1;
}

/*
 * Convert userspace handle data into a dentry.
 */
struct dentry *
xfs_handle_to_dentry(
	struct file		*parfilp,
	void __user		*uhandle,
	u32			hlen)
L
Linus Torvalds 已提交
159 160
{
	xfs_handle_t		handle;
161
	struct xfs_fid64	fid;
L
Linus Torvalds 已提交
162 163 164 165

	/*
	 * Only allow handle opens under a directory.
	 */
A
Al Viro 已提交
166
	if (!S_ISDIR(file_inode(parfilp)->i_mode))
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
		return ERR_PTR(-ENOTDIR);

	if (hlen != sizeof(xfs_handle_t))
		return ERR_PTR(-EINVAL);
	if (copy_from_user(&handle, uhandle, hlen))
		return ERR_PTR(-EFAULT);
	if (handle.ha_fid.fid_len !=
	    sizeof(handle.ha_fid) - sizeof(handle.ha_fid.fid_len))
		return ERR_PTR(-EINVAL);

	memset(&fid, 0, sizeof(struct fid));
	fid.ino = handle.ha_fid.fid_ino;
	fid.gen = handle.ha_fid.fid_gen;

	return exportfs_decode_fh(parfilp->f_path.mnt, (struct fid *)&fid, 3,
			FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG,
			xfs_handle_acceptable, NULL);
}
L
Linus Torvalds 已提交
185

186 187 188 189 190 191
STATIC struct dentry *
xfs_handlereq_to_dentry(
	struct file		*parfilp,
	xfs_fsop_handlereq_t	*hreq)
{
	return xfs_handle_to_dentry(parfilp, hreq->ihandle, hreq->ihandlen);
L
Linus Torvalds 已提交
192 193
}

194
int
L
Linus Torvalds 已提交
195 196
xfs_open_by_handle(
	struct file		*parfilp,
197
	xfs_fsop_handlereq_t	*hreq)
L
Linus Torvalds 已提交
198
{
199
	const struct cred	*cred = current_cred();
L
Linus Torvalds 已提交
200
	int			error;
201
	int			fd;
L
Linus Torvalds 已提交
202 203 204 205
	int			permflag;
	struct file		*filp;
	struct inode		*inode;
	struct dentry		*dentry;
206
	fmode_t			fmode;
207
	struct path		path;
L
Linus Torvalds 已提交
208 209 210 211

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

212 213 214 215
	dentry = xfs_handlereq_to_dentry(parfilp, hreq);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
	inode = dentry->d_inode;
L
Linus Torvalds 已提交
216 217 218

	/* Restrict xfs_open_by_handle to directories & regular files. */
	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
219 220
		error = -XFS_ERROR(EPERM);
		goto out_dput;
L
Linus Torvalds 已提交
221 222 223
	}

#if BITS_PER_LONG != 32
224
	hreq->oflags |= O_LARGEFILE;
L
Linus Torvalds 已提交
225
#endif
226

227
	permflag = hreq->oflags;
228
	fmode = OPEN_FMODE(permflag);
L
Linus Torvalds 已提交
229
	if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
230
	    (fmode & FMODE_WRITE) && IS_APPEND(inode)) {
231 232
		error = -XFS_ERROR(EPERM);
		goto out_dput;
L
Linus Torvalds 已提交
233 234
	}

235
	if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
236 237
		error = -XFS_ERROR(EACCES);
		goto out_dput;
L
Linus Torvalds 已提交
238 239 240
	}

	/* Can't write directories. */
241
	if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
242 243
		error = -XFS_ERROR(EISDIR);
		goto out_dput;
L
Linus Torvalds 已提交
244 245
	}

246
	fd = get_unused_fd_flags(0);
247 248 249
	if (fd < 0) {
		error = fd;
		goto out_dput;
L
Linus Torvalds 已提交
250 251
	}

252 253 254 255
	path.mnt = parfilp->f_path.mnt;
	path.dentry = dentry;
	filp = dentry_open(&path, hreq->oflags, cred);
	dput(dentry);
L
Linus Torvalds 已提交
256
	if (IS_ERR(filp)) {
257 258
		put_unused_fd(fd);
		return PTR_ERR(filp);
L
Linus Torvalds 已提交
259
	}
260

A
Al Viro 已提交
261
	if (S_ISREG(inode->i_mode)) {
262
		filp->f_flags |= O_NOATIME;
263
		filp->f_mode |= FMODE_NOCMTIME;
264
	}
L
Linus Torvalds 已提交
265

266 267 268 269 270 271
	fd_install(fd, filp);
	return fd;

 out_dput:
	dput(dentry);
	return error;
L
Linus Torvalds 已提交
272 273
}

274
int
L
Linus Torvalds 已提交
275
xfs_readlink_by_handle(
276 277
	struct file		*parfilp,
	xfs_fsop_handlereq_t	*hreq)
L
Linus Torvalds 已提交
278
{
279
	struct dentry		*dentry;
L
Linus Torvalds 已提交
280
	__u32			olen;
281 282
	void			*link;
	int			error;
L
Linus Torvalds 已提交
283 284 285 286

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

287 288 289
	dentry = xfs_handlereq_to_dentry(parfilp, hreq);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
L
Linus Torvalds 已提交
290 291

	/* Restrict this handle operation to symlinks only. */
292
	if (!S_ISLNK(dentry->d_inode->i_mode)) {
293
		error = -XFS_ERROR(EINVAL);
294
		goto out_dput;
L
Linus Torvalds 已提交
295 296
	}

297
	if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
298
		error = -XFS_ERROR(EFAULT);
299
		goto out_dput;
L
Linus Torvalds 已提交
300 301
	}

302
	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
303 304 305 306
	if (!link) {
		error = -XFS_ERROR(ENOMEM);
		goto out_dput;
	}
L
Linus Torvalds 已提交
307

308
	error = -xfs_readlink(XFS_I(dentry->d_inode), link);
309
	if (error)
310
		goto out_kfree;
A
Al Viro 已提交
311
	error = readlink_copy(hreq->ohandle, olen, link);
312 313
	if (error)
		goto out_kfree;
314

315 316
 out_kfree:
	kfree(link);
317 318
 out_dput:
	dput(dentry);
319
	return error;
L
Linus Torvalds 已提交
320 321
}

D
Dave Chinner 已提交
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
int
xfs_set_dmattrs(
	xfs_inode_t     *ip,
	u_int		evmask,
	u_int16_t	state)
{
	xfs_mount_t	*mp = ip->i_mount;
	xfs_trans_t	*tp;
	int		error;

	if (!capable(CAP_SYS_ADMIN))
		return XFS_ERROR(EPERM);

	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

	tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
339
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
D
Dave Chinner 已提交
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
	if (error) {
		xfs_trans_cancel(tp, 0);
		return error;
	}
	xfs_ilock(ip, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);

	ip->i_d.di_dmevmask = evmask;
	ip->i_d.di_dmstate  = state;

	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	error = xfs_trans_commit(tp, 0);

	return error;
}

L
Linus Torvalds 已提交
356 357
STATIC int
xfs_fssetdm_by_handle(
358 359
	struct file		*parfilp,
	void			__user *arg)
L
Linus Torvalds 已提交
360 361 362 363
{
	int			error;
	struct fsdmidata	fsd;
	xfs_fsop_setdm_handlereq_t dmhreq;
364
	struct dentry		*dentry;
L
Linus Torvalds 已提交
365 366 367 368 369 370

	if (!capable(CAP_MKNOD))
		return -XFS_ERROR(EPERM);
	if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
		return -XFS_ERROR(EFAULT);

J
Jan Kara 已提交
371 372 373 374
	error = mnt_want_write_file(parfilp);
	if (error)
		return error;

375
	dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);
J
Jan Kara 已提交
376 377
	if (IS_ERR(dentry)) {
		mnt_drop_write_file(parfilp);
378
		return PTR_ERR(dentry);
J
Jan Kara 已提交
379
	}
L
Linus Torvalds 已提交
380

381
	if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) {
382 383
		error = -XFS_ERROR(EPERM);
		goto out;
L
Linus Torvalds 已提交
384 385 386
	}

	if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
387 388
		error = -XFS_ERROR(EFAULT);
		goto out;
L
Linus Torvalds 已提交
389 390
	}

391
	error = -xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask,
392
				 fsd.fsd_dmstate);
L
Linus Torvalds 已提交
393

394
 out:
J
Jan Kara 已提交
395
	mnt_drop_write_file(parfilp);
396
	dput(dentry);
397
	return error;
L
Linus Torvalds 已提交
398 399 400 401
}

STATIC int
xfs_attrlist_by_handle(
402 403
	struct file		*parfilp,
	void			__user *arg)
L
Linus Torvalds 已提交
404
{
405
	int			error = -ENOMEM;
L
Linus Torvalds 已提交
406 407
	attrlist_cursor_kern_t	*cursor;
	xfs_fsop_attrlist_handlereq_t al_hreq;
408
	struct dentry		*dentry;
L
Linus Torvalds 已提交
409 410 411 412 413 414
	char			*kbuf;

	if (!capable(CAP_SYS_ADMIN))
		return -XFS_ERROR(EPERM);
	if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
		return -XFS_ERROR(EFAULT);
415 416
	if (al_hreq.buflen < sizeof(struct attrlist) ||
	    al_hreq.buflen > XATTR_LIST_MAX)
L
Linus Torvalds 已提交
417 418
		return -XFS_ERROR(EINVAL);

419 420 421 422 423 424
	/*
	 * Reject flags, only allow namespaces.
	 */
	if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
		return -XFS_ERROR(EINVAL);

425 426 427
	dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
L
Linus Torvalds 已提交
428

429 430 431
	kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP);
	if (!kbuf)
		goto out_dput;
L
Linus Torvalds 已提交
432 433

	cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
434
	error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,
435
					al_hreq.flags, cursor);
L
Linus Torvalds 已提交
436 437 438 439 440 441
	if (error)
		goto out_kfree;

	if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
		error = -EFAULT;

442 443 444
out_kfree:
	kmem_free(kbuf);
out_dput:
445 446
	dput(dentry);
	return error;
L
Linus Torvalds 已提交
447 448
}

449
int
L
Linus Torvalds 已提交
450
xfs_attrmulti_attr_get(
451
	struct inode		*inode,
452 453
	unsigned char		*name,
	unsigned char		__user *ubuf,
L
Linus Torvalds 已提交
454 455 456
	__uint32_t		*len,
	__uint32_t		flags)
{
457
	unsigned char		*kbuf;
L
Linus Torvalds 已提交
458
	int			error = EFAULT;
459

L
Linus Torvalds 已提交
460 461
	if (*len > XATTR_SIZE_MAX)
		return EINVAL;
462 463 464
	kbuf = kmem_zalloc_large(*len, KM_SLEEP);
	if (!kbuf)
		return ENOMEM;
L
Linus Torvalds 已提交
465

466
	error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
L
Linus Torvalds 已提交
467 468 469 470 471 472
	if (error)
		goto out_kfree;

	if (copy_to_user(ubuf, kbuf, *len))
		error = EFAULT;

473 474
out_kfree:
	kmem_free(kbuf);
L
Linus Torvalds 已提交
475 476 477
	return error;
}

478
int
L
Linus Torvalds 已提交
479
xfs_attrmulti_attr_set(
480
	struct inode		*inode,
481 482
	unsigned char		*name,
	const unsigned char	__user *ubuf,
L
Linus Torvalds 已提交
483 484 485
	__uint32_t		len,
	__uint32_t		flags)
{
486
	unsigned char		*kbuf;
L
Linus Torvalds 已提交
487 488
	int			error = EFAULT;

489
	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
L
Linus Torvalds 已提交
490 491 492 493
		return EPERM;
	if (len > XATTR_SIZE_MAX)
		return EINVAL;

L
Li Zefan 已提交
494 495 496
	kbuf = memdup_user(ubuf, len);
	if (IS_ERR(kbuf))
		return PTR_ERR(kbuf);
497

498
	error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
L
Linus Torvalds 已提交
499 500 501 502

	return error;
}

503
int
L
Linus Torvalds 已提交
504
xfs_attrmulti_attr_remove(
505
	struct inode		*inode,
506
	unsigned char		*name,
L
Linus Torvalds 已提交
507 508
	__uint32_t		flags)
{
509
	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
L
Linus Torvalds 已提交
510
		return EPERM;
511
	return xfs_attr_remove(XFS_I(inode), name, flags);
L
Linus Torvalds 已提交
512 513 514 515
}

STATIC int
xfs_attrmulti_by_handle(
516
	struct file		*parfilp,
517
	void			__user *arg)
L
Linus Torvalds 已提交
518 519 520 521
{
	int			error;
	xfs_attr_multiop_t	*ops;
	xfs_fsop_attrmulti_handlereq_t am_hreq;
522
	struct dentry		*dentry;
L
Linus Torvalds 已提交
523
	unsigned int		i, size;
524
	unsigned char		*attr_name;
L
Linus Torvalds 已提交
525 526 527 528 529 530

	if (!capable(CAP_SYS_ADMIN))
		return -XFS_ERROR(EPERM);
	if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
		return -XFS_ERROR(EFAULT);

531 532 533 534
	/* overflow check */
	if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))
		return -E2BIG;

535 536 537
	dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
L
Linus Torvalds 已提交
538 539

	error = E2BIG;
C
Christoph Hellwig 已提交
540
	size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);
L
Linus Torvalds 已提交
541
	if (!size || size > 16 * PAGE_SIZE)
542
		goto out_dput;
L
Linus Torvalds 已提交
543

L
Li Zefan 已提交
544 545
	ops = memdup_user(am_hreq.ops, size);
	if (IS_ERR(ops)) {
546
		error = -PTR_ERR(ops);
547
		goto out_dput;
L
Li Zefan 已提交
548
	}
L
Linus Torvalds 已提交
549

550
	error = ENOMEM;
L
Linus Torvalds 已提交
551 552 553 554 555 556
	attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);
	if (!attr_name)
		goto out_kfree_ops;

	error = 0;
	for (i = 0; i < am_hreq.opcount; i++) {
557
		ops[i].am_error = strncpy_from_user((char *)attr_name,
L
Linus Torvalds 已提交
558 559
				ops[i].am_attrname, MAXNAMELEN);
		if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)
560
			error = ERANGE;
L
Linus Torvalds 已提交
561 562 563 564 565
		if (ops[i].am_error < 0)
			break;

		switch (ops[i].am_opcode) {
		case ATTR_OP_GET:
566 567 568 569
			ops[i].am_error = xfs_attrmulti_attr_get(
					dentry->d_inode, attr_name,
					ops[i].am_attrvalue, &ops[i].am_length,
					ops[i].am_flags);
L
Linus Torvalds 已提交
570 571
			break;
		case ATTR_OP_SET:
572
			ops[i].am_error = mnt_want_write_file(parfilp);
573 574
			if (ops[i].am_error)
				break;
575 576 577 578
			ops[i].am_error = xfs_attrmulti_attr_set(
					dentry->d_inode, attr_name,
					ops[i].am_attrvalue, ops[i].am_length,
					ops[i].am_flags);
A
Al Viro 已提交
579
			mnt_drop_write_file(parfilp);
L
Linus Torvalds 已提交
580 581
			break;
		case ATTR_OP_REMOVE:
582
			ops[i].am_error = mnt_want_write_file(parfilp);
583 584
			if (ops[i].am_error)
				break;
585 586 587
			ops[i].am_error = xfs_attrmulti_attr_remove(
					dentry->d_inode, attr_name,
					ops[i].am_flags);
A
Al Viro 已提交
588
			mnt_drop_write_file(parfilp);
L
Linus Torvalds 已提交
589 590 591 592 593 594 595 596 597 598 599 600
			break;
		default:
			ops[i].am_error = EINVAL;
		}
	}

	if (copy_to_user(am_hreq.ops, ops, size))
		error = XFS_ERROR(EFAULT);

	kfree(attr_name);
 out_kfree_ops:
	kfree(ops);
601 602
 out_dput:
	dput(dentry);
L
Linus Torvalds 已提交
603 604 605
	return -error;
}

606
int
L
Linus Torvalds 已提交
607
xfs_ioc_space(
608
	struct xfs_inode	*ip,
609
	struct inode		*inode,
L
Linus Torvalds 已提交
610 611 612
	struct file		*filp,
	int			ioflags,
	unsigned int		cmd,
613
	xfs_flock64_t		*bf)
L
Linus Torvalds 已提交
614
{
615 616 617 618 619
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_trans	*tp;
	struct iattr		iattr;
	bool			setprealloc = false;
	bool			clrprealloc = false;
L
Linus Torvalds 已提交
620 621
	int			error;

622 623 624 625 626 627 628 629
	/*
	 * Only allow the sys admin to reserve space unless
	 * unwritten extents are enabled.
	 */
	if (!xfs_sb_version_hasextflgbit(&ip->i_mount->m_sb) &&
	    !capable(CAP_SYS_ADMIN))
		return -XFS_ERROR(EPERM);

630
	if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
L
Linus Torvalds 已提交
631 632
		return -XFS_ERROR(EPERM);

633
	if (!(filp->f_mode & FMODE_WRITE))
L
Linus Torvalds 已提交
634 635
		return -XFS_ERROR(EBADF);

636
	if (!S_ISREG(inode->i_mode))
L
Linus Torvalds 已提交
637 638
		return -XFS_ERROR(EINVAL);

J
Jan Kara 已提交
639 640 641
	error = mnt_want_write_file(filp);
	if (error)
		return error;
642

643
	xfs_ilock(ip, XFS_IOLOCK_EXCL);
644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 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

	switch (bf->l_whence) {
	case 0: /*SEEK_SET*/
		break;
	case 1: /*SEEK_CUR*/
		bf->l_start += filp->f_pos;
		break;
	case 2: /*SEEK_END*/
		bf->l_start += XFS_ISIZE(ip);
		break;
	default:
		error = XFS_ERROR(EINVAL);
		goto out_unlock;
	}

	/*
	 * length of <= 0 for resv/unresv/zero is invalid.  length for
	 * alloc/free is ignored completely and we have no idea what userspace
	 * might have set it to, so set it to zero to allow range
	 * checks to pass.
	 */
	switch (cmd) {
	case XFS_IOC_ZERO_RANGE:
	case XFS_IOC_RESVSP:
	case XFS_IOC_RESVSP64:
	case XFS_IOC_UNRESVSP:
	case XFS_IOC_UNRESVSP64:
		if (bf->l_len <= 0) {
			error = XFS_ERROR(EINVAL);
			goto out_unlock;
		}
		break;
	default:
		bf->l_len = 0;
		break;
	}

	if (bf->l_start < 0 ||
	    bf->l_start > mp->m_super->s_maxbytes ||
	    bf->l_start + bf->l_len < 0 ||
	    bf->l_start + bf->l_len >= mp->m_super->s_maxbytes) {
		error = XFS_ERROR(EINVAL);
		goto out_unlock;
	}

	switch (cmd) {
	case XFS_IOC_ZERO_RANGE:
		error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
		if (!error)
			setprealloc = true;
		break;
	case XFS_IOC_RESVSP:
	case XFS_IOC_RESVSP64:
		error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
						XFS_BMAPI_PREALLOC);
		if (!error)
			setprealloc = true;
		break;
	case XFS_IOC_UNRESVSP:
	case XFS_IOC_UNRESVSP64:
		error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
		break;
	case XFS_IOC_ALLOCSP:
	case XFS_IOC_ALLOCSP64:
	case XFS_IOC_FREESP:
	case XFS_IOC_FREESP64:
		if (bf->l_start > XFS_ISIZE(ip)) {
			error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
					bf->l_start - XFS_ISIZE(ip), 0);
			if (error)
				goto out_unlock;
		}

		iattr.ia_valid = ATTR_SIZE;
		iattr.ia_size = bf->l_start;

		error = xfs_setattr_size(ip, &iattr);
		if (!error)
			clrprealloc = true;
		break;
	default:
		ASSERT(0);
		error = XFS_ERROR(EINVAL);
	}

	if (error)
		goto out_unlock;

	tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_writeid, 0, 0);
	if (error) {
		xfs_trans_cancel(tp, 0);
		goto out_unlock;
	}

	xfs_ilock(ip, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);

	if (!(ioflags & IO_INVIS)) {
		ip->i_d.di_mode &= ~S_ISUID;
		if (ip->i_d.di_mode & S_IXGRP)
			ip->i_d.di_mode &= ~S_ISGID;
		xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
	}

	if (setprealloc)
		ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
	else if (clrprealloc)
		ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;

	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	if (filp->f_flags & O_DSYNC)
		xfs_trans_set_sync(tp);
	error = xfs_trans_commit(tp, 0);

out_unlock:
760
	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
J
Jan Kara 已提交
761
	mnt_drop_write_file(filp);
L
Linus Torvalds 已提交
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
	return -error;
}

STATIC int
xfs_ioc_bulkstat(
	xfs_mount_t		*mp,
	unsigned int		cmd,
	void			__user *arg)
{
	xfs_fsop_bulkreq_t	bulkreq;
	int			count;	/* # of records returned */
	xfs_ino_t		inlast;	/* last inode number */
	int			done;
	int			error;

	/* done = 1 if there are more stats to get and if bulkstat */
	/* should be called again (unused here, but used in dmapi) */

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

	if (XFS_FORCED_SHUTDOWN(mp))
		return -XFS_ERROR(EIO);

	if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
		return -XFS_ERROR(EFAULT);

	if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
		return -XFS_ERROR(EFAULT);

	if ((count = bulkreq.icount) <= 0)
		return -XFS_ERROR(EINVAL);

795 796 797
	if (bulkreq.ubuffer == NULL)
		return -XFS_ERROR(EINVAL);

L
Linus Torvalds 已提交
798 799
	if (cmd == XFS_IOC_FSINUMBERS)
		error = xfs_inumbers(mp, &inlast, &count,
800
					bulkreq.ubuffer, xfs_inumbers_fmt);
L
Linus Torvalds 已提交
801 802 803
	else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
		error = xfs_bulkstat_single(mp, &inlast,
						bulkreq.ubuffer, &done);
804
	else	/* XFS_IOC_FSBULKSTAT */
805 806 807
		error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
				     sizeof(xfs_bstat_t), bulkreq.ubuffer,
				     &done);
L
Linus Torvalds 已提交
808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828

	if (error)
		return -error;

	if (bulkreq.ocount != NULL) {
		if (copy_to_user(bulkreq.lastip, &inlast,
						sizeof(xfs_ino_t)))
			return -XFS_ERROR(EFAULT);

		if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
			return -XFS_ERROR(EFAULT);
	}

	return 0;
}

STATIC int
xfs_ioc_fsgeometry_v1(
	xfs_mount_t		*mp,
	void			__user *arg)
{
829
	xfs_fsop_geom_t         fsgeo;
L
Linus Torvalds 已提交
830 831
	int			error;

832
	error = xfs_fs_geometry(mp, &fsgeo, 3);
L
Linus Torvalds 已提交
833 834 835
	if (error)
		return -error;

836 837 838 839 840 841
	/*
	 * Caller should have passed an argument of type
	 * xfs_fsop_geom_v1_t.  This is a proper subset of the
	 * xfs_fsop_geom_t that xfs_fs_geometry() fills in.
	 */
	if (copy_to_user(arg, &fsgeo, sizeof(xfs_fsop_geom_v1_t)))
L
Linus Torvalds 已提交
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873
		return -XFS_ERROR(EFAULT);
	return 0;
}

STATIC int
xfs_ioc_fsgeometry(
	xfs_mount_t		*mp,
	void			__user *arg)
{
	xfs_fsop_geom_t		fsgeo;
	int			error;

	error = xfs_fs_geometry(mp, &fsgeo, 4);
	if (error)
		return -error;

	if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
		return -XFS_ERROR(EFAULT);
	return 0;
}

/*
 * Linux extended inode flags interface.
 */

STATIC unsigned int
xfs_merge_ioc_xflags(
	unsigned int	flags,
	unsigned int	start)
{
	unsigned int	xflags = start;

874
	if (flags & FS_IMMUTABLE_FL)
L
Linus Torvalds 已提交
875 876 877
		xflags |= XFS_XFLAG_IMMUTABLE;
	else
		xflags &= ~XFS_XFLAG_IMMUTABLE;
878
	if (flags & FS_APPEND_FL)
L
Linus Torvalds 已提交
879 880 881
		xflags |= XFS_XFLAG_APPEND;
	else
		xflags &= ~XFS_XFLAG_APPEND;
882
	if (flags & FS_SYNC_FL)
L
Linus Torvalds 已提交
883 884 885
		xflags |= XFS_XFLAG_SYNC;
	else
		xflags &= ~XFS_XFLAG_SYNC;
886
	if (flags & FS_NOATIME_FL)
L
Linus Torvalds 已提交
887 888 889
		xflags |= XFS_XFLAG_NOATIME;
	else
		xflags &= ~XFS_XFLAG_NOATIME;
890
	if (flags & FS_NODUMP_FL)
L
Linus Torvalds 已提交
891 892 893 894 895 896 897 898 899 900 901 902 903 904
		xflags |= XFS_XFLAG_NODUMP;
	else
		xflags &= ~XFS_XFLAG_NODUMP;

	return xflags;
}

STATIC unsigned int
xfs_di2lxflags(
	__uint16_t	di_flags)
{
	unsigned int	flags = 0;

	if (di_flags & XFS_DIFLAG_IMMUTABLE)
905
		flags |= FS_IMMUTABLE_FL;
L
Linus Torvalds 已提交
906
	if (di_flags & XFS_DIFLAG_APPEND)
907
		flags |= FS_APPEND_FL;
L
Linus Torvalds 已提交
908
	if (di_flags & XFS_DIFLAG_SYNC)
909
		flags |= FS_SYNC_FL;
L
Linus Torvalds 已提交
910
	if (di_flags & XFS_DIFLAG_NOATIME)
911
		flags |= FS_NOATIME_FL;
L
Linus Torvalds 已提交
912
	if (di_flags & XFS_DIFLAG_NODUMP)
913
		flags |= FS_NODUMP_FL;
L
Linus Torvalds 已提交
914 915 916
	return flags;
}

917 918 919 920 921 922 923 924
STATIC int
xfs_ioc_fsgetxattr(
	xfs_inode_t		*ip,
	int			attr,
	void			__user *arg)
{
	struct fsxattr		fa;

925 926
	memset(&fa, 0, sizeof(struct fsxattr));

927 928 929
	xfs_ilock(ip, XFS_ILOCK_SHARED);
	fa.fsx_xflags = xfs_ip2xflags(ip);
	fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;
930
	fa.fsx_projid = xfs_get_projid(ip);
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954

	if (attr) {
		if (ip->i_afp) {
			if (ip->i_afp->if_flags & XFS_IFEXTENTS)
				fa.fsx_nextents = ip->i_afp->if_bytes /
							sizeof(xfs_bmbt_rec_t);
			else
				fa.fsx_nextents = ip->i_d.di_anextents;
		} else
			fa.fsx_nextents = 0;
	} else {
		if (ip->i_df.if_flags & XFS_IFEXTENTS)
			fa.fsx_nextents = ip->i_df.if_bytes /
						sizeof(xfs_bmbt_rec_t);
		else
			fa.fsx_nextents = ip->i_d.di_nextents;
	}
	xfs_iunlock(ip, XFS_ILOCK_SHARED);

	if (copy_to_user(arg, &fa, sizeof(fa)))
		return -EFAULT;
	return 0;
}

955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
STATIC void
xfs_set_diflags(
	struct xfs_inode	*ip,
	unsigned int		xflags)
{
	unsigned int		di_flags;

	/* can't set PREALLOC this way, just preserve it */
	di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
	if (xflags & XFS_XFLAG_IMMUTABLE)
		di_flags |= XFS_DIFLAG_IMMUTABLE;
	if (xflags & XFS_XFLAG_APPEND)
		di_flags |= XFS_DIFLAG_APPEND;
	if (xflags & XFS_XFLAG_SYNC)
		di_flags |= XFS_DIFLAG_SYNC;
	if (xflags & XFS_XFLAG_NOATIME)
		di_flags |= XFS_DIFLAG_NOATIME;
	if (xflags & XFS_XFLAG_NODUMP)
		di_flags |= XFS_DIFLAG_NODUMP;
	if (xflags & XFS_XFLAG_PROJINHERIT)
		di_flags |= XFS_DIFLAG_PROJINHERIT;
	if (xflags & XFS_XFLAG_NODEFRAG)
		di_flags |= XFS_DIFLAG_NODEFRAG;
	if (xflags & XFS_XFLAG_FILESTREAM)
		di_flags |= XFS_DIFLAG_FILESTREAM;
980
	if (S_ISDIR(ip->i_d.di_mode)) {
981 982 983 984 985 986
		if (xflags & XFS_XFLAG_RTINHERIT)
			di_flags |= XFS_DIFLAG_RTINHERIT;
		if (xflags & XFS_XFLAG_NOSYMLINKS)
			di_flags |= XFS_DIFLAG_NOSYMLINKS;
		if (xflags & XFS_XFLAG_EXTSZINHERIT)
			di_flags |= XFS_DIFLAG_EXTSZINHERIT;
987
	} else if (S_ISREG(ip->i_d.di_mode)) {
988 989 990 991 992 993 994 995 996
		if (xflags & XFS_XFLAG_REALTIME)
			di_flags |= XFS_DIFLAG_REALTIME;
		if (xflags & XFS_XFLAG_EXTSIZE)
			di_flags |= XFS_DIFLAG_EXTSIZE;
	}

	ip->i_d.di_flags = di_flags;
}

997 998 999 1000
STATIC void
xfs_diflags_to_linux(
	struct xfs_inode	*ip)
{
1001
	struct inode		*inode = VFS_I(ip);
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
	unsigned int		xflags = xfs_ip2xflags(ip);

	if (xflags & XFS_XFLAG_IMMUTABLE)
		inode->i_flags |= S_IMMUTABLE;
	else
		inode->i_flags &= ~S_IMMUTABLE;
	if (xflags & XFS_XFLAG_APPEND)
		inode->i_flags |= S_APPEND;
	else
		inode->i_flags &= ~S_APPEND;
	if (xflags & XFS_XFLAG_SYNC)
		inode->i_flags |= S_SYNC;
	else
		inode->i_flags &= ~S_SYNC;
	if (xflags & XFS_XFLAG_NOATIME)
		inode->i_flags |= S_NOATIME;
	else
		inode->i_flags &= ~S_NOATIME;
}
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035

#define FSX_PROJID	1
#define FSX_EXTSIZE	2
#define FSX_XFLAGS	4
#define FSX_NONBLOCK	8

STATIC int
xfs_ioctl_setattr(
	xfs_inode_t		*ip,
	struct fsxattr		*fa,
	int			mask)
{
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_trans	*tp;
	unsigned int		lock_flags = 0;
C
Christoph Hellwig 已提交
1036
	struct xfs_dquot	*udqp = NULL;
1037
	struct xfs_dquot	*pdqp = NULL;
1038 1039 1040
	struct xfs_dquot	*olddquot = NULL;
	int			code;

C
Christoph Hellwig 已提交
1041
	trace_xfs_ioctl_setattr(ip);
1042 1043 1044 1045 1046 1047

	if (mp->m_flags & XFS_MOUNT_RDONLY)
		return XFS_ERROR(EROFS);
	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

1048
	/*
1049
	 * Disallow 32bit project ids when projid32bit feature is not enabled.
1050
	 */
1051 1052
	if ((mask & FSX_PROJID) && (fa->fsx_projid > (__uint16_t)-1) &&
			!xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
1053 1054
		return XFS_ERROR(EINVAL);

1055 1056 1057 1058 1059 1060 1061 1062 1063
	/*
	 * If disk quotas is on, we make sure that the dquots do exist on disk,
	 * before we start any other transactions. Trying to do this later
	 * is messy. We don't care to take a readlock to look at the ids
	 * in inode here, because we can't hold it across the trans_reserve.
	 * If the IDs do change before we take the ilock, we're covered
	 * because the i_*dquot fields will get updated anyway.
	 */
	if (XFS_IS_QUOTA_ON(mp) && (mask & FSX_PROJID)) {
C
Christoph Hellwig 已提交
1064
		code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
1065
					 ip->i_d.di_gid, fa->fsx_projid,
1066
					 XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
1067 1068 1069 1070 1071 1072 1073 1074 1075
		if (code)
			return code;
	}

	/*
	 * For the other attributes, we acquire the inode lock and
	 * first do an error checking pass.
	 */
	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
1076
	code = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
	if (code)
		goto error_return;

	lock_flags = XFS_ILOCK_EXCL;
	xfs_ilock(ip, lock_flags);

	/*
	 * CAP_FOWNER overrides the following restrictions:
	 *
	 * The user ID of the calling process must be equal
	 * to the file owner ID, except in cases where the
	 * CAP_FSETID capability is applicable.
	 */
1090
	if (!inode_owner_or_capable(VFS_I(ip))) {
1091 1092 1093 1094 1095 1096
		code = XFS_ERROR(EPERM);
		goto error_return;
	}

	/*
	 * Do a quota reservation only if projid is actually going to change.
1097 1098
	 * Only allow changing of projid from init_user_ns since it is a
	 * non user namespace aware identifier.
1099 1100
	 */
	if (mask & FSX_PROJID) {
1101 1102 1103 1104 1105
		if (current_user_ns() != &init_user_ns) {
			code = XFS_ERROR(EINVAL);
			goto error_return;
		}

C
Christoph Hellwig 已提交
1106 1107
		if (XFS_IS_QUOTA_RUNNING(mp) &&
		    XFS_IS_PQUOTA_ON(mp) &&
1108
		    xfs_get_projid(ip) != fa->fsx_projid) {
1109
			ASSERT(tp);
1110 1111
			code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL,
						pdqp, capable(CAP_FOWNER) ?
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
						XFS_QMOPT_FORCE_RES : 0);
			if (code)	/* out of quota */
				goto error_return;
		}
	}

	if (mask & FSX_EXTSIZE) {
		/*
		 * Can't change extent size if any extents are allocated.
		 */
		if (ip->i_d.di_nextents &&
		    ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=
		     fa->fsx_extsize)) {
			code = XFS_ERROR(EINVAL);	/* EFBIG? */
			goto error_return;
		}

		/*
		 * Extent size must be a multiple of the appropriate block
1131 1132 1133 1134 1135 1136
		 * size, if set at all. It must also be smaller than the
		 * maximum extent size supported by the filesystem.
		 *
		 * Also, for non-realtime files, limit the extent size hint to
		 * half the size of the AGs in the filesystem so alignment
		 * doesn't result in extents larger than an AG.
1137 1138
		 */
		if (fa->fsx_extsize != 0) {
1139 1140 1141 1142 1143 1144 1145 1146
			xfs_extlen_t    size;
			xfs_fsblock_t   extsize_fsb;

			extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
			if (extsize_fsb > MAXEXTLEN) {
				code = XFS_ERROR(EINVAL);
				goto error_return;
			}
1147 1148 1149 1150 1151 1152 1153 1154

			if (XFS_IS_REALTIME_INODE(ip) ||
			    ((mask & FSX_XFLAGS) &&
			    (fa->fsx_xflags & XFS_XFLAG_REALTIME))) {
				size = mp->m_sb.sb_rextsize <<
				       mp->m_sb.sb_blocklog;
			} else {
				size = mp->m_sb.sb_blocksize;
1155 1156 1157 1158
				if (extsize_fsb > mp->m_sb.sb_agblocks / 2) {
					code = XFS_ERROR(EINVAL);
					goto error_return;
				}
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
			}

			if (fa->fsx_extsize % size) {
				code = XFS_ERROR(EINVAL);
				goto error_return;
			}
		}
	}


	if (mask & FSX_XFLAGS) {
		/*
		 * Can't change realtime flag if any extents are allocated.
		 */
		if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
		    (XFS_IS_REALTIME_INODE(ip)) !=
		    (fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
			code = XFS_ERROR(EINVAL);	/* EFBIG? */
			goto error_return;
		}

		/*
		 * If realtime flag is set then must have realtime data.
		 */
		if ((fa->fsx_xflags & XFS_XFLAG_REALTIME)) {
			if ((mp->m_sb.sb_rblocks == 0) ||
			    (mp->m_sb.sb_rextsize == 0) ||
			    (ip->i_d.di_extsize % mp->m_sb.sb_rextsize)) {
				code = XFS_ERROR(EINVAL);
				goto error_return;
			}
		}

		/*
		 * Can't modify an immutable/append-only file unless
		 * we have appropriate permission.
		 */
		if ((ip->i_d.di_flags &
				(XFS_DIFLAG_IMMUTABLE|XFS_DIFLAG_APPEND) ||
		     (fa->fsx_xflags &
				(XFS_XFLAG_IMMUTABLE | XFS_XFLAG_APPEND))) &&
		    !capable(CAP_LINUX_IMMUTABLE)) {
			code = XFS_ERROR(EPERM);
			goto error_return;
		}
	}

1206
	xfs_trans_ijoin(tp, ip, 0);
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218

	/*
	 * Change file ownership.  Must be the owner or privileged.
	 */
	if (mask & FSX_PROJID) {
		/*
		 * CAP_FSETID overrides the following restrictions:
		 *
		 * The set-user-ID and set-group-ID bits of a file will be
		 * cleared upon successful return from chown()
		 */
		if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
1219
		    !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))
1220 1221 1222 1223 1224 1225
			ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);

		/*
		 * Change the ownerships and register quota modifications
		 * in the transaction.
		 */
1226
		if (xfs_get_projid(ip) != fa->fsx_projid) {
C
Christoph Hellwig 已提交
1227 1228
			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
				olddquot = xfs_qm_vop_chown(tp, ip,
1229
							&ip->i_pdquot, pdqp);
1230
			}
1231
			ASSERT(ip->i_d.di_version > 1);
1232
			xfs_set_projid(ip, fa->fsx_projid);
1233 1234 1235 1236 1237 1238
		}

	}

	if (mask & FSX_EXTSIZE)
		ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
1239
	if (mask & FSX_XFLAGS) {
1240
		xfs_set_diflags(ip, fa->fsx_xflags);
1241 1242
		xfs_diflags_to_linux(ip);
	}
1243

1244
	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

	XFS_STATS_INC(xs_ig_attrchg);

	/*
	 * If this is a synchronous mount, make sure that the
	 * transaction goes to disk before returning to the user.
	 * This is slightly sub-optimal in that truncates require
	 * two sync transactions instead of one for wsync filesystems.
	 * One for the truncate and one for the timestamps since we
	 * don't want to change the timestamps unless we're sure the
	 * truncate worked.  Truncates are less than 1% of the laddis
	 * mix so this probably isn't worth the trouble to optimize.
	 */
	if (mp->m_flags & XFS_MOUNT_WSYNC)
		xfs_trans_set_sync(tp);
	code = xfs_trans_commit(tp, 0);
	xfs_iunlock(ip, lock_flags);

	/*
	 * Release any dquot(s) the inode had kept before chown.
	 */
C
Christoph Hellwig 已提交
1267 1268
	xfs_qm_dqrele(olddquot);
	xfs_qm_dqrele(udqp);
1269
	xfs_qm_dqrele(pdqp);
1270

C
Christoph Hellwig 已提交
1271
	return code;
1272 1273

 error_return:
C
Christoph Hellwig 已提交
1274
	xfs_qm_dqrele(udqp);
1275
	xfs_qm_dqrele(pdqp);
1276 1277 1278 1279 1280 1281
	xfs_trans_cancel(tp, 0);
	if (lock_flags)
		xfs_iunlock(ip, lock_flags);
	return code;
}

L
Linus Torvalds 已提交
1282
STATIC int
L
Lachlan McIlroy 已提交
1283
xfs_ioc_fssetxattr(
L
Linus Torvalds 已提交
1284 1285 1286 1287 1288
	xfs_inode_t		*ip,
	struct file		*filp,
	void			__user *arg)
{
	struct fsxattr		fa;
1289
	unsigned int		mask;
J
Jan Kara 已提交
1290
	int error;
L
Lachlan McIlroy 已提交
1291 1292 1293

	if (copy_from_user(&fa, arg, sizeof(fa)))
		return -EFAULT;
L
Linus Torvalds 已提交
1294

1295
	mask = FSX_XFLAGS | FSX_EXTSIZE | FSX_PROJID;
L
Lachlan McIlroy 已提交
1296
	if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1297
		mask |= FSX_NONBLOCK;
L
Linus Torvalds 已提交
1298

J
Jan Kara 已提交
1299 1300 1301 1302 1303 1304
	error = mnt_want_write_file(filp);
	if (error)
		return error;
	error = xfs_ioctl_setattr(ip, &fa, mask);
	mnt_drop_write_file(filp);
	return -error;
L
Lachlan McIlroy 已提交
1305
}
L
Linus Torvalds 已提交
1306

L
Lachlan McIlroy 已提交
1307 1308 1309 1310 1311 1312
STATIC int
xfs_ioc_getxflags(
	xfs_inode_t		*ip,
	void			__user *arg)
{
	unsigned int		flags;
L
Linus Torvalds 已提交
1313

L
Lachlan McIlroy 已提交
1314 1315 1316 1317 1318
	flags = xfs_di2lxflags(ip->i_d.di_flags);
	if (copy_to_user(arg, &flags, sizeof(flags)))
		return -EFAULT;
	return 0;
}
L
Linus Torvalds 已提交
1319

L
Lachlan McIlroy 已提交
1320 1321 1322 1323 1324 1325
STATIC int
xfs_ioc_setxflags(
	xfs_inode_t		*ip,
	struct file		*filp,
	void			__user *arg)
{
1326
	struct fsxattr		fa;
L
Lachlan McIlroy 已提交
1327
	unsigned int		flags;
1328
	unsigned int		mask;
J
Jan Kara 已提交
1329
	int error;
L
Linus Torvalds 已提交
1330

L
Lachlan McIlroy 已提交
1331 1332
	if (copy_from_user(&flags, arg, sizeof(flags)))
		return -EFAULT;
L
Linus Torvalds 已提交
1333

L
Lachlan McIlroy 已提交
1334 1335 1336 1337
	if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
		      FS_NOATIME_FL | FS_NODUMP_FL | \
		      FS_SYNC_FL))
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
1338

1339
	mask = FSX_XFLAGS;
L
Lachlan McIlroy 已提交
1340
	if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
1341 1342
		mask |= FSX_NONBLOCK;
	fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
L
Linus Torvalds 已提交
1343

J
Jan Kara 已提交
1344 1345 1346 1347 1348 1349
	error = mnt_want_write_file(filp);
	if (error)
		return error;
	error = xfs_ioctl_setattr(ip, &fa, mask);
	mnt_drop_write_file(filp);
	return -error;
L
Linus Torvalds 已提交
1350 1351
}

1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
STATIC int
xfs_getbmap_format(void **ap, struct getbmapx *bmv, int *full)
{
	struct getbmap __user	*base = *ap;

	/* copy only getbmap portion (not getbmapx) */
	if (copy_to_user(base, bmv, sizeof(struct getbmap)))
		return XFS_ERROR(EFAULT);

	*ap += sizeof(struct getbmap);
	return 0;
}

L
Linus Torvalds 已提交
1365 1366
STATIC int
xfs_ioc_getbmap(
1367
	struct xfs_inode	*ip,
L
Linus Torvalds 已提交
1368 1369 1370 1371
	int			ioflags,
	unsigned int		cmd,
	void			__user *arg)
{
1372
	struct getbmapx		bmx;
L
Linus Torvalds 已提交
1373 1374
	int			error;

1375
	if (copy_from_user(&bmx, arg, sizeof(struct getbmapx)))
L
Linus Torvalds 已提交
1376 1377
		return -XFS_ERROR(EFAULT);

1378
	if (bmx.bmv_count < 2)
L
Linus Torvalds 已提交
1379 1380
		return -XFS_ERROR(EINVAL);

1381
	bmx.bmv_iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
L
Linus Torvalds 已提交
1382
	if (ioflags & IO_INVIS)
1383
		bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
L
Linus Torvalds 已提交
1384

1385 1386
	error = xfs_getbmap(ip, &bmx, xfs_getbmap_format,
			    (struct getbmap *)arg+1);
L
Linus Torvalds 已提交
1387 1388 1389
	if (error)
		return -error;

1390 1391
	/* copy back header - only size of getbmap */
	if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
L
Linus Torvalds 已提交
1392 1393 1394 1395
		return -XFS_ERROR(EFAULT);
	return 0;
}

1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
STATIC int
xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
{
	struct getbmapx __user	*base = *ap;

	if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
		return XFS_ERROR(EFAULT);

	*ap += sizeof(struct getbmapx);
	return 0;
}

L
Linus Torvalds 已提交
1408 1409
STATIC int
xfs_ioc_getbmapx(
1410
	struct xfs_inode	*ip,
L
Linus Torvalds 已提交
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
	void			__user *arg)
{
	struct getbmapx		bmx;
	int			error;

	if (copy_from_user(&bmx, arg, sizeof(bmx)))
		return -XFS_ERROR(EFAULT);

	if (bmx.bmv_count < 2)
		return -XFS_ERROR(EINVAL);

1422
	if (bmx.bmv_iflags & (~BMV_IF_VALID))
L
Linus Torvalds 已提交
1423 1424
		return -XFS_ERROR(EINVAL);

1425 1426
	error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
			    (struct getbmapx *)arg+1);
L
Linus Torvalds 已提交
1427 1428 1429
	if (error)
		return -error;

1430 1431
	/* copy back header */
	if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
L
Linus Torvalds 已提交
1432 1433 1434 1435
		return -XFS_ERROR(EFAULT);

	return 0;
}
L
Lachlan McIlroy 已提交
1436

D
Dave Chinner 已提交
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
int
xfs_ioc_swapext(
	xfs_swapext_t	*sxp)
{
	xfs_inode_t     *ip, *tip;
	struct fd	f, tmp;
	int		error = 0;

	/* Pull information for the target fd */
	f = fdget((int)sxp->sx_fdtarget);
	if (!f.file) {
		error = XFS_ERROR(EINVAL);
		goto out;
	}

	if (!(f.file->f_mode & FMODE_WRITE) ||
	    !(f.file->f_mode & FMODE_READ) ||
	    (f.file->f_flags & O_APPEND)) {
		error = XFS_ERROR(EBADF);
		goto out_put_file;
	}

	tmp = fdget((int)sxp->sx_fdtmp);
	if (!tmp.file) {
		error = XFS_ERROR(EINVAL);
		goto out_put_file;
	}

	if (!(tmp.file->f_mode & FMODE_WRITE) ||
	    !(tmp.file->f_mode & FMODE_READ) ||
	    (tmp.file->f_flags & O_APPEND)) {
		error = XFS_ERROR(EBADF);
		goto out_put_tmp_file;
	}

	if (IS_SWAPFILE(file_inode(f.file)) ||
	    IS_SWAPFILE(file_inode(tmp.file))) {
		error = XFS_ERROR(EINVAL);
		goto out_put_tmp_file;
	}

	ip = XFS_I(file_inode(f.file));
	tip = XFS_I(file_inode(tmp.file));

	if (ip->i_mount != tip->i_mount) {
		error = XFS_ERROR(EINVAL);
		goto out_put_tmp_file;
	}

	if (ip->i_ino == tip->i_ino) {
		error = XFS_ERROR(EINVAL);
		goto out_put_tmp_file;
	}

	if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
		error = XFS_ERROR(EIO);
		goto out_put_tmp_file;
	}

	error = xfs_swap_extents(ip, tip, sxp);

 out_put_tmp_file:
	fdput(tmp);
 out_put_file:
	fdput(f);
 out:
	return error;
}

1506 1507 1508 1509 1510 1511 1512 1513
/*
 * Note: some of the ioctl's return positive numbers as a
 * byte count indicating success, such as readlink_by_handle.
 * So we don't "sign flip" like most other routines.  This means
 * true errors need to be returned as a negative value.
 */
long
xfs_file_ioctl(
L
Lachlan McIlroy 已提交
1514 1515
	struct file		*filp,
	unsigned int		cmd,
1516
	unsigned long		p)
L
Lachlan McIlroy 已提交
1517
{
A
Al Viro 已提交
1518
	struct inode		*inode = file_inode(filp);
1519 1520 1521 1522
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	void			__user *arg = (void __user *)p;
	int			ioflags = 0;
L
Lachlan McIlroy 已提交
1523 1524
	int			error;

1525 1526
	if (filp->f_mode & FMODE_NOCMTIME)
		ioflags |= IO_INVIS;
L
Lachlan McIlroy 已提交
1527

C
Christoph Hellwig 已提交
1528
	trace_xfs_file_ioctl(ip);
1529 1530

	switch (cmd) {
C
Christoph Hellwig 已提交
1531 1532
	case FITRIM:
		return xfs_ioc_trim(mp, arg);
L
Lachlan McIlroy 已提交
1533 1534 1535 1536 1537 1538 1539
	case XFS_IOC_ALLOCSP:
	case XFS_IOC_FREESP:
	case XFS_IOC_RESVSP:
	case XFS_IOC_UNRESVSP:
	case XFS_IOC_ALLOCSP64:
	case XFS_IOC_FREESP64:
	case XFS_IOC_RESVSP64:
D
Dave Chinner 已提交
1540 1541
	case XFS_IOC_UNRESVSP64:
	case XFS_IOC_ZERO_RANGE: {
1542
		xfs_flock64_t		bf;
L
Lachlan McIlroy 已提交
1543

1544 1545 1546 1547
		if (copy_from_user(&bf, arg, sizeof(bf)))
			return -XFS_ERROR(EFAULT);
		return xfs_ioc_space(ip, inode, filp, ioflags, cmd, &bf);
	}
L
Lachlan McIlroy 已提交
1548 1549 1550 1551 1552 1553
	case XFS_IOC_DIOINFO: {
		struct dioattr	da;
		xfs_buftarg_t	*target =
			XFS_IS_REALTIME_INODE(ip) ?
			mp->m_rtdev_targp : mp->m_ddev_targp;

1554
		da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
L
Lachlan McIlroy 已提交
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
		da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);

		if (copy_to_user(arg, &da, sizeof(da)))
			return -XFS_ERROR(EFAULT);
		return 0;
	}

	case XFS_IOC_FSBULKSTAT_SINGLE:
	case XFS_IOC_FSBULKSTAT:
	case XFS_IOC_FSINUMBERS:
		return xfs_ioc_bulkstat(mp, cmd, arg);

	case XFS_IOC_FSGEOMETRY_V1:
		return xfs_ioc_fsgeometry_v1(mp, arg);

	case XFS_IOC_FSGEOMETRY:
		return xfs_ioc_fsgeometry(mp, arg);

	case XFS_IOC_GETVERSION:
		return put_user(inode->i_generation, (int __user *)arg);

	case XFS_IOC_FSGETXATTR:
		return xfs_ioc_fsgetxattr(ip, 0, arg);
	case XFS_IOC_FSGETXATTRA:
		return xfs_ioc_fsgetxattr(ip, 1, arg);
L
Lachlan McIlroy 已提交
1580 1581
	case XFS_IOC_FSSETXATTR:
		return xfs_ioc_fssetxattr(ip, filp, arg);
L
Lachlan McIlroy 已提交
1582
	case XFS_IOC_GETXFLAGS:
L
Lachlan McIlroy 已提交
1583
		return xfs_ioc_getxflags(ip, arg);
L
Lachlan McIlroy 已提交
1584
	case XFS_IOC_SETXFLAGS:
L
Lachlan McIlroy 已提交
1585
		return xfs_ioc_setxflags(ip, filp, arg);
L
Lachlan McIlroy 已提交
1586 1587 1588 1589 1590 1591 1592

	case XFS_IOC_FSSETDM: {
		struct fsdmidata	dmi;

		if (copy_from_user(&dmi, arg, sizeof(dmi)))
			return -XFS_ERROR(EFAULT);

J
Jan Kara 已提交
1593 1594 1595 1596
		error = mnt_want_write_file(filp);
		if (error)
			return error;

L
Lachlan McIlroy 已提交
1597 1598
		error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
				dmi.fsd_dmstate);
J
Jan Kara 已提交
1599
		mnt_drop_write_file(filp);
L
Lachlan McIlroy 已提交
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
		return -error;
	}

	case XFS_IOC_GETBMAP:
	case XFS_IOC_GETBMAPA:
		return xfs_ioc_getbmap(ip, ioflags, cmd, arg);

	case XFS_IOC_GETBMAPX:
		return xfs_ioc_getbmapx(ip, arg);

	case XFS_IOC_FD_TO_HANDLE:
	case XFS_IOC_PATH_TO_HANDLE:
1612 1613
	case XFS_IOC_PATH_TO_FSHANDLE: {
		xfs_fsop_handlereq_t	hreq;
L
Lachlan McIlroy 已提交
1614

1615 1616 1617 1618 1619 1620
		if (copy_from_user(&hreq, arg, sizeof(hreq)))
			return -XFS_ERROR(EFAULT);
		return xfs_find_handle(cmd, &hreq);
	}
	case XFS_IOC_OPEN_BY_HANDLE: {
		xfs_fsop_handlereq_t	hreq;
L
Lachlan McIlroy 已提交
1621

1622 1623
		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
			return -XFS_ERROR(EFAULT);
1624
		return xfs_open_by_handle(filp, &hreq);
1625
	}
L
Lachlan McIlroy 已提交
1626
	case XFS_IOC_FSSETDM_BY_HANDLE:
1627
		return xfs_fssetdm_by_handle(filp, arg);
L
Lachlan McIlroy 已提交
1628

1629 1630
	case XFS_IOC_READLINK_BY_HANDLE: {
		xfs_fsop_handlereq_t	hreq;
L
Lachlan McIlroy 已提交
1631

1632 1633
		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
			return -XFS_ERROR(EFAULT);
1634
		return xfs_readlink_by_handle(filp, &hreq);
1635
	}
L
Lachlan McIlroy 已提交
1636
	case XFS_IOC_ATTRLIST_BY_HANDLE:
1637
		return xfs_attrlist_by_handle(filp, arg);
L
Lachlan McIlroy 已提交
1638 1639

	case XFS_IOC_ATTRMULTI_BY_HANDLE:
1640
		return xfs_attrmulti_by_handle(filp, arg);
L
Lachlan McIlroy 已提交
1641 1642

	case XFS_IOC_SWAPEXT: {
1643 1644 1645 1646
		struct xfs_swapext	sxp;

		if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
			return -XFS_ERROR(EFAULT);
J
Jan Kara 已提交
1647 1648 1649
		error = mnt_want_write_file(filp);
		if (error)
			return error;
D
Dave Chinner 已提交
1650
		error = xfs_ioc_swapext(&sxp);
J
Jan Kara 已提交
1651
		mnt_drop_write_file(filp);
L
Lachlan McIlroy 已提交
1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
		return -error;
	}

	case XFS_IOC_FSCOUNTS: {
		xfs_fsop_counts_t out;

		error = xfs_fs_counts(mp, &out);
		if (error)
			return -error;

		if (copy_to_user(arg, &out, sizeof(out)))
			return -XFS_ERROR(EFAULT);
		return 0;
	}

	case XFS_IOC_SET_RESBLKS: {
		xfs_fsop_resblks_t inout;
		__uint64_t	   in;

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

E
Eric Sandeen 已提交
1674 1675 1676
		if (mp->m_flags & XFS_MOUNT_RDONLY)
			return -XFS_ERROR(EROFS);

L
Lachlan McIlroy 已提交
1677 1678 1679
		if (copy_from_user(&inout, arg, sizeof(inout)))
			return -XFS_ERROR(EFAULT);

J
Jan Kara 已提交
1680 1681 1682 1683
		error = mnt_want_write_file(filp);
		if (error)
			return error;

L
Lachlan McIlroy 已提交
1684 1685 1686
		/* input parameter is passed in resblks field of structure */
		in = inout.resblks;
		error = xfs_reserve_blocks(mp, &in, &inout);
J
Jan Kara 已提交
1687
		mnt_drop_write_file(filp);
L
Lachlan McIlroy 已提交
1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
		if (error)
			return -error;

		if (copy_to_user(arg, &inout, sizeof(inout)))
			return -XFS_ERROR(EFAULT);
		return 0;
	}

	case XFS_IOC_GET_RESBLKS: {
		xfs_fsop_resblks_t out;

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

		error = xfs_reserve_blocks(mp, NULL, &out);
		if (error)
			return -error;

		if (copy_to_user(arg, &out, sizeof(out)))
			return -XFS_ERROR(EFAULT);

		return 0;
	}

	case XFS_IOC_FSGROWFSDATA: {
		xfs_growfs_data_t in;

		if (copy_from_user(&in, arg, sizeof(in)))
			return -XFS_ERROR(EFAULT);

J
Jan Kara 已提交
1718 1719 1720
		error = mnt_want_write_file(filp);
		if (error)
			return error;
L
Lachlan McIlroy 已提交
1721
		error = xfs_growfs_data(mp, &in);
J
Jan Kara 已提交
1722
		mnt_drop_write_file(filp);
L
Lachlan McIlroy 已提交
1723 1724 1725 1726 1727 1728 1729 1730 1731
		return -error;
	}

	case XFS_IOC_FSGROWFSLOG: {
		xfs_growfs_log_t in;

		if (copy_from_user(&in, arg, sizeof(in)))
			return -XFS_ERROR(EFAULT);

J
Jan Kara 已提交
1732 1733 1734
		error = mnt_want_write_file(filp);
		if (error)
			return error;
L
Lachlan McIlroy 已提交
1735
		error = xfs_growfs_log(mp, &in);
J
Jan Kara 已提交
1736
		mnt_drop_write_file(filp);
L
Lachlan McIlroy 已提交
1737 1738 1739 1740 1741 1742 1743 1744 1745
		return -error;
	}

	case XFS_IOC_FSGROWFSRT: {
		xfs_growfs_rt_t in;

		if (copy_from_user(&in, arg, sizeof(in)))
			return -XFS_ERROR(EFAULT);

J
Jan Kara 已提交
1746 1747 1748
		error = mnt_want_write_file(filp);
		if (error)
			return error;
L
Lachlan McIlroy 已提交
1749
		error = xfs_growfs_rt(mp, &in);
J
Jan Kara 已提交
1750
		mnt_drop_write_file(filp);
L
Lachlan McIlroy 已提交
1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786
		return -error;
	}

	case XFS_IOC_GOINGDOWN: {
		__uint32_t in;

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

		if (get_user(in, (__uint32_t __user *)arg))
			return -XFS_ERROR(EFAULT);

		error = xfs_fs_goingdown(mp, in);
		return -error;
	}

	case XFS_IOC_ERROR_INJECTION: {
		xfs_error_injection_t in;

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

		if (copy_from_user(&in, arg, sizeof(in)))
			return -XFS_ERROR(EFAULT);

		error = xfs_errortag_add(in.errtag, mp);
		return -error;
	}

	case XFS_IOC_ERROR_CLEARALL:
		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;

		error = xfs_errortag_clearall(mp, 1);
		return -error;

1787
	case XFS_IOC_FREE_EOFBLOCKS: {
1788 1789
		struct xfs_fs_eofblocks eofb;
		struct xfs_eofblocks keofb;
1790

1791 1792 1793 1794 1795 1796
		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;

		if (mp->m_flags & XFS_MOUNT_RDONLY)
			return -XFS_ERROR(EROFS);

1797 1798 1799
		if (copy_from_user(&eofb, arg, sizeof(eofb)))
			return -XFS_ERROR(EFAULT);

1800 1801 1802
		error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
		if (error)
			return -error;
1803

1804
		return -xfs_icache_free_eofblocks(mp, &keofb);
1805 1806
	}

L
Lachlan McIlroy 已提交
1807 1808 1809 1810
	default:
		return -ENOTTY;
	}
}