1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (C) 1991, 1992 Linus Torvalds
8 #include <linux/syscalls.h>
10 #include <linux/capability.h>
11 #include <linux/compat.h>
12 #include <linux/file.h>
14 #include <linux/security.h>
15 #include <linux/export.h>
16 #include <linux/uaccess.h>
17 #include <linux/writeback.h>
18 #include <linux/buffer_head.h>
19 #include <linux/falloc.h>
20 #include <linux/sched/signal.h>
21 #include <linux/fiemap.h>
22 #include <linux/mount.h>
23 #include <linux/fscrypt.h>
24 #include <linux/fileattr.h>
28 #include <asm/ioctls.h>
30 /* So that the fiemap access checks can't overflow on 32 bit machines. */
31 #define FIEMAP_MAX_EXTENTS (UINT_MAX / sizeof(struct fiemap_extent))
34 * vfs_ioctl - call filesystem specific ioctl methods
35 * @filp: open file to invoke ioctl method on
36 * @cmd: ioctl command to execute
37 * @arg: command-specific argument for ioctl
39 * Invokes filesystem specific ->unlocked_ioctl, if one exists; otherwise
42 * Returns 0 on success, -errno on error.
44 long vfs_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
48 if (!filp
->f_op
->unlocked_ioctl
)
51 error
= filp
->f_op
->unlocked_ioctl(filp
, cmd
, arg
);
52 if (error
== -ENOIOCTLCMD
)
57 EXPORT_SYMBOL(vfs_ioctl
);
59 static int ioctl_fibmap(struct file
*filp
, int __user
*p
)
61 struct inode
*inode
= file_inode(filp
);
62 struct super_block
*sb
= inode
->i_sb
;
66 if (!capable(CAP_SYS_RAWIO
))
69 error
= get_user(ur_block
, p
);
77 error
= bmap(inode
, &block
);
79 if (block
> INT_MAX
) {
81 pr_warn_ratelimited("[%s/%d] FS: %s File: %pD4 would truncate fibmap result\n",
82 current
->comm
, task_pid_nr(current
),
91 if (put_user(ur_block
, p
))
98 * fiemap_fill_next_extent - Fiemap helper function
99 * @fieinfo: Fiemap context passed into ->fiemap
100 * @logical: Extent logical start offset, in bytes
101 * @phys: Extent physical start offset, in bytes
102 * @len: Extent length, in bytes
103 * @flags: FIEMAP_EXTENT flags that describe this extent
105 * Called from file system ->fiemap callback. Will populate extent
106 * info as passed in via arguments and copy to user memory. On
107 * success, extent count on fieinfo is incremented.
109 * Returns 0 on success, -errno on error, 1 if this was the last
110 * extent that will fit in user array.
112 #define SET_UNKNOWN_FLAGS (FIEMAP_EXTENT_DELALLOC)
113 #define SET_NO_UNMOUNTED_IO_FLAGS (FIEMAP_EXTENT_DATA_ENCRYPTED)
114 #define SET_NOT_ALIGNED_FLAGS (FIEMAP_EXTENT_DATA_TAIL|FIEMAP_EXTENT_DATA_INLINE)
115 int fiemap_fill_next_extent(struct fiemap_extent_info
*fieinfo
, u64 logical
,
116 u64 phys
, u64 len
, u32 flags
)
118 struct fiemap_extent extent
;
119 struct fiemap_extent __user
*dest
= fieinfo
->fi_extents_start
;
121 /* only count the extents */
122 if (fieinfo
->fi_extents_max
== 0) {
123 fieinfo
->fi_extents_mapped
++;
124 return (flags
& FIEMAP_EXTENT_LAST
) ? 1 : 0;
127 if (fieinfo
->fi_extents_mapped
>= fieinfo
->fi_extents_max
)
130 if (flags
& SET_UNKNOWN_FLAGS
)
131 flags
|= FIEMAP_EXTENT_UNKNOWN
;
132 if (flags
& SET_NO_UNMOUNTED_IO_FLAGS
)
133 flags
|= FIEMAP_EXTENT_ENCODED
;
134 if (flags
& SET_NOT_ALIGNED_FLAGS
)
135 flags
|= FIEMAP_EXTENT_NOT_ALIGNED
;
137 memset(&extent
, 0, sizeof(extent
));
138 extent
.fe_logical
= logical
;
139 extent
.fe_physical
= phys
;
140 extent
.fe_length
= len
;
141 extent
.fe_flags
= flags
;
143 dest
+= fieinfo
->fi_extents_mapped
;
144 if (copy_to_user(dest
, &extent
, sizeof(extent
)))
147 fieinfo
->fi_extents_mapped
++;
148 if (fieinfo
->fi_extents_mapped
== fieinfo
->fi_extents_max
)
150 return (flags
& FIEMAP_EXTENT_LAST
) ? 1 : 0;
152 EXPORT_SYMBOL(fiemap_fill_next_extent
);
155 * fiemap_prep - check validity of requested flags for fiemap
156 * @inode: Inode to operate on
157 * @fieinfo: Fiemap context passed into ->fiemap
158 * @start: Start of the mapped range
159 * @len: Length of the mapped range, can be truncated by this function.
160 * @supported_flags: Set of fiemap flags that the file system understands
162 * This function must be called from each ->fiemap instance to validate the
163 * fiemap request against the file system parameters.
165 * Returns 0 on success, or a negative error on failure.
167 int fiemap_prep(struct inode
*inode
, struct fiemap_extent_info
*fieinfo
,
168 u64 start
, u64
*len
, u32 supported_flags
)
170 u64 maxbytes
= inode
->i_sb
->s_maxbytes
;
176 if (start
> maxbytes
)
180 * Shrink request scope to what the fs can actually handle.
182 if (*len
> maxbytes
|| (maxbytes
- *len
) < start
)
183 *len
= maxbytes
- start
;
185 supported_flags
|= FIEMAP_FLAG_SYNC
;
186 supported_flags
&= FIEMAP_FLAGS_COMPAT
;
187 incompat_flags
= fieinfo
->fi_flags
& ~supported_flags
;
188 if (incompat_flags
) {
189 fieinfo
->fi_flags
= incompat_flags
;
193 if (fieinfo
->fi_flags
& FIEMAP_FLAG_SYNC
)
194 ret
= filemap_write_and_wait(inode
->i_mapping
);
197 EXPORT_SYMBOL(fiemap_prep
);
199 static int ioctl_fiemap(struct file
*filp
, struct fiemap __user
*ufiemap
)
201 struct fiemap fiemap
;
202 struct fiemap_extent_info fieinfo
= { 0, };
203 struct inode
*inode
= file_inode(filp
);
206 if (!inode
->i_op
->fiemap
)
209 if (copy_from_user(&fiemap
, ufiemap
, sizeof(fiemap
)))
212 if (fiemap
.fm_extent_count
> FIEMAP_MAX_EXTENTS
)
215 fieinfo
.fi_flags
= fiemap
.fm_flags
;
216 fieinfo
.fi_extents_max
= fiemap
.fm_extent_count
;
217 fieinfo
.fi_extents_start
= ufiemap
->fm_extents
;
219 error
= inode
->i_op
->fiemap(inode
, &fieinfo
, fiemap
.fm_start
,
222 fiemap
.fm_flags
= fieinfo
.fi_flags
;
223 fiemap
.fm_mapped_extents
= fieinfo
.fi_extents_mapped
;
224 if (copy_to_user(ufiemap
, &fiemap
, sizeof(fiemap
)))
230 static long ioctl_file_clone(struct file
*dst_file
, unsigned long srcfd
,
231 u64 off
, u64 olen
, u64 destoff
)
233 struct fd src_file
= fdget(srcfd
);
240 if (src_file
.file
->f_path
.mnt
!= dst_file
->f_path
.mnt
)
242 cloned
= vfs_clone_file_range(src_file
.file
, off
, dst_file
, destoff
,
246 else if (olen
&& cloned
!= olen
)
255 static long ioctl_file_clone_range(struct file
*file
,
256 struct file_clone_range __user
*argp
)
258 struct file_clone_range args
;
260 if (copy_from_user(&args
, argp
, sizeof(args
)))
262 return ioctl_file_clone(file
, args
.src_fd
, args
.src_offset
,
263 args
.src_length
, args
.dest_offset
);
268 static inline sector_t
logical_to_blk(struct inode
*inode
, loff_t offset
)
270 return (offset
>> inode
->i_blkbits
);
273 static inline loff_t
blk_to_logical(struct inode
*inode
, sector_t blk
)
275 return (blk
<< inode
->i_blkbits
);
279 * __generic_block_fiemap - FIEMAP for block based inodes (no locking)
280 * @inode: the inode to map
281 * @fieinfo: the fiemap info struct that will be passed back to userspace
282 * @start: where to start mapping in the inode
283 * @len: how much space to map
284 * @get_block: the fs's get_block function
286 * This does FIEMAP for block based inodes. Basically it will just loop
287 * through get_block until we hit the number of extents we want to map, or we
288 * go past the end of the file and hit a hole.
290 * If it is possible to have data blocks beyond a hole past @inode->i_size, then
291 * please do not use this function, it will stop at the first unmapped block
294 * If you use this function directly, you need to do your own locking. Use
295 * generic_block_fiemap if you want the locking done for you.
297 static int __generic_block_fiemap(struct inode
*inode
,
298 struct fiemap_extent_info
*fieinfo
, loff_t start
,
299 loff_t len
, get_block_t
*get_block
)
301 struct buffer_head map_bh
;
302 sector_t start_blk
, last_blk
;
303 loff_t isize
= i_size_read(inode
);
304 u64 logical
= 0, phys
= 0, size
= 0;
305 u32 flags
= FIEMAP_EXTENT_MERGED
;
306 bool past_eof
= false, whole_file
= false;
309 ret
= fiemap_prep(inode
, fieinfo
, start
, &len
, FIEMAP_FLAG_SYNC
);
314 * Either the i_mutex or other appropriate locking needs to be held
315 * since we expect isize to not change at all through the duration of
324 * Some filesystems can't deal with being asked to map less than
325 * blocksize, so make sure our len is at least block length.
327 if (logical_to_blk(inode
, len
) == 0)
328 len
= blk_to_logical(inode
, 1);
330 start_blk
= logical_to_blk(inode
, start
);
331 last_blk
= logical_to_blk(inode
, start
+ len
- 1);
335 * we set b_size to the total size we want so it will map as
336 * many contiguous blocks as possible at once
338 memset(&map_bh
, 0, sizeof(struct buffer_head
));
341 ret
= get_block(inode
, start_blk
, &map_bh
, 0);
346 if (!buffer_mapped(&map_bh
)) {
350 * We want to handle the case where there is an
351 * allocated block at the front of the file, and then
352 * nothing but holes up to the end of the file properly,
353 * to make sure that extent at the front gets properly
354 * marked with FIEMAP_EXTENT_LAST
357 blk_to_logical(inode
, start_blk
) >= isize
)
361 * First hole after going past the EOF, this is our
364 if (past_eof
&& size
) {
365 flags
= FIEMAP_EXTENT_MERGED
|FIEMAP_EXTENT_LAST
;
366 ret
= fiemap_fill_next_extent(fieinfo
, logical
,
370 ret
= fiemap_fill_next_extent(fieinfo
, logical
,
375 /* if we have holes up to/past EOF then we're done */
376 if (start_blk
> last_blk
|| past_eof
|| ret
)
380 * We have gone over the length of what we wanted to
381 * map, and it wasn't the entire file, so add the extent
382 * we got last time and exit.
384 * This is for the case where say we want to map all the
385 * way up to the second to the last block in a file, but
386 * the last block is a hole, making the second to last
387 * block FIEMAP_EXTENT_LAST. In this case we want to
388 * see if there is a hole after the second to last block
389 * so we can mark it properly. If we found data after
390 * we exceeded the length we were requesting, then we
391 * are good to go, just add the extent to the fieinfo
394 if (start_blk
> last_blk
&& !whole_file
) {
395 ret
= fiemap_fill_next_extent(fieinfo
, logical
,
402 * if size != 0 then we know we already have an extent
406 ret
= fiemap_fill_next_extent(fieinfo
, logical
,
413 logical
= blk_to_logical(inode
, start_blk
);
414 phys
= blk_to_logical(inode
, map_bh
.b_blocknr
);
415 size
= map_bh
.b_size
;
416 flags
= FIEMAP_EXTENT_MERGED
;
418 start_blk
+= logical_to_blk(inode
, size
);
421 * If we are past the EOF, then we need to make sure as
422 * soon as we find a hole that the last extent we found
423 * is marked with FIEMAP_EXTENT_LAST
425 if (!past_eof
&& logical
+ size
>= isize
)
429 if (fatal_signal_pending(current
)) {
436 /* If ret is 1 then we just hit the end of the extent array */
444 * generic_block_fiemap - FIEMAP for block based inodes
445 * @inode: The inode to map
446 * @fieinfo: The mapping information
447 * @start: The initial block to map
448 * @len: The length of the extect to attempt to map
449 * @get_block: The block mapping function for the fs
451 * Calls __generic_block_fiemap to map the inode, after taking
452 * the inode's mutex lock.
455 int generic_block_fiemap(struct inode
*inode
,
456 struct fiemap_extent_info
*fieinfo
, u64 start
,
457 u64 len
, get_block_t
*get_block
)
461 ret
= __generic_block_fiemap(inode
, fieinfo
, start
, len
, get_block
);
465 EXPORT_SYMBOL(generic_block_fiemap
);
467 #endif /* CONFIG_BLOCK */
470 * This provides compatibility with legacy XFS pre-allocation ioctls
471 * which predate the fallocate syscall.
473 * Only the l_start, l_len and l_whence fields of the 'struct space_resv'
474 * are used here, rest are ignored.
476 static int ioctl_preallocate(struct file
*filp
, int mode
, void __user
*argp
)
478 struct inode
*inode
= file_inode(filp
);
479 struct space_resv sr
;
481 if (copy_from_user(&sr
, argp
, sizeof(sr
)))
484 switch (sr
.l_whence
) {
488 sr
.l_start
+= filp
->f_pos
;
491 sr
.l_start
+= i_size_read(inode
);
497 return vfs_fallocate(filp
, mode
| FALLOC_FL_KEEP_SIZE
, sr
.l_start
,
501 /* on ia32 l_start is on a 32-bit boundary */
502 #if defined CONFIG_COMPAT && defined(CONFIG_X86_64)
503 /* just account for different alignment */
504 static int compat_ioctl_preallocate(struct file
*file
, int mode
,
505 struct space_resv_32 __user
*argp
)
507 struct inode
*inode
= file_inode(file
);
508 struct space_resv_32 sr
;
510 if (copy_from_user(&sr
, argp
, sizeof(sr
)))
513 switch (sr
.l_whence
) {
517 sr
.l_start
+= file
->f_pos
;
520 sr
.l_start
+= i_size_read(inode
);
526 return vfs_fallocate(file
, mode
| FALLOC_FL_KEEP_SIZE
, sr
.l_start
, sr
.l_len
);
530 static int file_ioctl(struct file
*filp
, unsigned int cmd
, int __user
*p
)
534 return ioctl_fibmap(filp
, p
);
536 case FS_IOC_RESVSP64
:
537 return ioctl_preallocate(filp
, 0, p
);
538 case FS_IOC_UNRESVSP
:
539 case FS_IOC_UNRESVSP64
:
540 return ioctl_preallocate(filp
, FALLOC_FL_PUNCH_HOLE
, p
);
541 case FS_IOC_ZERO_RANGE
:
542 return ioctl_preallocate(filp
, FALLOC_FL_ZERO_RANGE
, p
);
548 static int ioctl_fionbio(struct file
*filp
, int __user
*argp
)
553 error
= get_user(on
, argp
);
558 /* SunOS compatibility item. */
559 if (O_NONBLOCK
!= O_NDELAY
)
562 spin_lock(&filp
->f_lock
);
564 filp
->f_flags
|= flag
;
566 filp
->f_flags
&= ~flag
;
567 spin_unlock(&filp
->f_lock
);
571 static int ioctl_fioasync(unsigned int fd
, struct file
*filp
,
577 error
= get_user(on
, argp
);
580 flag
= on
? FASYNC
: 0;
582 /* Did FASYNC state change ? */
583 if ((flag
^ filp
->f_flags
) & FASYNC
) {
584 if (filp
->f_op
->fasync
)
585 /* fasync() adjusts filp->f_flags */
586 error
= filp
->f_op
->fasync(fd
, filp
, on
);
590 return error
< 0 ? error
: 0;
593 static int ioctl_fsfreeze(struct file
*filp
)
595 struct super_block
*sb
= file_inode(filp
)->i_sb
;
597 if (!ns_capable(sb
->s_user_ns
, CAP_SYS_ADMIN
))
600 /* If filesystem doesn't support freeze feature, return. */
601 if (sb
->s_op
->freeze_fs
== NULL
&& sb
->s_op
->freeze_super
== NULL
)
605 if (sb
->s_op
->freeze_super
)
606 return sb
->s_op
->freeze_super(sb
);
607 return freeze_super(sb
);
610 static int ioctl_fsthaw(struct file
*filp
)
612 struct super_block
*sb
= file_inode(filp
)->i_sb
;
614 if (!ns_capable(sb
->s_user_ns
, CAP_SYS_ADMIN
))
618 if (sb
->s_op
->thaw_super
)
619 return sb
->s_op
->thaw_super(sb
);
620 return thaw_super(sb
);
623 static int ioctl_file_dedupe_range(struct file
*file
,
624 struct file_dedupe_range __user
*argp
)
626 struct file_dedupe_range
*same
= NULL
;
631 if (get_user(count
, &argp
->dest_count
)) {
636 size
= offsetof(struct file_dedupe_range __user
, info
[count
]);
637 if (size
> PAGE_SIZE
) {
642 same
= memdup_user(argp
, size
);
649 same
->dest_count
= count
;
650 ret
= vfs_dedupe_file_range(file
, same
);
654 ret
= copy_to_user(argp
, same
, size
);
664 * fileattr_fill_xflags - initialize fileattr with xflags
665 * @fa: fileattr pointer
666 * @xflags: FS_XFLAG_* flags
668 * Set ->fsx_xflags, ->fsx_valid and ->flags (translated xflags). All
669 * other fields are zeroed.
671 void fileattr_fill_xflags(struct fileattr
*fa
, u32 xflags
)
673 memset(fa
, 0, sizeof(*fa
));
674 fa
->fsx_valid
= true;
675 fa
->fsx_xflags
= xflags
;
676 if (fa
->fsx_xflags
& FS_XFLAG_IMMUTABLE
)
677 fa
->flags
|= FS_IMMUTABLE_FL
;
678 if (fa
->fsx_xflags
& FS_XFLAG_APPEND
)
679 fa
->flags
|= FS_APPEND_FL
;
680 if (fa
->fsx_xflags
& FS_XFLAG_SYNC
)
681 fa
->flags
|= FS_SYNC_FL
;
682 if (fa
->fsx_xflags
& FS_XFLAG_NOATIME
)
683 fa
->flags
|= FS_NOATIME_FL
;
684 if (fa
->fsx_xflags
& FS_XFLAG_NODUMP
)
685 fa
->flags
|= FS_NODUMP_FL
;
686 if (fa
->fsx_xflags
& FS_XFLAG_DAX
)
687 fa
->flags
|= FS_DAX_FL
;
688 if (fa
->fsx_xflags
& FS_XFLAG_PROJINHERIT
)
689 fa
->flags
|= FS_PROJINHERIT_FL
;
691 EXPORT_SYMBOL(fileattr_fill_xflags
);
694 * fileattr_fill_flags - initialize fileattr with flags
695 * @fa: fileattr pointer
696 * @flags: FS_*_FL flags
698 * Set ->flags, ->flags_valid and ->fsx_xflags (translated flags).
699 * All other fields are zeroed.
701 void fileattr_fill_flags(struct fileattr
*fa
, u32 flags
)
703 memset(fa
, 0, sizeof(*fa
));
704 fa
->flags_valid
= true;
706 if (fa
->flags
& FS_SYNC_FL
)
707 fa
->fsx_xflags
|= FS_XFLAG_SYNC
;
708 if (fa
->flags
& FS_IMMUTABLE_FL
)
709 fa
->fsx_xflags
|= FS_XFLAG_IMMUTABLE
;
710 if (fa
->flags
& FS_APPEND_FL
)
711 fa
->fsx_xflags
|= FS_XFLAG_APPEND
;
712 if (fa
->flags
& FS_NODUMP_FL
)
713 fa
->fsx_xflags
|= FS_XFLAG_NODUMP
;
714 if (fa
->flags
& FS_NOATIME_FL
)
715 fa
->fsx_xflags
|= FS_XFLAG_NOATIME
;
716 if (fa
->flags
& FS_DAX_FL
)
717 fa
->fsx_xflags
|= FS_XFLAG_DAX
;
718 if (fa
->flags
& FS_PROJINHERIT_FL
)
719 fa
->fsx_xflags
|= FS_XFLAG_PROJINHERIT
;
721 EXPORT_SYMBOL(fileattr_fill_flags
);
724 * vfs_fileattr_get - retrieve miscellaneous file attributes
725 * @dentry: the object to retrieve from
726 * @fa: fileattr pointer
728 * Call i_op->fileattr_get() callback, if exists.
730 * Return: 0 on success, or a negative error on failure.
732 int vfs_fileattr_get(struct dentry
*dentry
, struct fileattr
*fa
)
734 struct inode
*inode
= d_inode(dentry
);
736 if (!inode
->i_op
->fileattr_get
)
739 return inode
->i_op
->fileattr_get(dentry
, fa
);
741 EXPORT_SYMBOL(vfs_fileattr_get
);
744 * copy_fsxattr_to_user - copy fsxattr to userspace.
745 * @fa: fileattr pointer
746 * @ufa: fsxattr user pointer
748 * Return: 0 on success, or -EFAULT on failure.
750 int copy_fsxattr_to_user(const struct fileattr
*fa
, struct fsxattr __user
*ufa
)
754 memset(&xfa
, 0, sizeof(xfa
));
755 xfa
.fsx_xflags
= fa
->fsx_xflags
;
756 xfa
.fsx_extsize
= fa
->fsx_extsize
;
757 xfa
.fsx_nextents
= fa
->fsx_nextents
;
758 xfa
.fsx_projid
= fa
->fsx_projid
;
759 xfa
.fsx_cowextsize
= fa
->fsx_cowextsize
;
761 if (copy_to_user(ufa
, &xfa
, sizeof(xfa
)))
766 EXPORT_SYMBOL(copy_fsxattr_to_user
);
768 static int copy_fsxattr_from_user(struct fileattr
*fa
,
769 struct fsxattr __user
*ufa
)
773 if (copy_from_user(&xfa
, ufa
, sizeof(xfa
)))
776 fileattr_fill_xflags(fa
, xfa
.fsx_xflags
);
777 fa
->fsx_extsize
= xfa
.fsx_extsize
;
778 fa
->fsx_nextents
= xfa
.fsx_nextents
;
779 fa
->fsx_projid
= xfa
.fsx_projid
;
780 fa
->fsx_cowextsize
= xfa
.fsx_cowextsize
;
786 * Generic function to check FS_IOC_FSSETXATTR/FS_IOC_SETFLAGS values and reject
787 * any invalid configurations.
789 * Note: must be called with inode lock held.
791 static int fileattr_set_prepare(struct inode
*inode
,
792 const struct fileattr
*old_ma
,
798 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
799 * the relevant capability.
801 if ((fa
->flags
^ old_ma
->flags
) & (FS_APPEND_FL
| FS_IMMUTABLE_FL
) &&
802 !capable(CAP_LINUX_IMMUTABLE
))
805 err
= fscrypt_prepare_setflags(inode
, old_ma
->flags
, fa
->flags
);
810 * Project Quota ID state is only allowed to change from within the init
811 * namespace. Enforce that restriction only if we are trying to change
812 * the quota ID state. Everything else is allowed in user namespaces.
814 if (current_user_ns() != &init_user_ns
) {
815 if (old_ma
->fsx_projid
!= fa
->fsx_projid
)
817 if ((old_ma
->fsx_xflags
^ fa
->fsx_xflags
) &
818 FS_XFLAG_PROJINHERIT
)
822 /* Check extent size hints. */
823 if ((fa
->fsx_xflags
& FS_XFLAG_EXTSIZE
) && !S_ISREG(inode
->i_mode
))
826 if ((fa
->fsx_xflags
& FS_XFLAG_EXTSZINHERIT
) &&
827 !S_ISDIR(inode
->i_mode
))
830 if ((fa
->fsx_xflags
& FS_XFLAG_COWEXTSIZE
) &&
831 !S_ISREG(inode
->i_mode
) && !S_ISDIR(inode
->i_mode
))
835 * It is only valid to set the DAX flag on regular files and
836 * directories on filesystems.
838 if ((fa
->fsx_xflags
& FS_XFLAG_DAX
) &&
839 !(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
)))
842 /* Extent size hints of zero turn off the flags. */
843 if (fa
->fsx_extsize
== 0)
844 fa
->fsx_xflags
&= ~(FS_XFLAG_EXTSIZE
| FS_XFLAG_EXTSZINHERIT
);
845 if (fa
->fsx_cowextsize
== 0)
846 fa
->fsx_xflags
&= ~FS_XFLAG_COWEXTSIZE
;
852 * vfs_fileattr_set - change miscellaneous file attributes
853 * @mnt_userns: user namespace of the mount
854 * @dentry: the object to change
855 * @fa: fileattr pointer
857 * After verifying permissions, call i_op->fileattr_set() callback, if
860 * Verifying attributes involves retrieving current attributes with
861 * i_op->fileattr_get(), this also allows initializing attributes that have
862 * not been set by the caller to current values. Inode lock is held
863 * thoughout to prevent racing with another instance.
865 * Return: 0 on success, or a negative error on failure.
867 int vfs_fileattr_set(struct user_namespace
*mnt_userns
, struct dentry
*dentry
,
870 struct inode
*inode
= d_inode(dentry
);
871 struct fileattr old_ma
= {};
874 if (!inode
->i_op
->fileattr_set
)
877 if (!inode_owner_or_capable(mnt_userns
, inode
))
881 err
= vfs_fileattr_get(dentry
, &old_ma
);
883 /* initialize missing bits from old_ma */
884 if (fa
->flags_valid
) {
885 fa
->fsx_xflags
|= old_ma
.fsx_xflags
& ~FS_XFLAG_COMMON
;
886 fa
->fsx_extsize
= old_ma
.fsx_extsize
;
887 fa
->fsx_nextents
= old_ma
.fsx_nextents
;
888 fa
->fsx_projid
= old_ma
.fsx_projid
;
889 fa
->fsx_cowextsize
= old_ma
.fsx_cowextsize
;
891 fa
->flags
|= old_ma
.flags
& ~FS_COMMON_FL
;
893 err
= fileattr_set_prepare(inode
, &old_ma
, fa
);
895 err
= inode
->i_op
->fileattr_set(mnt_userns
, dentry
, fa
);
901 EXPORT_SYMBOL(vfs_fileattr_set
);
903 static int ioctl_getflags(struct file
*file
, unsigned int __user
*argp
)
905 struct fileattr fa
= { .flags_valid
= true }; /* hint only */
908 err
= vfs_fileattr_get(file
->f_path
.dentry
, &fa
);
910 err
= put_user(fa
.flags
, argp
);
914 static int ioctl_setflags(struct file
*file
, unsigned int __user
*argp
)
916 struct user_namespace
*mnt_userns
= file_mnt_user_ns(file
);
917 struct dentry
*dentry
= file
->f_path
.dentry
;
922 err
= get_user(flags
, argp
);
924 err
= mnt_want_write_file(file
);
926 fileattr_fill_flags(&fa
, flags
);
927 err
= vfs_fileattr_set(mnt_userns
, dentry
, &fa
);
928 mnt_drop_write_file(file
);
934 static int ioctl_fsgetxattr(struct file
*file
, void __user
*argp
)
936 struct fileattr fa
= { .fsx_valid
= true }; /* hint only */
939 err
= vfs_fileattr_get(file
->f_path
.dentry
, &fa
);
941 err
= copy_fsxattr_to_user(&fa
, argp
);
946 static int ioctl_fssetxattr(struct file
*file
, void __user
*argp
)
948 struct user_namespace
*mnt_userns
= file_mnt_user_ns(file
);
949 struct dentry
*dentry
= file
->f_path
.dentry
;
953 err
= copy_fsxattr_from_user(&fa
, argp
);
955 err
= mnt_want_write_file(file
);
957 err
= vfs_fileattr_set(mnt_userns
, dentry
, &fa
);
958 mnt_drop_write_file(file
);
965 * do_vfs_ioctl() is not for drivers and not intended to be EXPORT_SYMBOL()'d.
966 * It's just a simple helper for sys_ioctl and compat_sys_ioctl.
968 * When you add any new common ioctls to the switches above and below,
969 * please ensure they have compatible arguments in compat mode.
971 static int do_vfs_ioctl(struct file
*filp
, unsigned int fd
,
972 unsigned int cmd
, unsigned long arg
)
974 void __user
*argp
= (void __user
*)arg
;
975 struct inode
*inode
= file_inode(filp
);
979 set_close_on_exec(fd
, 1);
983 set_close_on_exec(fd
, 0);
987 return ioctl_fionbio(filp
, argp
);
990 return ioctl_fioasync(fd
, filp
, argp
);
993 if (S_ISDIR(inode
->i_mode
) || S_ISREG(inode
->i_mode
) ||
994 S_ISLNK(inode
->i_mode
)) {
995 loff_t res
= inode_get_bytes(inode
);
996 return copy_to_user(argp
, &res
, sizeof(res
)) ?
1003 return ioctl_fsfreeze(filp
);
1006 return ioctl_fsthaw(filp
);
1009 return ioctl_fiemap(filp
, argp
);
1012 /* anon_bdev filesystems may not have a block size */
1013 if (!inode
->i_sb
->s_blocksize
)
1016 return put_user(inode
->i_sb
->s_blocksize
, (int __user
*)argp
);
1019 return ioctl_file_clone(filp
, arg
, 0, 0, 0);
1022 return ioctl_file_clone_range(filp
, argp
);
1025 return ioctl_file_dedupe_range(filp
, argp
);
1028 if (!S_ISREG(inode
->i_mode
))
1029 return vfs_ioctl(filp
, cmd
, arg
);
1031 return put_user(i_size_read(inode
) - filp
->f_pos
,
1032 (int __user
*)argp
);
1034 case FS_IOC_GETFLAGS
:
1035 return ioctl_getflags(filp
, argp
);
1037 case FS_IOC_SETFLAGS
:
1038 return ioctl_setflags(filp
, argp
);
1040 case FS_IOC_FSGETXATTR
:
1041 return ioctl_fsgetxattr(filp
, argp
);
1043 case FS_IOC_FSSETXATTR
:
1044 return ioctl_fssetxattr(filp
, argp
);
1047 if (S_ISREG(inode
->i_mode
))
1048 return file_ioctl(filp
, cmd
, argp
);
1052 return -ENOIOCTLCMD
;
1055 SYSCALL_DEFINE3(ioctl
, unsigned int, fd
, unsigned int, cmd
, unsigned long, arg
)
1057 struct fd f
= fdget(fd
);
1063 error
= security_file_ioctl(f
.file
, cmd
, arg
);
1067 error
= do_vfs_ioctl(f
.file
, fd
, cmd
, arg
);
1068 if (error
== -ENOIOCTLCMD
)
1069 error
= vfs_ioctl(f
.file
, cmd
, arg
);
1076 #ifdef CONFIG_COMPAT
1078 * compat_ptr_ioctl - generic implementation of .compat_ioctl file operation
1080 * This is not normally called as a function, but instead set in struct
1081 * file_operations as
1083 * .compat_ioctl = compat_ptr_ioctl,
1085 * On most architectures, the compat_ptr_ioctl() just passes all arguments
1086 * to the corresponding ->ioctl handler. The exception is arch/s390, where
1087 * compat_ptr() clears the top bit of a 32-bit pointer value, so user space
1088 * pointers to the second 2GB alias the first 2GB, as is the case for
1089 * native 32-bit s390 user space.
1091 * The compat_ptr_ioctl() function must therefore be used only with ioctl
1092 * functions that either ignore the argument or pass a pointer to a
1093 * compatible data type.
1095 * If any ioctl command handled by fops->unlocked_ioctl passes a plain
1096 * integer instead of a pointer, or any of the passed data types
1097 * is incompatible between 32-bit and 64-bit architectures, a proper
1098 * handler is required instead of compat_ptr_ioctl.
1100 long compat_ptr_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1102 if (!file
->f_op
->unlocked_ioctl
)
1103 return -ENOIOCTLCMD
;
1105 return file
->f_op
->unlocked_ioctl(file
, cmd
, (unsigned long)compat_ptr(arg
));
1107 EXPORT_SYMBOL(compat_ptr_ioctl
);
1109 COMPAT_SYSCALL_DEFINE3(ioctl
, unsigned int, fd
, unsigned int, cmd
,
1110 compat_ulong_t
, arg
)
1112 struct fd f
= fdget(fd
);
1118 /* RED-PEN how should LSM module know it's handling 32bit? */
1119 error
= security_file_ioctl(f
.file
, cmd
, arg
);
1124 /* FICLONE takes an int argument, so don't use compat_ptr() */
1126 error
= ioctl_file_clone(f
.file
, arg
, 0, 0, 0);
1129 #if defined(CONFIG_X86_64)
1130 /* these get messy on amd64 due to alignment differences */
1131 case FS_IOC_RESVSP_32
:
1132 case FS_IOC_RESVSP64_32
:
1133 error
= compat_ioctl_preallocate(f
.file
, 0, compat_ptr(arg
));
1135 case FS_IOC_UNRESVSP_32
:
1136 case FS_IOC_UNRESVSP64_32
:
1137 error
= compat_ioctl_preallocate(f
.file
, FALLOC_FL_PUNCH_HOLE
,
1140 case FS_IOC_ZERO_RANGE_32
:
1141 error
= compat_ioctl_preallocate(f
.file
, FALLOC_FL_ZERO_RANGE
,
1147 * These access 32-bit values anyway so no further handling is
1150 case FS_IOC32_GETFLAGS
:
1151 case FS_IOC32_SETFLAGS
:
1152 cmd
= (cmd
== FS_IOC32_GETFLAGS
) ?
1153 FS_IOC_GETFLAGS
: FS_IOC_SETFLAGS
;
1156 * everything else in do_vfs_ioctl() takes either a compatible
1157 * pointer argument or no argument -- call it with a modified
1161 error
= do_vfs_ioctl(f
.file
, fd
, cmd
,
1162 (unsigned long)compat_ptr(arg
));
1163 if (error
!= -ENOIOCTLCMD
)
1166 if (f
.file
->f_op
->compat_ioctl
)
1167 error
= f
.file
->f_op
->compat_ioctl(f
.file
, cmd
, arg
);
1168 if (error
== -ENOIOCTLCMD
)