xfs_ioctl.c 47.2 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 25
#include "xfs_mount.h"
#include "xfs_inode.h"
26
#include "xfs_ioctl.h"
27
#include "xfs_alloc.h"
L
Linus Torvalds 已提交
28 29
#include "xfs_rtalloc.h"
#include "xfs_itable.h"
30
#include "xfs_error.h"
L
Linus Torvalds 已提交
31
#include "xfs_attr.h"
32
#include "xfs_bmap.h"
D
Dave Chinner 已提交
33
#include "xfs_bmap_util.h"
L
Linus Torvalds 已提交
34
#include "xfs_fsops.h"
C
Christoph Hellwig 已提交
35
#include "xfs_discard.h"
36
#include "xfs_quota.h"
37
#include "xfs_export.h"
C
Christoph Hellwig 已提交
38
#include "xfs_trace.h"
39
#include "xfs_icache.h"
D
Dave Chinner 已提交
40
#include "xfs_symlink.h"
41
#include "xfs_trans.h"
42
#include "xfs_pnfs.h"
43
#include "xfs_acl.h"
44 45 46
#include "xfs_btree.h"
#include <linux/fsmap.h>
#include "xfs_fsmap.h"
L
Linus Torvalds 已提交
47

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

/*
 * 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
 */
68
int
L
Linus Torvalds 已提交
69 70
xfs_find_handle(
	unsigned int		cmd,
71
	xfs_fsop_handlereq_t	*hreq)
L
Linus Torvalds 已提交
72 73 74 75
{
	int			hsize;
	xfs_handle_t		handle;
	struct inode		*inode;
76
	struct fd		f = {NULL};
C
Christoph Hellwig 已提交
77
	struct path		path;
78
	int			error;
C
Christoph Hellwig 已提交
79
	struct xfs_inode	*ip;
L
Linus Torvalds 已提交
80

C
Christoph Hellwig 已提交
81
	if (cmd == XFS_IOC_FD_TO_HANDLE) {
82 83
		f = fdget(hreq->fd);
		if (!f.file)
C
Christoph Hellwig 已提交
84
			return -EBADF;
A
Al Viro 已提交
85
		inode = file_inode(f.file);
C
Christoph Hellwig 已提交
86 87 88 89
	} else {
		error = user_lpath((const char __user *)hreq->path, &path);
		if (error)
			return error;
90
		inode = d_inode(path.dentry);
L
Linus Torvalds 已提交
91
	}
C
Christoph Hellwig 已提交
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
	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 已提交
118 119 120
		handle.ha_fid.fid_len = sizeof(xfs_fid_t) -
					sizeof(handle.ha_fid.fid_len);
		handle.ha_fid.fid_pad = 0;
121
		handle.ha_fid.fid_gen = inode->i_generation;
C
Christoph Hellwig 已提交
122
		handle.ha_fid.fid_ino = ip->i_ino;
L
Linus Torvalds 已提交
123 124 125 126

		hsize = XFS_HSIZE(handle);
	}

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

C
Christoph Hellwig 已提交
132 133 134 135
	error = 0;

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

/*
143 144
 * No need to do permission checks on the various pathname components
 * as the handle operations are privileged.
L
Linus Torvalds 已提交
145 146
 */
STATIC int
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
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 已提交
162 163
{
	xfs_handle_t		handle;
164
	struct xfs_fid64	fid;
L
Linus Torvalds 已提交
165 166 167 168

	/*
	 * Only allow handle opens under a directory.
	 */
A
Al Viro 已提交
169
	if (!S_ISDIR(file_inode(parfilp)->i_mode))
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
		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 已提交
188

189 190 191 192 193 194
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 已提交
195 196
}

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

	if (!capable(CAP_SYS_ADMIN))
E
Eric Sandeen 已提交
213
		return -EPERM;
L
Linus Torvalds 已提交
214

215 216 217
	dentry = xfs_handlereq_to_dentry(parfilp, hreq);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
218
	inode = d_inode(dentry);
L
Linus Torvalds 已提交
219 220 221

	/* Restrict xfs_open_by_handle to directories & regular files. */
	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {
E
Eric Sandeen 已提交
222
		error = -EPERM;
223
		goto out_dput;
L
Linus Torvalds 已提交
224 225 226
	}

#if BITS_PER_LONG != 32
227
	hreq->oflags |= O_LARGEFILE;
L
Linus Torvalds 已提交
228
#endif
229

230
	permflag = hreq->oflags;
231
	fmode = OPEN_FMODE(permflag);
L
Linus Torvalds 已提交
232
	if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&
233
	    (fmode & FMODE_WRITE) && IS_APPEND(inode)) {
E
Eric Sandeen 已提交
234
		error = -EPERM;
235
		goto out_dput;
L
Linus Torvalds 已提交
236 237
	}

238
	if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {
E
Eryu Guan 已提交
239
		error = -EPERM;
240
		goto out_dput;
L
Linus Torvalds 已提交
241 242 243
	}

	/* Can't write directories. */
244
	if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {
E
Eric Sandeen 已提交
245
		error = -EISDIR;
246
		goto out_dput;
L
Linus Torvalds 已提交
247 248
	}

249
	fd = get_unused_fd_flags(0);
250 251 252
	if (fd < 0) {
		error = fd;
		goto out_dput;
L
Linus Torvalds 已提交
253 254
	}

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

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

269 270 271 272 273 274
	fd_install(fd, filp);
	return fd;

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

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

	if (!capable(CAP_SYS_ADMIN))
E
Eric Sandeen 已提交
287
		return -EPERM;
L
Linus Torvalds 已提交
288

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

	/* Restrict this handle operation to symlinks only. */
294
	if (!d_is_symlink(dentry)) {
E
Eric Sandeen 已提交
295
		error = -EINVAL;
296
		goto out_dput;
L
Linus Torvalds 已提交
297 298
	}

299
	if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {
E
Eric Sandeen 已提交
300
		error = -EFAULT;
301
		goto out_dput;
L
Linus Torvalds 已提交
302 303
	}

304
	error = vfs_readlink(dentry, hreq->ohandle, olen);
305

306 307
 out_dput:
	dput(dentry);
308
	return error;
L
Linus Torvalds 已提交
309 310
}

D
Dave Chinner 已提交
311 312 313 314 315 316 317 318 319 320 321
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))
D
Dave Chinner 已提交
322
		return -EPERM;
D
Dave Chinner 已提交
323 324

	if (XFS_FORCED_SHUTDOWN(mp))
D
Dave Chinner 已提交
325
		return -EIO;
D
Dave Chinner 已提交
326

327 328
	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
	if (error)
D
Dave Chinner 已提交
329
		return error;
330

D
Dave Chinner 已提交
331 332 333 334 335 336 337
	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);
338
	error = xfs_trans_commit(tp);
D
Dave Chinner 已提交
339 340 341 342

	return error;
}

L
Linus Torvalds 已提交
343 344
STATIC int
xfs_fssetdm_by_handle(
345 346
	struct file		*parfilp,
	void			__user *arg)
L
Linus Torvalds 已提交
347 348 349 350
{
	int			error;
	struct fsdmidata	fsd;
	xfs_fsop_setdm_handlereq_t dmhreq;
351
	struct dentry		*dentry;
L
Linus Torvalds 已提交
352 353

	if (!capable(CAP_MKNOD))
E
Eric Sandeen 已提交
354
		return -EPERM;
L
Linus Torvalds 已提交
355
	if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))
E
Eric Sandeen 已提交
356
		return -EFAULT;
L
Linus Torvalds 已提交
357

J
Jan Kara 已提交
358 359 360 361
	error = mnt_want_write_file(parfilp);
	if (error)
		return error;

362
	dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);
J
Jan Kara 已提交
363 364
	if (IS_ERR(dentry)) {
		mnt_drop_write_file(parfilp);
365
		return PTR_ERR(dentry);
J
Jan Kara 已提交
366
	}
L
Linus Torvalds 已提交
367

368
	if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {
E
Eric Sandeen 已提交
369
		error = -EPERM;
370
		goto out;
L
Linus Torvalds 已提交
371 372 373
	}

	if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {
E
Eric Sandeen 已提交
374
		error = -EFAULT;
375
		goto out;
L
Linus Torvalds 已提交
376 377
	}

378
	error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,
379
				 fsd.fsd_dmstate);
L
Linus Torvalds 已提交
380

381
 out:
J
Jan Kara 已提交
382
	mnt_drop_write_file(parfilp);
383
	dput(dentry);
384
	return error;
L
Linus Torvalds 已提交
385 386 387 388
}

STATIC int
xfs_attrlist_by_handle(
389 390
	struct file		*parfilp,
	void			__user *arg)
