UBIFS: use anonymous device
[linux-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/smp_lock.h>
29 #include <linux/mount.h>
30 #include "ubifs.h"
31
32 /**
33  * ubifs_set_inode_flags - set VFS inode flags.
34  * @inode: VFS inode to set flags for
35  *
36  * This function propagates flags from UBIFS inode object to VFS inode object.
37  */
38 void ubifs_set_inode_flags(struct inode *inode)
39 {
40         unsigned int flags = ubifs_inode(inode)->flags;
41
42         inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_DIRSYNC);
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 }
52
53 /*
54  * ioctl2ubifs - convert ioctl inode flags to UBIFS inode flags.
55  * @ioctl_flags: flags to convert
56  *
57  * This function convert ioctl flags (@FS_COMPR_FL, etc) to UBIFS inode flags
58  * (@UBIFS_COMPR_FL, etc).
59  */
60 static 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 convert UBIFS (@UBIFS_COMPR_FL, etc) to ioctl flags
83  * (@FS_COMPR_FL, etc).
84  */
85 static 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
100         return ioctl_flags;
101 }
102
103 static int setflags(struct inode *inode, int flags)
104 {
105         int oldflags, err, release;
106         struct ubifs_inode *ui = ubifs_inode(inode);
107         struct ubifs_info *c = inode->i_sb->s_fs_info;
108         struct ubifs_budget_req req = { .dirtied_ino = 1,
109                                         .dirtied_ino_d = ui->data_len };
110
111         err = ubifs_budget_space(c, &req);
112         if (err)
113                 return err;
114
115         /*
116          * The IMMUTABLE and APPEND_ONLY flags can only be changed by
117          * the relevant capability.
118          */
119         mutex_lock(&ui->ui_mutex);
120         oldflags = ubifs2ioctl(ui->flags);
121         if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
122                 if (!capable(CAP_LINUX_IMMUTABLE)) {
123                         err = -EPERM;
124                         goto out_unlock;
125                 }
126         }
127
128         ui->flags = ioctl2ubifs(flags);
129         ubifs_set_inode_flags(inode);
130         inode->i_ctime = ubifs_current_time(inode);
131         release = ui->dirty;
132         mark_inode_dirty_sync(inode);
133         mutex_unlock(&ui->ui_mutex);
134
135         if (release)
136                 ubifs_release_budget(c, &req);
137         if (IS_SYNC(inode))
138                 err = write_inode_now(inode, 1);
139         return err;
140
141 out_unlock:
142         ubifs_err("can't modify inode %lu attributes", inode->i_ino);
143         mutex_unlock(&ui->ui_mutex);
144         ubifs_release_budget(c, &req);
145         return err;
146 }
147
148 long ubifs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
149 {
150         int flags, err;
151         struct inode *inode = file->f_path.dentry->d_inode;
152
153         switch (cmd) {
154         case FS_IOC_GETFLAGS:
155                 flags = ubifs2ioctl(ubifs_inode(inode)->flags);
156
157                 dbg_gen("get flags: %#x, i_flags %#x", flags, inode->i_flags);
158                 return put_user(flags, (int __user *) arg);
159
160         case FS_IOC_SETFLAGS: {
161                 if (IS_RDONLY(inode))
162                         return -EROFS;
163
164                 if (!is_owner_or_cap(inode))
165                         return -EACCES;
166
167                 if (get_user(flags, (int __user *) arg))
168                         return -EFAULT;
169
170                 if (!S_ISDIR(inode->i_mode))
171                         flags &= ~FS_DIRSYNC_FL;
172
173                 /*
174                  * Make sure the file-system is read-write and make sure it
175                  * will not become read-only while we are changing the flags.
176                  */
177                 err = mnt_want_write(file->f_path.mnt);
178                 if (err)
179                         return err;
180                 dbg_gen("set flags: %#x, i_flags %#x", flags, inode->i_flags);
181                 err = setflags(inode, flags);
182                 mnt_drop_write(file->f_path.mnt);
183                 return err;
184         }
185
186         default:
187                 return -ENOTTY;
188         }
189 }
190
191 #ifdef CONFIG_COMPAT
192 long ubifs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
193 {
194         switch (cmd) {
195         case FS_IOC32_GETFLAGS:
196                 cmd = FS_IOC_GETFLAGS;
197                 break;
198         case FS_IOC32_SETFLAGS:
199                 cmd = FS_IOC_SETFLAGS;
200                 break;
201         default:
202                 return -ENOIOCTLCMD;
203         }
204         return ubifs_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
205 }
206 #endif