// SPDX-License-Identifier: GPL-2.0 /* * Copyright (C) 2007 Oracle. All rights reserved. */ #include <linux/kernel.h> #include <linux/bio.h> #include <linux/file.h> #include <linux/fs.h> #include <linux/fsnotify.h> #include <linux/pagemap.h> #include <linux/highmem.h> #include <linux/time.h> #include <linux/string.h> #include <linux/backing-dev.h> #include <linux/mount.h> #include <linux/namei.h> #include <linux/writeback.h> #include <linux/compat.h> #include <linux/security.h> #include <linux/xattr.h> #include <linux/mm.h> #include <linux/slab.h> #include <linux/blkdev.h> #include <linux/uuid.h> #include <linux/btrfs.h> #include <linux/uaccess.h> #include <linux/iversion.h> #include <linux/fileattr.h> #include <linux/fsverity.h> #include <linux/sched/xacct.h> #include "ctree.h" #include "disk-io.h" #include "export.h" #include "transaction.h" #include "btrfs_inode.h" #include "volumes.h" #include "locking.h" #include "backref.h" #include "send.h" #include "dev-replace.h" #include "props.h" #include "sysfs.h" #include "qgroup.h" #include "tree-log.h" #include "compression.h" #include "space-info.h" #include "block-group.h" #include "fs.h" #include "accessors.h" #include "extent-tree.h" #include "root-tree.h" #include "defrag.h" #include "dir-item.h" #include "uuid-tree.h" #include "ioctl.h" #include "file.h" #include "scrub.h" #include "super.h" #ifdef CONFIG_64BIT /* If we have a 32-bit userspace and 64-bit kernel, then the UAPI * structures are incorrect, as the timespec structure from userspace * is 4 bytes too small. We define these alternatives here to teach * the kernel about the 32-bit struct packing. */ struct btrfs_ioctl_timespec_32 { … } __attribute__ ((packed)); struct btrfs_ioctl_received_subvol_args_32 { … } __attribute__ ((packed)); #define BTRFS_IOC_SET_RECEIVED_SUBVOL_32 … #endif #if defined(CONFIG_64BIT) && defined(CONFIG_COMPAT) struct btrfs_ioctl_send_args_32 { … } __attribute__ ((packed)); #define BTRFS_IOC_SEND_32 … struct btrfs_ioctl_encoded_io_args_32 { … }; #define BTRFS_IOC_ENCODED_READ_32 … #define BTRFS_IOC_ENCODED_WRITE_32 … #endif /* Mask out flags that are inappropriate for the given type of inode. */ static unsigned int btrfs_mask_fsflags_for_type(struct inode *inode, unsigned int flags) { … } /* * Export internal inode flags to the format expected by the FS_IOC_GETFLAGS * ioctl. */ static unsigned int btrfs_inode_flags_to_fsflags(struct btrfs_inode *binode) { … } /* * Update inode->i_flags based on the btrfs internal flags. */ void btrfs_sync_inode_flags_to_i_flags(struct inode *inode) { … } /* * Check if @flags are a supported and valid set of FS_*_FL flags and that * the old and new flags are not conflicting */ static int check_fsflags(unsigned int old_flags, unsigned int flags) { … } static int check_fsflags_compatible(struct btrfs_fs_info *fs_info, unsigned int flags) { … } int btrfs_check_ioctl_vol_args_path(const struct btrfs_ioctl_vol_args *vol_args) { … } static int btrfs_check_ioctl_vol_args2_subvol_name(const struct btrfs_ioctl_vol_args_v2 *vol_args2) { … } /* * Set flags/xflags from the internal inode flags. The remaining items of * fsxattr are zeroed. */ int btrfs_fileattr_get(struct dentry *dentry, struct fileattr *fa) { … } int btrfs_fileattr_set(struct mnt_idmap *idmap, struct dentry *dentry, struct fileattr *fa) { … } /* * Start exclusive operation @type, return true on success */ bool btrfs_exclop_start(struct btrfs_fs_info *fs_info, enum btrfs_exclusive_operation type) { … } /* * Conditionally allow to enter the exclusive operation in case it's compatible * with the running one. This must be paired with btrfs_exclop_start_unlock and * btrfs_exclop_finish. * * Compatibility: * - the same type is already running * - when trying to add a device and balance has been paused * - not BTRFS_EXCLOP_NONE - this is intentionally incompatible and the caller * must check the condition first that would allow none -> @type */ bool btrfs_exclop_start_try_lock(struct btrfs_fs_info *fs_info, enum btrfs_exclusive_operation type) { … } void btrfs_exclop_start_unlock(struct btrfs_fs_info *fs_info) { … } void btrfs_exclop_finish(struct btrfs_fs_info *fs_info) { … } void btrfs_exclop_balance(struct btrfs_fs_info *fs_info, enum btrfs_exclusive_operation op) { … } static int btrfs_ioctl_getversion(struct inode *inode, int __user *arg) { … } static noinline int btrfs_ioctl_fitrim(struct btrfs_fs_info *fs_info, void __user *arg) { … } int __pure btrfs_is_empty_uuid(const u8 *uuid) { … } /* * Calculate the number of transaction items to reserve for creating a subvolume * or snapshot, not including the inode, directory entries, or parent directory. */ static unsigned int create_subvol_num_items(struct btrfs_qgroup_inherit *inherit) { … } static noinline int create_subvol(struct mnt_idmap *idmap, struct inode *dir, struct dentry *dentry, struct btrfs_qgroup_inherit *inherit) { … } static int create_snapshot(struct btrfs_root *root, struct inode *dir, struct dentry *dentry, bool readonly, struct btrfs_qgroup_inherit *inherit) { … } /* copy of may_delete in fs/namei.c() * Check whether we can remove a link victim from directory dir, check * whether the type of victim is right. * 1. We can't do it if dir is read-only (done in permission()) * 2. We should have write and exec permissions on dir * 3. We can't remove anything from append-only dir * 4. We can't do anything with immutable dir (done in permission()) * 5. If the sticky bit on dir is set we should either * a. be owner of dir, or * b. be owner of victim, or * c. have CAP_FOWNER capability * 6. If the victim is append-only or immutable we can't do anything with * links pointing to it. * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR. * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR. * 9. We can't remove a root or mountpoint. * 10. We don't allow removal of NFS sillyrenamed files; it's handled by * nfs_async_unlink(). */ static int btrfs_may_delete(struct mnt_idmap *idmap, struct inode *dir, struct dentry *victim, int isdir) { … } /* copy of may_create in fs/namei.c() */ static inline int btrfs_may_create(struct mnt_idmap *idmap, struct inode *dir, struct dentry *child) { … } /* * Create a new subvolume below @parent. This is largely modeled after * sys_mkdirat and vfs_mkdir, but we only do a single component lookup * inside this filesystem so it's quite a bit simpler. */ static noinline int btrfs_mksubvol(const struct path *parent, struct mnt_idmap *idmap, const char *name, int namelen, struct btrfs_root *snap_src, bool readonly, struct btrfs_qgroup_inherit *inherit) { … } static noinline int btrfs_mksnapshot(const struct path *parent, struct mnt_idmap *idmap, const char *name, int namelen, struct btrfs_root *root, bool readonly, struct btrfs_qgroup_inherit *inherit) { … } /* * Try to start exclusive operation @type or cancel it if it's running. * * Return: * 0 - normal mode, newly claimed op started * >0 - normal mode, something else is running, * return BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS to user space * ECANCELED - cancel mode, successful cancel * ENOTCONN - cancel mode, operation not running anymore */ static int exclop_start_or_cancel_reloc(struct btrfs_fs_info *fs_info, enum btrfs_exclusive_operation type, bool cancel) { … } static noinline int btrfs_ioctl_resize(struct file *file, void __user *arg) { … } static noinline int __btrfs_ioctl_snap_create(struct file *file, struct mnt_idmap *idmap, const char *name, unsigned long fd, int subvol, bool readonly, struct btrfs_qgroup_inherit *inherit) { … } static noinline int btrfs_ioctl_snap_create(struct file *file, void __user *arg, int subvol) { … } static noinline int btrfs_ioctl_snap_create_v2(struct file *file, void __user *arg, int subvol) { … } static noinline int btrfs_ioctl_subvol_getflags(struct inode *inode, void __user *arg) { … } static noinline int btrfs_ioctl_subvol_setflags(struct file *file, void __user *arg) { … } static noinline int key_in_sk(struct btrfs_key *key, struct btrfs_ioctl_search_key *sk) { … } static noinline int copy_to_sk(struct btrfs_path *path, struct btrfs_key *key, struct btrfs_ioctl_search_key *sk, u64 *buf_size, char __user *ubuf, unsigned long *sk_offset, int *num_found) { … } static noinline int search_ioctl(struct inode *inode, struct btrfs_ioctl_search_key *sk, u64 *buf_size, char __user *ubuf) { … } static noinline int btrfs_ioctl_tree_search(struct inode *inode, void __user *argp) { … } static noinline int btrfs_ioctl_tree_search_v2(struct inode *inode, void __user *argp) { … } /* * Search INODE_REFs to identify path name of 'dirid' directory * in a 'tree_id' tree. and sets path name to 'name'. */ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info, u64 tree_id, u64 dirid, char *name) { … } static int btrfs_search_path_in_tree_user(struct mnt_idmap *idmap, struct inode *inode, struct btrfs_ioctl_ino_lookup_user_args *args) { … } static noinline int btrfs_ioctl_ino_lookup(struct btrfs_root *root, void __user *argp) { … } /* * Version of ino_lookup ioctl (unprivileged) * * The main differences from ino_lookup ioctl are: * * 1. Read + Exec permission will be checked using inode_permission() during * path construction. -EACCES will be returned in case of failure. * 2. Path construction will be stopped at the inode number which corresponds * to the fd with which this ioctl is called. If constructed path does not * exist under fd's inode, -EACCES will be returned. * 3. The name of bottom subvolume is also searched and filled. */ static int btrfs_ioctl_ino_lookup_user(struct file *file, void __user *argp) { … } /* Get the subvolume information in BTRFS_ROOT_ITEM and BTRFS_ROOT_BACKREF */ static int btrfs_ioctl_get_subvol_info(struct inode *inode, void __user *argp) { … } /* * Return ROOT_REF information of the subvolume containing this inode * except the subvolume name. */ static int btrfs_ioctl_get_subvol_rootref(struct btrfs_root *root, void __user *argp) { … } static noinline int btrfs_ioctl_snap_destroy(struct file *file, void __user *arg, bool destroy_v2) { … } static int btrfs_ioctl_defrag(struct file *file, void __user *argp) { … } static long btrfs_ioctl_add_dev(struct btrfs_fs_info *fs_info, void __user *arg) { … } static long btrfs_ioctl_rm_dev_v2(struct file *file, void __user *arg) { … } static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg) { … } static long btrfs_ioctl_fs_info(struct btrfs_fs_info *fs_info, void __user *arg) { … } static long btrfs_ioctl_dev_info(struct btrfs_fs_info *fs_info, void __user *arg) { … } static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp) { … } static void get_block_group_info(struct list_head *groups_list, struct btrfs_ioctl_space_info *space) { … } static long btrfs_ioctl_space_info(struct btrfs_fs_info *fs_info, void __user *arg) { … } static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root, void __user *argp) { … } static noinline long btrfs_ioctl_wait_sync(struct btrfs_fs_info *fs_info, void __user *argp) { … } static long btrfs_ioctl_scrub(struct file *file, void __user *arg) { … } static long btrfs_ioctl_scrub_cancel(struct btrfs_fs_info *fs_info) { … } static long btrfs_ioctl_scrub_progress(struct btrfs_fs_info *fs_info, void __user *arg) { … } static long btrfs_ioctl_get_dev_stats(struct btrfs_fs_info *fs_info, void __user *arg) { … } static long btrfs_ioctl_dev_replace(struct btrfs_fs_info *fs_info, void __user *arg) { … } static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg) { … } static long btrfs_ioctl_logical_to_ino(struct btrfs_fs_info *fs_info, void __user *arg, int version) { … } void btrfs_update_ioctl_balance_args(struct btrfs_fs_info *fs_info, struct btrfs_ioctl_balance_args *bargs) { … } /* * Try to acquire fs_info::balance_mutex as well as set BTRFS_EXLCOP_BALANCE as * required. * * @fs_info: the filesystem * @excl_acquired: ptr to boolean value which is set to false in case balance * is being resumed * * Return 0 on success in which case both fs_info::balance is acquired as well * as exclusive ops are blocked. In case of failure return an error code. */ static int btrfs_try_lock_balance(struct btrfs_fs_info *fs_info, bool *excl_acquired) { … } static long btrfs_ioctl_balance(struct file *file, void __user *arg) { … } static long btrfs_ioctl_balance_ctl(struct btrfs_fs_info *fs_info, int cmd) { … } static long btrfs_ioctl_balance_progress(struct btrfs_fs_info *fs_info, void __user *arg) { … } static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg) { … } /* * Quick check for ioctl handlers if quotas are enabled. Proper locking must be * done before any operations. */ static bool qgroup_enabled(struct btrfs_fs_info *fs_info) { … } static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg) { … } static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg) { … } static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg) { … } static long btrfs_ioctl_quota_rescan(struct file *file, void __user *arg) { … } static long btrfs_ioctl_quota_rescan_status(struct btrfs_fs_info *fs_info, void __user *arg) { … } static long btrfs_ioctl_quota_rescan_wait(struct btrfs_fs_info *fs_info, void __user *arg) { … } static long _btrfs_ioctl_set_received_subvol(struct file *file, struct mnt_idmap *idmap, struct btrfs_ioctl_received_subvol_args *sa) { … } #ifdef CONFIG_64BIT static long btrfs_ioctl_set_received_subvol_32(struct file *file, void __user *arg) { … } #endif static long btrfs_ioctl_set_received_subvol(struct file *file, void __user *arg) { … } static int btrfs_ioctl_get_fslabel(struct btrfs_fs_info *fs_info, void __user *arg) { … } static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg) { … } #define INIT_FEATURE_FLAGS(suffix) … int btrfs_ioctl_get_supported_features(void __user *arg) { … } static int btrfs_ioctl_get_features(struct btrfs_fs_info *fs_info, void __user *arg) { … } static int check_feature_bits(struct btrfs_fs_info *fs_info, enum btrfs_feature_set set, u64 change_mask, u64 flags, u64 supported_flags, u64 safe_set, u64 safe_clear) { … } #define check_feature(fs_info, change_mask, flags, mask_base) … static int btrfs_ioctl_set_features(struct file *file, void __user *arg) { … } static int _btrfs_ioctl_send(struct btrfs_inode *inode, void __user *argp, bool compat) { … } static int btrfs_ioctl_encoded_read(struct file *file, void __user *argp, bool compat) { … } static int btrfs_ioctl_encoded_write(struct file *file, void __user *argp, bool compat) { … } long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { … } #ifdef CONFIG_COMPAT long btrfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { … } #endif
Codebase Browser
linux