L
Linus Torvalds 已提交
391
{
392
	int			error = -ENOMEM;
L
Linus Torvalds 已提交
393
	attrlist_cursor_kern_t	*cursor;
394
	struct xfs_fsop_attrlist_handlereq __user	*p = arg;
L
Linus Torvalds 已提交
395
	xfs_fsop_attrlist_handlereq_t al_hreq;
396
	struct dentry		*dentry;
L
Linus Torvalds 已提交
397 398 399
	char			*kbuf;

	if (!capable(CAP_SYS_ADMIN))
E
Eric Sandeen 已提交
400
		return -EPERM;
L
Linus Torvalds 已提交
401
	if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))
E
Eric Sandeen 已提交
402
		return -EFAULT;
403
	if (al_hreq.buflen < sizeof(struct attrlist) ||
J
Jan Tulak 已提交
404
	    al_hreq.buflen > XFS_XATTR_LIST_MAX)
E
Eric Sandeen 已提交
405
		return -EINVAL;
L
Linus Torvalds 已提交
406

407 408 409 410
	/*
	 * Reject flags, only allow namespaces.
	 */
	if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))
E
Eric Sandeen 已提交
411
		return -EINVAL;
412

413 414 415
	dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);
L
Linus Torvalds 已提交
416

417 418 419
	kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP);
	if (!kbuf)
		goto out_dput;
L
Linus Torvalds 已提交
420 421

	cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
422
	error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,
423
					al_hreq.flags, cursor);
L
Linus Torvalds 已提交
424 425 426
	if (error)
		goto out_kfree;

427 428 429 430 431
	if (copy_to_user(&p->pos, cursor, sizeof(attrlist_cursor_kern_t))) {
		error = -EFAULT;
		goto out_kfree;
	}

L
Linus Torvalds 已提交
432 433 434
	if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
		error = -EFAULT;

435 436 437
out_kfree:
	kmem_free(kbuf);
out_dput:
438 439
	dput(dentry);
	return error;
L
Linus Torvalds 已提交
440 441
}

442
int
L
Linus Torvalds 已提交
443
xfs_attrmulti_attr_get(
444
	struct inode		*inode,
445 446
	unsigned char		*name,
	unsigned char		__user *ubuf,
L
Linus Torvalds 已提交
447 448 449
	__uint32_t		*len,
	__uint32_t		flags)
{
450
	unsigned char		*kbuf;
D
Dave Chinner 已提交
451
	int			error = -EFAULT;
452

453
	if (*len > XFS_XATTR_SIZE_MAX)
D
Dave Chinner 已提交
454
		return -EINVAL;
455 456
	kbuf = kmem_zalloc_large(*len, KM_SLEEP);
	if (!kbuf)
D
Dave Chinner 已提交
457
		return -ENOMEM;
L
Linus Torvalds 已提交
458

459
	error = xfs_attr_get(XFS_I(inode), name, kbuf, (int *)len, flags);
L
Linus Torvalds 已提交
460 461 462 463
	if (error)
		goto out_kfree;

	if (copy_to_user(ubuf, kbuf, *len))
D
Dave Chinner 已提交
464
		error = -EFAULT;
L
Linus Torvalds 已提交
465

466 467
out_kfree:
	kmem_free(kbuf);
L
Linus Torvalds 已提交
468 469 470
	return error;
}

471
int
L
Linus Torvalds 已提交
472
xfs_attrmulti_attr_set(
473
	struct inode		*inode,
474 475
	unsigned char		*name,
	const unsigned char	__user *ubuf,
L
Linus Torvalds 已提交
476 477 478
	__uint32_t		len,
	__uint32_t		flags)
{
479
	unsigned char		*kbuf;
480
	int			error;
L
Linus Torvalds 已提交
481

482
	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
D
Dave Chinner 已提交
483
		return -EPERM;
484
	if (len > XFS_XATTR_SIZE_MAX)
D
Dave Chinner 已提交
485
		return -EINVAL;
L
Linus Torvalds 已提交
486

L
Li Zefan 已提交
487 488 489
	kbuf = memdup_user(ubuf, len);
	if (IS_ERR(kbuf))
		return PTR_ERR(kbuf);
490

491
	error = xfs_attr_set(XFS_I(inode), name, kbuf, len, flags);
492 493
	if (!error)
		xfs_forget_acl(inode, name, flags);
494 495
	kfree(kbuf);
	return error;
L
Linus Torvalds 已提交
496 497
}

498
int
L
Linus Torvalds 已提交
499
xfs_attrmulti_attr_remove(
500
	struct inode		*inode,
501
	unsigned char		*name,
L
Linus Torvalds 已提交
502 503
	__uint32_t		flags)
{
504 505
	int			error;

506
	if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
D
Dave Chinner 已提交
507
		return -EPERM;
508 509 510 511
	error = xfs_attr_remove(XFS_I(inode), name, flags);
	if (!error)
		xfs_forget_acl(inode, name, flags);
	return error;
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

	if (!capable(CAP_SYS_ADMIN))
E
Eric Sandeen 已提交
527
		return -EPERM;
L
Linus Torvalds 已提交
528
	if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))
E
Eric Sandeen 已提交
529
		return -EFAULT;
L
Linus Torvalds 已提交
530

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

D
Dave Chinner 已提交
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)) {
D
Dave Chinner 已提交
546
		error = PTR_ERR(ops);
547
		goto out_dput;
L
Li Zefan 已提交
548
	}
L
Linus Torvalds 已提交
549

D
Dave Chinner 已提交
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)
D
Dave Chinner 已提交
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
			ops[i].am_error = xfs_attrmulti_attr_get(
567
					d_inode(dentry), attr_name,
568 569
					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
			ops[i].am_error = xfs_attrmulti_attr_set(
576
					d_inode(dentry), attr_name,
577 578
					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
			ops[i].am_error = xfs_attrmulti_attr_remove(
586
					d_inode(dentry), attr_name,
587
					ops[i].am_flags);
A
Al Viro 已提交
588
			mnt_drop_write_file(parfilp);
L
Linus Torvalds 已提交
589 590
			break;
		default:
D
Dave Chinner 已提交
591
			ops[i].am_error = -EINVAL;
L
Linus Torvalds 已提交
592 593 594 595
		}
	}

	if (copy_to_user(am_hreq.ops, ops, size))
D
Dave Chinner 已提交
596
		error = -EFAULT;
L
Linus Torvalds 已提交
597 598 599 600

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

606
int
L
Linus Torvalds 已提交
607 608 609
xfs_ioc_space(
	struct file		*filp,
	unsigned int		cmd,
610
	xfs_flock64_t		*bf)
