fcntl.c 14 KB

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