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