xref: /openbmc/linux/fs/fcntl.c (revision 545e4006) 
1 /*
2  *  linux/fs/fcntl.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  */
6 
7 #include <linux/syscalls.h>
8 #include <linux/init.h>
9 #include <linux/mm.h>
10 #include <linux/fs.h>
11 #include <linux/file.h>
12 #include <linux/fdtable.h>
13 #include <linux/capability.h>
14 #include <linux/dnotify.h>
15 #include <linux/slab.h>
16 #include <linux/module.h>
17 #include <linux/security.h>
18 #include <linux/ptrace.h>
19 #include <linux/signal.h>
20 #include <linux/rcupdate.h>
21 #include <linux/pid_namespace.h>
22 
23 #include <asm/poll.h>
24 #include <asm/siginfo.h>
25 #include <asm/uaccess.h>
26 
27 void set_close_on_exec(unsigned int fd, int flag)
28 {
29 	struct files_struct *files = current->files;
30 	struct fdtable *fdt;
31 	spin_lock(&files->file_lock);
32 	fdt = files_fdtable(files);
33 	if (flag)
34 		FD_SET(fd, fdt->close_on_exec);
35 	else
36 		FD_CLR(fd, fdt->close_on_exec);
37 	spin_unlock(&files->file_lock);
38 }
39 
40 static int get_close_on_exec(unsigned int fd)
41 {
42 	struct files_struct *files = current->files;
43 	struct fdtable *fdt;
44 	int res;
45 	rcu_read_lock();
46 	fdt = files_fdtable(files);
47 	res = FD_ISSET(fd, fdt->close_on_exec);
48 	rcu_read_unlock();
49 	return res;
50 }
51 
52 /*
53  * locate_fd finds a free file descriptor in the open_fds fdset,
54  * expanding the fd arrays if necessary.  Must be called with the
55  * file_lock held for write.
56  */
57 
58 static int locate_fd(unsigned int orig_start, int cloexec)
59 {
60 	struct files_struct *files = current->files;
61 	unsigned int newfd;
62 	unsigned int start;
63 	int error;
64 	struct fdtable *fdt;
65 
66 	spin_lock(&files->file_lock);
67 
68 	error = -EINVAL;
69 	if (orig_start >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
70 		goto out;
71 
72 repeat:
73 	fdt = files_fdtable(files);
74 	/*
75 	 * Someone might have closed fd's in the range
76 	 * orig_start..fdt->next_fd
77 	 */
78 	start = orig_start;
79 	if (start < files->next_fd)
80 		start = files->next_fd;
81 
82 	newfd = start;
83 	if (start < fdt->max_fds)
84 		newfd = find_next_zero_bit(fdt->open_fds->fds_bits,
85 					   fdt->max_fds, start);
86 
87 	error = -EMFILE;
88 	if (newfd >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
89 		goto out;
90 
91 	error = expand_files(files, newfd);
92 	if (error < 0)
93 		goto out;
94 
95 	/*
96 	 * If we needed to expand the fs array we
97 	 * might have blocked - try again.
98 	 */
99 	if (error)
100 		goto repeat;
101 
102 	if (start <= files->next_fd)
103 		files->next_fd = newfd + 1;
104 
105 	FD_SET(newfd, fdt->open_fds);
106 	if (cloexec)
107 		FD_SET(newfd, fdt->close_on_exec);
108 	else
109 		FD_CLR(newfd, fdt->close_on_exec);
110 	error = newfd;
111 
112 out:
113 	spin_unlock(&files->file_lock);
114 	return error;
115 }
116 
117 static int dupfd(struct file *file, unsigned int start, int cloexec)
118 {
119 	int fd = locate_fd(start, cloexec);
120 	if (fd >= 0)
121 		fd_install(fd, file);
122 	else
123 		fput(file);
124 
125 	return fd;
126 }
127 
128 asmlinkage long sys_dup3(unsigned int oldfd, unsigned int newfd, int flags)
129 {
130 	int err = -EBADF;
131 	struct file * file, *tofree;
132 	struct files_struct * files = current->files;
133 	struct fdtable *fdt;
134 
135 	if ((flags & ~O_CLOEXEC) != 0)
136 		return -EINVAL;
137 
138 	spin_lock(&files->file_lock);
139 	if (!(file = fcheck(oldfd)))
140 		goto out_unlock;
141 	err = newfd;
142 	if (newfd == oldfd)
143 		goto out_unlock;
144 	err = -EBADF;
145 	if (newfd >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
146 		goto out_unlock;
147 	get_file(file);			/* We are now finished with oldfd */
148 
149 	err = expand_files(files, newfd);
150 	if (err < 0)
151 		goto out_fput;
152 
153 	/* To avoid races with open() and dup(), we will mark the fd as
154 	 * in-use in the open-file bitmap throughout the entire dup2()
155 	 * process.  This is quite safe: do_close() uses the fd array
156 	 * entry, not the bitmap, to decide what work needs to be
157 	 * done.  --sct */
158 	/* Doesn't work. open() might be there first. --AV */
159 
160 	/* Yes. It's a race. In user space. Nothing sane to do */
161 	err = -EBUSY;
162 	fdt = files_fdtable(files);
163 	tofree = fdt->fd[newfd];
164 	if (!tofree && FD_ISSET(newfd, fdt->open_fds))
165 		goto out_fput;
166 
167 	rcu_assign_pointer(fdt->fd[newfd], file);
168 	FD_SET(newfd, fdt->open_fds);
169 	if (flags & O_CLOEXEC)
170 		FD_SET(newfd, fdt->close_on_exec);
171 	else
172 		FD_CLR(newfd, fdt->close_on_exec);
173 	spin_unlock(&files->file_lock);
174 
175 	if (tofree)
176 		filp_close(tofree, files);
177 	err = newfd;
178 out:
179 	return err;
180 out_unlock:
181 	spin_unlock(&files->file_lock);
182 	goto out;
183 
184 out_fput:
185 	spin_unlock(&files->file_lock);
186 	fput(file);
187 	goto out;
188 }
189 
190 asmlinkage long sys_dup2(unsigned int oldfd, unsigned int newfd)
191 {
192 	return sys_dup3(oldfd, newfd, 0);
193 }
194 
195 asmlinkage long sys_dup(unsigned int fildes)
196 {
197 	int ret = -EBADF;
198 	struct file * file = fget(fildes);
199 
200 	if (file)
201 		ret = dupfd(file, 0, 0);
202 	return ret;
203 }
204 
205 #define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | FASYNC | O_DIRECT | O_NOATIME)
206 
207 static int setfl(int fd, struct file * filp, unsigned long arg)
208 {
209 	struct inode * inode = filp->f_path.dentry->d_inode;
210 	int error = 0;
211 
212 	/*
213 	 * O_APPEND cannot be cleared if the file is marked as append-only
214 	 * and the file is open for write.
215 	 */
216 	if (((arg ^ filp->f_flags) & O_APPEND) && IS_APPEND(inode))
217 		return -EPERM;
218 
219 	/* O_NOATIME can only be set by the owner or superuser */
220 	if ((arg & O_NOATIME) && !(filp->f_flags & O_NOATIME))
221 		if (!is_owner_or_cap(inode))
222 			return -EPERM;
223 
224 	/* required for strict SunOS emulation */
225 	if (O_NONBLOCK != O_NDELAY)
226 	       if (arg & O_NDELAY)
227 		   arg |= O_NONBLOCK;
228 
229 	if (arg & O_DIRECT) {
230 		if (!filp->f_mapping || !filp->f_mapping->a_ops ||
231 			!filp->f_mapping->a_ops->direct_IO)
232 				return -EINVAL;
233 	}
234 
235 	if (filp->f_op && filp->f_op->check_flags)
236 		error = filp->f_op->check_flags(arg);
237 	if (error)
238 		return error;
239 
240 	if ((arg ^ filp->f_flags) & FASYNC) {
241 		if (filp->f_op && filp->f_op->fasync) {
242 			error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
243 			if (error < 0)
244 				goto out;
245 		}
246 	}
247 
248 	filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
249  out:
250 	return error;
251 }
252 
253 static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
254                      uid_t uid, uid_t euid, int force)
255 {
256 	write_lock_irq(&filp->f_owner.lock);
257 	if (force || !filp->f_owner.pid) {
258 		put_pid(filp->f_owner.pid);
259 		filp->f_owner.pid = get_pid(pid);
260 		filp->f_owner.pid_type = type;
261 		filp->f_owner.uid = uid;
262 		filp->f_owner.euid = euid;
263 	}
264 	write_unlock_irq(&filp->f_owner.lock);
265 }
266 
267 int __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
268 		int force)
269 {
270 	int err;
271 
272 	err = security_file_set_fowner(filp);
273 	if (err)
274 		return err;
275 
276 	f_modown(filp, pid, type, current->uid, current->euid, force);
277 	return 0;
278 }
279 EXPORT_SYMBOL(__f_setown);
280 
281 int f_setown(struct file *filp, unsigned long arg, int force)
282 {
283 	enum pid_type type;
284 	struct pid *pid;
285 	int who = arg;
286 	int result;
287 	type = PIDTYPE_PID;
288 	if (who < 0) {
289 		type = PIDTYPE_PGID;
290 		who = -who;
291 	}
292 	rcu_read_lock();
293 	pid = find_vpid(who);
294 	result = __f_setown(filp, pid, type, force);
295 	rcu_read_unlock();
296 	return result;
297 }
298 EXPORT_SYMBOL(f_setown);
299 
300 void f_delown(struct file *filp)
301 {
302 	f_modown(filp, NULL, PIDTYPE_PID, 0, 0, 1);
303 }
304 
305 pid_t f_getown(struct file *filp)
306 {
307 	pid_t pid;
308 	read_lock(&filp->f_owner.lock);
309 	pid = pid_vnr(filp->f_owner.pid);
310 	if (filp->f_owner.pid_type == PIDTYPE_PGID)
311 		pid = -pid;
312 	read_unlock(&filp->f_owner.lock);
313 	return pid;
314 }
315 
316 static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
317 		struct file *filp)
318 {
319 	long err = -EINVAL;
320 
321 	switch (cmd) {
322 	case F_DUPFD:
323 	case F_DUPFD_CLOEXEC:
324 		get_file(filp);
325 		err = dupfd(filp, arg, cmd == F_DUPFD_CLOEXEC);
326 		break;
327 	case F_GETFD:
328 		err = get_close_on_exec(fd) ? FD_CLOEXEC : 0;
329 		break;
330 	case F_SETFD:
331 		err = 0;
332 		set_close_on_exec(fd, arg & FD_CLOEXEC);
333 		break;
334 	case F_GETFL:
335 		err = filp->f_flags;
336 		break;
337 	case F_SETFL:
338 		err = setfl(fd, filp, arg);
339 		break;
340 	case F_GETLK:
341 		err = fcntl_getlk(filp, (struct flock __user *) arg);
342 		break;
343 	case F_SETLK:
344 	case F_SETLKW:
345 		err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg);
346 		break;
347 	case F_GETOWN:
348 		/*
349 		 * XXX If f_owner is a process group, the
350 		 * negative return value will get converted
351 		 * into an error.  Oops.  If we keep the
352 		 * current syscall conventions, the only way
353 		 * to fix this will be in libc.
354 		 */
355 		err = f_getown(filp);
356 		force_successful_syscall_return();
357 		break;
358 	case F_SETOWN:
359 		err = f_setown(filp, arg, 1);
360 		break;
361 	case F_GETSIG:
362 		err = filp->f_owner.signum;
363 		break;
364 	case F_SETSIG:
365 		/* arg == 0 restores default behaviour. */
366 		if (!valid_signal(arg)) {
367 			break;
368 		}
369 		err = 0;
370 		filp->f_owner.signum = arg;
371 		break;
372 	case F_GETLEASE:
373 		err = fcntl_getlease(filp);
374 		break;
375 	case F_SETLEASE:
376 		err = fcntl_setlease(fd, filp, arg);
377 		break;
378 	case F_NOTIFY:
379 		err = fcntl_dirnotify(fd, filp, arg);
380 		break;
381 	default:
382 		break;
383 	}
384 	return err;
385 }
386 
387 asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
388 {
389 	struct file *filp;
390 	long err = -EBADF;
391 
392 	filp = fget(fd);
393 	if (!filp)
394 		goto out;
395 
396 	err = security_file_fcntl(filp, cmd, arg);
397 	if (err) {
398 		fput(filp);
399 		return err;
400 	}
401 
402 	err = do_fcntl(fd, cmd, arg, filp);
403 
404  	fput(filp);
405 out:
406 	return err;
407 }
408 
409 #if BITS_PER_LONG == 32
410 asmlinkage long sys_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg)
411 {
412 	struct file * filp;
413 	long err;
414 
415 	err = -EBADF;
416 	filp = fget(fd);
417 	if (!filp)
418 		goto out;
419 
420 	err = security_file_fcntl(filp, cmd, arg);
421 	if (err) {
422 		fput(filp);
423 		return err;
424 	}
425 	err = -EBADF;
426 
427 	switch (cmd) {
428 		case F_GETLK64:
429 			err = fcntl_getlk64(filp, (struct flock64 __user *) arg);
430 			break;
431 		case F_SETLK64:
432 		case F_SETLKW64:
433 			err = fcntl_setlk64(fd, filp, cmd,
434 					(struct flock64 __user *) arg);
435 			break;
436 		default:
437 			err = do_fcntl(fd, cmd, arg, filp);
438 			break;
439 	}
440 	fput(filp);
441 out:
442 	return err;
443 }
444 #endif
445 
446 /* Table to convert sigio signal codes into poll band bitmaps */
447 
448 static const long band_table[NSIGPOLL] = {
449 	POLLIN | POLLRDNORM,			/* POLL_IN */
450 	POLLOUT | POLLWRNORM | POLLWRBAND,	/* POLL_OUT */
451 	POLLIN | POLLRDNORM | POLLMSG,		/* POLL_MSG */
452 	POLLERR,				/* POLL_ERR */
453 	POLLPRI | POLLRDBAND,			/* POLL_PRI */
454 	POLLHUP | POLLERR			/* POLL_HUP */
455 };
456 
457 static inline int sigio_perm(struct task_struct *p,
458                              struct fown_struct *fown, int sig)
459 {
460 	return (((fown->euid == 0) ||
461 		 (fown->euid == p->suid) || (fown->euid == p->uid) ||
462 		 (fown->uid == p->suid) || (fown->uid == p->uid)) &&
463 		!security_file_send_sigiotask(p, fown, sig));
464 }
465 
466 static void send_sigio_to_task(struct task_struct *p,
467 			       struct fown_struct *fown,
468 			       int fd,
469 			       int reason)
470 {
471 	if (!sigio_perm(p, fown, fown->signum))
472 		return;
473 
474 	switch (fown->signum) {
475 		siginfo_t si;
476 		default:
477 			/* Queue a rt signal with the appropriate fd as its
478 			   value.  We use SI_SIGIO as the source, not
479 			   SI_KERNEL, since kernel signals always get
480 			   delivered even if we can't queue.  Failure to
481 			   queue in this case _should_ be reported; we fall
482 			   back to SIGIO in that case. --sct */
483 			si.si_signo = fown->signum;
484 			si.si_errno = 0;
485 		        si.si_code  = reason;
486 			/* Make sure we are called with one of the POLL_*
487 			   reasons, otherwise we could leak kernel stack into
488 			   userspace.  */
489 			BUG_ON((reason & __SI_MASK) != __SI_POLL);
490 			if (reason - POLL_IN >= NSIGPOLL)
491 				si.si_band  = ~0L;
492 			else
493 				si.si_band = band_table[reason - POLL_IN];
494 			si.si_fd    = fd;
495 			if (!group_send_sig_info(fown->signum, &si, p))
496 				break;
497 		/* fall-through: fall back on the old plain SIGIO signal */
498 		case 0:
499 			group_send_sig_info(SIGIO, SEND_SIG_PRIV, p);
500 	}
501 }
502 
503 void send_sigio(struct fown_struct *fown, int fd, int band)
504 {
505 	struct task_struct *p;
506 	enum pid_type type;
507 	struct pid *pid;
508 
509 	read_lock(&fown->lock);
510 	type = fown->pid_type;
511 	pid = fown->pid;
512 	if (!pid)
513 		goto out_unlock_fown;
514 
515 	read_lock(&tasklist_lock);
516 	do_each_pid_task(pid, type, p) {
517 		send_sigio_to_task(p, fown, fd, band);
518 	} while_each_pid_task(pid, type, p);
519 	read_unlock(&tasklist_lock);
520  out_unlock_fown:
521 	read_unlock(&fown->lock);
522 }
523 
524 static void send_sigurg_to_task(struct task_struct *p,
525                                 struct fown_struct *fown)
526 {
527 	if (sigio_perm(p, fown, SIGURG))
528 		group_send_sig_info(SIGURG, SEND_SIG_PRIV, p);
529 }
530 
531 int send_sigurg(struct fown_struct *fown)
532 {
533 	struct task_struct *p;
534 	enum pid_type type;
535 	struct pid *pid;
536 	int ret = 0;
537 
538 	read_lock(&fown->lock);
539 	type = fown->pid_type;
540 	pid = fown->pid;
541 	if (!pid)
542 		goto out_unlock_fown;
543 
544 	ret = 1;
545 
546 	read_lock(&tasklist_lock);
547 	do_each_pid_task(pid, type, p) {
548 		send_sigurg_to_task(p, fown);
549 	} while_each_pid_task(pid, type, p);
550 	read_unlock(&tasklist_lock);
551  out_unlock_fown:
552 	read_unlock(&fown->lock);
553 	return ret;
554 }
555 
556 static DEFINE_RWLOCK(fasync_lock);
557 static struct kmem_cache *fasync_cache __read_mostly;
558 
559 /*
560  * fasync_helper() is used by some character device drivers (mainly mice)
561  * to set up the fasync queue. It returns negative on error, 0 if it did
562  * no changes and positive if it added/deleted the entry.
563  */
564 int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
565 {
566 	struct fasync_struct *fa, **fp;
567 	struct fasync_struct *new = NULL;
568 	int result = 0;
569 
570 	if (on) {
571 		new = kmem_cache_alloc(fasync_cache, GFP_KERNEL);
572 		if (!new)
573 			return -ENOMEM;
574 	}
575 	write_lock_irq(&fasync_lock);
576 	for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
577 		if (fa->fa_file == filp) {
578 			if(on) {
579 				fa->fa_fd = fd;
580 				kmem_cache_free(fasync_cache, new);
581 			} else {
582 				*fp = fa->fa_next;
583 				kmem_cache_free(fasync_cache, fa);
584 				result = 1;
585 			}
586 			goto out;
587 		}
588 	}
589 
590 	if (on) {
591 		new->magic = FASYNC_MAGIC;
592 		new->fa_file = filp;
593 		new->fa_fd = fd;
594 		new->fa_next = *fapp;
595 		*fapp = new;
596 		result = 1;
597 	}
598 out:
599 	write_unlock_irq(&fasync_lock);
600 	return result;
601 }
602 
603 EXPORT_SYMBOL(fasync_helper);
604 
605 void __kill_fasync(struct fasync_struct *fa, int sig, int band)
606 {
607 	while (fa) {
608 		struct fown_struct * fown;
609 		if (fa->magic != FASYNC_MAGIC) {
610 			printk(KERN_ERR "kill_fasync: bad magic number in "
611 			       "fasync_struct!\n");
612 			return;
613 		}
614 		fown = &fa->fa_file->f_owner;
615 		/* Don't send SIGURG to processes which have not set a
616 		   queued signum: SIGURG has its own default signalling
617 		   mechanism. */
618 		if (!(sig == SIGURG && fown->signum == 0))
619 			send_sigio(fown, fa->fa_fd, band);
620 		fa = fa->fa_next;
621 	}
622 }
623 
624 EXPORT_SYMBOL(__kill_fasync);
625 
626 void kill_fasync(struct fasync_struct **fp, int sig, int band)
627 {
628 	/* First a quick test without locking: usually
629 	 * the list is empty.
630 	 */
631 	if (*fp) {
632 		read_lock(&fasync_lock);
633 		/* reread *fp after obtaining the lock */
634 		__kill_fasync(*fp, sig, band);
635 		read_unlock(&fasync_lock);
636 	}
637 }
638 EXPORT_SYMBOL(kill_fasync);
639 
640 static int __init fasync_init(void)
641 {
642 	fasync_cache = kmem_cache_create("fasync_cache",
643 		sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);
644 	return 0;
645 }
646 
647 module_init(fasync_init)
648