L
Linus Torvalds 已提交
611
{
612 613
	struct inode		*inode = file_inode(filp);
	struct xfs_inode	*ip = XFS_I(inode);
614
	struct iattr		iattr;
615
	enum xfs_prealloc_flags	flags = 0;
616
	uint			iolock = XFS_IOLOCK_EXCL;
L
Linus Torvalds 已提交
617 618
	int			error;

619 620 621 622 623 624
	/*
	 * 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))
E
Eric Sandeen 已提交
625
		return -EPERM;
626

627
	if (inode->i_flags & (S_IMMUTABLE|S_APPEND))
E
Eric Sandeen 已提交
628
		return -EPERM;
L
Linus Torvalds 已提交
629

630
	if (!(filp->f_mode & FMODE_WRITE))
E
Eric Sandeen 已提交
631
		return -EBADF;
L
Linus Torvalds 已提交
632

633
	if (!S_ISREG(inode->i_mode))
E
Eric Sandeen 已提交
634
		return -EINVAL;
L
Linus Torvalds 已提交
635

636 637
	if (filp->f_flags & O_DSYNC)
		flags |= XFS_PREALLOC_SYNC;
638
	if (filp->f_mode & FMODE_NOCMTIME)
639 640
		flags |= XFS_PREALLOC_INVISIBLE;

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

645
	xfs_ilock(ip, iolock);
646
	error = xfs_break_layouts(inode, &iolock);
647 648
	if (error)
		goto out_unlock;
649

650 651 652
	xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
	iolock |= XFS_MMAPLOCK_EXCL;

653 654 655 656 657 658 659 660 661 662
	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:
D
Dave Chinner 已提交
663
		error = -EINVAL;
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
		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) {
D
Dave Chinner 已提交
680
			error = -EINVAL;
681 682 683 684 685 686 687 688 689
			goto out_unlock;
		}
		break;
	default:
		bf->l_len = 0;
		break;
	}

	if (bf->l_start < 0 ||
690
	    bf->l_start > inode->i_sb->s_maxbytes ||
691
	    bf->l_start + bf->l_len < 0 ||
692
	    bf->l_start + bf->l_len >= inode->i_sb->s_maxbytes) {
D
Dave Chinner 已提交
693
		error = -EINVAL;
694 695 696 697 698
		goto out_unlock;
	}

	switch (cmd) {
	case XFS_IOC_ZERO_RANGE:
699
		flags |= XFS_PREALLOC_SET;
700 701 702 703
		error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
		break;
	case XFS_IOC_RESVSP:
	case XFS_IOC_RESVSP64:
704
		flags |= XFS_PREALLOC_SET;
705 706 707 708 709 710 711 712 713 714 715
		error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
						XFS_BMAPI_PREALLOC);
		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:
716
		flags |= XFS_PREALLOC_CLEAR;
717 718 719 720 721 722 723 724 725 726
		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;

727
		error = xfs_vn_setattr_size(file_dentry(filp), &iattr);
728 729 730
		break;
	default:
		ASSERT(0);
D
Dave Chinner 已提交
731
		error = -EINVAL;
732 733 734 735 736
	}

	if (error)
		goto out_unlock;

737
	error = xfs_update_prealloc_flags(ip, flags);
738 739

out_unlock:
740
	xfs_iunlock(ip, iolock);
J
Jan Kara 已提交
741
	mnt_drop_write_file(filp);
D
Dave Chinner 已提交
742
	return error;
L
Linus Torvalds 已提交
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
}

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))
E
Eric Sandeen 已提交
764
		return -EIO;
L
Linus Torvalds 已提交
765 766

	if (copy_from_user(&bulkreq, arg, sizeof(xfs_fsop_bulkreq_t)))
E
Eric Sandeen 已提交
767
		return -EFAULT;
L
Linus Torvalds 已提交
768 769

	if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
E
Eric Sandeen 已提交
770
		return -EFAULT;
L
Linus Torvalds 已提交
771 772

	if ((count = bulkreq.icount) <= 0)
E
Eric Sandeen 已提交
773
		return -EINVAL;
L
Linus Torvalds 已提交
774

775
	if (bulkreq.ubuffer == NULL)
E
Eric Sandeen 已提交
776
		return -EINVAL;
777

L
Linus Torvalds 已提交
778 779
	if (cmd == XFS_IOC_FSINUMBERS)
		error = xfs_inumbers(mp, &inlast, &count,
780
					bulkreq.ubuffer, xfs_inumbers_fmt);
L
Linus Torvalds 已提交
781
	else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
782 783
		error = xfs_bulkstat_one(mp, inlast, bulkreq.ubuffer,
					sizeof(xfs_bstat_t), NULL, &done);
784
	else	/* XFS_IOC_FSBULKSTAT */
785 786 787
		error = xfs_bulkstat(mp, &inlast, &count, xfs_bulkstat_one,
				     sizeof(xfs_bstat_t), bulkreq.ubuffer,
				     &done);
L
Linus Torvalds 已提交
788 789

	if (error)
D
Dave Chinner 已提交
790
		return error;
L
Linus Torvalds 已提交
791 792 793 794

	if (bulkreq.ocount != NULL) {
		if (copy_to_user(bulkreq.lastip, &inlast,
						sizeof(xfs_ino_t)))
E
Eric Sandeen 已提交
795
			return -EFAULT;
L
Linus Torvalds 已提交
796 797

		if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
E
Eric Sandeen 已提交
798
			return -EFAULT;
L
Linus Torvalds 已提交
799 800 801 802 803 804 805 806 807 808
	}

	return 0;
}

STATIC int
xfs_ioc_fsgeometry_v1(
	xfs_mount_t		*mp,
	void			__user *arg)
{
809
	xfs_fsop_geom_t         fsgeo;
L
Linus Torvalds 已提交
810 811
	int			error;

812
	error = xfs_fs_geometry(mp, &fsgeo, 3);
L
Linus Torvalds 已提交
813
	if (error)
D
Dave Chinner 已提交
814
		return error;
L
Linus Torvalds 已提交
815

816 817 818 819 820 821
	/*
	 * 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)))
E
Eric Sandeen 已提交
822
		return -EFAULT;
L
Linus Torvalds 已提交
823 824 825 826 827 828 829 830 831 832 833 834 835
	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)
D
Dave Chinner 已提交
836
		return error;
L
Linus Torvalds 已提交
837 838

	if (copy_to_user(arg, &fsgeo, sizeof(fsgeo)))
E
Eric Sandeen 已提交
839
		return -EFAULT;
L
Linus Torvalds 已提交
840 841 842 843 844 845 846 847 848 849 850 851 852 853
	return 0;
}

/*
 * Linux extended inode flags interface.
 */

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

854
	if (flags & FS_IMMUTABLE_FL)
855
		xflags |= FS_XFLAG_IMMUTABLE;
L
Linus Torvalds 已提交
856
	else
857
		xflags &= ~FS_XFLAG_IMMUTABLE;
858
	if (flags & FS_APPEND_FL)
859
		xflags |= FS_XFLAG_APPEND;
L
Linus Torvalds 已提交
860
	else
861
		xflags &= ~FS_XFLAG_APPEND;
862
	if (flags & FS_SYNC_FL)
863
		xflags |= FS_XFLAG_SYNC;
L
Linus Torvalds 已提交
864
	else
865
		xflags &= ~FS_XFLAG_SYNC;
866
	if (flags & FS_NOATIME_FL)
867
		xflags |= FS_XFLAG_NOATIME;
L
Linus Torvalds 已提交
868
	else
869
		xflags &= ~FS_XFLAG_NOATIME;
870
	if (flags & FS_NODUMP_FL)
871
		xflags |= FS_XFLAG_NODUMP;
L
Linus Torvalds 已提交
872
	else
873
		xflags &= ~FS_XFLAG_NODUMP;
L
Linus Torvalds 已提交
874 875 876 877 878 879 880 881 882 883 884

	return xflags;
}

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

	if (di_flags & XFS_DIFLAG_IMMUTABLE)
885
		flags |= FS_IMMUTABLE_FL;
L
Linus Torvalds 已提交
886
	if (di_flags & XFS_DIFLAG_APPEND)
887
		flags |= FS_APPEND_FL;
L
Linus Torvalds 已提交
888
	if (di_flags & XFS_DIFLAG_SYNC)
889
		flags |= FS_SYNC_FL;
L
Linus Torvalds 已提交
890
	if (di_flags & XFS_DIFLAG_NOATIME)
891
		flags |= FS_NOATIME_FL;
L
Linus Torvalds 已提交
892
	if (di_flags & XFS_DIFLAG_NODUMP)
893
		flags |= FS_NODUMP_FL;
L
Linus Torvalds 已提交
894 895 896
	return flags;
}

