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