1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * This file is part of UBIFS. 4 * 5 * Copyright (C) 2006-2008 Nokia Corporation. 6 * Copyright (C) 2006, 2007 University of Szeged, Hungary 7 * 8 * Authors: Zoltan Sogor 9 * Artem Bityutskiy (Битюцкий Артём) 10 * Adrian Hunter 11 */ 12 13 /* This file implements EXT2-compatible extended attribute ioctl() calls */ 14 15 #include <linux/compat.h> 16 #include <linux/mount.h> 17 #include "ubifs.h" 18 19 /* Need to be kept consistent with checked flags in ioctl2ubifs() */ 20 #define UBIFS_SETTABLE_IOCTL_FLAGS \ 21 (FS_COMPR_FL | FS_SYNC_FL | FS_APPEND_FL | \ 22 FS_IMMUTABLE_FL | FS_DIRSYNC_FL) 23 24 /* Need to be kept consistent with checked flags in ubifs2ioctl() */ 25 #define UBIFS_GETTABLE_IOCTL_FLAGS \ 26 (UBIFS_SETTABLE_IOCTL_FLAGS | FS_ENCRYPT_FL) 27 28 /** 29 * ubifs_set_inode_flags - set VFS inode flags. 30 * @inode: VFS inode to set flags for 31 * 32 * This function propagates flags from UBIFS inode object to VFS inode object. 33 */ 34 void ubifs_set_inode_flags(struct inode *inode) 35 { 36 unsigned int flags = ubifs_inode(inode)->flags; 37 38 inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_DIRSYNC | 39 S_ENCRYPTED); 40 if (flags & UBIFS_SYNC_FL) 41 inode->i_flags |= S_SYNC; 42 if (flags & UBIFS_APPEND_FL) 43 inode->i_flags |= S_APPEND; 44 if (flags & UBIFS_IMMUTABLE_FL) 45 inode->i_flags |= S_IMMUTABLE; 46 if (flags & UBIFS_DIRSYNC_FL) 47 inode->i_flags |= S_DIRSYNC; 48 if (flags & UBIFS_CRYPT_FL) 49 inode->i_flags |= S_ENCRYPTED; 50 } 51 52 /* 53 * ioctl2ubifs - convert ioctl inode flags to UBIFS inode flags. 54 * @ioctl_flags: flags to convert 55 * 56 * This function converts ioctl flags (@FS_COMPR_FL, etc) to UBIFS inode flags 57 * (@UBIFS_COMPR_FL, etc). 58 */ 59 static int ioctl2ubifs(int ioctl_flags) 60 { 61 int ubifs_flags = 0; 62 63 if (ioctl_flags & FS_COMPR_FL) 64 ubifs_flags |= UBIFS_COMPR_FL; 65 if (ioctl_flags & FS_SYNC_FL) 66 ubifs_flags |= UBIFS_SYNC_FL; 67 if (ioctl_flags & FS_APPEND_FL) 68 ubifs_flags |= UBIFS_APPEND_FL; 69 if (ioctl_flags & FS_IMMUTABLE_FL) 70 ubifs_flags |= UBIFS_IMMUTABLE_FL; 71 if (ioctl_flags & FS_DIRSYNC_FL) 72 ubifs_flags |= UBIFS_DIRSYNC_FL; 73 74 return ubifs_flags; 75 } 76 77 /* 78 * ubifs2ioctl - convert UBIFS inode flags to ioctl inode flags. 79 * @ubifs_flags: flags to convert 80 * 81 * This function converts UBIFS inode flags (@UBIFS_COMPR_FL, etc) to ioctl 82 * flags (@FS_COMPR_FL, etc). 83 */ 84 static int ubifs2ioctl(int ubifs_flags) 85 { 86 int ioctl_flags = 0; 87 88 if (ubifs_flags & UBIFS_COMPR_FL) 89 ioctl_flags |= FS_COMPR_FL; 90 if (ubifs_flags & UBIFS_SYNC_FL) 91 ioctl_flags |= FS_SYNC_FL; 92 if (ubifs_flags & UBIFS_APPEND_FL) 93 ioctl_flags |= FS_APPEND_FL; 94 if (ubifs_flags & UBIFS_IMMUTABLE_FL) 95 ioctl_flags |= FS_IMMUTABLE_FL; 96 if (ubifs_flags & UBIFS_DIRSYNC_FL) 97 ioctl_flags |= FS_DIRSYNC_FL; 98 if (ubifs_flags & UBIFS_CRYPT_FL) 99 ioctl_flags |= FS_ENCRYPT_FL; 100 101 return ioctl_flags; 102 } 103 104 static int setflags(struct inode *inode, int flags) 105 { 106 int oldflags, err, release; 107 struct ubifs_inode *ui = ubifs_inode(inode); 108 struct ubifs_info *c = inode->i_sb->s_fs_info; 109 struct ubifs_budget_req req = { .dirtied_ino = 1, 110 .dirtied_ino_d = ui->data_len }; 111 112 err = ubifs_budget_space(c, &req); 113 if (err) 114 return err; 115 116 mutex_lock(&ui->ui_mutex); 117 oldflags = ubifs2ioctl(ui->flags); 118 err = vfs_ioc_setflags_prepare(inode, oldflags, flags); 119 if (err) 120 goto out_unlock; 121 122 ui->flags &= ~ioctl2ubifs(UBIFS_SETTABLE_IOCTL_FLAGS); 123 ui->flags |= ioctl2ubifs(flags); 124 ubifs_set_inode_flags(inode); 125 inode->i_ctime = current_time(inode); 126 release = ui->dirty; 127 mark_inode_dirty_sync(inode); 128 mutex_unlock(&ui->ui_mutex); 129 130 if (release) 131 ubifs_release_budget(c, &req); 132 if (IS_SYNC(inode)) 133 err = write_inode_now(inode, 1); 134 return err; 135 136 out_unlock: 137 mutex_unlock(&ui->ui_mutex); 138 ubifs_release_budget(c, &req); 139 return err; 140 } 141 142 long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 143 { 144 int flags, err; 145 struct inode *inode = file_inode(file); 146 147 switch (cmd) { 148 case FS_IOC_GETFLAGS: 149 flags = ubifs2ioctl(ubifs_inode(inode)->flags); 150 151 dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags); 152 return put_user(flags, (int __user *) arg); 153 154 case FS_IOC_SETFLAGS: { 155 if (IS_RDONLY(inode)) 156 return -EROFS; 157 158 if (!inode_owner_or_capable(&init_user_ns, inode)) 159 return -EACCES; 160 161 if (get_user(flags, (int __user *) arg)) 162 return -EFAULT; 163 164 if (flags & ~UBIFS_GETTABLE_IOCTL_FLAGS) 165 return -EOPNOTSUPP; 166 flags &= UBIFS_SETTABLE_IOCTL_FLAGS; 167 168 if (!S_ISDIR(inode->i_mode)) 169 flags &= ~FS_DIRSYNC_FL; 170 171 /* 172 * Make sure the file-system is read-write and make sure it 173 * will not become read-only while we are changing the flags. 174 */ 175 err = mnt_want_write_file(file); 176 if (err) 177 return err; 178 dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags); 179 err = setflags(inode, flags); 180 mnt_drop_write_file(file); 181 return err; 182 } 183 case FS_IOC_SET_ENCRYPTION_POLICY: { 184 struct ubifs_info *c = inode->i_sb->s_fs_info; 185 186 err = ubifs_enable_encryption(c); 187 if (err) 188 return err; 189 190 return fscrypt_ioctl_set_policy(file, (const void __user *)arg); 191 } 192 case FS_IOC_GET_ENCRYPTION_POLICY: 193 return fscrypt_ioctl_get_policy(file, (void __user *)arg); 194 195 case FS_IOC_GET_ENCRYPTION_POLICY_EX: 196 return fscrypt_ioctl_get_policy_ex(file, (void __user *)arg); 197 198 case FS_IOC_ADD_ENCRYPTION_KEY: 199 return fscrypt_ioctl_add_key(file, (void __user *)arg); 200 201 case FS_IOC_REMOVE_ENCRYPTION_KEY: 202 return fscrypt_ioctl_remove_key(file, (void __user *)arg); 203 204 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS: 205 return fscrypt_ioctl_remove_key_all_users(file, 206 (void __user *)arg); 207 case FS_IOC_GET_ENCRYPTION_KEY_STATUS: 208 return fscrypt_ioctl_get_key_status(file, (void __user *)arg); 209 210 case FS_IOC_GET_ENCRYPTION_NONCE: 211 return fscrypt_ioctl_get_nonce(file, (void __user *)arg); 212 213 default: 214 return -ENOTTY; 215 } 216 } 217 218 #ifdef CONFIG_COMPAT 219 long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 220 { 221 switch (cmd) { 222 case FS_IOC32_GETFLAGS: 223 cmd = FS_IOC_GETFLAGS; 224 break; 225 case FS_IOC32_SETFLAGS: 226 cmd = FS_IOC_SETFLAGS; 227 break; 228 case FS_IOC_SET_ENCRYPTION_POLICY: 229 case FS_IOC_GET_ENCRYPTION_POLICY: 230 case FS_IOC_GET_ENCRYPTION_POLICY_EX: 231 case FS_IOC_ADD_ENCRYPTION_KEY: 232 case FS_IOC_REMOVE_ENCRYPTION_KEY: 233 case FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS: 234 case FS_IOC_GET_ENCRYPTION_KEY_STATUS: 235 case FS_IOC_GET_ENCRYPTION_NONCE: 236 break; 237 default: 238 return -ENOIOCTLCMD; 239 } 240 return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); 241 } 242 #endif 243