arm: tegra: enterprise: Add drivers for flashless XMM modem
[linux-2.6.git] / fs / reiserfs / ioctl.c
1 /*
2  * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3  */
4
5 #include <linux/capability.h>
6 #include <linux/fs.h>
7 #include <linux/mount.h>
8 #include <linux/reiserfs_fs.h>
9 #include <linux/time.h>
10 #include <asm/uaccess.h>
11 #include <linux/pagemap.h>
12 #include <linux/compat.h>
13
14 /*
15  * reiserfs_ioctl - handler for ioctl for inode
16  * supported commands:
17  *  1) REISERFS_IOC_UNPACK - try to unpack tail from direct item into indirect
18  *                           and prevent packing file (argument arg has to be non-zero)
19  *  2) REISERFS_IOC_[GS]ETFLAGS, REISERFS_IOC_[GS]ETVERSION
20  *  3) That's all for a while ...
21  */
22 long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
23 {
24         struct inode *inode = filp->f_path.dentry->d_inode;
25         unsigned int flags;
26         int err = 0;
27
28         reiserfs_write_lock(inode->i_sb);
29
30         switch (cmd) {
31         case REISERFS_IOC_UNPACK:
32                 if (S_ISREG(inode->i_mode)) {
33                         if (arg)
34                                 err = reiserfs_unpack(inode, filp);
35                 } else
36                         err = -ENOTTY;
37                 break;
38                 /*
39                  * following two cases are taken from fs/ext2/ioctl.c by Remy
40                  * Card (card@masi.ibp.fr)
41                  */
42         case REISERFS_IOC_GETFLAGS:
43                 if (!reiserfs_attrs(inode->i_sb)) {
44                         err = -ENOTTY;
45                         break;
46                 }
47
48                 flags = REISERFS_I(inode)->i_attrs;
49                 i_attrs_to_sd_attrs(inode, (__u16 *) & flags);
50                 err = put_user(flags, (int __user *)arg);
51                 break;
52         case REISERFS_IOC_SETFLAGS:{
53                         if (!reiserfs_attrs(inode->i_sb)) {
54                                 err = -ENOTTY;
55                                 break;
56                         }
57
58                         err = mnt_want_write_file(filp);
59                         if (err)
60                                 break;
61
62                         if (!inode_owner_or_capable(inode)) {
63                                 err = -EPERM;
64                                 goto setflags_out;
65                         }
66                         if (get_user(flags, (int __user *)arg)) {
67                                 err = -EFAULT;
68                                 goto setflags_out;
69                         }
70                         /*
71                          * Is it quota file? Do not allow user to mess with it
72                          */
73                         if (IS_NOQUOTA(inode)) {
74                                 err = -EPERM;
75                                 goto setflags_out;
76                         }
77                         if (((flags ^ REISERFS_I(inode)->
78                               i_attrs) & (REISERFS_IMMUTABLE_FL |
79                                           REISERFS_APPEND_FL))
80                             && !capable(CAP_LINUX_IMMUTABLE)) {
81                                 err = -EPERM;
82                                 goto setflags_out;
83                         }
84                         if ((flags & REISERFS_NOTAIL_FL) &&
85                             S_ISREG(inode->i_mode)) {
86                                 int result;
87
88                                 result = reiserfs_unpack(inode, filp);
89                                 if (result) {
90                                         err = result;
91                                         goto setflags_out;
92                                 }
93                         }
94                         sd_attrs_to_i_attrs(flags, inode);
95                         REISERFS_I(inode)->i_attrs = flags;
96                         inode->i_ctime = CURRENT_TIME_SEC;
97                         mark_inode_dirty(inode);
98 setflags_out:
99                         mnt_drop_write_file(filp);
100                         break;
101                 }
102         case REISERFS_IOC_GETVERSION:
103                 err = put_user(inode->i_generation, (int __user *)arg);
104                 break;
105         case REISERFS_IOC_SETVERSION:
106                 if (!inode_owner_or_capable(inode)) {
107                         err = -EPERM;
108                         break;
109                 }
110                 err = mnt_want_write_file(filp);
111                 if (err)
112                         break;
113                 if (get_user(inode->i_generation, (int __user *)arg)) {
114                         err = -EFAULT;
115                         goto setversion_out;
116                 }
117                 inode->i_ctime = CURRENT_TIME_SEC;
118                 mark_inode_dirty(inode);
119 setversion_out:
120                 mnt_drop_write_file(filp);
121                 break;
122         default:
123                 err = -ENOTTY;
124         }
125
126         reiserfs_write_unlock(inode->i_sb);
127
128         return err;
129 }
130
131 #ifdef CONFIG_COMPAT
132 long reiserfs_compat_ioctl(struct file *file, unsigned int cmd,
133                                 unsigned long arg)
134 {
135         /* These are just misnamed, they actually get/put from/to user an int */
136         switch (cmd) {
137         case REISERFS_IOC32_UNPACK:
138                 cmd = REISERFS_IOC_UNPACK;
139                 break;
140         case REISERFS_IOC32_GETFLAGS:
141                 cmd = REISERFS_IOC_GETFLAGS;
142                 break;
143         case REISERFS_IOC32_SETFLAGS:
144                 cmd = REISERFS_IOC_SETFLAGS;
145                 break;
146         case REISERFS_IOC32_GETVERSION:
147                 cmd = REISERFS_IOC_GETVERSION;
148                 break;
149         case REISERFS_IOC32_SETVERSION:
150                 cmd = REISERFS_IOC_SETVERSION;
151                 break;
152         default:
153                 return -ENOIOCTLCMD;
154         }
155
156         return reiserfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));
157 }
158 #endif
159
160 int reiserfs_commit_write(struct file *f, struct page *page,
161                           unsigned from, unsigned to);
162 /*
163 ** reiserfs_unpack
164 ** Function try to convert tail from direct item into indirect.
165 ** It set up nopack attribute in the REISERFS_I(inode)->nopack
166 */
167 int reiserfs_unpack(struct inode *inode, struct file *filp)
168 {
169         int retval = 0;
170         int depth;
171         int index;
172         struct page *page;
173         struct address_space *mapping;
174         unsigned long write_from;
175         unsigned long blocksize = inode->i_sb->s_blocksize;
176
177         if (inode->i_size == 0) {
178                 REISERFS_I(inode)->i_flags |= i_nopack_mask;
179                 return 0;
180         }
181         /* ioctl already done */
182         if (REISERFS_I(inode)->i_flags & i_nopack_mask) {
183                 return 0;
184         }
185
186         depth = reiserfs_write_lock_once(inode->i_sb);
187
188         /* we need to make sure nobody is changing the file size beneath us */
189         reiserfs_mutex_lock_safe(&inode->i_mutex, inode->i_sb);
190
191         write_from = inode->i_size & (blocksize - 1);
192         /* if we are on a block boundary, we are already unpacked.  */
193         if (write_from == 0) {
194                 REISERFS_I(inode)->i_flags |= i_nopack_mask;
195                 goto out;
196         }
197
198         /* we unpack by finding the page with the tail, and calling
199          ** __reiserfs_write_begin on that page.  This will force a
200          ** reiserfs_get_block to unpack the tail for us.
201          */
202         index = inode->i_size >> PAGE_CACHE_SHIFT;
203         mapping = inode->i_mapping;
204         page = grab_cache_page(mapping, index);
205         retval = -ENOMEM;
206         if (!page) {
207                 goto out;
208         }
209         retval = __reiserfs_write_begin(page, write_from, 0);
210         if (retval)
211                 goto out_unlock;
212
213         /* conversion can change page contents, must flush */
214         flush_dcache_page(page);
215         retval = reiserfs_commit_write(NULL, page, write_from, write_from);
216         REISERFS_I(inode)->i_flags |= i_nopack_mask;
217
218       out_unlock:
219         unlock_page(page);
220         page_cache_release(page);
221
222       out:
223         mutex_unlock(&inode->i_mutex);
224         reiserfs_write_unlock_once(inode->i_sb, depth);
225         return retval;
226 }