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 */
ubifs_set_inode_flags(struct inode * inode)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 */
ioctl2ubifs(int ioctl_flags)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 */
ubifs2ioctl(int ubifs_flags)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
setflags(struct inode * inode,int flags)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 = ALIGN(ui->data_len, 8) };
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
ubifs_ioctl(struct file * file,unsigned int cmd,unsigned long arg)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(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
ubifs_compat_ioctl(struct file * file,unsigned int cmd,unsigned long arg)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