897 898 899 900 901 902 903 904
STATIC int
xfs_ioc_fsgetxattr(
	xfs_inode_t		*ip,
	int			attr,
	void			__user *arg)
{
	struct fsxattr		fa;

905 906
	memset(&fa, 0, sizeof(struct fsxattr));

907 908 909
	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;
910 911
	fa.fsx_cowextsize = ip->i_d.di_cowextsize <<
			ip->i_mount->m_sb.sb_blocklog;
912
	fa.fsx_projid = xfs_get_projid(ip);
913 914 915 916

	if (attr) {
		if (ip->i_afp) {
			if (ip->i_afp->if_flags & XFS_IFEXTENTS)
917
				fa.fsx_nextents = xfs_iext_count(ip->i_afp);
918 919 920 921 922 923
			else
				fa.fsx_nextents = ip->i_d.di_anextents;
		} else
			fa.fsx_nextents = 0;
	} else {
		if (ip->i_df.if_flags & XFS_IFEXTENTS)
924
			fa.fsx_nextents = xfs_iext_count(&ip->i_df);
925 926 927 928 929 930 931 932 933 934
		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;
}

935 936 937 938 939 940
STATIC void
xfs_set_diflags(
	struct xfs_inode	*ip,
	unsigned int		xflags)
{
	unsigned int		di_flags;
941
	uint64_t		di_flags2;
942 943 944

	/* can't set PREALLOC this way, just preserve it */
	di_flags = (ip->i_d.di_flags & XFS_DIFLAG_PREALLOC);
945
	if (xflags & FS_XFLAG_IMMUTABLE)
946
		di_flags |= XFS_DIFLAG_IMMUTABLE;
947
	if (xflags & FS_XFLAG_APPEND)
948
		di_flags |= XFS_DIFLAG_APPEND;
949
	if (xflags & FS_XFLAG_SYNC)
950
		di_flags |= XFS_DIFLAG_SYNC;
951
	if (xflags & FS_XFLAG_NOATIME)
952
		di_flags |= XFS_DIFLAG_NOATIME;
953
	if (xflags & FS_XFLAG_NODUMP)
954
		di_flags |= XFS_DIFLAG_NODUMP;
955
	if (xflags & FS_XFLAG_NODEFRAG)
956
		di_flags |= XFS_DIFLAG_NODEFRAG;
957
	if (xflags & FS_XFLAG_FILESTREAM)
958
		di_flags |= XFS_DIFLAG_FILESTREAM;
D
Dave Chinner 已提交
959
	if (S_ISDIR(VFS_I(ip)->i_mode)) {
960
		if (xflags & FS_XFLAG_RTINHERIT)
961
			di_flags |= XFS_DIFLAG_RTINHERIT;
962
		if (xflags & FS_XFLAG_NOSYMLINKS)
963
			di_flags |= XFS_DIFLAG_NOSYMLINKS;
964
		if (xflags & FS_XFLAG_EXTSZINHERIT)
965
			di_flags |= XFS_DIFLAG_EXTSZINHERIT;
966
		if (xflags & FS_XFLAG_PROJINHERIT)
967
			di_flags |= XFS_DIFLAG_PROJINHERIT;
D
Dave Chinner 已提交
968
	} else if (S_ISREG(VFS_I(ip)->i_mode)) {
969
		if (xflags & FS_XFLAG_REALTIME)
970
			di_flags |= XFS_DIFLAG_REALTIME;
971
		if (xflags & FS_XFLAG_EXTSIZE)
972 973 974
			di_flags |= XFS_DIFLAG_EXTSIZE;
	}
	ip->i_d.di_flags = di_flags;
975 976 977 978 979

	/* diflags2 only valid for v3 inodes. */
	if (ip->i_d.di_version < 3)
		return;

980
	di_flags2 = (ip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK);
981 982
	if (xflags & FS_XFLAG_DAX)
		di_flags2 |= XFS_DIFLAG2_DAX;
983 984
	if (xflags & FS_XFLAG_COWEXTSIZE)
		di_flags2 |= XFS_DIFLAG2_COWEXTSIZE;
985 986

	ip->i_d.di_flags2 = di_flags2;
987 988
}

989 990 991 992
STATIC void
xfs_diflags_to_linux(
	struct xfs_inode	*ip)
{
993
	struct inode		*inode = VFS_I(ip);
994 995
	unsigned int		xflags = xfs_ip2xflags(ip);

996
	if (xflags & FS_XFLAG_IMMUTABLE)
997 998 999
		inode->i_flags |= S_IMMUTABLE;
	else
		inode->i_flags &= ~S_IMMUTABLE;
1000
	if (xflags & FS_XFLAG_APPEND)
1001 1002 1003
		inode->i_flags |= S_APPEND;
	else
		inode->i_flags &= ~S_APPEND;
1004
	if (xflags & FS_XFLAG_SYNC)
1005 1006 1007
		inode->i_flags |= S_SYNC;
	else
		inode->i_flags &= ~S_SYNC;
1008
	if (xflags & FS_XFLAG_NOATIME)
1009 1010 1011
		inode->i_flags |= S_NOATIME;
	else
		inode->i_flags &= ~S_NOATIME;
1012 1013 1014 1015 1016
	if (xflags & FS_XFLAG_DAX)
		inode->i_flags |= S_DAX;
	else
		inode->i_flags &= ~S_DAX;

1017
}
1018

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
static int
xfs_ioctl_setattr_xflags(
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
	struct fsxattr		*fa)
{
	struct xfs_mount	*mp = ip->i_mount;

	/* Can't change realtime flag if any extents are allocated. */
	if ((ip->i_d.di_nextents || ip->i_delayed_blks) &&
1029
	    XFS_IS_REALTIME_INODE(ip) != (fa->fsx_xflags & FS_XFLAG_REALTIME))
1030 1031 1032
		return -EINVAL;

	/* If realtime flag is set then must have realtime device */
1033
	if (fa->fsx_xflags & FS_XFLAG_REALTIME) {
1034 1035 1036 1037 1038
		if (mp->m_sb.sb_rblocks == 0 || mp->m_sb.sb_rextsize == 0 ||
		    (ip->i_d.di_extsize % mp->m_sb.sb_rextsize))
			return -EINVAL;
	}

1039
	/* Clear reflink if we are actually able to set the rt flag. */
1040
	if ((fa->fsx_xflags & FS_XFLAG_REALTIME) && xfs_is_reflink_inode(ip))
1041
		ip->i_d.di_flags2 &= ~XFS_DIFLAG2_REFLINK;
1042

1043 1044 1045 1046
	/* Don't allow us to set DAX mode for a reflinked file for now. */
	if ((fa->fsx_xflags & FS_XFLAG_DAX) && xfs_is_reflink_inode(ip))
		return -EINVAL;

1047 1048 1049 1050 1051
	/*
	 * 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)) ||
1052
	     (fa->fsx_xflags & (FS_XFLAG_IMMUTABLE | FS_XFLAG_APPEND))) &&
1053 1054 1055 1056 1057 1058 1059
	    !capable(CAP_LINUX_IMMUTABLE))
		return -EPERM;

	xfs_set_diflags(ip, fa->fsx_xflags);
	xfs_diflags_to_linux(ip);
	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1060
	XFS_STATS_INC(mp, xs_ig_attrchg);
1061 1062 1063
	return 0;
}

1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
/*
 * If we are changing DAX flags, we have to ensure the file is clean and any
 * cached objects in the address space are invalidated and removed. This
 * requires us to lock out other IO and page faults similar to a truncate
 * operation. The locks need to be held until the transaction has been committed
 * so that the cache invalidation is atomic with respect to the DAX flag
 * manipulation.
 */
static int
xfs_ioctl_setattr_dax_invalidate(
	struct xfs_inode	*ip,
	struct fsxattr		*fa,
	int			*join_flags)
{
	struct inode		*inode = VFS_I(ip);
	int			error;

	*join_flags = 0;

1083 1084
	/*
	 * It is only valid to set the DAX flag on regular files and
1085 1086
	 * directories on filesystems where the block size is equal to the page
	 * size. On directories it serves as an inherit hint.
1087
	 */
1088 1089 1090 1091 1092 1093
	if (fa->fsx_xflags & FS_XFLAG_DAX) {
		if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)))
			return -EINVAL;
		if (ip->i_mount->m_sb.sb_blocksize != PAGE_SIZE)
			return -EINVAL;
	}
1094

1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110
	/* If the DAX state is not changing, we have nothing to do here. */
	if ((fa->fsx_xflags & FS_XFLAG_DAX) && IS_DAX(inode))
		return 0;
	if (!(fa->fsx_xflags & FS_XFLAG_DAX) && !IS_DAX(inode))
		return 0;

	/* lock, flush and invalidate mapping in preparation for flag change */
	xfs_ilock(ip, XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL);
	error = filemap_write_and_wait(inode->i_mapping);
	if (error)
		goto out_unlock;
	error = invalidate_inode_pages2(inode->i_mapping);
	if (error)
		goto out_unlock;

	*join_flags = XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL;
1111
	return 0;
1112 1113 1114 1115 1116

out_unlock:
	xfs_iunlock(ip, XFS_MMAPLOCK_EXCL | XFS_IOLOCK_EXCL);
	return error;

1117 1118
}

1119 1120 1121 1122 1123
/*
 * Set up the transaction structure for the setattr operation, checking that we
 * have permission to do so. On success, return a clean transaction and the
 * inode locked exclusively ready for further operation specific checks. On
 * failure, return an error without modifying or locking the inode.
1124 1125 1126 1127 1128 1129
 *
 * The inode might already be IO locked on call. If this is the case, it is
 * indicated in @join_flags and we take full responsibility for ensuring they
 * are unlocked from now on. Hence if we have an error here, we still have to
 * unlock them. Otherwise, once they are joined to the transaction, they will
 * be unlocked on commit/cancel.
1130 1131 1132
 */
static struct xfs_trans *
xfs_ioctl_setattr_get_trans(
1133 1134
	struct xfs_inode	*ip,
	int			join_flags)
1135 1136 1137
{
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_trans	*tp;
1138
	int			error = -EROFS;
1139 1140

	if (mp->m_flags & XFS_MOUNT_RDONLY)
1141 1142
		goto out_unlock;
	error = -EIO;
1143
	if (XFS_FORCED_SHUTDOWN(mp))
1144
		goto out_unlock;
1145

1146
	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
1147
	if (error)
1148
		return ERR_PTR(error);
1149 1150

	xfs_ilock(ip, XFS_ILOCK_EXCL);
1151 1152
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | join_flags);
	join_flags = 0;
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170

	/*
	 * 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.
	 */
	if (!inode_owner_or_capable(VFS_I(ip))) {
		error = -EPERM;
		goto out_cancel;
	}

	if (mp->m_flags & XFS_MOUNT_WSYNC)
		xfs_trans_set_sync(tp);

	return tp;

out_cancel:
1171
	xfs_trans_cancel(tp);
1172 1173 1174
out_unlock:
	if (join_flags)
		xfs_iunlock(ip, join_flags);
1175 1176 1177
	return ERR_PTR(error);
}

1178 1179 1180 1181
/*
 * extent size hint validation is somewhat cumbersome. Rules are:
 *
 * 1. extent size hint is only valid for directories and regular files
1182 1183
 * 2. FS_XFLAG_EXTSIZE is only valid for regular files
 * 3. FS_XFLAG_EXTSZINHERIT is only valid for directories.
1184 1185 1186 1187 1188 1189 1190 1191
 * 4. can only be changed on regular files if no extents are allocated
 * 5. can be changed on directories at any time
 * 6. extsize hint of 0 turns off hints, clears inode flags.
 * 7. Extent size must be a multiple of the appropriate block size.
 * 8. for non-realtime files, the extent size hint must be limited
 *    to half the AG size to avoid alignment extending the extent beyond the
 *    limits of the AG.
 */
