2 * linux/fs/ocfs2/ioctl.c
4 * Copyright (C) 2006 Herbert Poetzl
5 * adapted from Remy Card's ext2/ioctl.c
9 #include <linux/mount.h>
10 #include <linux/blkdev.h>
11 #include <linux/compat.h>
13 #include <cluster/masklog.h>
25 #include "refcounttree.h"
28 #include "buffer_head_io.h"
30 #include "move_extents.h"
32 #define o2info_from_user(a, b) \
33 copy_from_user(&(a), (b), sizeof(a))
34 #define o2info_to_user(a, b) \
35 copy_to_user((typeof(a) __user *)b, &(a), sizeof(a))
38 * This call is void because we are already reporting an error that may
39 * be -EFAULT. The error will be returned from the ioctl(2) call. It's
40 * just a best-effort to tell userspace that this request caused the error.
42 static inline void o2info_set_request_error(struct ocfs2_info_request
*kreq
,
43 struct ocfs2_info_request __user
*req
)
45 kreq
->ir_flags
|= OCFS2_INFO_FL_ERROR
;
46 (void)put_user(kreq
->ir_flags
, (__u32 __user
*)&(req
->ir_flags
));
49 static inline void o2info_set_request_filled(struct ocfs2_info_request
*req
)
51 req
->ir_flags
|= OCFS2_INFO_FL_FILLED
;
54 static inline void o2info_clear_request_filled(struct ocfs2_info_request
*req
)
56 req
->ir_flags
&= ~OCFS2_INFO_FL_FILLED
;
59 static inline int o2info_coherent(struct ocfs2_info_request
*req
)
61 return (!(req
->ir_flags
& OCFS2_INFO_FL_NON_COHERENT
));
64 static int ocfs2_get_inode_attr(struct inode
*inode
, unsigned *flags
)
68 status
= ocfs2_inode_lock(inode
, NULL
, 0);
73 ocfs2_get_inode_flags(OCFS2_I(inode
));
74 *flags
= OCFS2_I(inode
)->ip_attr
;
75 ocfs2_inode_unlock(inode
, 0);
80 static int ocfs2_set_inode_attr(struct inode
*inode
, unsigned flags
,
83 struct ocfs2_inode_info
*ocfs2_inode
= OCFS2_I(inode
);
84 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
85 handle_t
*handle
= NULL
;
86 struct buffer_head
*bh
= NULL
;
90 mutex_lock(&inode
->i_mutex
);
92 status
= ocfs2_inode_lock(inode
, &bh
, 1);
99 if (!inode_owner_or_capable(inode
))
102 if (!S_ISDIR(inode
->i_mode
))
103 flags
&= ~OCFS2_DIRSYNC_FL
;
105 oldflags
= ocfs2_inode
->ip_attr
;
106 flags
= flags
& mask
;
107 flags
|= oldflags
& ~mask
;
110 * The IMMUTABLE and APPEND_ONLY flags can only be changed by
111 * the relevant capability.
114 if ((oldflags
& OCFS2_IMMUTABLE_FL
) || ((flags
^ oldflags
) &
115 (OCFS2_APPEND_FL
| OCFS2_IMMUTABLE_FL
))) {
116 if (!capable(CAP_LINUX_IMMUTABLE
))
120 handle
= ocfs2_start_trans(osb
, OCFS2_INODE_UPDATE_CREDITS
);
121 if (IS_ERR(handle
)) {
122 status
= PTR_ERR(handle
);
127 ocfs2_inode
->ip_attr
= flags
;
128 ocfs2_set_inode_flags(inode
);
130 status
= ocfs2_mark_inode_dirty(handle
, inode
, bh
);
134 ocfs2_commit_trans(osb
, handle
);
137 ocfs2_inode_unlock(inode
, 1);
139 mutex_unlock(&inode
->i_mutex
);
146 int ocfs2_info_handle_blocksize(struct inode
*inode
,
147 struct ocfs2_info_request __user
*req
)
149 int status
= -EFAULT
;
150 struct ocfs2_info_blocksize oib
;
152 if (o2info_from_user(oib
, req
))
155 oib
.ib_blocksize
= inode
->i_sb
->s_blocksize
;
157 o2info_set_request_filled(&oib
.ib_req
);
159 if (o2info_to_user(oib
, req
))
165 o2info_set_request_error(&oib
.ib_req
, req
);
170 int ocfs2_info_handle_clustersize(struct inode
*inode
,
171 struct ocfs2_info_request __user
*req
)
173 int status
= -EFAULT
;
174 struct ocfs2_info_clustersize oic
;
175 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
177 if (o2info_from_user(oic
, req
))
180 oic
.ic_clustersize
= osb
->s_clustersize
;
182 o2info_set_request_filled(&oic
.ic_req
);
184 if (o2info_to_user(oic
, req
))
190 o2info_set_request_error(&oic
.ic_req
, req
);
195 int ocfs2_info_handle_maxslots(struct inode
*inode
,
196 struct ocfs2_info_request __user
*req
)
198 int status
= -EFAULT
;
199 struct ocfs2_info_maxslots oim
;
200 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
202 if (o2info_from_user(oim
, req
))
205 oim
.im_max_slots
= osb
->max_slots
;
207 o2info_set_request_filled(&oim
.im_req
);
209 if (o2info_to_user(oim
, req
))
215 o2info_set_request_error(&oim
.im_req
, req
);
220 int ocfs2_info_handle_label(struct inode
*inode
,
221 struct ocfs2_info_request __user
*req
)
223 int status
= -EFAULT
;
224 struct ocfs2_info_label oil
;
225 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
227 if (o2info_from_user(oil
, req
))
230 memcpy(oil
.il_label
, osb
->vol_label
, OCFS2_MAX_VOL_LABEL_LEN
);
232 o2info_set_request_filled(&oil
.il_req
);
234 if (o2info_to_user(oil
, req
))
240 o2info_set_request_error(&oil
.il_req
, req
);
245 int ocfs2_info_handle_uuid(struct inode
*inode
,
246 struct ocfs2_info_request __user
*req
)
248 int status
= -EFAULT
;
249 struct ocfs2_info_uuid oiu
;
250 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
252 if (o2info_from_user(oiu
, req
))
255 memcpy(oiu
.iu_uuid_str
, osb
->uuid_str
, OCFS2_TEXT_UUID_LEN
+ 1);
257 o2info_set_request_filled(&oiu
.iu_req
);
259 if (o2info_to_user(oiu
, req
))
265 o2info_set_request_error(&oiu
.iu_req
, req
);
270 int ocfs2_info_handle_fs_features(struct inode
*inode
,
271 struct ocfs2_info_request __user
*req
)
273 int status
= -EFAULT
;
274 struct ocfs2_info_fs_features oif
;
275 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
277 if (o2info_from_user(oif
, req
))
280 oif
.if_compat_features
= osb
->s_feature_compat
;
281 oif
.if_incompat_features
= osb
->s_feature_incompat
;
282 oif
.if_ro_compat_features
= osb
->s_feature_ro_compat
;
284 o2info_set_request_filled(&oif
.if_req
);
286 if (o2info_to_user(oif
, req
))
292 o2info_set_request_error(&oif
.if_req
, req
);
297 int ocfs2_info_handle_journal_size(struct inode
*inode
,
298 struct ocfs2_info_request __user
*req
)
300 int status
= -EFAULT
;
301 struct ocfs2_info_journal_size oij
;
302 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
304 if (o2info_from_user(oij
, req
))
307 oij
.ij_journal_size
= i_size_read(osb
->journal
->j_inode
);
309 o2info_set_request_filled(&oij
.ij_req
);
311 if (o2info_to_user(oij
, req
))
317 o2info_set_request_error(&oij
.ij_req
, req
);
322 int ocfs2_info_scan_inode_alloc(struct ocfs2_super
*osb
,
323 struct inode
*inode_alloc
, u64 blkno
,
324 struct ocfs2_info_freeinode
*fi
, u32 slot
)
326 int status
= 0, unlock
= 0;
328 struct buffer_head
*bh
= NULL
;
329 struct ocfs2_dinode
*dinode_alloc
= NULL
;
332 mutex_lock(&inode_alloc
->i_mutex
);
334 if (o2info_coherent(&fi
->ifi_req
)) {
335 status
= ocfs2_inode_lock(inode_alloc
, &bh
, 0);
342 status
= ocfs2_read_blocks_sync(osb
, blkno
, 1, &bh
);
349 dinode_alloc
= (struct ocfs2_dinode
*)bh
->b_data
;
351 fi
->ifi_stat
[slot
].lfi_total
=
352 le32_to_cpu(dinode_alloc
->id1
.bitmap1
.i_total
);
353 fi
->ifi_stat
[slot
].lfi_free
=
354 le32_to_cpu(dinode_alloc
->id1
.bitmap1
.i_total
) -
355 le32_to_cpu(dinode_alloc
->id1
.bitmap1
.i_used
);
359 ocfs2_inode_unlock(inode_alloc
, 0);
362 mutex_unlock(&inode_alloc
->i_mutex
);
369 int ocfs2_info_handle_freeinode(struct inode
*inode
,
370 struct ocfs2_info_request __user
*req
)
375 int status
= -EFAULT
, type
= INODE_ALLOC_SYSTEM_INODE
;
376 struct ocfs2_info_freeinode
*oifi
= NULL
;
377 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
378 struct inode
*inode_alloc
= NULL
;
380 oifi
= kzalloc(sizeof(struct ocfs2_info_freeinode
), GFP_KERNEL
);
387 if (o2info_from_user(*oifi
, req
))
390 oifi
->ifi_slotnum
= osb
->max_slots
;
392 for (i
= 0; i
< oifi
->ifi_slotnum
; i
++) {
393 if (o2info_coherent(&oifi
->ifi_req
)) {
394 inode_alloc
= ocfs2_get_system_file_inode(osb
, type
, i
);
396 mlog(ML_ERROR
, "unable to get alloc inode in "
402 ocfs2_sprintf_system_inode_name(namebuf
,
405 status
= ocfs2_lookup_ino_from_name(osb
->sys_root_inode
,
415 status
= ocfs2_info_scan_inode_alloc(osb
, inode_alloc
, blkno
, oifi
, i
);
424 o2info_set_request_filled(&oifi
->ifi_req
);
426 if (o2info_to_user(*oifi
, req
))
432 o2info_set_request_error(&oifi
->ifi_req
, req
);
439 static void o2ffg_update_histogram(struct ocfs2_info_free_chunk_list
*hist
,
440 unsigned int chunksize
)
444 index
= __ilog2_u32(chunksize
);
445 if (index
>= OCFS2_INFO_MAX_HIST
)
446 index
= OCFS2_INFO_MAX_HIST
- 1;
448 hist
->fc_chunks
[index
]++;
449 hist
->fc_clusters
[index
] += chunksize
;
452 static void o2ffg_update_stats(struct ocfs2_info_freefrag_stats
*stats
,
453 unsigned int chunksize
)
455 if (chunksize
> stats
->ffs_max
)
456 stats
->ffs_max
= chunksize
;
458 if (chunksize
< stats
->ffs_min
)
459 stats
->ffs_min
= chunksize
;
461 stats
->ffs_avg
+= chunksize
;
462 stats
->ffs_free_chunks_real
++;
465 void ocfs2_info_update_ffg(struct ocfs2_info_freefrag
*ffg
,
466 unsigned int chunksize
)
468 o2ffg_update_histogram(&(ffg
->iff_ffs
.ffs_fc_hist
), chunksize
);
469 o2ffg_update_stats(&(ffg
->iff_ffs
), chunksize
);
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
,
479 int status
= 0, used
;
482 struct buffer_head
*bh
= NULL
;
483 struct ocfs2_group_desc
*bg
= NULL
;
485 unsigned int max_bits
, num_clusters
;
486 unsigned int offset
= 0, cluster
, chunk
;
487 unsigned int chunk_free
, last_chunksize
= 0;
489 if (!le32_to_cpu(rec
->c_free
))
494 blkno
= le64_to_cpu(rec
->c_blkno
);
496 blkno
= le64_to_cpu(bg
->bg_next_group
);
503 if (o2info_coherent(&ffg
->iff_req
))
504 status
= ocfs2_read_group_descriptor(gb_inode
,
508 status
= ocfs2_read_blocks_sync(osb
, blkno
, 1, &bh
);
511 mlog(ML_ERROR
, "Can't read the group descriptor # "
512 "%llu from device.", (unsigned long long)blkno
);
517 bg
= (struct ocfs2_group_desc
*)bh
->b_data
;
519 if (!le16_to_cpu(bg
->bg_free_bits_count
))
522 max_bits
= le16_to_cpu(bg
->bg_bits
);
525 for (chunk
= 0; chunk
< chunks_in_group
; chunk
++) {
527 * last chunk may be not an entire one.
529 if ((offset
+ ffg
->iff_chunksize
) > max_bits
)
530 num_clusters
= max_bits
- offset
;
532 num_clusters
= ffg
->iff_chunksize
;
535 for (cluster
= 0; cluster
< num_clusters
; cluster
++) {
536 used
= ocfs2_test_bit(offset
,
537 (unsigned long *)bg
->bg_bitmap
);
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.
548 if (used
&& last_chunksize
) {
549 ocfs2_info_update_ffg(ffg
,
557 if (chunk_free
== ffg
->iff_chunksize
)
558 ffg
->iff_ffs
.ffs_free_chunks
++;
562 * need to update the info for last free chunk.
565 ocfs2_info_update_ffg(ffg
, last_chunksize
);
567 } while (le64_to_cpu(bg
->bg_next_group
));
575 int ocfs2_info_freefrag_scan_bitmap(struct ocfs2_super
*osb
,
576 struct inode
*gb_inode
, u64 blkno
,
577 struct ocfs2_info_freefrag
*ffg
)
580 int status
= 0, unlock
= 0, i
;
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
;
588 mutex_lock(&gb_inode
->i_mutex
);
590 if (o2info_coherent(&ffg
->iff_req
)) {
591 status
= ocfs2_inode_lock(gb_inode
, &bh
, 0);
598 status
= ocfs2_read_blocks_sync(osb
, blkno
, 1, &bh
);
605 gb_dinode
= (struct ocfs2_dinode
*)bh
->b_data
;
606 cl
= &(gb_dinode
->id2
.i_chain
);
609 * Chunksize(in) clusters from userspace should be
610 * less than clusters in a group.
612 if (ffg
->iff_chunksize
> le16_to_cpu(cl
->cl_cpg
)) {
617 memset(&ffg
->iff_ffs
, 0, sizeof(struct ocfs2_info_freefrag_stats
));
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
);
625 chunks_in_group
= le16_to_cpu(cl
->cl_cpg
) / ffg
->iff_chunksize
+ 1;
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
,
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
);
642 ocfs2_inode_unlock(gb_inode
, 0);
645 mutex_unlock(&gb_inode
->i_mutex
);
655 int ocfs2_info_handle_freefrag(struct inode
*inode
,
656 struct ocfs2_info_request __user
*req
)
660 int status
= -EFAULT
, type
= GLOBAL_BITMAP_SYSTEM_INODE
;
662 struct ocfs2_info_freefrag
*oiff
;
663 struct ocfs2_super
*osb
= OCFS2_SB(inode
->i_sb
);
664 struct inode
*gb_inode
= NULL
;
666 oiff
= kzalloc(sizeof(struct ocfs2_info_freefrag
), GFP_KERNEL
);
673 if (o2info_from_user(*oiff
, req
))
676 * chunksize from userspace should be power of 2.
678 if ((oiff
->iff_chunksize
& (oiff
->iff_chunksize
- 1)) ||
679 (!oiff
->iff_chunksize
)) {
684 if (o2info_coherent(&oiff
->iff_req
)) {
685 gb_inode
= ocfs2_get_system_file_inode(osb
, type
,
688 mlog(ML_ERROR
, "unable to get global_bitmap inode\n");
693 ocfs2_sprintf_system_inode_name(namebuf
, sizeof(namebuf
), type
,
695 status
= ocfs2_lookup_ino_from_name(osb
->sys_root_inode
,
705 status
= ocfs2_info_freefrag_scan_bitmap(osb
, gb_inode
, blkno
, oiff
);
709 o2info_set_request_filled(&oiff
->iff_req
);
711 if (o2info_to_user(*oiff
, req
)) {
719 o2info_set_request_error(&oiff
->iff_req
, req
);
726 int ocfs2_info_handle_unknown(struct inode
*inode
,
727 struct ocfs2_info_request __user
*req
)
729 int status
= -EFAULT
;
730 struct ocfs2_info_request oir
;
732 if (o2info_from_user(oir
, req
))
735 o2info_clear_request_filled(&oir
);
737 if (o2info_to_user(oir
, req
))
743 o2info_set_request_error(&oir
, req
);
749 * Validate and distinguish OCFS2_IOC_INFO requests.
751 * - validate the magic number.
752 * - distinguish different requests.
753 * - validate size of different requests.
755 int ocfs2_info_handle_request(struct inode
*inode
,
756 struct ocfs2_info_request __user
*req
)
758 int status
= -EFAULT
;
759 struct ocfs2_info_request oir
;
761 if (o2info_from_user(oir
, req
))
765 if (oir
.ir_magic
!= OCFS2_INFO_MAGIC
)
768 switch (oir
.ir_code
) {
769 case OCFS2_INFO_BLOCKSIZE
:
770 if (oir
.ir_size
== sizeof(struct ocfs2_info_blocksize
))
771 status
= ocfs2_info_handle_blocksize(inode
, req
);
773 case OCFS2_INFO_CLUSTERSIZE
:
774 if (oir
.ir_size
== sizeof(struct ocfs2_info_clustersize
))
775 status
= ocfs2_info_handle_clustersize(inode
, req
);
777 case OCFS2_INFO_MAXSLOTS
:
778 if (oir
.ir_size
== sizeof(struct ocfs2_info_maxslots
))
779 status
= ocfs2_info_handle_maxslots(inode
, req
);
781 case OCFS2_INFO_LABEL
:
782 if (oir
.ir_size
== sizeof(struct ocfs2_info_label
))
783 status
= ocfs2_info_handle_label(inode
, req
);
785 case OCFS2_INFO_UUID
:
786 if (oir
.ir_size
== sizeof(struct ocfs2_info_uuid
))
787 status
= ocfs2_info_handle_uuid(inode
, req
);
789 case OCFS2_INFO_FS_FEATURES
:
790 if (oir
.ir_size
== sizeof(struct ocfs2_info_fs_features
))
791 status
= ocfs2_info_handle_fs_features(inode
, req
);
793 case OCFS2_INFO_JOURNAL_SIZE
:
794 if (oir
.ir_size
== sizeof(struct ocfs2_info_journal_size
))
795 status
= ocfs2_info_handle_journal_size(inode
, req
);
797 case OCFS2_INFO_FREEINODE
:
798 if (oir
.ir_size
== sizeof(struct ocfs2_info_freeinode
))
799 status
= ocfs2_info_handle_freeinode(inode
, req
);
801 case OCFS2_INFO_FREEFRAG
:
802 if (oir
.ir_size
== sizeof(struct ocfs2_info_freefrag
))
803 status
= ocfs2_info_handle_freefrag(inode
, req
);
806 status
= ocfs2_info_handle_unknown(inode
, req
);
814 int ocfs2_get_request_ptr(struct ocfs2_info
*info
, int idx
,
815 u64
*req_addr
, int compat_flag
)
817 int status
= -EFAULT
;
818 u64 __user
*bp
= NULL
;
823 * pointer bp stores the base address of a pointers array,
824 * which collects all addresses of separate request.
826 bp
= (u64 __user
*)(unsigned long)compat_ptr(info
->oi_requests
);
831 bp
= (u64 __user
*)(unsigned long)(info
->oi_requests
);
833 if (o2info_from_user(*req_addr
, bp
+ idx
))
842 * OCFS2_IOC_INFO handles an array of requests passed from userspace.
844 * ocfs2_info_handle() recevies a large info aggregation, grab and
845 * validate the request count from header, then break it into small
846 * pieces, later specific handlers can handle them one by one.
848 * Idea here is to make each separate request small enough to ensure
849 * a better backward&forward compatibility, since a small piece of
850 * request will be less likely to be broken if disk layout get changed.
852 int ocfs2_info_handle(struct inode
*inode
, struct ocfs2_info
*info
,
857 struct ocfs2_info_request __user
*reqp
;
859 if ((info
->oi_count
> OCFS2_INFO_MAX_REQUEST
) ||
860 (!info
->oi_requests
)) {
865 for (i
= 0; i
< info
->oi_count
; i
++) {
867 status
= ocfs2_get_request_ptr(info
, i
, &req_addr
, compat_flag
);
871 reqp
= (struct ocfs2_info_request __user
*)(unsigned long)req_addr
;
877 status
= ocfs2_info_handle_request(inode
, reqp
);
886 long ocfs2_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
888 struct inode
*inode
= file_inode(filp
);
892 struct ocfs2_space_resv sr
;
893 struct ocfs2_new_group_input input
;
894 struct reflink_arguments args
;
895 const char __user
*old_path
;
896 const char __user
*new_path
;
898 struct ocfs2_info info
;
899 void __user
*argp
= (void __user
*)arg
;
902 case OCFS2_IOC_GETFLAGS
:
903 status
= ocfs2_get_inode_attr(inode
, &flags
);
907 flags
&= OCFS2_FL_VISIBLE
;
908 return put_user(flags
, (int __user
*) arg
);
909 case OCFS2_IOC_SETFLAGS
:
910 if (get_user(flags
, (int __user
*) arg
))
913 status
= mnt_want_write_file(filp
);
916 status
= ocfs2_set_inode_attr(inode
, flags
,
917 OCFS2_FL_MODIFIABLE
);
918 mnt_drop_write_file(filp
);
920 case OCFS2_IOC_RESVSP
:
921 case OCFS2_IOC_RESVSP64
:
922 case OCFS2_IOC_UNRESVSP
:
923 case OCFS2_IOC_UNRESVSP64
:
924 if (copy_from_user(&sr
, (int __user
*) arg
, sizeof(sr
)))
927 return ocfs2_change_file_space(filp
, cmd
, &sr
);
928 case OCFS2_IOC_GROUP_EXTEND
:
929 if (!capable(CAP_SYS_RESOURCE
))
932 if (get_user(new_clusters
, (int __user
*)arg
))
935 status
= mnt_want_write_file(filp
);
938 status
= ocfs2_group_extend(inode
, new_clusters
);
939 mnt_drop_write_file(filp
);
941 case OCFS2_IOC_GROUP_ADD
:
942 case OCFS2_IOC_GROUP_ADD64
:
943 if (!capable(CAP_SYS_RESOURCE
))
946 if (copy_from_user(&input
, (int __user
*) arg
, sizeof(input
)))
949 status
= mnt_want_write_file(filp
);
952 status
= ocfs2_group_add(inode
, &input
);
953 mnt_drop_write_file(filp
);
955 case OCFS2_IOC_REFLINK
:
956 if (copy_from_user(&args
, argp
, sizeof(args
)))
958 old_path
= (const char __user
*)(unsigned long)args
.old_path
;
959 new_path
= (const char __user
*)(unsigned long)args
.new_path
;
960 preserve
= (args
.preserve
!= 0);
962 return ocfs2_reflink_ioctl(inode
, old_path
, new_path
, preserve
);
964 if (copy_from_user(&info
, argp
, sizeof(struct ocfs2_info
)))
967 return ocfs2_info_handle(inode
, &info
, 0);
970 struct super_block
*sb
= inode
->i_sb
;
971 struct request_queue
*q
= bdev_get_queue(sb
->s_bdev
);
972 struct fstrim_range range
;
975 if (!capable(CAP_SYS_ADMIN
))
978 if (!blk_queue_discard(q
))
981 if (copy_from_user(&range
, argp
, sizeof(range
)))
984 range
.minlen
= max_t(u64
, q
->limits
.discard_granularity
,
986 ret
= ocfs2_trim_fs(sb
, &range
);
990 if (copy_to_user(argp
, &range
, sizeof(range
)))
995 case OCFS2_IOC_MOVE_EXT
:
996 return ocfs2_ioctl_move_extents(filp
, argp
);
1002 #ifdef CONFIG_COMPAT
1003 long ocfs2_compat_ioctl(struct file
*file
, unsigned cmd
, unsigned long arg
)
1006 struct reflink_arguments args
;
1007 struct inode
*inode
= file_inode(file
);
1008 struct ocfs2_info info
;
1009 void __user
*argp
= (void __user
*)arg
;
1012 case OCFS2_IOC32_GETFLAGS
:
1013 cmd
= OCFS2_IOC_GETFLAGS
;
1015 case OCFS2_IOC32_SETFLAGS
:
1016 cmd
= OCFS2_IOC_SETFLAGS
;
1018 case OCFS2_IOC_RESVSP
:
1019 case OCFS2_IOC_RESVSP64
:
1020 case OCFS2_IOC_UNRESVSP
:
1021 case OCFS2_IOC_UNRESVSP64
:
1022 case OCFS2_IOC_GROUP_EXTEND
:
1023 case OCFS2_IOC_GROUP_ADD
:
1024 case OCFS2_IOC_GROUP_ADD64
:
1027 case OCFS2_IOC_REFLINK
:
1028 if (copy_from_user(&args
, argp
, sizeof(args
)))
1030 preserve
= (args
.preserve
!= 0);
1032 return ocfs2_reflink_ioctl(inode
, compat_ptr(args
.old_path
),
1033 compat_ptr(args
.new_path
), preserve
);
1034 case OCFS2_IOC_INFO
:
1035 if (copy_from_user(&info
, argp
, sizeof(struct ocfs2_info
)))
1038 return ocfs2_info_handle(inode
, &info
, 1);
1039 case OCFS2_IOC_MOVE_EXT
:
1042 return -ENOIOCTLCMD
;
1045 return ocfs2_ioctl(file
, cmd
, arg
);