ioctl.c

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