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