1192
static int
1193 1194 1195 1196 1197 1198
xfs_ioctl_setattr_check_extsize(
	struct xfs_inode	*ip,
	struct fsxattr		*fa)
{
	struct xfs_mount	*mp = ip->i_mount;

D
Dave Chinner 已提交
1199
	if ((fa->fsx_xflags & FS_XFLAG_EXTSIZE) && !S_ISREG(VFS_I(ip)->i_mode))
1200 1201
		return -EINVAL;

1202
	if ((fa->fsx_xflags & FS_XFLAG_EXTSZINHERIT) &&
D
Dave Chinner 已提交
1203
	    !S_ISDIR(VFS_I(ip)->i_mode))
1204 1205
		return -EINVAL;

D
Dave Chinner 已提交
1206
	if (S_ISREG(VFS_I(ip)->i_mode) && ip->i_d.di_nextents &&
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
	    ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) != fa->fsx_extsize))
		return -EINVAL;

	if (fa->fsx_extsize != 0) {
		xfs_extlen_t    size;
		xfs_fsblock_t   extsize_fsb;

		extsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_extsize);
		if (extsize_fsb > MAXEXTLEN)
			return -EINVAL;

		if (XFS_IS_REALTIME_INODE(ip) ||
1219
		    (fa->fsx_xflags & FS_XFLAG_REALTIME)) {
1220 1221 1222 1223 1224 1225 1226 1227 1228
			size = mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog;
		} else {
			size = mp->m_sb.sb_blocksize;
			if (extsize_fsb > mp->m_sb.sb_agblocks / 2)
				return -EINVAL;
		}

		if (fa->fsx_extsize % size)
			return -EINVAL;
1229
	} else
1230
		fa->fsx_xflags &= ~(FS_XFLAG_EXTSIZE | FS_XFLAG_EXTSZINHERIT);
1231

1232 1233 1234
	return 0;
}

1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
/*
 * CoW extent size hint validation rules are:
 *
 * 1. CoW extent size hint can only be set if reflink is enabled on the fs.
 *    The inode does not have to have any shared blocks, but it must be a v3.
 * 2. FS_XFLAG_COWEXTSIZE is only valid for directories and regular files;
 *    for a directory, the hint is propagated to new files.
 * 3. Can be changed on files & directories at any time.
 * 4. CoW extsize hint of 0 turns off hints, clears inode flags.
 * 5. Extent size must be a multiple of the appropriate block size.
 * 6. The extent size hint must be limited to half the AG size to avoid
 *    alignment extending the extent beyond the limits of the AG.
 */
static int
xfs_ioctl_setattr_check_cowextsize(
	struct xfs_inode	*ip,
	struct fsxattr		*fa)
{
	struct xfs_mount	*mp = ip->i_mount;

	if (!(fa->fsx_xflags & FS_XFLAG_COWEXTSIZE))
		return 0;

	if (!xfs_sb_version_hasreflink(&ip->i_mount->m_sb) ||
	    ip->i_d.di_version != 3)
		return -EINVAL;

	if (!S_ISREG(VFS_I(ip)->i_mode) && !S_ISDIR(VFS_I(ip)->i_mode))
		return -EINVAL;

	if (fa->fsx_cowextsize != 0) {
		xfs_extlen_t    size;
		xfs_fsblock_t   cowextsize_fsb;

		cowextsize_fsb = XFS_B_TO_FSB(mp, fa->fsx_cowextsize);
		if (cowextsize_fsb > MAXEXTLEN)
			return -EINVAL;

		size = mp->m_sb.sb_blocksize;
		if (cowextsize_fsb > mp->m_sb.sb_agblocks / 2)
			return -EINVAL;

		if (fa->fsx_cowextsize % size)
			return -EINVAL;
	} else
		fa->fsx_xflags &= ~FS_XFLAG_COWEXTSIZE;

	return 0;
}

1285
static int
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
xfs_ioctl_setattr_check_projid(
	struct xfs_inode	*ip,
	struct fsxattr		*fa)
{
	/* Disallow 32bit project ids if projid32bit feature is not enabled. */
	if (fa->fsx_projid > (__uint16_t)-1 &&
	    !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))
		return -EINVAL;

	/*
	 * Project Quota ID state is only allowed to change from within the init
	 * namespace. Enforce that restriction only if we are trying to change
	 * the quota ID state. Everything else is allowed in user namespaces.
	 */
	if (current_user_ns() == &init_user_ns)
		return 0;

	if (xfs_get_projid(ip) != fa->fsx_projid)
		return -EINVAL;
1305
	if ((fa->fsx_xflags & FS_XFLAG_PROJINHERIT) !=
1306 1307 1308 1309 1310
	    (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT))
		return -EINVAL;

	return 0;
}
1311 1312 1313 1314

STATIC int
xfs_ioctl_setattr(
	xfs_inode_t		*ip,
1315
	struct fsxattr		*fa)
1316 1317 1318
{
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_trans	*tp;
C
Christoph Hellwig 已提交
1319
	struct xfs_dquot	*udqp = NULL;
1320
	struct xfs_dquot	*pdqp = NULL;
1321 1322
	struct xfs_dquot	*olddquot = NULL;
	int			code;
1323
	int			join_flags = 0;
1324

C
Christoph Hellwig 已提交
1325
	trace_xfs_ioctl_setattr(ip);
1326

1327 1328 1329
	code = xfs_ioctl_setattr_check_projid(ip, fa);
	if (code)
		return code;
1330

1331 1332 1333 1334 1335 1336 1337 1338
	/*
	 * 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.
	 */
1339
	if (XFS_IS_QUOTA_ON(mp)) {
C
Christoph Hellwig 已提交
1340
		code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,
1341
					 ip->i_d.di_gid, fa->fsx_projid,
1342
					 XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);
1343 1344 1345 1346
		if (code)
			return code;
	}

1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
	/*
	 * Changing DAX config may require inode locking for mapping
	 * invalidation. These need to be held all the way to transaction commit
	 * or cancel time, so need to be passed through to
	 * xfs_ioctl_setattr_get_trans() so it can apply them to the join call
	 * appropriately.
	 */
	code = xfs_ioctl_setattr_dax_invalidate(ip, fa, &join_flags);
	if (code)
		goto error_free_dquots;

	tp = xfs_ioctl_setattr_get_trans(ip, join_flags);
1359 1360 1361
	if (IS_ERR(tp)) {
		code = PTR_ERR(tp);
		goto error_free_dquots;
1362 1363 1364
	}


1365 1366 1367 1368 1369
	if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp) &&
	    xfs_get_projid(ip) != fa->fsx_projid) {
		code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL, pdqp,
				capable(CAP_FOWNER) ?  XFS_QMOPT_FORCE_RES : 0);
		if (code)	/* out of quota */
1370
			goto error_trans_cancel;
1371 1372
	}

1373 1374 1375
	code = xfs_ioctl_setattr_check_extsize(ip, fa);
	if (code)
		goto error_trans_cancel;
1376

1377 1378 1379 1380
	code = xfs_ioctl_setattr_check_cowextsize(ip, fa);
	if (code)
		goto error_trans_cancel;

1381 1382
	code = xfs_ioctl_setattr_xflags(tp, ip, fa);
	if (code)
1383
		goto error_trans_cancel;
1384 1385

	/*
1386 1387 1388 1389 1390
	 * Change file ownership.  Must be the owner or privileged.  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()
1391 1392
	 */

D
Dave Chinner 已提交
1393
	if ((VFS_I(ip)->i_mode & (S_ISUID|S_ISGID)) &&
1394
	    !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))
D
Dave Chinner 已提交
1395
		VFS_I(ip)->i_mode &= ~(S_ISUID|S_ISGID);
1396

1397 1398 1399 1400 1401 1402 1403 1404
	/* Change the ownerships and register project quota modifications */
	if (xfs_get_projid(ip) != fa->fsx_projid) {
		if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {
			olddquot = xfs_qm_vop_chown(tp, ip,
						&ip->i_pdquot, pdqp);
		}
		ASSERT(ip->i_d.di_version > 1);
		xfs_set_projid(ip, fa->fsx_projid);
1405
	}
1406

1407 1408 1409 1410 1411
	/*
	 * Only set the extent size hint if we've already determined that the
	 * extent size hint should be set on the inode. If no extent size flags
	 * are set on the inode then unconditionally clear the extent size hint.
	 */
1412 1413 1414 1415
	if (ip->i_d.di_flags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
		ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
	else
		ip->i_d.di_extsize = 0;
1416 1417 1418 1419 1420 1421
	if (ip->i_d.di_version == 3 &&
	    (ip->i_d.di_flags2 & XFS_DIFLAG2_COWEXTSIZE))
		ip->i_d.di_cowextsize = fa->fsx_cowextsize >>
				mp->m_sb.sb_blocklog;
	else
		ip->i_d.di_cowextsize = 0;
1422

1423
	code = xfs_trans_commit(tp);
1424 1425 1426 1427

	/*
	 * Release any dquot(s) the inode had kept before chown.
	 */
C
Christoph Hellwig 已提交
1428 1429
	xfs_qm_dqrele(olddquot);
	xfs_qm_dqrele(udqp);
1430
	xfs_qm_dqrele(pdqp);
1431

C
Christoph Hellwig 已提交
1432
	return code;
1433

1434
error_trans_cancel:
1435
	xfs_trans_cancel(tp);
1436
error_free_dquots:
C
Christoph Hellwig 已提交
1437
	xfs_qm_dqrele(udqp);
1438
	xfs_qm_dqrele(pdqp);
1439 1440 1441
	return code;
}

