Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 7ebab4536958b05f65b71ec312073acf5d66578d

Authored by Wei Yongjun
Committed by Linus Torvalds
1 parent b3e0767abc
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

ocfs2: fix error return code in ocfs2_info_handle_freefrag() 

Fix to return a negative error code from the error handling case instead
of 0, as returned elsewhere in this function.

Signed-off-by: Wei Yongjun <yongjun_wei@trendmicro.com.cn>
Cc: Joel Becker <jlbec@evilplan.org>
Cc: Mark Fasheh <mfasheh@suse.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 1 changed file with 3 additions and 1 deletions Inline Diff

1 /* 1 /*
2 * linux/fs/ocfs2/ioctl.c 2 * linux/fs/ocfs2/ioctl.c
3 * 3 *
4 * Copyright (C) 2006 Herbert Poetzl 4 * Copyright (C) 2006 Herbert Poetzl
5 * adapted from Remy Card's ext2/ioctl.c 5 * adapted from Remy Card's ext2/ioctl.c
6 */ 6 */
7 7
8 #include <linux/fs.h> 8 #include <linux/fs.h>
9 #include <linux/mount.h> 9 #include <linux/mount.h>
10 #include <linux/compat.h> 10 #include <linux/compat.h>
11 11
12 #include <cluster/masklog.h> 12 #include <cluster/masklog.h>
13 13
14 #include "ocfs2.h" 14 #include "ocfs2.h"
15 #include "alloc.h" 15 #include "alloc.h"
16 #include "dlmglue.h" 16 #include "dlmglue.h"
17 #include "file.h" 17 #include "file.h"
18 #include "inode.h" 18 #include "inode.h"
19 #include "journal.h" 19 #include "journal.h"
20 20
21 #include "ocfs2_fs.h" 21 #include "ocfs2_fs.h"
22 #include "ioctl.h" 22 #include "ioctl.h"
23 #include "resize.h" 23 #include "resize.h"
24 #include "refcounttree.h" 24 #include "refcounttree.h"
25 #include "sysfile.h" 25 #include "sysfile.h"
26 #include "dir.h" 26 #include "dir.h"
27 #include "buffer_head_io.h" 27 #include "buffer_head_io.h"
28 #include "suballoc.h" 28 #include "suballoc.h"
29 #include "move_extents.h" 29 #include "move_extents.h"
30 30
31 #define o2info_from_user(a, b) \ 31 #define o2info_from_user(a, b) \
32 copy_from_user(&(a), (b), sizeof(a)) 32 copy_from_user(&(a), (b), sizeof(a))
33 #define o2info_to_user(a, b) \ 33 #define o2info_to_user(a, b) \
34 copy_to_user((typeof(a) __user *)b, &(a), sizeof(a)) 34 copy_to_user((typeof(a) __user *)b, &(a), sizeof(a))
35 35
36 /* 36 /*
37 * This call is void because we are already reporting an error that may 37 * This call is void because we are already reporting an error that may
38 * be -EFAULT. The error will be returned from the ioctl(2) call. It's 38 * be -EFAULT. The error will be returned from the ioctl(2) call. It's
39 * just a best-effort to tell userspace that this request caused the error. 39 * just a best-effort to tell userspace that this request caused the error.
40 */ 40 */
41 static inline void o2info_set_request_error(struct ocfs2_info_request *kreq, 41 static inline void o2info_set_request_error(struct ocfs2_info_request *kreq,
42 struct ocfs2_info_request __user *req) 42 struct ocfs2_info_request __user *req)
43 { 43 {
44 kreq->ir_flags |= OCFS2_INFO_FL_ERROR; 44 kreq->ir_flags |= OCFS2_INFO_FL_ERROR;
45 (void)put_user(kreq->ir_flags, (__u32 __user *)&(req->ir_flags)); 45 (void)put_user(kreq->ir_flags, (__u32 __user *)&(req->ir_flags));
46 } 46 }
47 47
48 static inline void o2info_set_request_filled(struct ocfs2_info_request *req) 48 static inline void o2info_set_request_filled(struct ocfs2_info_request *req)
49 { 49 {
50 req->ir_flags |= OCFS2_INFO_FL_FILLED; 50 req->ir_flags |= OCFS2_INFO_FL_FILLED;
51 } 51 }
52 52
53 static inline void o2info_clear_request_filled(struct ocfs2_info_request *req) 53 static inline void o2info_clear_request_filled(struct ocfs2_info_request *req)
54 { 54 {
55 req->ir_flags &= ~OCFS2_INFO_FL_FILLED; 55 req->ir_flags &= ~OCFS2_INFO_FL_FILLED;
56 } 56 }
57 57
58 static inline int o2info_coherent(struct ocfs2_info_request *req) 58 static inline int o2info_coherent(struct ocfs2_info_request *req)
59 { 59 {
60 return (!(req->ir_flags & OCFS2_INFO_FL_NON_COHERENT)); 60 return (!(req->ir_flags & OCFS2_INFO_FL_NON_COHERENT));
61 } 61 }
62 62
63 static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags) 63 static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags)
64 { 64 {
65 int status; 65 int status;
66 66
67 status = ocfs2_inode_lock(inode, NULL, 0); 67 status = ocfs2_inode_lock(inode, NULL, 0);
68 if (status < 0) { 68 if (status < 0) {
69 mlog_errno(status); 69 mlog_errno(status);
70 return status; 70 return status;
71 } 71 }
72 ocfs2_get_inode_flags(OCFS2_I(inode)); 72 ocfs2_get_inode_flags(OCFS2_I(inode));
73 *flags = OCFS2_I(inode)->ip_attr; 73 *flags = OCFS2_I(inode)->ip_attr;
74 ocfs2_inode_unlock(inode, 0); 74 ocfs2_inode_unlock(inode, 0);
75 75
76 return status; 76 return status;
77 } 77 }
78 78
79 static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags, 79 static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags,
80 unsigned mask) 80 unsigned mask)
81 { 81 {
82 struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode); 82 struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode);
83 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 83 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
84 handle_t *handle = NULL; 84 handle_t *handle = NULL;
85 struct buffer_head *bh = NULL; 85 struct buffer_head *bh = NULL;
86 unsigned oldflags; 86 unsigned oldflags;
87 int status; 87 int status;
88 88
89 mutex_lock(&inode->i_mutex); 89 mutex_lock(&inode->i_mutex);
90 90
91 status = ocfs2_inode_lock(inode, &bh, 1); 91 status = ocfs2_inode_lock(inode, &bh, 1);
92 if (status < 0) { 92 if (status < 0) {
93 mlog_errno(status); 93 mlog_errno(status);
94 goto bail; 94 goto bail;
95 } 95 }
96 96
97 status = -EACCES; 97 status = -EACCES;
98 if (!inode_owner_or_capable(inode)) 98 if (!inode_owner_or_capable(inode))
99 goto bail_unlock; 99 goto bail_unlock;
100 100
101 if (!S_ISDIR(inode->i_mode)) 101 if (!S_ISDIR(inode->i_mode))
102 flags &= ~OCFS2_DIRSYNC_FL; 102 flags &= ~OCFS2_DIRSYNC_FL;
103 103
104 oldflags = ocfs2_inode->ip_attr; 104 oldflags = ocfs2_inode->ip_attr;
105 flags = flags & mask; 105 flags = flags & mask;
106 flags |= oldflags & ~mask; 106 flags |= oldflags & ~mask;
107 107
108 /* 108 /*
109 * The IMMUTABLE and APPEND_ONLY flags can only be changed by 109 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
110 * the relevant capability. 110 * the relevant capability.
111 */ 111 */
112 status = -EPERM; 112 status = -EPERM;
113 if ((oldflags & OCFS2_IMMUTABLE_FL) || ((flags ^ oldflags) & 113 if ((oldflags & OCFS2_IMMUTABLE_FL) || ((flags ^ oldflags) &
114 (OCFS2_APPEND_FL | OCFS2_IMMUTABLE_FL))) { 114 (OCFS2_APPEND_FL | OCFS2_IMMUTABLE_FL))) {
115 if (!capable(CAP_LINUX_IMMUTABLE)) 115 if (!capable(CAP_LINUX_IMMUTABLE))
116 goto bail_unlock; 116 goto bail_unlock;
117 } 117 }
118 118
119 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); 119 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
120 if (IS_ERR(handle)) { 120 if (IS_ERR(handle)) {
121 status = PTR_ERR(handle); 121 status = PTR_ERR(handle);
122 mlog_errno(status); 122 mlog_errno(status);
123 goto bail_unlock; 123 goto bail_unlock;
124 } 124 }
125 125
126 ocfs2_inode->ip_attr = flags; 126 ocfs2_inode->ip_attr = flags;
127 ocfs2_set_inode_flags(inode); 127 ocfs2_set_inode_flags(inode);
128 128
129 status = ocfs2_mark_inode_dirty(handle, inode, bh); 129 status = ocfs2_mark_inode_dirty(handle, inode, bh);
130 if (status < 0) 130 if (status < 0)
131 mlog_errno(status); 131 mlog_errno(status);
132 132
133 ocfs2_commit_trans(osb, handle); 133 ocfs2_commit_trans(osb, handle);
134 134
135 bail_unlock: 135 bail_unlock:
136 ocfs2_inode_unlock(inode, 1); 136 ocfs2_inode_unlock(inode, 1);
137 bail: 137 bail:
138 mutex_unlock(&inode->i_mutex); 138 mutex_unlock(&inode->i_mutex);
139 139
140 brelse(bh); 140 brelse(bh);
141 141
142 return status; 142 return status;
143 } 143 }
144 144
145 int ocfs2_info_handle_blocksize(struct inode *inode, 145 int ocfs2_info_handle_blocksize(struct inode *inode,
146 struct ocfs2_info_request __user *req) 146 struct ocfs2_info_request __user *req)
147 { 147 {
148 int status = -EFAULT; 148 int status = -EFAULT;
149 struct ocfs2_info_blocksize oib; 149 struct ocfs2_info_blocksize oib;
150 150
151 if (o2info_from_user(oib, req)) 151 if (o2info_from_user(oib, req))
152 goto bail; 152 goto bail;
153 153
154 oib.ib_blocksize = inode->i_sb->s_blocksize; 154 oib.ib_blocksize = inode->i_sb->s_blocksize;
155 155
156 o2info_set_request_filled(&oib.ib_req); 156 o2info_set_request_filled(&oib.ib_req);
157 157
158 if (o2info_to_user(oib, req)) 158 if (o2info_to_user(oib, req))
159 goto bail; 159 goto bail;
160 160
161 status = 0; 161 status = 0;
162 bail: 162 bail:
163 if (status) 163 if (status)
164 o2info_set_request_error(&oib.ib_req, req); 164 o2info_set_request_error(&oib.ib_req, req);
165 165
166 return status; 166 return status;
167 } 167 }
168 168
169 int ocfs2_info_handle_clustersize(struct inode *inode, 169 int ocfs2_info_handle_clustersize(struct inode *inode,
170 struct ocfs2_info_request __user *req) 170 struct ocfs2_info_request __user *req)
171 { 171 {
172 int status = -EFAULT; 172 int status = -EFAULT;
173 struct ocfs2_info_clustersize oic; 173 struct ocfs2_info_clustersize oic;
174 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 174 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
175 175
176 if (o2info_from_user(oic, req)) 176 if (o2info_from_user(oic, req))
177 goto bail; 177 goto bail;
178 178
179 oic.ic_clustersize = osb->s_clustersize; 179 oic.ic_clustersize = osb->s_clustersize;
180 180
181 o2info_set_request_filled(&oic.ic_req); 181 o2info_set_request_filled(&oic.ic_req);
182 182
183 if (o2info_to_user(oic, req)) 183 if (o2info_to_user(oic, req))
184 goto bail; 184 goto bail;
185 185
186 status = 0; 186 status = 0;
187 bail: 187 bail:
188 if (status) 188 if (status)
189 o2info_set_request_error(&oic.ic_req, req); 189 o2info_set_request_error(&oic.ic_req, req);
190 190
191 return status; 191 return status;
192 } 192 }
193 193
194 int ocfs2_info_handle_maxslots(struct inode *inode, 194 int ocfs2_info_handle_maxslots(struct inode *inode,
195 struct ocfs2_info_request __user *req) 195 struct ocfs2_info_request __user *req)
196 { 196 {
197 int status = -EFAULT; 197 int status = -EFAULT;
198 struct ocfs2_info_maxslots oim; 198 struct ocfs2_info_maxslots oim;
199 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 199 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
200 200
201 if (o2info_from_user(oim, req)) 201 if (o2info_from_user(oim, req))
202 goto bail; 202 goto bail;
203 203
204 oim.im_max_slots = osb->max_slots; 204 oim.im_max_slots = osb->max_slots;
205 205
206 o2info_set_request_filled(&oim.im_req); 206 o2info_set_request_filled(&oim.im_req);
207 207
208 if (o2info_to_user(oim, req)) 208 if (o2info_to_user(oim, req))
209 goto bail; 209 goto bail;
210 210
211 status = 0; 211 status = 0;
212 bail: 212 bail:
213 if (status) 213 if (status)
214 o2info_set_request_error(&oim.im_req, req); 214 o2info_set_request_error(&oim.im_req, req);
215 215
216 return status; 216 return status;
217 } 217 }
218 218
219 int ocfs2_info_handle_label(struct inode *inode, 219 int ocfs2_info_handle_label(struct inode *inode,
220 struct ocfs2_info_request __user *req) 220 struct ocfs2_info_request __user *req)
221 { 221 {
222 int status = -EFAULT; 222 int status = -EFAULT;
223 struct ocfs2_info_label oil; 223 struct ocfs2_info_label oil;
224 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 224 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
225 225
226 if (o2info_from_user(oil, req)) 226 if (o2info_from_user(oil, req))
227 goto bail; 227 goto bail;
228 228
229 memcpy(oil.il_label, osb->vol_label, OCFS2_MAX_VOL_LABEL_LEN); 229 memcpy(oil.il_label, osb->vol_label, OCFS2_MAX_VOL_LABEL_LEN);
230 230
231 o2info_set_request_filled(&oil.il_req); 231 o2info_set_request_filled(&oil.il_req);
232 232
233 if (o2info_to_user(oil, req)) 233 if (o2info_to_user(oil, req))
234 goto bail; 234 goto bail;
235 235
236 status = 0; 236 status = 0;
237 bail: 237 bail:
238 if (status) 238 if (status)
239 o2info_set_request_error(&oil.il_req, req); 239 o2info_set_request_error(&oil.il_req, req);
240 240
241 return status; 241 return status;
242 } 242 }
243 243
244 int ocfs2_info_handle_uuid(struct inode *inode, 244 int ocfs2_info_handle_uuid(struct inode *inode,
245 struct ocfs2_info_request __user *req) 245 struct ocfs2_info_request __user *req)
246 { 246 {
247 int status = -EFAULT; 247 int status = -EFAULT;
248 struct ocfs2_info_uuid oiu; 248 struct ocfs2_info_uuid oiu;
249 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 249 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
250 250
251 if (o2info_from_user(oiu, req)) 251 if (o2info_from_user(oiu, req))
252 goto bail; 252 goto bail;
253 253
254 memcpy(oiu.iu_uuid_str, osb->uuid_str, OCFS2_TEXT_UUID_LEN + 1); 254 memcpy(oiu.iu_uuid_str, osb->uuid_str, OCFS2_TEXT_UUID_LEN + 1);
255 255
256 o2info_set_request_filled(&oiu.iu_req); 256 o2info_set_request_filled(&oiu.iu_req);
257 257
258 if (o2info_to_user(oiu, req)) 258 if (o2info_to_user(oiu, req))
259 goto bail; 259 goto bail;
260 260
261 status = 0; 261 status = 0;
262 bail: 262 bail:
263 if (status) 263 if (status)
264 o2info_set_request_error(&oiu.iu_req, req); 264 o2info_set_request_error(&oiu.iu_req, req);
265 265
266 return status; 266 return status;
267 } 267 }
268 268
269 int ocfs2_info_handle_fs_features(struct inode *inode, 269 int ocfs2_info_handle_fs_features(struct inode *inode,
270 struct ocfs2_info_request __user *req) 270 struct ocfs2_info_request __user *req)
271 { 271 {
272 int status = -EFAULT; 272 int status = -EFAULT;
273 struct ocfs2_info_fs_features oif; 273 struct ocfs2_info_fs_features oif;
274 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 274 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
275 275
276 if (o2info_from_user(oif, req)) 276 if (o2info_from_user(oif, req))
277 goto bail; 277 goto bail;
278 278
279 oif.if_compat_features = osb->s_feature_compat; 279 oif.if_compat_features = osb->s_feature_compat;
280 oif.if_incompat_features = osb->s_feature_incompat; 280 oif.if_incompat_features = osb->s_feature_incompat;
281 oif.if_ro_compat_features = osb->s_feature_ro_compat; 281 oif.if_ro_compat_features = osb->s_feature_ro_compat;
282 282
283 o2info_set_request_filled(&oif.if_req); 283 o2info_set_request_filled(&oif.if_req);
284 284
285 if (o2info_to_user(oif, req)) 285 if (o2info_to_user(oif, req))
286 goto bail; 286 goto bail;
287 287
288 status = 0; 288 status = 0;
289 bail: 289 bail:
290 if (status) 290 if (status)
291 o2info_set_request_error(&oif.if_req, req); 291 o2info_set_request_error(&oif.if_req, req);
292 292
293 return status; 293 return status;
294 } 294 }
295 295
296 int ocfs2_info_handle_journal_size(struct inode *inode, 296 int ocfs2_info_handle_journal_size(struct inode *inode,
297 struct ocfs2_info_request __user *req) 297 struct ocfs2_info_request __user *req)
298 { 298 {
299 int status = -EFAULT; 299 int status = -EFAULT;
300 struct ocfs2_info_journal_size oij; 300 struct ocfs2_info_journal_size oij;
301 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 301 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
302 302
303 if (o2info_from_user(oij, req)) 303 if (o2info_from_user(oij, req))
304 goto bail; 304 goto bail;
305 305
306 oij.ij_journal_size = osb->journal->j_inode->i_size; 306 oij.ij_journal_size = osb->journal->j_inode->i_size;
307 307
308 o2info_set_request_filled(&oij.ij_req); 308 o2info_set_request_filled(&oij.ij_req);
309 309
310 if (o2info_to_user(oij, req)) 310 if (o2info_to_user(oij, req))
311 goto bail; 311 goto bail;
312 312
313 status = 0; 313 status = 0;
314 bail: 314 bail:
315 if (status) 315 if (status)
316 o2info_set_request_error(&oij.ij_req, req); 316 o2info_set_request_error(&oij.ij_req, req);
317 317
318 return status; 318 return status;
319 } 319 }
320 320
321 int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb, 321 int ocfs2_info_scan_inode_alloc(struct ocfs2_super *osb,
322 struct inode *inode_alloc, u64 blkno, 322 struct inode *inode_alloc, u64 blkno,
323 struct ocfs2_info_freeinode *fi, u32 slot) 323 struct ocfs2_info_freeinode *fi, u32 slot)
324 { 324 {
325 int status = 0, unlock = 0; 325 int status = 0, unlock = 0;
326 326
327 struct buffer_head *bh = NULL; 327 struct buffer_head *bh = NULL;
328 struct ocfs2_dinode *dinode_alloc = NULL; 328 struct ocfs2_dinode *dinode_alloc = NULL;
329 329
330 if (inode_alloc) 330 if (inode_alloc)
331 mutex_lock(&inode_alloc->i_mutex); 331 mutex_lock(&inode_alloc->i_mutex);
332 332
333 if (o2info_coherent(&fi->ifi_req)) { 333 if (o2info_coherent(&fi->ifi_req)) {
334 status = ocfs2_inode_lock(inode_alloc, &bh, 0); 334 status = ocfs2_inode_lock(inode_alloc, &bh, 0);
335 if (status < 0) { 335 if (status < 0) {
336 mlog_errno(status); 336 mlog_errno(status);
337 goto bail; 337 goto bail;
338 } 338 }
339 unlock = 1; 339 unlock = 1;
340 } else { 340 } else {
341 status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh); 341 status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh);
342 if (status < 0) { 342 if (status < 0) {
343 mlog_errno(status); 343 mlog_errno(status);
344 goto bail; 344 goto bail;
345 } 345 }
346 } 346 }
347 347
348 dinode_alloc = (struct ocfs2_dinode *)bh->b_data; 348 dinode_alloc = (struct ocfs2_dinode *)bh->b_data;
349 349
350 fi->ifi_stat[slot].lfi_total = 350 fi->ifi_stat[slot].lfi_total =
351 le32_to_cpu(dinode_alloc->id1.bitmap1.i_total); 351 le32_to_cpu(dinode_alloc->id1.bitmap1.i_total);
352 fi->ifi_stat[slot].lfi_free = 352 fi->ifi_stat[slot].lfi_free =
353 le32_to_cpu(dinode_alloc->id1.bitmap1.i_total) - 353 le32_to_cpu(dinode_alloc->id1.bitmap1.i_total) -
354 le32_to_cpu(dinode_alloc->id1.bitmap1.i_used); 354 le32_to_cpu(dinode_alloc->id1.bitmap1.i_used);
355 355
356 bail: 356 bail:
357 if (unlock) 357 if (unlock)
358 ocfs2_inode_unlock(inode_alloc, 0); 358 ocfs2_inode_unlock(inode_alloc, 0);
359 359
360 if (inode_alloc) 360 if (inode_alloc)
361 mutex_unlock(&inode_alloc->i_mutex); 361 mutex_unlock(&inode_alloc->i_mutex);
362 362
363 brelse(bh); 363 brelse(bh);
364 364
365 return status; 365 return status;
366 } 366 }
367 367
368 int ocfs2_info_handle_freeinode(struct inode *inode, 368 int ocfs2_info_handle_freeinode(struct inode *inode,
369 struct ocfs2_info_request __user *req) 369 struct ocfs2_info_request __user *req)
370 { 370 {
371 u32 i; 371 u32 i;
372 u64 blkno = -1; 372 u64 blkno = -1;
373 char namebuf[40]; 373 char namebuf[40];
374 int status = -EFAULT, type = INODE_ALLOC_SYSTEM_INODE; 374 int status = -EFAULT, type = INODE_ALLOC_SYSTEM_INODE;
375 struct ocfs2_info_freeinode *oifi = NULL; 375 struct ocfs2_info_freeinode *oifi = NULL;
376 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 376 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
377 struct inode *inode_alloc = NULL; 377 struct inode *inode_alloc = NULL;
378 378
379 oifi = kzalloc(sizeof(struct ocfs2_info_freeinode), GFP_KERNEL); 379 oifi = kzalloc(sizeof(struct ocfs2_info_freeinode), GFP_KERNEL);
380 if (!oifi) { 380 if (!oifi) {
381 status = -ENOMEM; 381 status = -ENOMEM;
382 mlog_errno(status); 382 mlog_errno(status);
383 goto out_err; 383 goto out_err;
384 } 384 }
385 385
386 if (o2info_from_user(*oifi, req)) 386 if (o2info_from_user(*oifi, req))
387 goto bail; 387 goto bail;
388 388
389 oifi->ifi_slotnum = osb->max_slots; 389 oifi->ifi_slotnum = osb->max_slots;
390 390
391 for (i = 0; i < oifi->ifi_slotnum; i++) { 391 for (i = 0; i < oifi->ifi_slotnum; i++) {
392 if (o2info_coherent(&oifi->ifi_req)) { 392 if (o2info_coherent(&oifi->ifi_req)) {
393 inode_alloc = ocfs2_get_system_file_inode(osb, type, i); 393 inode_alloc = ocfs2_get_system_file_inode(osb, type, i);
394 if (!inode_alloc) { 394 if (!inode_alloc) {
395 mlog(ML_ERROR, "unable to get alloc inode in " 395 mlog(ML_ERROR, "unable to get alloc inode in "
396 "slot %u\n", i); 396 "slot %u\n", i);
397 status = -EIO; 397 status = -EIO;
398 goto bail; 398 goto bail;
399 } 399 }
400 } else { 400 } else {
401 ocfs2_sprintf_system_inode_name(namebuf, 401 ocfs2_sprintf_system_inode_name(namebuf,
402 sizeof(namebuf), 402 sizeof(namebuf),
403 type, i); 403 type, i);
404 status = ocfs2_lookup_ino_from_name(osb->sys_root_inode, 404 status = ocfs2_lookup_ino_from_name(osb->sys_root_inode,
405 namebuf, 405 namebuf,
406 strlen(namebuf), 406 strlen(namebuf),
407 &blkno); 407 &blkno);
408 if (status < 0) { 408 if (status < 0) {
409 status = -ENOENT; 409 status = -ENOENT;
410 goto bail; 410 goto bail;
411 } 411 }
412 } 412 }
413 413
414 status = ocfs2_info_scan_inode_alloc(osb, inode_alloc, blkno, oifi, i); 414 status = ocfs2_info_scan_inode_alloc(osb, inode_alloc, blkno, oifi, i);
415 if (status < 0) 415 if (status < 0)
416 goto bail; 416 goto bail;
417 417
418 iput(inode_alloc); 418 iput(inode_alloc);
419 inode_alloc = NULL; 419 inode_alloc = NULL;
420 } 420 }
421 421
422 o2info_set_request_filled(&oifi->ifi_req); 422 o2info_set_request_filled(&oifi->ifi_req);
423 423
424 if (o2info_to_user(*oifi, req)) 424 if (o2info_to_user(*oifi, req))
425 goto bail; 425 goto bail;
426 426
427 status = 0; 427 status = 0;
428 bail: 428 bail:
429 if (status) 429 if (status)
430 o2info_set_request_error(&oifi->ifi_req, req); 430 o2info_set_request_error(&oifi->ifi_req, req);
431 431
432 kfree(oifi); 432 kfree(oifi);
433 out_err: 433 out_err:
434 return status; 434 return status;
435 } 435 }
436 436
437 static void o2ffg_update_histogram(struct ocfs2_info_free_chunk_list *hist, 437 static void o2ffg_update_histogram(struct ocfs2_info_free_chunk_list *hist,
438 unsigned int chunksize) 438 unsigned int chunksize)
439 { 439 {
440 int index; 440 int index;
441 441
442 index = __ilog2_u32(chunksize); 442 index = __ilog2_u32(chunksize);
443 if (index >= OCFS2_INFO_MAX_HIST) 443 if (index >= OCFS2_INFO_MAX_HIST)
444 index = OCFS2_INFO_MAX_HIST - 1; 444 index = OCFS2_INFO_MAX_HIST - 1;
445 445
446 hist->fc_chunks[index]++; 446 hist->fc_chunks[index]++;
447 hist->fc_clusters[index] += chunksize; 447 hist->fc_clusters[index] += chunksize;
448 } 448 }
449 449
450 static void o2ffg_update_stats(struct ocfs2_info_freefrag_stats *stats, 450 static void o2ffg_update_stats(struct ocfs2_info_freefrag_stats *stats,
451 unsigned int chunksize) 451 unsigned int chunksize)
452 { 452 {
453 if (chunksize > stats->ffs_max) 453 if (chunksize > stats->ffs_max)
454 stats->ffs_max = chunksize; 454 stats->ffs_max = chunksize;
455 455
456 if (chunksize < stats->ffs_min) 456 if (chunksize < stats->ffs_min)
457 stats->ffs_min = chunksize; 457 stats->ffs_min = chunksize;
458 458
459 stats->ffs_avg += chunksize; 459 stats->ffs_avg += chunksize;
460 stats->ffs_free_chunks_real++; 460 stats->ffs_free_chunks_real++;
461 } 461 }
462 462
463 void ocfs2_info_update_ffg(struct ocfs2_info_freefrag *ffg, 463 void ocfs2_info_update_ffg(struct ocfs2_info_freefrag *ffg,
464 unsigned int chunksize) 464 unsigned int chunksize)
465 { 465 {
466 o2ffg_update_histogram(&(ffg->iff_ffs.ffs_fc_hist), chunksize); 466 o2ffg_update_histogram(&(ffg->iff_ffs.ffs_fc_hist), chunksize);
467 o2ffg_update_stats(&(ffg->iff_ffs), chunksize); 467 o2ffg_update_stats(&(ffg->iff_ffs), chunksize);
468 } 468 }
469 469
470 int ocfs2_info_freefrag_scan_chain(struct ocfs2_super *osb, 470 int ocfs2_info_freefrag_scan_chain(struct ocfs2_super *osb,
471 struct inode *gb_inode, 471 struct inode *gb_inode,
472 struct ocfs2_dinode *gb_dinode, 472 struct ocfs2_dinode *gb_dinode,
473 struct ocfs2_chain_rec *rec, 473 struct ocfs2_chain_rec *rec,
474 struct ocfs2_info_freefrag *ffg, 474 struct ocfs2_info_freefrag *ffg,
475 u32 chunks_in_group) 475 u32 chunks_in_group)
476 { 476 {
477 int status = 0, used; 477 int status = 0, used;
478 u64 blkno; 478 u64 blkno;
479 479
480 struct buffer_head *bh = NULL; 480 struct buffer_head *bh = NULL;
481 struct ocfs2_group_desc *bg = NULL; 481 struct ocfs2_group_desc *bg = NULL;
482 482
483 unsigned int max_bits, num_clusters; 483 unsigned int max_bits, num_clusters;
484 unsigned int offset = 0, cluster, chunk; 484 unsigned int offset = 0, cluster, chunk;
485 unsigned int chunk_free, last_chunksize = 0; 485 unsigned int chunk_free, last_chunksize = 0;
486 486
487 if (!le32_to_cpu(rec->c_free)) 487 if (!le32_to_cpu(rec->c_free))
488 goto bail; 488 goto bail;
489 489
490 do { 490 do {
491 if (!bg) 491 if (!bg)
492 blkno = le64_to_cpu(rec->c_blkno); 492 blkno = le64_to_cpu(rec->c_blkno);
493 else 493 else
494 blkno = le64_to_cpu(bg->bg_next_group); 494 blkno = le64_to_cpu(bg->bg_next_group);
495 495
496 if (bh) { 496 if (bh) {
497 brelse(bh); 497 brelse(bh);
498 bh = NULL; 498 bh = NULL;
499 } 499 }
500 500
501 if (o2info_coherent(&ffg->iff_req)) 501 if (o2info_coherent(&ffg->iff_req))
502 status = ocfs2_read_group_descriptor(gb_inode, 502 status = ocfs2_read_group_descriptor(gb_inode,
503 gb_dinode, 503 gb_dinode,
504 blkno, &bh); 504 blkno, &bh);
505 else 505 else
506 status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh); 506 status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh);
507 507
508 if (status < 0) { 508 if (status < 0) {
509 mlog(ML_ERROR, "Can't read the group descriptor # " 509 mlog(ML_ERROR, "Can't read the group descriptor # "
510 "%llu from device.", (unsigned long long)blkno); 510 "%llu from device.", (unsigned long long)blkno);
511 status = -EIO; 511 status = -EIO;
512 goto bail; 512 goto bail;
513 } 513 }
514 514
515 bg = (struct ocfs2_group_desc *)bh->b_data; 515 bg = (struct ocfs2_group_desc *)bh->b_data;
516 516
517 if (!le16_to_cpu(bg->bg_free_bits_count)) 517 if (!le16_to_cpu(bg->bg_free_bits_count))
518 continue; 518 continue;
519 519
520 max_bits = le16_to_cpu(bg->bg_bits); 520 max_bits = le16_to_cpu(bg->bg_bits);
521 offset = 0; 521 offset = 0;
522 522
523 for (chunk = 0; chunk < chunks_in_group; chunk++) { 523 for (chunk = 0; chunk < chunks_in_group; chunk++) {
524 /* 524 /*
525 * last chunk may be not an entire one. 525 * last chunk may be not an entire one.
526 */ 526 */
527 if ((offset + ffg->iff_chunksize) > max_bits) 527 if ((offset + ffg->iff_chunksize) > max_bits)
528 num_clusters = max_bits - offset; 528 num_clusters = max_bits - offset;
529 else 529 else
530 num_clusters = ffg->iff_chunksize; 530 num_clusters = ffg->iff_chunksize;
531 531
532 chunk_free = 0; 532 chunk_free = 0;
533 for (cluster = 0; cluster < num_clusters; cluster++) { 533 for (cluster = 0; cluster < num_clusters; cluster++) {
534 used = ocfs2_test_bit(offset, 534 used = ocfs2_test_bit(offset,
535 (unsigned long *)bg->bg_bitmap); 535 (unsigned long *)bg->bg_bitmap);
536 /* 536 /*
537 * - chunk_free counts free clusters in #N chunk. 537 * - chunk_free counts free clusters in #N chunk.
538 * - last_chunksize records the size(in) clusters 538 * - last_chunksize records the size(in) clusters
539 * for the last real free chunk being counted. 539 * for the last real free chunk being counted.
540 */ 540 */
541 if (!used) { 541 if (!used) {
542 last_chunksize++; 542 last_chunksize++;
543 chunk_free++; 543 chunk_free++;
544 } 544 }
545 545
546 if (used && last_chunksize) { 546 if (used && last_chunksize) {
547 ocfs2_info_update_ffg(ffg, 547 ocfs2_info_update_ffg(ffg,
548 last_chunksize); 548 last_chunksize);
549 last_chunksize = 0; 549 last_chunksize = 0;
550 } 550 }
551 551
552 offset++; 552 offset++;
553 } 553 }
554 554
555 if (chunk_free == ffg->iff_chunksize) 555 if (chunk_free == ffg->iff_chunksize)
556 ffg->iff_ffs.ffs_free_chunks++; 556 ffg->iff_ffs.ffs_free_chunks++;
557 } 557 }
558 558
559 /* 559 /*
560 * need to update the info for last free chunk. 560 * need to update the info for last free chunk.
561 */ 561 */
562 if (last_chunksize) 562 if (last_chunksize)
563 ocfs2_info_update_ffg(ffg, last_chunksize); 563 ocfs2_info_update_ffg(ffg, last_chunksize);
564 564
565 } while (le64_to_cpu(bg->bg_next_group)); 565 } while (le64_to_cpu(bg->bg_next_group));
566 566
567 bail: 567 bail:
568 brelse(bh); 568 brelse(bh);
569 569
570 return status; 570 return status;
571 } 571 }
572 572
573 int ocfs2_info_freefrag_scan_bitmap(struct ocfs2_super *osb, 573 int ocfs2_info_freefrag_scan_bitmap(struct ocfs2_super *osb,
574 struct inode *gb_inode, u64 blkno, 574 struct inode *gb_inode, u64 blkno,
575 struct ocfs2_info_freefrag *ffg) 575 struct ocfs2_info_freefrag *ffg)
576 { 576 {
577 u32 chunks_in_group; 577 u32 chunks_in_group;
578 int status = 0, unlock = 0, i; 578 int status = 0, unlock = 0, i;
579 579
580 struct buffer_head *bh = NULL; 580 struct buffer_head *bh = NULL;
581 struct ocfs2_chain_list *cl = NULL; 581 struct ocfs2_chain_list *cl = NULL;
582 struct ocfs2_chain_rec *rec = NULL; 582 struct ocfs2_chain_rec *rec = NULL;
583 struct ocfs2_dinode *gb_dinode = NULL; 583 struct ocfs2_dinode *gb_dinode = NULL;
584 584
585 if (gb_inode) 585 if (gb_inode)
586 mutex_lock(&gb_inode->i_mutex); 586 mutex_lock(&gb_inode->i_mutex);
587 587
588 if (o2info_coherent(&ffg->iff_req)) { 588 if (o2info_coherent(&ffg->iff_req)) {
589 status = ocfs2_inode_lock(gb_inode, &bh, 0); 589 status = ocfs2_inode_lock(gb_inode, &bh, 0);
590 if (status < 0) { 590 if (status < 0) {
591 mlog_errno(status); 591 mlog_errno(status);
592 goto bail; 592 goto bail;
593 } 593 }
594 unlock = 1; 594 unlock = 1;
595 } else { 595 } else {
596 status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh); 596 status = ocfs2_read_blocks_sync(osb, blkno, 1, &bh);
597 if (status < 0) { 597 if (status < 0) {
598 mlog_errno(status); 598 mlog_errno(status);
599 goto bail; 599 goto bail;
600 } 600 }
601 } 601 }
602 602
603 gb_dinode = (struct ocfs2_dinode *)bh->b_data; 603 gb_dinode = (struct ocfs2_dinode *)bh->b_data;
604 cl = &(gb_dinode->id2.i_chain); 604 cl = &(gb_dinode->id2.i_chain);
605 605
606 /* 606 /*
607 * Chunksize(in) clusters from userspace should be 607 * Chunksize(in) clusters from userspace should be
608 * less than clusters in a group. 608 * less than clusters in a group.
609 */ 609 */
610 if (ffg->iff_chunksize > le16_to_cpu(cl->cl_cpg)) { 610 if (ffg->iff_chunksize > le16_to_cpu(cl->cl_cpg)) {
611 status = -EINVAL; 611 status = -EINVAL;
612 goto bail; 612 goto bail;
613 } 613 }
614 614
615 memset(&ffg->iff_ffs, 0, sizeof(struct ocfs2_info_freefrag_stats)); 615 memset(&ffg->iff_ffs, 0, sizeof(struct ocfs2_info_freefrag_stats));
616 616
617 ffg->iff_ffs.ffs_min = ~0U; 617 ffg->iff_ffs.ffs_min = ~0U;
618 ffg->iff_ffs.ffs_clusters = 618 ffg->iff_ffs.ffs_clusters =
619 le32_to_cpu(gb_dinode->id1.bitmap1.i_total); 619 le32_to_cpu(gb_dinode->id1.bitmap1.i_total);
620 ffg->iff_ffs.ffs_free_clusters = ffg->iff_ffs.ffs_clusters - 620 ffg->iff_ffs.ffs_free_clusters = ffg->iff_ffs.ffs_clusters -
621 le32_to_cpu(gb_dinode->id1.bitmap1.i_used); 621 le32_to_cpu(gb_dinode->id1.bitmap1.i_used);
622 622
623 chunks_in_group = le16_to_cpu(cl->cl_cpg) / ffg->iff_chunksize + 1; 623 chunks_in_group = le16_to_cpu(cl->cl_cpg) / ffg->iff_chunksize + 1;
624 624
625 for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i++) { 625 for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i++) {
626 rec = &(cl->cl_recs[i]); 626 rec = &(cl->cl_recs[i]);
627 status = ocfs2_info_freefrag_scan_chain(osb, gb_inode, 627 status = ocfs2_info_freefrag_scan_chain(osb, gb_inode,
628 gb_dinode, 628 gb_dinode,
629 rec, ffg, 629 rec, ffg,
630 chunks_in_group); 630 chunks_in_group);
631 if (status) 631 if (status)
632 goto bail; 632 goto bail;
633 } 633 }
634 634
635 if (ffg->iff_ffs.ffs_free_chunks_real) 635 if (ffg->iff_ffs.ffs_free_chunks_real)
636 ffg->iff_ffs.ffs_avg = (ffg->iff_ffs.ffs_avg / 636 ffg->iff_ffs.ffs_avg = (ffg->iff_ffs.ffs_avg /
637 ffg->iff_ffs.ffs_free_chunks_real); 637 ffg->iff_ffs.ffs_free_chunks_real);
638 bail: 638 bail:
639 if (unlock) 639 if (unlock)
640 ocfs2_inode_unlock(gb_inode, 0); 640 ocfs2_inode_unlock(gb_inode, 0);
641 641
642 if (gb_inode) 642 if (gb_inode)
643 mutex_unlock(&gb_inode->i_mutex); 643 mutex_unlock(&gb_inode->i_mutex);
644 644
645 if (gb_inode) 645 if (gb_inode)
646 iput(gb_inode); 646 iput(gb_inode);
647 647
648 brelse(bh); 648 brelse(bh);
649 649
650 return status; 650 return status;
651 } 651 }
652 652
653 int ocfs2_info_handle_freefrag(struct inode *inode, 653 int ocfs2_info_handle_freefrag(struct inode *inode,
654 struct ocfs2_info_request __user *req) 654 struct ocfs2_info_request __user *req)
655 { 655 {
656 u64 blkno = -1; 656 u64 blkno = -1;
657 char namebuf[40]; 657 char namebuf[40];
658 int status = -EFAULT, type = GLOBAL_BITMAP_SYSTEM_INODE; 658 int status = -EFAULT, type = GLOBAL_BITMAP_SYSTEM_INODE;
659 659
660 struct ocfs2_info_freefrag *oiff; 660 struct ocfs2_info_freefrag *oiff;
661 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 661 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
662 struct inode *gb_inode = NULL; 662 struct inode *gb_inode = NULL;
663 663
664 oiff = kzalloc(sizeof(struct ocfs2_info_freefrag), GFP_KERNEL); 664 oiff = kzalloc(sizeof(struct ocfs2_info_freefrag), GFP_KERNEL);
665 if (!oiff) { 665 if (!oiff) {
666 status = -ENOMEM; 666 status = -ENOMEM;
667 mlog_errno(status); 667 mlog_errno(status);
668 goto out_err; 668 goto out_err;
669 } 669 }
670 670
671 if (o2info_from_user(*oiff, req)) 671 if (o2info_from_user(*oiff, req))
672 goto bail; 672 goto bail;
673 /* 673 /*
674 * chunksize from userspace should be power of 2. 674 * chunksize from userspace should be power of 2.
675 */ 675 */
676 if ((oiff->iff_chunksize & (oiff->iff_chunksize - 1)) || 676 if ((oiff->iff_chunksize & (oiff->iff_chunksize - 1)) ||
677 (!oiff->iff_chunksize)) { 677 (!oiff->iff_chunksize)) {
678 status = -EINVAL; 678 status = -EINVAL;
679 goto bail; 679 goto bail;
680 } 680 }
681 681
682 if (o2info_coherent(&oiff->iff_req)) { 682 if (o2info_coherent(&oiff->iff_req)) {
683 gb_inode = ocfs2_get_system_file_inode(osb, type, 683 gb_inode = ocfs2_get_system_file_inode(osb, type,
684 OCFS2_INVALID_SLOT); 684 OCFS2_INVALID_SLOT);
685 if (!gb_inode) { 685 if (!gb_inode) {
686 mlog(ML_ERROR, "unable to get global_bitmap inode\n"); 686 mlog(ML_ERROR, "unable to get global_bitmap inode\n");
687 status = -EIO; 687 status = -EIO;
688 goto bail; 688 goto bail;
689 } 689 }
690 } else { 690 } else {
691 ocfs2_sprintf_system_inode_name(namebuf, sizeof(namebuf), type, 691 ocfs2_sprintf_system_inode_name(namebuf, sizeof(namebuf), type,
692 OCFS2_INVALID_SLOT); 692 OCFS2_INVALID_SLOT);
693 status = ocfs2_lookup_ino_from_name(osb->sys_root_inode, 693 status = ocfs2_lookup_ino_from_name(osb->sys_root_inode,
694 namebuf, 694 namebuf,
695 strlen(namebuf), 695 strlen(namebuf),
696 &blkno); 696 &blkno);
697 if (status < 0) { 697 if (status < 0) {
698 status = -ENOENT; 698 status = -ENOENT;
699 goto bail; 699 goto bail;
700 } 700 }
701 } 701 }
702 702
703 status = ocfs2_info_freefrag_scan_bitmap(osb, gb_inode, blkno, oiff); 703 status = ocfs2_info_freefrag_scan_bitmap(osb, gb_inode, blkno, oiff);
704 if (status < 0) 704 if (status < 0)
705 goto bail; 705 goto bail;
706 706
707 o2info_set_request_filled(&oiff->iff_req); 707 o2info_set_request_filled(&oiff->iff_req);
708 708
709 if (o2info_to_user(*oiff, req)) 709 if (o2info_to_user(*oiff, req)) {
710 status = -EFAULT;
710 goto bail; 711 goto bail;
712 }
711 713
712 status = 0; 714 status = 0;
713 bail: 715 bail:
714 if (status) 716 if (status)
715 o2info_set_request_error(&oiff->iff_req, req); 717 o2info_set_request_error(&oiff->iff_req, req);
716 718
717 kfree(oiff); 719 kfree(oiff);
718 out_err: 720 out_err:
719 return status; 721 return status;
720 } 722 }
721 723
722 int ocfs2_info_handle_unknown(struct inode *inode, 724 int ocfs2_info_handle_unknown(struct inode *inode,
723 struct ocfs2_info_request __user *req) 725 struct ocfs2_info_request __user *req)
724 { 726 {
725 int status = -EFAULT; 727 int status = -EFAULT;
726 struct ocfs2_info_request oir; 728 struct ocfs2_info_request oir;
727 729
728 if (o2info_from_user(oir, req)) 730 if (o2info_from_user(oir, req))
729 goto bail; 731 goto bail;
730 732
731 o2info_clear_request_filled(&oir); 733 o2info_clear_request_filled(&oir);
732 734
733 if (o2info_to_user(oir, req)) 735 if (o2info_to_user(oir, req))
734 goto bail; 736 goto bail;
735 737
736 status = 0; 738 status = 0;
737 bail: 739 bail:
738 if (status) 740 if (status)
739 o2info_set_request_error(&oir, req); 741 o2info_set_request_error(&oir, req);
740 742
741 return status; 743 return status;
742 } 744 }
743 745
744 /* 746 /*
745 * Validate and distinguish OCFS2_IOC_INFO requests. 747 * Validate and distinguish OCFS2_IOC_INFO requests.
746 * 748 *
747 * - validate the magic number. 749 * - validate the magic number.
748 * - distinguish different requests. 750 * - distinguish different requests.
749 * - validate size of different requests. 751 * - validate size of different requests.
750 */ 752 */
751 int ocfs2_info_handle_request(struct inode *inode, 753 int ocfs2_info_handle_request(struct inode *inode,
752 struct ocfs2_info_request __user *req) 754 struct ocfs2_info_request __user *req)
753 { 755 {
754 int status = -EFAULT; 756 int status = -EFAULT;
755 struct ocfs2_info_request oir; 757 struct ocfs2_info_request oir;
756 758
757 if (o2info_from_user(oir, req)) 759 if (o2info_from_user(oir, req))
758 goto bail; 760 goto bail;
759 761
760 status = -EINVAL; 762 status = -EINVAL;
761 if (oir.ir_magic != OCFS2_INFO_MAGIC) 763 if (oir.ir_magic != OCFS2_INFO_MAGIC)
762 goto bail; 764 goto bail;
763 765
764 switch (oir.ir_code) { 766 switch (oir.ir_code) {
765 case OCFS2_INFO_BLOCKSIZE: 767 case OCFS2_INFO_BLOCKSIZE:
766 if (oir.ir_size == sizeof(struct ocfs2_info_blocksize)) 768 if (oir.ir_size == sizeof(struct ocfs2_info_blocksize))
767 status = ocfs2_info_handle_blocksize(inode, req); 769 status = ocfs2_info_handle_blocksize(inode, req);
768 break; 770 break;
769 case OCFS2_INFO_CLUSTERSIZE: 771 case OCFS2_INFO_CLUSTERSIZE:
770 if (oir.ir_size == sizeof(struct ocfs2_info_clustersize)) 772 if (oir.ir_size == sizeof(struct ocfs2_info_clustersize))
771 status = ocfs2_info_handle_clustersize(inode, req); 773 status = ocfs2_info_handle_clustersize(inode, req);
772 break; 774 break;
773 case OCFS2_INFO_MAXSLOTS: 775 case OCFS2_INFO_MAXSLOTS:
774 if (oir.ir_size == sizeof(struct ocfs2_info_maxslots)) 776 if (oir.ir_size == sizeof(struct ocfs2_info_maxslots))
775 status = ocfs2_info_handle_maxslots(inode, req); 777 status = ocfs2_info_handle_maxslots(inode, req);
776 break; 778 break;
777 case OCFS2_INFO_LABEL: 779 case OCFS2_INFO_LABEL:
778 if (oir.ir_size == sizeof(struct ocfs2_info_label)) 780 if (oir.ir_size == sizeof(struct ocfs2_info_label))
779 status = ocfs2_info_handle_label(inode, req); 781 status = ocfs2_info_handle_label(inode, req);
780 break; 782 break;
781 case OCFS2_INFO_UUID: 783 case OCFS2_INFO_UUID:
782 if (oir.ir_size == sizeof(struct ocfs2_info_uuid)) 784 if (oir.ir_size == sizeof(struct ocfs2_info_uuid))
783 status = ocfs2_info_handle_uuid(inode, req); 785 status = ocfs2_info_handle_uuid(inode, req);
784 break; 786 break;
785 case OCFS2_INFO_FS_FEATURES: 787 case OCFS2_INFO_FS_FEATURES:
786 if (oir.ir_size == sizeof(struct ocfs2_info_fs_features)) 788 if (oir.ir_size == sizeof(struct ocfs2_info_fs_features))
787 status = ocfs2_info_handle_fs_features(inode, req); 789 status = ocfs2_info_handle_fs_features(inode, req);
788 break; 790 break;
789 case OCFS2_INFO_JOURNAL_SIZE: 791 case OCFS2_INFO_JOURNAL_SIZE:
790 if (oir.ir_size == sizeof(struct ocfs2_info_journal_size)) 792 if (oir.ir_size == sizeof(struct ocfs2_info_journal_size))
791 status = ocfs2_info_handle_journal_size(inode, req); 793 status = ocfs2_info_handle_journal_size(inode, req);
792 break; 794 break;
793 case OCFS2_INFO_FREEINODE: 795 case OCFS2_INFO_FREEINODE:
794 if (oir.ir_size == sizeof(struct ocfs2_info_freeinode)) 796 if (oir.ir_size == sizeof(struct ocfs2_info_freeinode))
795 status = ocfs2_info_handle_freeinode(inode, req); 797 status = ocfs2_info_handle_freeinode(inode, req);
796 break; 798 break;
797 case OCFS2_INFO_FREEFRAG: 799 case OCFS2_INFO_FREEFRAG:
798 if (oir.ir_size == sizeof(struct ocfs2_info_freefrag)) 800 if (oir.ir_size == sizeof(struct ocfs2_info_freefrag))
799 status = ocfs2_info_handle_freefrag(inode, req); 801 status = ocfs2_info_handle_freefrag(inode, req);
800 break; 802 break;
801 default: 803 default:
802 status = ocfs2_info_handle_unknown(inode, req); 804 status = ocfs2_info_handle_unknown(inode, req);
803 break; 805 break;
804 } 806 }
805 807
806 bail: 808 bail:
807 return status; 809 return status;
808 } 810 }
809 811
810 int ocfs2_get_request_ptr(struct ocfs2_info *info, int idx, 812 int ocfs2_get_request_ptr(struct ocfs2_info *info, int idx,
811 u64 *req_addr, int compat_flag) 813 u64 *req_addr, int compat_flag)
812 { 814 {
813 int status = -EFAULT; 815 int status = -EFAULT;
814 u64 __user *bp = NULL; 816 u64 __user *bp = NULL;
815 817
816 if (compat_flag) { 818 if (compat_flag) {
817 #ifdef CONFIG_COMPAT 819 #ifdef CONFIG_COMPAT
818 /* 820 /*
819 * pointer bp stores the base address of a pointers array, 821 * pointer bp stores the base address of a pointers array,
820 * which collects all addresses of separate request. 822 * which collects all addresses of separate request.
821 */ 823 */
822 bp = (u64 __user *)(unsigned long)compat_ptr(info->oi_requests); 824 bp = (u64 __user *)(unsigned long)compat_ptr(info->oi_requests);
823 #else 825 #else
824 BUG(); 826 BUG();
825 #endif 827 #endif
826 } else 828 } else
827 bp = (u64 __user *)(unsigned long)(info->oi_requests); 829 bp = (u64 __user *)(unsigned long)(info->oi_requests);
828 830
829 if (o2info_from_user(*req_addr, bp + idx)) 831 if (o2info_from_user(*req_addr, bp + idx))
830 goto bail; 832 goto bail;
831 833
832 status = 0; 834 status = 0;
833 bail: 835 bail:
834 return status; 836 return status;
835 } 837 }
836 838
837 /* 839 /*
838 * OCFS2_IOC_INFO handles an array of requests passed from userspace. 840 * OCFS2_IOC_INFO handles an array of requests passed from userspace.
839 * 841 *
840 * ocfs2_info_handle() recevies a large info aggregation, grab and 842 * ocfs2_info_handle() recevies a large info aggregation, grab and
841 * validate the request count from header, then break it into small 843 * validate the request count from header, then break it into small
842 * pieces, later specific handlers can handle them one by one. 844 * pieces, later specific handlers can handle them one by one.
843 * 845 *
844 * Idea here is to make each separate request small enough to ensure 846 * Idea here is to make each separate request small enough to ensure
845 * a better backward&forward compatibility, since a small piece of 847 * a better backward&forward compatibility, since a small piece of
846 * request will be less likely to be broken if disk layout get changed. 848 * request will be less likely to be broken if disk layout get changed.
847 */ 849 */
848 int ocfs2_info_handle(struct inode *inode, struct ocfs2_info *info, 850 int ocfs2_info_handle(struct inode *inode, struct ocfs2_info *info,
849 int compat_flag) 851 int compat_flag)
850 { 852 {
851 int i, status = 0; 853 int i, status = 0;
852 u64 req_addr; 854 u64 req_addr;
853 struct ocfs2_info_request __user *reqp; 855 struct ocfs2_info_request __user *reqp;
854 856
855 if ((info->oi_count > OCFS2_INFO_MAX_REQUEST) || 857 if ((info->oi_count > OCFS2_INFO_MAX_REQUEST) ||
856 (!info->oi_requests)) { 858 (!info->oi_requests)) {
857 status = -EINVAL; 859 status = -EINVAL;
858 goto bail; 860 goto bail;
859 } 861 }
860 862
861 for (i = 0; i < info->oi_count; i++) { 863 for (i = 0; i < info->oi_count; i++) {
862 864
863 status = ocfs2_get_request_ptr(info, i, &req_addr, compat_flag); 865 status = ocfs2_get_request_ptr(info, i, &req_addr, compat_flag);
864 if (status) 866 if (status)
865 break; 867 break;
866 868
867 reqp = (struct ocfs2_info_request __user *)(unsigned long)req_addr; 869 reqp = (struct ocfs2_info_request __user *)(unsigned long)req_addr;
868 if (!reqp) { 870 if (!reqp) {
869 status = -EINVAL; 871 status = -EINVAL;
870 goto bail; 872 goto bail;
871 } 873 }
872 874
873 status = ocfs2_info_handle_request(inode, reqp); 875 status = ocfs2_info_handle_request(inode, reqp);
874 if (status) 876 if (status)
875 break; 877 break;
876 } 878 }
877 879
878 bail: 880 bail:
879 return status; 881 return status;
880 } 882 }
881 883
882 long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 884 long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
883 { 885 {
884 struct inode *inode = file_inode(filp); 886 struct inode *inode = file_inode(filp);
885 unsigned int flags; 887 unsigned int flags;
886 int new_clusters; 888 int new_clusters;
887 int status; 889 int status;
888 struct ocfs2_space_resv sr; 890 struct ocfs2_space_resv sr;
889 struct ocfs2_new_group_input input; 891 struct ocfs2_new_group_input input;
890 struct reflink_arguments args; 892 struct reflink_arguments args;
891 const char __user *old_path; 893 const char __user *old_path;
892 const char __user *new_path; 894 const char __user *new_path;
893 bool preserve; 895 bool preserve;
894 struct ocfs2_info info; 896 struct ocfs2_info info;
895 void __user *argp = (void __user *)arg; 897 void __user *argp = (void __user *)arg;
896 898
897 switch (cmd) { 899 switch (cmd) {
898 case OCFS2_IOC_GETFLAGS: 900 case OCFS2_IOC_GETFLAGS:
899 status = ocfs2_get_inode_attr(inode, &flags); 901 status = ocfs2_get_inode_attr(inode, &flags);
900 if (status < 0) 902 if (status < 0)
901 return status; 903 return status;
902 904
903 flags &= OCFS2_FL_VISIBLE; 905 flags &= OCFS2_FL_VISIBLE;
904 return put_user(flags, (int __user *) arg); 906 return put_user(flags, (int __user *) arg);
905 case OCFS2_IOC_SETFLAGS: 907 case OCFS2_IOC_SETFLAGS:
906 if (get_user(flags, (int __user *) arg)) 908 if (get_user(flags, (int __user *) arg))
907 return -EFAULT; 909 return -EFAULT;
908 910
909 status = mnt_want_write_file(filp); 911 status = mnt_want_write_file(filp);
910 if (status) 912 if (status)
911 return status; 913 return status;
912 status = ocfs2_set_inode_attr(inode, flags, 914 status = ocfs2_set_inode_attr(inode, flags,
913 OCFS2_FL_MODIFIABLE); 915 OCFS2_FL_MODIFIABLE);
914 mnt_drop_write_file(filp); 916 mnt_drop_write_file(filp);
915 return status; 917 return status;
916 case OCFS2_IOC_RESVSP: 918 case OCFS2_IOC_RESVSP:
917 case OCFS2_IOC_RESVSP64: 919 case OCFS2_IOC_RESVSP64:
918 case OCFS2_IOC_UNRESVSP: 920 case OCFS2_IOC_UNRESVSP:
919 case OCFS2_IOC_UNRESVSP64: 921 case OCFS2_IOC_UNRESVSP64:
920 if (copy_from_user(&sr, (int __user *) arg, sizeof(sr))) 922 if (copy_from_user(&sr, (int __user *) arg, sizeof(sr)))
921 return -EFAULT; 923 return -EFAULT;
922 924
923 return ocfs2_change_file_space(filp, cmd, &sr); 925 return ocfs2_change_file_space(filp, cmd, &sr);
924 case OCFS2_IOC_GROUP_EXTEND: 926 case OCFS2_IOC_GROUP_EXTEND:
925 if (!capable(CAP_SYS_RESOURCE)) 927 if (!capable(CAP_SYS_RESOURCE))
926 return -EPERM; 928 return -EPERM;
927 929
928 if (get_user(new_clusters, (int __user *)arg)) 930 if (get_user(new_clusters, (int __user *)arg))
929 return -EFAULT; 931 return -EFAULT;
930 932
931 status = mnt_want_write_file(filp); 933 status = mnt_want_write_file(filp);
932 if (status) 934 if (status)
933 return status; 935 return status;
934 status = ocfs2_group_extend(inode, new_clusters); 936 status = ocfs2_group_extend(inode, new_clusters);
935 mnt_drop_write_file(filp); 937 mnt_drop_write_file(filp);
936 return status; 938 return status;
937 case OCFS2_IOC_GROUP_ADD: 939 case OCFS2_IOC_GROUP_ADD:
938 case OCFS2_IOC_GROUP_ADD64: 940 case OCFS2_IOC_GROUP_ADD64:
939 if (!capable(CAP_SYS_RESOURCE)) 941 if (!capable(CAP_SYS_RESOURCE))
940 return -EPERM; 942 return -EPERM;
941 943
942 if (copy_from_user(&input, (int __user *) arg, sizeof(input))) 944 if (copy_from_user(&input, (int __user *) arg, sizeof(input)))
943 return -EFAULT; 945 return -EFAULT;
944 946
945 status = mnt_want_write_file(filp); 947 status = mnt_want_write_file(filp);
946 if (status) 948 if (status)
947 return status; 949 return status;
948 status = ocfs2_group_add(inode, &input); 950 status = ocfs2_group_add(inode, &input);
949 mnt_drop_write_file(filp); 951 mnt_drop_write_file(filp);
950 return status; 952 return status;
951 case OCFS2_IOC_REFLINK: 953 case OCFS2_IOC_REFLINK:
952 if (copy_from_user(&args, argp, sizeof(args))) 954 if (copy_from_user(&args, argp, sizeof(args)))
953 return -EFAULT; 955 return -EFAULT;
954 old_path = (const char __user *)(unsigned long)args.old_path; 956 old_path = (const char __user *)(unsigned long)args.old_path;
955 new_path = (const char __user *)(unsigned long)args.new_path; 957 new_path = (const char __user *)(unsigned long)args.new_path;
956 preserve = (args.preserve != 0); 958 preserve = (args.preserve != 0);
957 959
958 return ocfs2_reflink_ioctl(inode, old_path, new_path, preserve); 960 return ocfs2_reflink_ioctl(inode, old_path, new_path, preserve);
959 case OCFS2_IOC_INFO: 961 case OCFS2_IOC_INFO:
960 if (copy_from_user(&info, argp, sizeof(struct ocfs2_info))) 962 if (copy_from_user(&info, argp, sizeof(struct ocfs2_info)))
961 return -EFAULT; 963 return -EFAULT;
962 964
963 return ocfs2_info_handle(inode, &info, 0); 965 return ocfs2_info_handle(inode, &info, 0);
964 case FITRIM: 966 case FITRIM:
965 { 967 {
966 struct super_block *sb = inode->i_sb; 968 struct super_block *sb = inode->i_sb;
967 struct fstrim_range range; 969 struct fstrim_range range;
968 int ret = 0; 970 int ret = 0;
969 971
970 if (!capable(CAP_SYS_ADMIN)) 972 if (!capable(CAP_SYS_ADMIN))
971 return -EPERM; 973 return -EPERM;
972 974
973 if (copy_from_user(&range, argp, sizeof(range))) 975 if (copy_from_user(&range, argp, sizeof(range)))
974 return -EFAULT; 976 return -EFAULT;
975 977
976 ret = ocfs2_trim_fs(sb, &range); 978 ret = ocfs2_trim_fs(sb, &range);
977 if (ret < 0) 979 if (ret < 0)
978 return ret; 980 return ret;
979 981
980 if (copy_to_user(argp, &range, sizeof(range))) 982 if (copy_to_user(argp, &range, sizeof(range)))
981 return -EFAULT; 983 return -EFAULT;
982 984
983 return 0; 985 return 0;
984 } 986 }
985 case OCFS2_IOC_MOVE_EXT: 987 case OCFS2_IOC_MOVE_EXT:
986 return ocfs2_ioctl_move_extents(filp, argp); 988 return ocfs2_ioctl_move_extents(filp, argp);
987 default: 989 default:
988 return -ENOTTY; 990 return -ENOTTY;
989 } 991 }
990 } 992 }
991 993
992 #ifdef CONFIG_COMPAT 994 #ifdef CONFIG_COMPAT
993 long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg) 995 long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
994 { 996 {
995 bool preserve; 997 bool preserve;
996 struct reflink_arguments args; 998 struct reflink_arguments args;
997 struct inode *inode = file_inode(file); 999 struct inode *inode = file_inode(file);
998 struct ocfs2_info info; 1000 struct ocfs2_info info;
999 void __user *argp = (void __user *)arg; 1001 void __user *argp = (void __user *)arg;
1000 1002
1001 switch (cmd) { 1003 switch (cmd) {
1002 case OCFS2_IOC32_GETFLAGS: 1004 case OCFS2_IOC32_GETFLAGS:
1003 cmd = OCFS2_IOC_GETFLAGS; 1005 cmd = OCFS2_IOC_GETFLAGS;
1004 break; 1006 break;
1005 case OCFS2_IOC32_SETFLAGS: 1007 case OCFS2_IOC32_SETFLAGS:
1006 cmd = OCFS2_IOC_SETFLAGS; 1008 cmd = OCFS2_IOC_SETFLAGS;
1007 break; 1009 break;
1008 case OCFS2_IOC_RESVSP: 1010 case OCFS2_IOC_RESVSP:
1009 case OCFS2_IOC_RESVSP64: 1011 case OCFS2_IOC_RESVSP64:
1010 case OCFS2_IOC_UNRESVSP: 1012 case OCFS2_IOC_UNRESVSP:
1011 case OCFS2_IOC_UNRESVSP64: 1013 case OCFS2_IOC_UNRESVSP64:
1012 case OCFS2_IOC_GROUP_EXTEND: 1014 case OCFS2_IOC_GROUP_EXTEND:
1013 case OCFS2_IOC_GROUP_ADD: 1015 case OCFS2_IOC_GROUP_ADD:
1014 case OCFS2_IOC_GROUP_ADD64: 1016 case OCFS2_IOC_GROUP_ADD64:
1015 case FITRIM: 1017 case FITRIM:
1016 break; 1018 break;
1017 case OCFS2_IOC_REFLINK: 1019 case OCFS2_IOC_REFLINK:
1018 if (copy_from_user(&args, argp, sizeof(args))) 1020 if (copy_from_user(&args, argp, sizeof(args)))
1019 return -EFAULT; 1021 return -EFAULT;
1020 preserve = (args.preserve != 0); 1022 preserve = (args.preserve != 0);
1021 1023
1022 return ocfs2_reflink_ioctl(inode, compat_ptr(args.old_path), 1024 return ocfs2_reflink_ioctl(inode, compat_ptr(args.old_path),
1023 compat_ptr(args.new_path), preserve); 1025 compat_ptr(args.new_path), preserve);
1024 case OCFS2_IOC_INFO: 1026 case OCFS2_IOC_INFO:
1025 if (copy_from_user(&info, argp, sizeof(struct ocfs2_info))) 1027 if (copy_from_user(&info, argp, sizeof(struct ocfs2_info)))
1026 return -EFAULT; 1028 return -EFAULT;
1027 1029
1028 return ocfs2_info_handle(inode, &info, 1); 1030 return ocfs2_info_handle(inode, &info, 1);
1029 case OCFS2_IOC_MOVE_EXT: 1031 case OCFS2_IOC_MOVE_EXT:
1030 break; 1032 break;
1031 default: 1033 default:
1032 return -ENOIOCTLCMD; 1034 return -ENOIOCTLCMD;
1033 } 1035 }
1034 1036
1035 return ocfs2_ioctl(file, cmd, arg); 1037 return ocfs2_ioctl(file, cmd, arg);
1036 } 1038 }
1037 #endif 1039 #endif
1038 1040