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