Loading...
1/*
2 * This file is part of UBIFS.
3 *
4 * Copyright (C) 2006-2008 Nokia Corporation.
5 * Copyright (C) 2006, 2007 University of Szeged, Hungary
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as published by
9 * the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc., 51
18 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 * Authors: Zoltan Sogor
21 * Artem Bityutskiy (Битюцкий Артём)
22 * Adrian Hunter
23 */
24
25/* This file implements EXT2-compatible extended attribute ioctl() calls */
26
27#include <linux/compat.h>
28#include <linux/mount.h>
29#include "ubifs.h"
30
31/**
32 * ubifs_set_inode_flags - set VFS inode flags.
33 * @inode: VFS inode to set flags for
34 *
35 * This function propagates flags from UBIFS inode object to VFS inode object.
36 */
37void ubifs_set_inode_flags(struct inode *inode)
38{
39 unsigned int flags = ubifs_inode(inode)->flags;
40
41 inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_DIRSYNC);
42 if (flags & UBIFS_SYNC_FL)
43 inode->i_flags |= S_SYNC;
44 if (flags & UBIFS_APPEND_FL)
45 inode->i_flags |= S_APPEND;
46 if (flags & UBIFS_IMMUTABLE_FL)
47 inode->i_flags |= S_IMMUTABLE;
48 if (flags & UBIFS_DIRSYNC_FL)
49 inode->i_flags |= S_DIRSYNC;
50}
51
52/*
53 * ioctl2ubifs - convert ioctl inode flags to UBIFS inode flags.
54 * @ioctl_flags: flags to convert
55 *
56 * This function convert ioctl flags (@FS_COMPR_FL, etc) to UBIFS inode flags
57 * (@UBIFS_COMPR_FL, etc).
58 */
59static 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 convert UBIFS (@UBIFS_COMPR_FL, etc) to ioctl flags
82 * (@FS_COMPR_FL, etc).
83 */
84static 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
99 return ioctl_flags;
100}
101
102static int setflags(struct inode *inode, int flags)
103{
104 int oldflags, err, release;
105 struct ubifs_inode *ui = ubifs_inode(inode);
106 struct ubifs_info *c = inode->i_sb->s_fs_info;
107 struct ubifs_budget_req req = { .dirtied_ino = 1,
108 .dirtied_ino_d = ui->data_len };
109
110 err = ubifs_budget_space(c, &req);
111 if (err)
112 return err;
113
114 /*
115 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
116 * the relevant capability.
117 */
118 mutex_lock(&ui->ui_mutex);
119 oldflags = ubifs2ioctl(ui->flags);
120 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
121 if (!capable(CAP_LINUX_IMMUTABLE)) {
122 err = -EPERM;
123 goto out_unlock;
124 }
125 }
126
127 ui->flags = ioctl2ubifs(flags);
128 ubifs_set_inode_flags(inode);
129 inode->i_ctime = ubifs_current_time(inode);
130 release = ui->dirty;
131 mark_inode_dirty_sync(inode);
132 mutex_unlock(&ui->ui_mutex);
133
134 if (release)
135 ubifs_release_budget(c, &req);
136 if (IS_SYNC(inode))
137 err = write_inode_now(inode, 1);
138 return err;
139
140out_unlock:
141 ubifs_err("can't modify inode %lu attributes", inode->i_ino);
142 mutex_unlock(&ui->ui_mutex);
143 ubifs_release_budget(c, &req);
144 return err;
145}
146
147long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
148{
149 int flags, err;
150 struct inode *inode = file_inode(file);
151
152 switch (cmd) {
153 case FS_IOC_GETFLAGS:
154 flags = ubifs2ioctl(ubifs_inode(inode)->flags);
155
156 dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags);
157 return put_user(flags, (int __user *) arg);
158
159 case FS_IOC_SETFLAGS: {
160 if (IS_RDONLY(inode))
161 return -EROFS;
162
163 if (!inode_owner_or_capable(inode))
164 return -EACCES;
165
166 if (get_user(flags, (int __user *) arg))
167 return -EFAULT;
168
169 if (!S_ISDIR(inode->i_mode))
170 flags &= ~FS_DIRSYNC_FL;
171
172 /*
173 * Make sure the file-system is read-write and make sure it
174 * will not become read-only while we are changing the flags.
175 */
176 err = mnt_want_write_file(file);
177 if (err)
178 return err;
179 dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
180 err = setflags(inode, flags);
181 mnt_drop_write_file(file);
182 return err;
183 }
184
185 default:
186 return -ENOTTY;
187 }
188}
189
190#ifdef CONFIG_COMPAT
191long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
192{
193 switch (cmd) {
194 case FS_IOC32_GETFLAGS:
195 cmd = FS_IOC_GETFLAGS;
196 break;
197 case FS_IOC32_SETFLAGS:
198 cmd = FS_IOC_SETFLAGS;
199 break;
200 default:
201 return -ENOIOCTLCMD;
202 }
203 return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
204}
205#endif
1/*
2 * This file is part of UBIFS.
3 *
4 * Copyright (C) 2006-2008 Nokia Corporation.
5 * Copyright (C) 2006, 2007 University of Szeged, Hungary
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as published by
9 * the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc., 51
18 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 * Authors: Zoltan Sogor
21 * Artem Bityutskiy (Битюцкий Артём)
22 * Adrian Hunter
23 */
24
25/* This file implements EXT2-compatible extended attribute ioctl() calls */
26
27#include <linux/compat.h>
28#include <linux/mount.h>
29#include "ubifs.h"
30
31/**
32 * ubifs_set_inode_flags - set VFS inode flags.
33 * @inode: VFS inode to set flags for
34 *
35 * This function propagates flags from UBIFS inode object to VFS inode object.
36 */
37void ubifs_set_inode_flags(struct inode *inode)
38{
39 unsigned int flags = ubifs_inode(inode)->flags;
40
41 inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_DIRSYNC |
42 S_ENCRYPTED);
43 if (flags & UBIFS_SYNC_FL)
44 inode->i_flags |= S_SYNC;
45 if (flags & UBIFS_APPEND_FL)
46 inode->i_flags |= S_APPEND;
47 if (flags & UBIFS_IMMUTABLE_FL)
48 inode->i_flags |= S_IMMUTABLE;
49 if (flags & UBIFS_DIRSYNC_FL)
50 inode->i_flags |= S_DIRSYNC;
51 if (flags & UBIFS_CRYPT_FL)
52 inode->i_flags |= S_ENCRYPTED;
53}
54
55/*
56 * ioctl2ubifs - convert ioctl inode flags to UBIFS inode flags.
57 * @ioctl_flags: flags to convert
58 *
59 * This function converts ioctl flags (@FS_COMPR_FL, etc) to UBIFS inode flags
60 * (@UBIFS_COMPR_FL, etc).
61 */
62static int ioctl2ubifs(int ioctl_flags)
63{
64 int ubifs_flags = 0;
65
66 if (ioctl_flags & FS_COMPR_FL)
67 ubifs_flags |= UBIFS_COMPR_FL;
68 if (ioctl_flags & FS_SYNC_FL)
69 ubifs_flags |= UBIFS_SYNC_FL;
70 if (ioctl_flags & FS_APPEND_FL)
71 ubifs_flags |= UBIFS_APPEND_FL;
72 if (ioctl_flags & FS_IMMUTABLE_FL)
73 ubifs_flags |= UBIFS_IMMUTABLE_FL;
74 if (ioctl_flags & FS_DIRSYNC_FL)
75 ubifs_flags |= UBIFS_DIRSYNC_FL;
76
77 return ubifs_flags;
78}
79
80/*
81 * ubifs2ioctl - convert UBIFS inode flags to ioctl inode flags.
82 * @ubifs_flags: flags to convert
83 *
84 * This function converts UBIFS inode flags (@UBIFS_COMPR_FL, etc) to ioctl
85 * flags (@FS_COMPR_FL, etc).
86 */
87static int ubifs2ioctl(int ubifs_flags)
88{
89 int ioctl_flags = 0;
90
91 if (ubifs_flags & UBIFS_COMPR_FL)
92 ioctl_flags |= FS_COMPR_FL;
93 if (ubifs_flags & UBIFS_SYNC_FL)
94 ioctl_flags |= FS_SYNC_FL;
95 if (ubifs_flags & UBIFS_APPEND_FL)
96 ioctl_flags |= FS_APPEND_FL;
97 if (ubifs_flags & UBIFS_IMMUTABLE_FL)
98 ioctl_flags |= FS_IMMUTABLE_FL;
99 if (ubifs_flags & UBIFS_DIRSYNC_FL)
100 ioctl_flags |= FS_DIRSYNC_FL;
101
102 return ioctl_flags;
103}
104
105static int setflags(struct inode *inode, int flags)
106{
107 int oldflags, 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 = ui->data_len };
112
113 err = ubifs_budget_space(c, &req);
114 if (err)
115 return err;
116
117 /*
118 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
119 * the relevant capability.
120 */
121 mutex_lock(&ui->ui_mutex);
122 oldflags = ubifs2ioctl(ui->flags);
123 if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
124 if (!capable(CAP_LINUX_IMMUTABLE)) {
125 err = -EPERM;
126 goto out_unlock;
127 }
128 }
129
130 ui->flags = ioctl2ubifs(flags);
131 ubifs_set_inode_flags(inode);
132 inode->i_ctime = current_time(inode);
133 release = ui->dirty;
134 mark_inode_dirty_sync(inode);
135 mutex_unlock(&ui->ui_mutex);
136
137 if (release)
138 ubifs_release_budget(c, &req);
139 if (IS_SYNC(inode))
140 err = write_inode_now(inode, 1);
141 return err;
142
143out_unlock:
144 ubifs_err(c, "can't modify inode %lu attributes", inode->i_ino);
145 mutex_unlock(&ui->ui_mutex);
146 ubifs_release_budget(c, &req);
147 return err;
148}
149
150long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
151{
152 int flags, err;
153 struct inode *inode = file_inode(file);
154
155 switch (cmd) {
156 case FS_IOC_GETFLAGS:
157 flags = ubifs2ioctl(ubifs_inode(inode)->flags);
158
159 dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags);
160 return put_user(flags, (int __user *) arg);
161
162 case FS_IOC_SETFLAGS: {
163 if (IS_RDONLY(inode))
164 return -EROFS;
165
166 if (!inode_owner_or_capable(inode))
167 return -EACCES;
168
169 if (get_user(flags, (int __user *) arg))
170 return -EFAULT;
171
172 if (!S_ISDIR(inode->i_mode))
173 flags &= ~FS_DIRSYNC_FL;
174
175 /*
176 * Make sure the file-system is read-write and make sure it
177 * will not become read-only while we are changing the flags.
178 */
179 err = mnt_want_write_file(file);
180 if (err)
181 return err;
182 dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
183 err = setflags(inode, flags);
184 mnt_drop_write_file(file);
185 return err;
186 }
187 case FS_IOC_SET_ENCRYPTION_POLICY: {
188#ifdef CONFIG_UBIFS_FS_ENCRYPTION
189 struct ubifs_info *c = inode->i_sb->s_fs_info;
190
191 err = ubifs_enable_encryption(c);
192 if (err)
193 return err;
194
195 return fscrypt_ioctl_set_policy(file, (const void __user *)arg);
196#else
197 return -EOPNOTSUPP;
198#endif
199 }
200 case FS_IOC_GET_ENCRYPTION_POLICY: {
201#ifdef CONFIG_UBIFS_FS_ENCRYPTION
202 return fscrypt_ioctl_get_policy(file, (void __user *)arg);
203#else
204 return -EOPNOTSUPP;
205#endif
206 }
207
208 default:
209 return -ENOTTY;
210 }
211}
212
213#ifdef CONFIG_COMPAT
214long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
215{
216 switch (cmd) {
217 case FS_IOC32_GETFLAGS:
218 cmd = FS_IOC_GETFLAGS;
219 break;
220 case FS_IOC32_SETFLAGS:
221 cmd = FS_IOC_SETFLAGS;
222 break;
223 case FS_IOC_SET_ENCRYPTION_POLICY:
224 case FS_IOC_GET_ENCRYPTION_POLICY:
225 break;
226 default:
227 return -ENOIOCTLCMD;
228 }
229 return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
230}
231#endif