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