L
Linus Torvalds 已提交
1442
STATIC int
L
Lachlan McIlroy 已提交
1443
xfs_ioc_fssetxattr(
L
Linus Torvalds 已提交
1444 1445 1446 1447 1448
	xfs_inode_t		*ip,
	struct file		*filp,
	void			__user *arg)
{
	struct fsxattr		fa;
J
Jan Kara 已提交
1449
	int error;
L
Lachlan McIlroy 已提交
1450 1451 1452

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

J
Jan Kara 已提交
1454 1455 1456
	error = mnt_want_write_file(filp);
	if (error)
		return error;
1457
	error = xfs_ioctl_setattr(ip, &fa);
J
Jan Kara 已提交
1458
	mnt_drop_write_file(filp);
D
Dave Chinner 已提交
1459
	return error;
L
Lachlan McIlroy 已提交
1460
}
L
Linus Torvalds 已提交
1461

L
Lachlan McIlroy 已提交
1462 1463 1464 1465 1466 1467
STATIC int
xfs_ioc_getxflags(
	xfs_inode_t		*ip,
	void			__user *arg)
{
	unsigned int		flags;
L
Linus Torvalds 已提交
1468

L
Lachlan McIlroy 已提交
1469 1470 1471 1472 1473
	flags = xfs_di2lxflags(ip->i_d.di_flags);
	if (copy_to_user(arg, &flags, sizeof(flags)))
		return -EFAULT;
	return 0;
}
L
Linus Torvalds 已提交
1474

L
Lachlan McIlroy 已提交
1475 1476
STATIC int
xfs_ioc_setxflags(
1477
	struct xfs_inode	*ip,
L
Lachlan McIlroy 已提交
1478 1479 1480
	struct file		*filp,
	void			__user *arg)
{
1481
	struct xfs_trans	*tp;
1482
	struct fsxattr		fa;
L
Lachlan McIlroy 已提交
1483
	unsigned int		flags;
1484
	int			join_flags = 0;
1485
	int			error;
L
Linus Torvalds 已提交
1486

L
Lachlan McIlroy 已提交
1487 1488
	if (copy_from_user(&flags, arg, sizeof(flags)))
		return -EFAULT;
L
Linus Torvalds 已提交
1489

L
Lachlan McIlroy 已提交
1490 1491 1492 1493
	if (flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | \
		      FS_NOATIME_FL | FS_NODUMP_FL | \
		      FS_SYNC_FL))
		return -EOPNOTSUPP;
L
Linus Torvalds 已提交
1494

1495
	fa.fsx_xflags = xfs_merge_ioc_xflags(flags, xfs_ip2xflags(ip));
L
Linus Torvalds 已提交
1496

J
Jan Kara 已提交
1497 1498 1499
	error = mnt_want_write_file(filp);
	if (error)
		return error;
1500

1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
	/*
	 * Changing DAX config may require inode locking for mapping
	 * invalidation. These need to be held all the way to transaction commit
	 * or cancel time, so need to be passed through to
	 * xfs_ioctl_setattr_get_trans() so it can apply them to the join call
	 * appropriately.
	 */
	error = xfs_ioctl_setattr_dax_invalidate(ip, &fa, &join_flags);
	if (error)
		goto out_drop_write;

	tp = xfs_ioctl_setattr_get_trans(ip, join_flags);
1513 1514 1515 1516 1517 1518 1519
	if (IS_ERR(tp)) {
		error = PTR_ERR(tp);
		goto out_drop_write;
	}

	error = xfs_ioctl_setattr_xflags(tp, ip, &fa);
	if (error) {
1520
		xfs_trans_cancel(tp);
1521 1522 1523
		goto out_drop_write;
	}

1524
	error = xfs_trans_commit(tp);
1525
out_drop_write:
J
Jan Kara 已提交
1526
	mnt_drop_write_file(filp);
D
Dave Chinner 已提交
1527
	return error;
L
Linus Torvalds 已提交
1528 1529
}

