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