ubifs: Use fscrypt ioctl() helpers
[sfrench/cifs-2.6.git] / fs / ubifs / ioctl.c
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  */
37 void 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  */
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 convert UBIFS (@UBIFS_COMPR_FL, etc) to ioctl flags
82  * (@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
99         return ioctl_flags;
100 }
101
102 static 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
140 out_unlock:
141         ubifs_err(c, "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
147 long 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         case FS_IOC_SET_ENCRYPTION_POLICY: {
185 #ifdef CONFIG_UBIFS_FS_ENCRYPTION
186                 struct ubifs_info *c = inode->i_sb->s_fs_info;
187
188                 err = ubifs_enable_encryption(c);
189                 if (err)
190                         return err;
191
192                 return fscrypt_ioctl_set_policy(file, (const void __user *)arg);
193 #else
194                 return -EOPNOTSUPP;
195 #endif
196         }
197         case FS_IOC_GET_ENCRYPTION_POLICY: {
198 #ifdef CONFIG_UBIFS_FS_ENCRYPTION
199                 return fscrypt_ioctl_get_policy(file, (void __user *)arg);
200 #else
201                 return -EOPNOTSUPP;
202 #endif
203         }
204
205         default:
206                 return -ENOTTY;
207         }
208 }
209
210 #ifdef CONFIG_COMPAT
211 long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
212 {
213         switch (cmd) {
214         case FS_IOC32_GETFLAGS:
215                 cmd = FS_IOC_GETFLAGS;
216                 break;
217         case FS_IOC32_SETFLAGS:
218                 cmd = FS_IOC_SETFLAGS;
219                 break;
220         default:
221                 return -ENOIOCTLCMD;
222         }
223         return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
224 }
225 #endif