1530
STATIC int
1531
xfs_getbmap_format(void **ap, struct getbmapx *bmv)
1532
{
1533
	struct getbmap __user	*base = (struct getbmap __user *)*ap;
1534 1535 1536

	/* copy only getbmap portion (not getbmapx) */
	if (copy_to_user(base, bmv, sizeof(struct getbmap)))
D
Dave Chinner 已提交
1537
		return -EFAULT;
1538 1539 1540 1541 1542

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

L
Linus Torvalds 已提交
1543 1544
STATIC int
xfs_ioc_getbmap(
1545
	struct file		*file,
L
Linus Torvalds 已提交
1546 1547 1548
	unsigned int		cmd,
	void			__user *arg)
{
1549
	struct getbmapx		bmx = { 0 };
L
Linus Torvalds 已提交
1550 1551
	int			error;

1552 1553
	/* struct getbmap is a strict subset of struct getbmapx. */
	if (copy_from_user(&bmx, arg, offsetof(struct getbmapx, bmv_iflags)))
E
Eric Sandeen 已提交
1554
		return -EFAULT;
L
Linus Torvalds 已提交
1555

1556
	if (bmx.bmv_count < 2)
E
Eric Sandeen 已提交
1557
		return -EINVAL;
L
Linus Torvalds 已提交
1558

1559
	bmx.bmv_iflags = (cmd == XFS_IOC_GETBMAPA ? BMV_IF_ATTRFORK : 0);
1560
	if (file->f_mode & FMODE_NOCMTIME)
1561
		bmx.bmv_iflags |= BMV_IF_NO_DMAPI_READ;
L
Linus Torvalds 已提交
1562

1563
	error = xfs_getbmap(XFS_I(file_inode(file)), &bmx, xfs_getbmap_format,
1564
			    (__force struct getbmap *)arg+1);
L
Linus Torvalds 已提交
1565
	if (error)
D
Dave Chinner 已提交
1566
		return error;
L
Linus Torvalds 已提交
1567

1568 1569
	/* copy back header - only size of getbmap */
	if (copy_to_user(arg, &bmx, sizeof(struct getbmap)))
E
Eric Sandeen 已提交
1570
		return -EFAULT;
L
Linus Torvalds 已提交
1571 1572 1573
	return 0;
}

1574
STATIC int
1575
xfs_getbmapx_format(void **ap, struct getbmapx *bmv)
1576
{
1577
	struct getbmapx __user	*base = (struct getbmapx __user *)*ap;
1578 1579

	if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
D
Dave Chinner 已提交
1580
		return -EFAULT;
1581 1582 1583 1584 1585

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

L
Linus Torvalds 已提交
1586 1587
STATIC int
xfs_ioc_getbmapx(
1588
	struct xfs_inode	*ip,
L
Linus Torvalds 已提交
1589 1590 1591 1592 1593 1594
	void			__user *arg)
{
	struct getbmapx		bmx;
	int			error;

	if (copy_from_user(&bmx, arg, sizeof(bmx)))
E
Eric Sandeen 已提交
1595
		return -EFAULT;
L
Linus Torvalds 已提交
1596 1597

	if (bmx.bmv_count < 2)
E
Eric Sandeen 已提交
1598
		return -EINVAL;
L
Linus Torvalds 已提交
1599

1600
	if (bmx.bmv_iflags & (~BMV_IF_VALID))
E
Eric Sandeen 已提交
1601
		return -EINVAL;
L
Linus Torvalds 已提交
1602

1603
	error = xfs_getbmap(ip, &bmx, xfs_getbmapx_format,
1604
			    (__force struct getbmapx *)arg+1);
L
Linus Torvalds 已提交
1605
	if (error)
D
Dave Chinner 已提交
1606
		return error;
L
Linus Torvalds 已提交
1607

1608 1609
	/* copy back header */
	if (copy_to_user(arg, &bmx, sizeof(struct getbmapx)))
E
Eric Sandeen 已提交
1610
		return -EFAULT;
L
Linus Torvalds 已提交
1611 1612 1613

	return 0;
}
L
Lachlan McIlroy 已提交
1614

1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692
struct getfsmap_info {
	struct xfs_mount	*mp;
	struct fsmap __user	*data;
	__u32			last_flags;
};

STATIC int
xfs_getfsmap_format(struct xfs_fsmap *xfm, void *priv)
{
	struct getfsmap_info	*info = priv;
	struct fsmap		fm;

	trace_xfs_getfsmap_mapping(info->mp, xfm);

	info->last_flags = xfm->fmr_flags;
	xfs_fsmap_from_internal(&fm, xfm);
	if (copy_to_user(info->data, &fm, sizeof(struct fsmap)))
		return -EFAULT;

	info->data++;
	return 0;
}

STATIC int
xfs_ioc_getfsmap(
	struct xfs_inode	*ip,
	void			__user *arg)
{
	struct getfsmap_info	info = {0};
	struct xfs_fsmap_head	xhead = {0};
	struct fsmap_head	head;
	bool			aborted = false;
	int			error;

	if (copy_from_user(&head, arg, sizeof(struct fsmap_head)))
		return -EFAULT;
	if (memchr_inv(head.fmh_reserved, 0, sizeof(head.fmh_reserved)) ||
	    memchr_inv(head.fmh_keys[0].fmr_reserved, 0,
		       sizeof(head.fmh_keys[0].fmr_reserved)) ||
	    memchr_inv(head.fmh_keys[1].fmr_reserved, 0,
		       sizeof(head.fmh_keys[1].fmr_reserved)))
		return -EINVAL;

	xhead.fmh_iflags = head.fmh_iflags;
	xhead.fmh_count = head.fmh_count;
	xfs_fsmap_to_internal(&xhead.fmh_keys[0], &head.fmh_keys[0]);
	xfs_fsmap_to_internal(&xhead.fmh_keys[1], &head.fmh_keys[1]);

	trace_xfs_getfsmap_low_key(ip->i_mount, &xhead.fmh_keys[0]);
	trace_xfs_getfsmap_high_key(ip->i_mount, &xhead.fmh_keys[1]);

	info.mp = ip->i_mount;
	info.data = ((__force struct fsmap_head *)arg)->fmh_recs;
	error = xfs_getfsmap(ip->i_mount, &xhead, xfs_getfsmap_format, &info);
	if (error == XFS_BTREE_QUERY_RANGE_ABORT) {
		error = 0;
		aborted = true;
	} else if (error)
		return error;

	/* If we didn't abort, set the "last" flag in the last fmx */
	if (!aborted && xhead.fmh_entries) {
		info.data--;
		info.last_flags |= FMR_OF_LAST;
		if (copy_to_user(&info.data->fmr_flags, &info.last_flags,
				sizeof(info.last_flags)))
			return -EFAULT;
	}

	/* copy back header */
	head.fmh_entries = xhead.fmh_entries;
	head.fmh_oflags = xhead.fmh_oflags;
	if (copy_to_user(arg, &head, sizeof(struct fsmap_head)))
		return -EFAULT;

	return 0;
}

D
Dave Chinner 已提交
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
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) {
D
Dave Chinner 已提交
1704
		error = -EINVAL;
D
Dave Chinner 已提交
1705 1706 1707 1708 1709 1710
		goto out;
	}

	if (!(f.file->f_mode & FMODE_WRITE) ||
	    !(f.file->f_mode & FMODE_READ) ||
	    (f.file->f_flags & O_APPEND)) {
D
Dave Chinner 已提交
1711
		error = -EBADF;
D
Dave Chinner 已提交
1712 1713 1714 1715 1716
		goto out_put_file;
	}

	tmp = fdget((int)sxp->sx_fdtmp);
	if (!tmp.file) {
D
Dave Chinner 已提交
1717
		error = -EINVAL;
D
Dave Chinner 已提交
1718 1719 1720 1721 1722 1723
		goto out_put_file;
	}

	if (!(tmp.file->f_mode & FMODE_WRITE) ||
	    !(tmp.file->f_mode & FMODE_READ) ||
	    (tmp.file->f_flags & O_APPEND)) {
D
Dave Chinner 已提交
1724
		error = -EBADF;
D
Dave Chinner 已提交
1725 1726 1727 1728 1729
		goto out_put_tmp_file;
	}

	if (IS_SWAPFILE(file_inode(f.file)) ||
	    IS_SWAPFILE(file_inode(tmp.file))) {
D
Dave Chinner 已提交
1730
		error = -EINVAL;
D
Dave Chinner 已提交
1731 1732 1733
		goto out_put_tmp_file;
	}

1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
	/*
	 * We need to ensure that the fds passed in point to XFS inodes
	 * before we cast and access them as XFS structures as we have no
	 * control over what the user passes us here.
	 */
	if (f.file->f_op != &xfs_file_operations ||
	    tmp.file->f_op != &xfs_file_operations) {
		error = -EINVAL;
		goto out_put_tmp_file;
	}

D
Dave Chinner 已提交
1745 1746 1747 1748
	ip = XFS_I(file_inode(f.file));
	tip = XFS_I(file_inode(tmp.file));

	if (ip->i_mount != tip->i_mount) {
D
Dave Chinner 已提交
1749
		error = -EINVAL;
D
Dave Chinner 已提交
1750 1751 1752 1753
		goto out_put_tmp_file;
	}

	if (ip->i_ino == tip->i_ino) {
D
Dave Chinner 已提交
1754
		error = -EINVAL;
D
Dave Chinner 已提交
1755 1756 1757 1758
		goto out_put_tmp_file;
	}

	if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
D
Dave Chinner 已提交
1759
		error = -EIO;
D
Dave Chinner 已提交
1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772
		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;
}

