Commit | Line | Data |
---|---|---|
ca4d147e HP |
1 | /* |
2 | * linux/fs/ocfs2/ioctl.c | |
3 | * | |
4 | * Copyright (C) 2006 Herbert Poetzl | |
5 | * adapted from Remy Card's ext2/ioctl.c | |
6 | */ | |
7 | ||
8 | #include <linux/fs.h> | |
9 | #include <linux/mount.h> | |
34e6c59a | 10 | #include <linux/compat.h> |
ca4d147e HP |
11 | |
12 | #define MLOG_MASK_PREFIX ML_INODE | |
13 | #include <cluster/masklog.h> | |
14 | ||
15 | #include "ocfs2.h" | |
16 | #include "alloc.h" | |
17 | #include "dlmglue.h" | |
b2580103 | 18 | #include "file.h" |
ca4d147e HP |
19 | #include "inode.h" |
20 | #include "journal.h" | |
21 | ||
22 | #include "ocfs2_fs.h" | |
2d562518 | 23 | #include "ioctl.h" |
d659072f | 24 | #include "resize.h" |
bd50873d | 25 | #include "refcounttree.h" |
2d562518 | 26 | |
ca4d147e HP |
27 | #include <linux/ext2_fs.h> |
28 | ||
ddee5cdb TY |
29 | #define o2info_from_user(a, b) \ |
30 | copy_from_user(&(a), (b), sizeof(a)) | |
31 | #define o2info_to_user(a, b) \ | |
32 | copy_to_user((typeof(a) __user *)b, &(a), sizeof(a)) | |
33 | ||
34 | /* | |
35 | * This call is void because we are already reporting an error that may | |
36 | * be -EFAULT. The error will be returned from the ioctl(2) call. It's | |
37 | * just a best-effort to tell userspace that this request caused the error. | |
38 | */ | |
39 | static inline void __o2info_set_request_error(struct ocfs2_info_request *kreq, | |
40 | struct ocfs2_info_request __user *req) | |
41 | { | |
42 | kreq->ir_flags |= OCFS2_INFO_FL_ERROR; | |
43 | (void)put_user(kreq->ir_flags, (__u32 __user *)&(req->ir_flags)); | |
44 | } | |
45 | ||
46 | #define o2info_set_request_error(a, b) \ | |
47 | __o2info_set_request_error((struct ocfs2_info_request *)&(a), b) | |
48 | ||
ca4d147e HP |
49 | static int ocfs2_get_inode_attr(struct inode *inode, unsigned *flags) |
50 | { | |
51 | int status; | |
52 | ||
e63aecb6 | 53 | status = ocfs2_inode_lock(inode, NULL, 0); |
ca4d147e HP |
54 | if (status < 0) { |
55 | mlog_errno(status); | |
56 | return status; | |
57 | } | |
6e4b0d56 | 58 | ocfs2_get_inode_flags(OCFS2_I(inode)); |
ca4d147e | 59 | *flags = OCFS2_I(inode)->ip_attr; |
e63aecb6 | 60 | ocfs2_inode_unlock(inode, 0); |
ca4d147e HP |
61 | |
62 | mlog_exit(status); | |
63 | return status; | |
64 | } | |
65 | ||
66 | static int ocfs2_set_inode_attr(struct inode *inode, unsigned flags, | |
67 | unsigned mask) | |
68 | { | |
69 | struct ocfs2_inode_info *ocfs2_inode = OCFS2_I(inode); | |
70 | struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); | |
1fabe148 | 71 | handle_t *handle = NULL; |
ca4d147e HP |
72 | struct buffer_head *bh = NULL; |
73 | unsigned oldflags; | |
74 | int status; | |
75 | ||
76 | mutex_lock(&inode->i_mutex); | |
77 | ||
e63aecb6 | 78 | status = ocfs2_inode_lock(inode, &bh, 1); |
ca4d147e HP |
79 | if (status < 0) { |
80 | mlog_errno(status); | |
81 | goto bail; | |
82 | } | |
83 | ||
ca4d147e | 84 | status = -EACCES; |
2e149670 | 85 | if (!inode_owner_or_capable(inode)) |
ca4d147e HP |
86 | goto bail_unlock; |
87 | ||
88 | if (!S_ISDIR(inode->i_mode)) | |
89 | flags &= ~OCFS2_DIRSYNC_FL; | |
90 | ||
65eff9cc | 91 | handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS); |
ca4d147e HP |
92 | if (IS_ERR(handle)) { |
93 | status = PTR_ERR(handle); | |
94 | mlog_errno(status); | |
95 | goto bail_unlock; | |
96 | } | |
97 | ||
98 | oldflags = ocfs2_inode->ip_attr; | |
99 | flags = flags & mask; | |
100 | flags |= oldflags & ~mask; | |
101 | ||
102 | /* | |
103 | * The IMMUTABLE and APPEND_ONLY flags can only be changed by | |
104 | * the relevant capability. | |
105 | */ | |
106 | status = -EPERM; | |
107 | if ((oldflags & OCFS2_IMMUTABLE_FL) || ((flags ^ oldflags) & | |
108 | (OCFS2_APPEND_FL | OCFS2_IMMUTABLE_FL))) { | |
109 | if (!capable(CAP_LINUX_IMMUTABLE)) | |
110 | goto bail_unlock; | |
111 | } | |
112 | ||
113 | ocfs2_inode->ip_attr = flags; | |
114 | ocfs2_set_inode_flags(inode); | |
115 | ||
116 | status = ocfs2_mark_inode_dirty(handle, inode, bh); | |
117 | if (status < 0) | |
118 | mlog_errno(status); | |
119 | ||
02dc1af4 | 120 | ocfs2_commit_trans(osb, handle); |
ca4d147e | 121 | bail_unlock: |
e63aecb6 | 122 | ocfs2_inode_unlock(inode, 1); |
ca4d147e HP |
123 | bail: |
124 | mutex_unlock(&inode->i_mutex); | |
125 | ||
a81cb88b | 126 | brelse(bh); |
ca4d147e HP |
127 | |
128 | mlog_exit(status); | |
129 | return status; | |
130 | } | |
131 | ||
ddee5cdb TY |
132 | int ocfs2_info_handle_blocksize(struct inode *inode, |
133 | struct ocfs2_info_request __user *req) | |
134 | { | |
135 | int status = -EFAULT; | |
136 | struct ocfs2_info_blocksize oib; | |
137 | ||
138 | if (o2info_from_user(oib, req)) | |
139 | goto bail; | |
140 | ||
141 | oib.ib_blocksize = inode->i_sb->s_blocksize; | |
142 | oib.ib_req.ir_flags |= OCFS2_INFO_FL_FILLED; | |
143 | ||
144 | if (o2info_to_user(oib, req)) | |
145 | goto bail; | |
146 | ||
147 | status = 0; | |
148 | bail: | |
149 | if (status) | |
150 | o2info_set_request_error(oib, req); | |
151 | ||
152 | return status; | |
153 | } | |
154 | ||
155 | int ocfs2_info_handle_clustersize(struct inode *inode, | |
156 | struct ocfs2_info_request __user *req) | |
157 | { | |
158 | int status = -EFAULT; | |
159 | struct ocfs2_info_clustersize oic; | |
160 | struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); | |
161 | ||
162 | if (o2info_from_user(oic, req)) | |
163 | goto bail; | |
164 | ||
165 | oic.ic_clustersize = osb->s_clustersize; | |
166 | oic.ic_req.ir_flags |= OCFS2_INFO_FL_FILLED; | |
167 | ||
168 | if (o2info_to_user(oic, req)) | |
169 | goto bail; | |
170 | ||
171 | status = 0; | |
172 | bail: | |
173 | if (status) | |
174 | o2info_set_request_error(oic, req); | |
175 | ||
176 | return status; | |
177 | } | |
178 | ||
179 | int ocfs2_info_handle_maxslots(struct inode *inode, | |
180 | struct ocfs2_info_request __user *req) | |
181 | { | |
182 | int status = -EFAULT; | |
183 | struct ocfs2_info_maxslots oim; | |
184 | struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); | |
185 | ||
186 | if (o2info_from_user(oim, req)) | |
187 | goto bail; | |
188 | ||
189 | oim.im_max_slots = osb->max_slots; | |
190 | oim.im_req.ir_flags |= OCFS2_INFO_FL_FILLED; | |
191 | ||
192 | if (o2info_to_user(oim, req)) | |
193 | goto bail; | |
194 | ||
195 | status = 0; | |
196 | bail: | |
197 | if (status) | |
198 | o2info_set_request_error(oim, req); | |
199 | ||
200 | return status; | |
201 | } | |
202 | ||
203 | int ocfs2_info_handle_label(struct inode *inode, | |
204 | struct ocfs2_info_request __user *req) | |
205 | { | |
206 | int status = -EFAULT; | |
207 | struct ocfs2_info_label oil; | |
208 | struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); | |
209 | ||
210 | if (o2info_from_user(oil, req)) | |
211 | goto bail; | |
212 | ||
213 | memcpy(oil.il_label, osb->vol_label, OCFS2_MAX_VOL_LABEL_LEN); | |
214 | oil.il_req.ir_flags |= OCFS2_INFO_FL_FILLED; | |
215 | ||
216 | if (o2info_to_user(oil, req)) | |
217 | goto bail; | |
218 | ||
219 | status = 0; | |
220 | bail: | |
221 | if (status) | |
222 | o2info_set_request_error(oil, req); | |
223 | ||
224 | return status; | |
225 | } | |
226 | ||
227 | int ocfs2_info_handle_uuid(struct inode *inode, | |
228 | struct ocfs2_info_request __user *req) | |
229 | { | |
230 | int status = -EFAULT; | |
231 | struct ocfs2_info_uuid oiu; | |
232 | struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); | |
233 | ||
234 | if (o2info_from_user(oiu, req)) | |
235 | goto bail; | |
236 | ||
237 | memcpy(oiu.iu_uuid_str, osb->uuid_str, OCFS2_TEXT_UUID_LEN + 1); | |
238 | oiu.iu_req.ir_flags |= OCFS2_INFO_FL_FILLED; | |
239 | ||
240 | if (o2info_to_user(oiu, req)) | |
241 | goto bail; | |
242 | ||
243 | status = 0; | |
244 | bail: | |
245 | if (status) | |
246 | o2info_set_request_error(oiu, req); | |
247 | ||
248 | return status; | |
249 | } | |
250 | ||
251 | int ocfs2_info_handle_fs_features(struct inode *inode, | |
252 | struct ocfs2_info_request __user *req) | |
253 | { | |
254 | int status = -EFAULT; | |
255 | struct ocfs2_info_fs_features oif; | |
256 | struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); | |
257 | ||
258 | if (o2info_from_user(oif, req)) | |
259 | goto bail; | |
260 | ||
261 | oif.if_compat_features = osb->s_feature_compat; | |
262 | oif.if_incompat_features = osb->s_feature_incompat; | |
263 | oif.if_ro_compat_features = osb->s_feature_ro_compat; | |
264 | oif.if_req.ir_flags |= OCFS2_INFO_FL_FILLED; | |
265 | ||
266 | if (o2info_to_user(oif, req)) | |
267 | goto bail; | |
268 | ||
269 | status = 0; | |
270 | bail: | |
271 | if (status) | |
272 | o2info_set_request_error(oif, req); | |
273 | ||
274 | return status; | |
275 | } | |
276 | ||
277 | int ocfs2_info_handle_journal_size(struct inode *inode, | |
278 | struct ocfs2_info_request __user *req) | |
279 | { | |
280 | int status = -EFAULT; | |
281 | struct ocfs2_info_journal_size oij; | |
282 | struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); | |
283 | ||
284 | if (o2info_from_user(oij, req)) | |
285 | goto bail; | |
286 | ||
287 | oij.ij_journal_size = osb->journal->j_inode->i_size; | |
288 | ||
289 | oij.ij_req.ir_flags |= OCFS2_INFO_FL_FILLED; | |
290 | ||
291 | if (o2info_to_user(oij, req)) | |
292 | goto bail; | |
293 | ||
294 | status = 0; | |
295 | bail: | |
296 | if (status) | |
297 | o2info_set_request_error(oij, req); | |
298 | ||
299 | return status; | |
300 | } | |
301 | ||
302 | int ocfs2_info_handle_unknown(struct inode *inode, | |
303 | struct ocfs2_info_request __user *req) | |
304 | { | |
305 | int status = -EFAULT; | |
306 | struct ocfs2_info_request oir; | |
307 | ||
308 | if (o2info_from_user(oir, req)) | |
309 | goto bail; | |
310 | ||
311 | oir.ir_flags &= ~OCFS2_INFO_FL_FILLED; | |
312 | ||
313 | if (o2info_to_user(oir, req)) | |
314 | goto bail; | |
315 | ||
316 | status = 0; | |
317 | bail: | |
318 | if (status) | |
319 | o2info_set_request_error(oir, req); | |
320 | ||
321 | return status; | |
322 | } | |
323 | ||
324 | /* | |
325 | * Validate and distinguish OCFS2_IOC_INFO requests. | |
326 | * | |
327 | * - validate the magic number. | |
328 | * - distinguish different requests. | |
329 | * - validate size of different requests. | |
330 | */ | |
331 | int ocfs2_info_handle_request(struct inode *inode, | |
332 | struct ocfs2_info_request __user *req) | |
333 | { | |
334 | int status = -EFAULT; | |
335 | struct ocfs2_info_request oir; | |
336 | ||
337 | if (o2info_from_user(oir, req)) | |
338 | goto bail; | |
339 | ||
340 | status = -EINVAL; | |
341 | if (oir.ir_magic != OCFS2_INFO_MAGIC) | |
342 | goto bail; | |
343 | ||
344 | switch (oir.ir_code) { | |
345 | case OCFS2_INFO_BLOCKSIZE: | |
346 | if (oir.ir_size == sizeof(struct ocfs2_info_blocksize)) | |
347 | status = ocfs2_info_handle_blocksize(inode, req); | |
348 | break; | |
349 | case OCFS2_INFO_CLUSTERSIZE: | |
350 | if (oir.ir_size == sizeof(struct ocfs2_info_clustersize)) | |
351 | status = ocfs2_info_handle_clustersize(inode, req); | |
352 | break; | |
353 | case OCFS2_INFO_MAXSLOTS: | |
354 | if (oir.ir_size == sizeof(struct ocfs2_info_maxslots)) | |
355 | status = ocfs2_info_handle_maxslots(inode, req); | |
356 | break; | |
357 | case OCFS2_INFO_LABEL: | |
358 | if (oir.ir_size == sizeof(struct ocfs2_info_label)) | |
359 | status = ocfs2_info_handle_label(inode, req); | |
360 | break; | |
361 | case OCFS2_INFO_UUID: | |
362 | if (oir.ir_size == sizeof(struct ocfs2_info_uuid)) | |
363 | status = ocfs2_info_handle_uuid(inode, req); | |
364 | break; | |
365 | case OCFS2_INFO_FS_FEATURES: | |
366 | if (oir.ir_size == sizeof(struct ocfs2_info_fs_features)) | |
367 | status = ocfs2_info_handle_fs_features(inode, req); | |
368 | break; | |
369 | case OCFS2_INFO_JOURNAL_SIZE: | |
370 | if (oir.ir_size == sizeof(struct ocfs2_info_journal_size)) | |
371 | status = ocfs2_info_handle_journal_size(inode, req); | |
372 | break; | |
373 | default: | |
374 | status = ocfs2_info_handle_unknown(inode, req); | |
375 | break; | |
376 | } | |
377 | ||
378 | bail: | |
379 | return status; | |
380 | } | |
381 | ||
382 | int ocfs2_get_request_ptr(struct ocfs2_info *info, int idx, | |
383 | u64 *req_addr, int compat_flag) | |
384 | { | |
385 | int status = -EFAULT; | |
386 | u64 __user *bp = NULL; | |
387 | ||
388 | if (compat_flag) { | |
389 | #ifdef CONFIG_COMPAT | |
390 | /* | |
391 | * pointer bp stores the base address of a pointers array, | |
392 | * which collects all addresses of separate request. | |
393 | */ | |
394 | bp = (u64 __user *)(unsigned long)compat_ptr(info->oi_requests); | |
395 | #else | |
396 | BUG(); | |
397 | #endif | |
398 | } else | |
399 | bp = (u64 __user *)(unsigned long)(info->oi_requests); | |
400 | ||
401 | if (o2info_from_user(*req_addr, bp + idx)) | |
402 | goto bail; | |
403 | ||
404 | status = 0; | |
405 | bail: | |
406 | return status; | |
407 | } | |
408 | ||
409 | /* | |
410 | * OCFS2_IOC_INFO handles an array of requests passed from userspace. | |
411 | * | |
412 | * ocfs2_info_handle() recevies a large info aggregation, grab and | |
413 | * validate the request count from header, then break it into small | |
414 | * pieces, later specific handlers can handle them one by one. | |
415 | * | |
416 | * Idea here is to make each separate request small enough to ensure | |
417 | * a better backward&forward compatibility, since a small piece of | |
418 | * request will be less likely to be broken if disk layout get changed. | |
419 | */ | |
420 | int ocfs2_info_handle(struct inode *inode, struct ocfs2_info *info, | |
421 | int compat_flag) | |
422 | { | |
423 | int i, status = 0; | |
424 | u64 req_addr; | |
425 | struct ocfs2_info_request __user *reqp; | |
426 | ||
427 | if ((info->oi_count > OCFS2_INFO_MAX_REQUEST) || | |
428 | (!info->oi_requests)) { | |
429 | status = -EINVAL; | |
430 | goto bail; | |
431 | } | |
432 | ||
433 | for (i = 0; i < info->oi_count; i++) { | |
434 | ||
435 | status = ocfs2_get_request_ptr(info, i, &req_addr, compat_flag); | |
436 | if (status) | |
437 | break; | |
438 | ||
439 | reqp = (struct ocfs2_info_request *)(unsigned long)req_addr; | |
440 | if (!reqp) { | |
441 | status = -EINVAL; | |
442 | goto bail; | |
443 | } | |
444 | ||
445 | status = ocfs2_info_handle_request(inode, reqp); | |
446 | if (status) | |
447 | break; | |
448 | } | |
449 | ||
450 | bail: | |
451 | return status; | |
452 | } | |
453 | ||
c9ec1488 | 454 | long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) |
ca4d147e | 455 | { |
c9ec1488 | 456 | struct inode *inode = filp->f_path.dentry->d_inode; |
ca4d147e | 457 | unsigned int flags; |
d659072f | 458 | int new_clusters; |
ca4d147e | 459 | int status; |
b2580103 | 460 | struct ocfs2_space_resv sr; |
7909f2bf | 461 | struct ocfs2_new_group_input input; |
bd50873d TM |
462 | struct reflink_arguments args; |
463 | const char *old_path, *new_path; | |
464 | bool preserve; | |
ddee5cdb | 465 | struct ocfs2_info info; |
ca4d147e HP |
466 | |
467 | switch (cmd) { | |
468 | case OCFS2_IOC_GETFLAGS: | |
469 | status = ocfs2_get_inode_attr(inode, &flags); | |
470 | if (status < 0) | |
471 | return status; | |
472 | ||
473 | flags &= OCFS2_FL_VISIBLE; | |
474 | return put_user(flags, (int __user *) arg); | |
475 | case OCFS2_IOC_SETFLAGS: | |
476 | if (get_user(flags, (int __user *) arg)) | |
477 | return -EFAULT; | |
478 | ||
42a74f20 DH |
479 | status = mnt_want_write(filp->f_path.mnt); |
480 | if (status) | |
481 | return status; | |
482 | status = ocfs2_set_inode_attr(inode, flags, | |
ca4d147e | 483 | OCFS2_FL_MODIFIABLE); |
42a74f20 DH |
484 | mnt_drop_write(filp->f_path.mnt); |
485 | return status; | |
b2580103 MF |
486 | case OCFS2_IOC_RESVSP: |
487 | case OCFS2_IOC_RESVSP64: | |
488 | case OCFS2_IOC_UNRESVSP: | |
489 | case OCFS2_IOC_UNRESVSP64: | |
490 | if (copy_from_user(&sr, (int __user *) arg, sizeof(sr))) | |
491 | return -EFAULT; | |
492 | ||
493 | return ocfs2_change_file_space(filp, cmd, &sr); | |
d659072f | 494 | case OCFS2_IOC_GROUP_EXTEND: |
0957f007 MF |
495 | if (!capable(CAP_SYS_RESOURCE)) |
496 | return -EPERM; | |
497 | ||
d659072f TM |
498 | if (get_user(new_clusters, (int __user *)arg)) |
499 | return -EFAULT; | |
500 | ||
501 | return ocfs2_group_extend(inode, new_clusters); | |
7909f2bf TM |
502 | case OCFS2_IOC_GROUP_ADD: |
503 | case OCFS2_IOC_GROUP_ADD64: | |
0957f007 MF |
504 | if (!capable(CAP_SYS_RESOURCE)) |
505 | return -EPERM; | |
506 | ||
7909f2bf TM |
507 | if (copy_from_user(&input, (int __user *) arg, sizeof(input))) |
508 | return -EFAULT; | |
509 | ||
510 | return ocfs2_group_add(inode, &input); | |
bd50873d TM |
511 | case OCFS2_IOC_REFLINK: |
512 | if (copy_from_user(&args, (struct reflink_arguments *)arg, | |
513 | sizeof(args))) | |
514 | return -EFAULT; | |
515 | old_path = (const char *)(unsigned long)args.old_path; | |
516 | new_path = (const char *)(unsigned long)args.new_path; | |
517 | preserve = (args.preserve != 0); | |
518 | ||
519 | return ocfs2_reflink_ioctl(inode, old_path, new_path, preserve); | |
ddee5cdb TY |
520 | case OCFS2_IOC_INFO: |
521 | if (copy_from_user(&info, (struct ocfs2_info __user *)arg, | |
522 | sizeof(struct ocfs2_info))) | |
523 | return -EFAULT; | |
524 | ||
525 | return ocfs2_info_handle(inode, &info, 0); | |
ca4d147e HP |
526 | default: |
527 | return -ENOTTY; | |
528 | } | |
529 | } | |
530 | ||
586d232b MF |
531 | #ifdef CONFIG_COMPAT |
532 | long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg) | |
533 | { | |
34e6c59a TM |
534 | bool preserve; |
535 | struct reflink_arguments args; | |
536 | struct inode *inode = file->f_path.dentry->d_inode; | |
ddee5cdb | 537 | struct ocfs2_info info; |
34e6c59a | 538 | |
586d232b MF |
539 | switch (cmd) { |
540 | case OCFS2_IOC32_GETFLAGS: | |
541 | cmd = OCFS2_IOC_GETFLAGS; | |
542 | break; | |
543 | case OCFS2_IOC32_SETFLAGS: | |
544 | cmd = OCFS2_IOC_SETFLAGS; | |
545 | break; | |
b2580103 MF |
546 | case OCFS2_IOC_RESVSP: |
547 | case OCFS2_IOC_RESVSP64: | |
548 | case OCFS2_IOC_UNRESVSP: | |
549 | case OCFS2_IOC_UNRESVSP64: | |
d659072f | 550 | case OCFS2_IOC_GROUP_EXTEND: |
7909f2bf TM |
551 | case OCFS2_IOC_GROUP_ADD: |
552 | case OCFS2_IOC_GROUP_ADD64: | |
b2580103 | 553 | break; |
34e6c59a TM |
554 | case OCFS2_IOC_REFLINK: |
555 | if (copy_from_user(&args, (struct reflink_arguments *)arg, | |
556 | sizeof(args))) | |
557 | return -EFAULT; | |
558 | preserve = (args.preserve != 0); | |
559 | ||
560 | return ocfs2_reflink_ioctl(inode, compat_ptr(args.old_path), | |
561 | compat_ptr(args.new_path), preserve); | |
ddee5cdb TY |
562 | case OCFS2_IOC_INFO: |
563 | if (copy_from_user(&info, (struct ocfs2_info __user *)arg, | |
564 | sizeof(struct ocfs2_info))) | |
565 | return -EFAULT; | |
566 | ||
567 | return ocfs2_info_handle(inode, &info, 1); | |
586d232b MF |
568 | default: |
569 | return -ENOIOCTLCMD; | |
570 | } | |
571 | ||
c9ec1488 | 572 | return ocfs2_ioctl(file, cmd, arg); |
586d232b MF |
573 | } |
574 | #endif |