1773 1774 1775 1776 1777 1778 1779 1780
/*
 * 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 已提交
1781 1782
	struct file		*filp,
	unsigned int		cmd,
1783
	unsigned long		p)
L
Lachlan McIlroy 已提交
1784
{
A
Al Viro 已提交
1785
	struct inode		*inode = file_inode(filp);
1786 1787 1788
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	void			__user *arg = (void __user *)p;
L
Lachlan McIlroy 已提交
1789 1790
	int			error;

C
Christoph Hellwig 已提交
1791
	trace_xfs_file_ioctl(ip);
1792 1793

	switch (cmd) {
C
Christoph Hellwig 已提交
1794 1795
	case FITRIM:
		return xfs_ioc_trim(mp, arg);
L
Lachlan McIlroy 已提交
1796 1797 1798 1799 1800 1801 1802
	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 已提交
1803 1804
	case XFS_IOC_UNRESVSP64:
	case XFS_IOC_ZERO_RANGE: {
1805
		xfs_flock64_t		bf;
L
Lachlan McIlroy 已提交
1806

1807
		if (copy_from_user(&bf, arg, sizeof(bf)))
E
Eric Sandeen 已提交
1808
			return -EFAULT;
1809
		return xfs_ioc_space(filp, cmd, &bf);
1810
	}
L
Lachlan McIlroy 已提交
1811 1812 1813 1814 1815 1816
	case XFS_IOC_DIOINFO: {
		struct dioattr	da;
		xfs_buftarg_t	*target =
			XFS_IS_REALTIME_INODE(ip) ?
			mp->m_rtdev_targp : mp->m_ddev_targp;

1817
		da.d_mem =  da.d_miniosz = target->bt_logical_sectorsize;
L
Lachlan McIlroy 已提交
1818 1819 1820
		da.d_maxiosz = INT_MAX & ~(da.d_miniosz - 1);

		if (copy_to_user(arg, &da, sizeof(da)))
E
Eric Sandeen 已提交
1821
			return -EFAULT;
L
Lachlan McIlroy 已提交
1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842
		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 已提交
1843 1844
	case XFS_IOC_FSSETXATTR:
		return xfs_ioc_fssetxattr(ip, filp, arg);
L
Lachlan McIlroy 已提交
1845
	case XFS_IOC_GETXFLAGS:
L
Lachlan McIlroy 已提交
1846
		return xfs_ioc_getxflags(ip, arg);
L
Lachlan McIlroy 已提交
1847
	case XFS_IOC_SETXFLAGS:
L
Lachlan McIlroy 已提交
1848
		return xfs_ioc_setxflags(ip, filp, arg);
L
Lachlan McIlroy 已提交
1849 1850 1851 1852 1853

	case XFS_IOC_FSSETDM: {
		struct fsdmidata	dmi;

		if (copy_from_user(&dmi, arg, sizeof(dmi)))
E
Eric Sandeen 已提交
1854
			return -EFAULT;
L
Lachlan McIlroy 已提交
1855

J
Jan Kara 已提交
1856 1857 1858 1859
		error = mnt_want_write_file(filp);
		if (error)
			return error;

L
Lachlan McIlroy 已提交
1860 1861
		error = xfs_set_dmattrs(ip, dmi.fsd_dmevmask,
				dmi.fsd_dmstate);
J
Jan Kara 已提交
1862
		mnt_drop_write_file(filp);
D
Dave Chinner 已提交
1863
		return error;
L
Lachlan McIlroy 已提交
1864 1865 1866 1867
	}

	case XFS_IOC_GETBMAP:
	case XFS_IOC_GETBMAPA:
1868
		return xfs_ioc_getbmap(filp, cmd, arg);
L
Lachlan McIlroy 已提交
1869 1870 1871 1872

	case XFS_IOC_GETBMAPX:
		return xfs_ioc_getbmapx(ip, arg);

1873 1874 1875
	case FS_IOC_GETFSMAP:
		return xfs_ioc_getfsmap(ip, arg);

L
Lachlan McIlroy 已提交
1876 1877
	case XFS_IOC_FD_TO_HANDLE:
	case XFS_IOC_PATH_TO_HANDLE:
1878 1879
	case XFS_IOC_PATH_TO_FSHANDLE: {
		xfs_fsop_handlereq_t	hreq;
L
Lachlan McIlroy 已提交
1880

1881
		if (copy_from_user(&hreq, arg, sizeof(hreq)))
E
Eric Sandeen 已提交
1882
			return -EFAULT;
1883 1884 1885 1886
		return xfs_find_handle(cmd, &hreq);
	}
	case XFS_IOC_OPEN_BY_HANDLE: {
		xfs_fsop_handlereq_t	hreq;
L
Lachlan McIlroy 已提交
1887

1888
		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
E
Eric Sandeen 已提交
1889
			return -EFAULT;
1890
		return xfs_open_by_handle(filp, &hreq);
1891
	}
L
Lachlan McIlroy 已提交
1892
	case XFS_IOC_FSSETDM_BY_HANDLE:
1893
		return xfs_fssetdm_by_handle(filp, arg);
L
Lachlan McIlroy 已提交
1894

1895 1896
	case XFS_IOC_READLINK_BY_HANDLE: {
		xfs_fsop_handlereq_t	hreq;
L
Lachlan McIlroy 已提交
1897

1898
		if (copy_from_user(&hreq, arg, sizeof(xfs_fsop_handlereq_t)))
E
Eric Sandeen 已提交
1899
			return -EFAULT;
1900
		return xfs_readlink_by_handle(filp, &hreq);
1901
	}
L
Lachlan McIlroy 已提交
1902
	case XFS_IOC_ATTRLIST_BY_HANDLE:
1903
		return xfs_attrlist_by_handle(filp, arg);
L
Lachlan McIlroy 已提交
1904 1905

	case XFS_IOC_ATTRMULTI_BY_HANDLE:
1906
		return xfs_attrmulti_by_handle(filp, arg);
L
Lachlan McIlroy 已提交
1907 1908

	case XFS_IOC_SWAPEXT: {
1909 1910 1911
		struct xfs_swapext	sxp;

		if (copy_from_user(&sxp, arg, sizeof(xfs_swapext_t)))
E
Eric Sandeen 已提交
1912
			return -EFAULT;
J
Jan Kara 已提交
1913 1914 1915
		error = mnt_want_write_file(filp);
		if (error)
			return error;
D
Dave Chinner 已提交
1916
		error = xfs_ioc_swapext(&sxp);
J
Jan Kara 已提交
1917
		mnt_drop_write_file(filp);
D
Dave Chinner 已提交
1918
		return error;
L
Lachlan McIlroy 已提交
1919 1920 1921 1922 1923 1924 1925
	}

	case XFS_IOC_FSCOUNTS: {
		xfs_fsop_counts_t out;

		error = xfs_fs_counts(mp, &out);
		if (error)
D
Dave Chinner 已提交
1926
			return error;
L
Lachlan McIlroy 已提交
1927 1928

		if (copy_to_user(arg, &out, sizeof(out)))
E
Eric Sandeen 已提交
1929
			return -EFAULT;
L
Lachlan McIlroy 已提交
1930 1931 1932 1933 1934 1935 1936 1937 1938 1939
		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 已提交
1940
		if (mp->m_flags & XFS_MOUNT_RDONLY)
E
Eric Sandeen 已提交
1941
			return -EROFS;
E
Eric Sandeen 已提交
1942

L
Lachlan McIlroy 已提交
1943
		if (copy_from_user(&inout, arg, sizeof(inout)))
E
Eric Sandeen 已提交
1944
			return -EFAULT;
L
Lachlan McIlroy 已提交
1945

J
Jan Kara 已提交
1946 1947 1948 1949
		error = mnt_want_write_file(filp);
		if (error)
			return error;

L
Lachlan McIlroy 已提交
1950 1951 1952
		/* input parameter is passed in resblks field of structure */
		in = inout.resblks;
		error = xfs_reserve_blocks(mp, &in, &inout);
J
Jan Kara 已提交
1953
		mnt_drop_write_file(filp);
L
Lachlan McIlroy 已提交
1954
		if (error)
D
Dave Chinner 已提交
1955
			return error;
L
Lachlan McIlroy 已提交
1956 1957

		if (copy_to_user(arg, &inout, sizeof(inout)))
E
Eric Sandeen 已提交
1958
			return -EFAULT;
L
Lachlan McIlroy 已提交
1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
		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)
D
Dave Chinner 已提交
1970
			return error;
L
Lachlan McIlroy 已提交
1971 1972

		if (copy_to_user(arg, &out, sizeof(out)))
E
Eric Sandeen 已提交
1973
			return -EFAULT;
L
Lachlan McIlroy 已提交
1974 1975 1976 1977 1978 1979 1980 1981

		return 0;
	}

	case XFS_IOC_FSGROWFSDATA: {
		xfs_growfs_data_t in;

		if (copy_from_user(&in, arg, sizeof(in)))
E
Eric Sandeen 已提交
1982
			return -EFAULT;
L
Lachlan McIlroy 已提交
1983

J
Jan Kara 已提交
1984 1985 1986
		error = mnt_want_write_file(filp);
		if (error)
			return error;
L
Lachlan McIlroy 已提交
1987
		error = xfs_growfs_data(mp, &in);
J
Jan Kara 已提交
1988
		mnt_drop_write_file(filp);
D
Dave Chinner 已提交
1989
		return error;
L
Lachlan McIlroy 已提交
1990 1991 1992 1993 1994 1995
	}

	case XFS_IOC_FSGROWFSLOG: {
		xfs_growfs_log_t in;

		if (copy_from_user(&in, arg, sizeof(in)))
E
Eric Sandeen 已提交
1996
			return -EFAULT;
L
Lachlan McIlroy 已提交
1997

J
Jan Kara 已提交
1998 1999 2000
		error = mnt_want_write_file(filp);
		if (error)
			return error;
L
Lachlan McIlroy 已提交
2001
		error = xfs_growfs_log(mp, &in);
J
Jan Kara 已提交
2002
		mnt_drop_write_file(filp);
D
Dave Chinner 已提交
2003
		return error;
L
Lachlan McIlroy 已提交
2004 2005 2006 2007 2008 2009
	}

	case XFS_IOC_FSGROWFSRT: {
		xfs_growfs_rt_t in;

		if (copy_from_user(&in, arg, sizeof(in)))
E
Eric Sandeen 已提交
2010
			return -EFAULT;
L
Lachlan McIlroy 已提交
2011

J
Jan Kara 已提交
2012 2013 2014
		error = mnt_want_write_file(filp);
		if (error)
			return error;
L
Lachlan McIlroy 已提交
2015
		error = xfs_growfs_rt(mp, &in);
J
Jan Kara 已提交
2016
		mnt_drop_write_file(filp);
D
Dave Chinner 已提交
2017
		return error;
L
Lachlan McIlroy 已提交
2018 2019 2020 2021 2022 2023 2024 2025 2026
	}

	case XFS_IOC_GOINGDOWN: {
		__uint32_t in;

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

		if (get_user(in, (__uint32_t __user *)arg))
E
Eric Sandeen 已提交
2027
			return -EFAULT;
L
Lachlan McIlroy 已提交
2028

D
Dave Chinner 已提交
2029
		return xfs_fs_goingdown(mp, in);
L
Lachlan McIlroy 已提交
2030 2031 2032 2033 2034 2035 2036 2037 2038
	}

	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)))
E
Eric Sandeen 已提交
2039
			return -EFAULT;
L
Lachlan McIlroy 已提交
2040

D
Dave Chinner 已提交
2041
		return xfs_errortag_add(in.errtag, mp);
L
Lachlan McIlroy 已提交
2042 2043 2044 2045 2046 2047
	}

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

D
Dave Chinner 已提交
2048
		return xfs_errortag_clearall(mp, 1);
L
Lachlan McIlroy 已提交
2049

2050
	case XFS_IOC_FREE_EOFBLOCKS: {
2051 2052
		struct xfs_fs_eofblocks eofb;
		struct xfs_eofblocks keofb;
2053

2054 2055 2056 2057
		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;

		if (mp->m_flags & XFS_MOUNT_RDONLY)
E
Eric Sandeen 已提交
2058
			return -EROFS;
2059

2060
		if (copy_from_user(&eofb, arg, sizeof(eofb)))
E
Eric Sandeen 已提交
2061
			return -EFAULT;
2062

2063 2064
		error = xfs_fs_eofblocks_from_user(&eofb, &keofb);
		if (error)
D
Dave Chinner 已提交
2065
			return error;
2066

D
Dave Chinner 已提交
2067
		return xfs_icache_free_eofblocks(mp, &keofb);
2068 2069
	}

L
Lachlan McIlroy 已提交
2070 2071 2072 2073
	default:
		return -ENOTTY;
	}
}