Branch data Line data Source code
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/pipe_fs_i.h>
18 : : #include <linux/security.h>
19 : : #include <linux/ptrace.h>
20 : : #include <linux/signal.h>
21 : : #include <linux/rcupdate.h>
22 : : #include <linux/pid_namespace.h>
23 : : #include <linux/user_namespace.h>
24 : :
25 : : #include <asm/poll.h>
26 : : #include <asm/siginfo.h>
27 : : #include <asm/uaccess.h>
28 : :
29 : : #define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME)
30 : :
31 : 0 : static int setfl(int fd, struct file * filp, unsigned long arg)
32 : : {
33 : : struct inode * inode = file_inode(filp);
34 : : int error = 0;
35 : :
36 : : /*
37 : : * O_APPEND cannot be cleared if the file is marked as append-only
38 : : * and the file is open for write.
39 : : */
40 [ + + ][ + ]: 6267 : if (((arg ^ filp->f_flags) & O_APPEND) && IS_APPEND(inode))
41 : : return -EPERM;
42 : :
43 : : /* O_NOATIME can only be set by the owner or superuser */
44 [ - + ][ # # ]: 12534 : if ((arg & O_NOATIME) && !(filp->f_flags & O_NOATIME))
45 [ # # ]: 0 : if (!inode_owner_or_capable(inode))
46 : : return -EPERM;
47 : :
48 : : /* required for strict SunOS emulation */
49 : : if (O_NONBLOCK != O_NDELAY)
50 : : if (arg & O_NDELAY)
51 : : arg |= O_NONBLOCK;
52 : :
53 [ - + ]: 6267 : if (arg & O_DIRECT) {
54 [ # # ][ # # ]: 0 : if (!filp->f_mapping || !filp->f_mapping->a_ops ||
[ # # ]
55 : 0 : !filp->f_mapping->a_ops->direct_IO)
56 : : return -EINVAL;
57 : : }
58 : :
59 [ - + ]: 6267 : if (filp->f_op->check_flags)
60 : 0 : error = filp->f_op->check_flags(arg);
61 [ + - ]: 6267 : if (error)
62 : : return error;
63 : :
64 : : /*
65 : : * ->fasync() is responsible for setting the FASYNC bit.
66 : : */
67 [ - + ][ # # ]: 6267 : if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op->fasync) {
68 : 0 : error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
69 [ # # ]: 0 : if (error < 0)
70 : : goto out;
71 [ # # ]: 0 : if (error > 0)
72 : : error = 0;
73 : : }
74 : : spin_lock(&filp->f_lock);
75 : 6267 : filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
76 : : spin_unlock(&filp->f_lock);
77 : :
78 : : out:
79 : 6267 : return error;
80 : : }
81 : :
82 : 0 : static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
83 : : int force)
84 : : {
85 : 16 : write_lock_irq(&filp->f_owner.lock);
86 [ + + ][ + - ]: 16 : if (force || !filp->f_owner.pid) {
87 : 16 : put_pid(filp->f_owner.pid);
88 : 16 : filp->f_owner.pid = get_pid(pid);
89 : 16 : filp->f_owner.pid_type = type;
90 : :
91 [ + + ]: 32 : if (pid) {
92 : 8 : const struct cred *cred = current_cred();
93 : 8 : filp->f_owner.uid = cred->uid;
94 : 8 : filp->f_owner.euid = cred->euid;
95 : : }
96 : : }
97 : : write_unlock_irq(&filp->f_owner.lock);
98 : 16 : }
99 : :
100 : 0 : int __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
101 : : int force)
102 : : {
103 : : int err;
104 : :
105 : 8 : err = security_file_set_fowner(filp);
106 [ + - ]: 8 : if (err)
107 : : return err;
108 : :
109 : 8 : f_modown(filp, pid, type, force);
110 : 8 : return 0;
111 : : }
112 : : EXPORT_SYMBOL(__f_setown);
113 : :
114 : 0 : int f_setown(struct file *filp, unsigned long arg, int force)
115 : : {
116 : : enum pid_type type;
117 : : struct pid *pid;
118 : 0 : int who = arg;
119 : : int result;
120 : : type = PIDTYPE_PID;
121 [ # # ]: 0 : if (who < 0) {
122 : : type = PIDTYPE_PGID;
123 : 0 : who = -who;
124 : : }
125 : : rcu_read_lock();
126 : 0 : pid = find_vpid(who);
127 : 0 : result = __f_setown(filp, pid, type, force);
128 : : rcu_read_unlock();
129 : 0 : return result;
130 : : }
131 : : EXPORT_SYMBOL(f_setown);
132 : :
133 : 0 : void f_delown(struct file *filp)
134 : : {
135 : 8 : f_modown(filp, NULL, PIDTYPE_PID, 1);
136 : 8 : }
137 : :
138 : 0 : pid_t f_getown(struct file *filp)
139 : : {
140 : : pid_t pid;
141 : 0 : read_lock(&filp->f_owner.lock);
142 : 0 : pid = pid_vnr(filp->f_owner.pid);
143 [ # # ]: 0 : if (filp->f_owner.pid_type == PIDTYPE_PGID)
144 : 0 : pid = -pid;
145 : : read_unlock(&filp->f_owner.lock);
146 : 0 : return pid;
147 : : }
148 : :
149 : 0 : static int f_setown_ex(struct file *filp, unsigned long arg)
150 : : {
151 : 0 : struct f_owner_ex __user *owner_p = (void __user *)arg;
152 : : struct f_owner_ex owner;
153 : : struct pid *pid;
154 : : int type;
155 : : int ret;
156 : :
157 : : ret = copy_from_user(&owner, owner_p, sizeof(owner));
158 [ # # ]: 0 : if (ret)
159 : : return -EFAULT;
160 : :
161 [ # # # # ]: 0 : switch (owner.type) {
162 : : case F_OWNER_TID:
163 : : type = PIDTYPE_MAX;
164 : : break;
165 : :
166 : : case F_OWNER_PID:
167 : : type = PIDTYPE_PID;
168 : 0 : break;
169 : :
170 : : case F_OWNER_PGRP:
171 : : type = PIDTYPE_PGID;
172 : 0 : break;
173 : :
174 : : default:
175 : : return -EINVAL;
176 : : }
177 : :
178 : : rcu_read_lock();
179 : 0 : pid = find_vpid(owner.pid);
180 [ # # ][ # # ]: 0 : if (owner.pid && !pid)
181 : : ret = -ESRCH;
182 : : else
183 : 0 : ret = __f_setown(filp, pid, type, 1);
184 : : rcu_read_unlock();
185 : :
186 : 0 : return ret;
187 : : }
188 : :
189 : 0 : static int f_getown_ex(struct file *filp, unsigned long arg)
190 : : {
191 : 0 : struct f_owner_ex __user *owner_p = (void __user *)arg;
192 : : struct f_owner_ex owner;
193 : : int ret = 0;
194 : :
195 : 0 : read_lock(&filp->f_owner.lock);
196 : 0 : owner.pid = pid_vnr(filp->f_owner.pid);
197 [ # # # # ]: 0 : switch (filp->f_owner.pid_type) {
198 : : case PIDTYPE_MAX:
199 : 0 : owner.type = F_OWNER_TID;
200 : 0 : break;
201 : :
202 : : case PIDTYPE_PID:
203 : 0 : owner.type = F_OWNER_PID;
204 : 0 : break;
205 : :
206 : : case PIDTYPE_PGID:
207 : 0 : owner.type = F_OWNER_PGRP;
208 : 0 : break;
209 : :
210 : : default:
211 : 0 : WARN_ON(1);
212 : : ret = -EINVAL;
213 : 0 : break;
214 : : }
215 : : read_unlock(&filp->f_owner.lock);
216 : :
217 [ # # ]: 0 : if (!ret) {
218 : 0 : ret = copy_to_user(owner_p, &owner, sizeof(owner));
219 [ # # ]: 0 : if (ret)
220 : : ret = -EFAULT;
221 : : }
222 : 0 : return ret;
223 : : }
224 : :
225 : : #ifdef CONFIG_CHECKPOINT_RESTORE
226 : : static int f_getowner_uids(struct file *filp, unsigned long arg)
227 : : {
228 : : struct user_namespace *user_ns = current_user_ns();
229 : : uid_t __user *dst = (void __user *)arg;
230 : : uid_t src[2];
231 : : int err;
232 : :
233 : : read_lock(&filp->f_owner.lock);
234 : : src[0] = from_kuid(user_ns, filp->f_owner.uid);
235 : : src[1] = from_kuid(user_ns, filp->f_owner.euid);
236 : : read_unlock(&filp->f_owner.lock);
237 : :
238 : : err = put_user(src[0], &dst[0]);
239 : : err |= put_user(src[1], &dst[1]);
240 : :
241 : : return err;
242 : : }
243 : : #else
244 : : static int f_getowner_uids(struct file *filp, unsigned long arg)
245 : : {
246 : : return -EINVAL;
247 : : }
248 : : #endif
249 : :
250 : 0 : static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
251 : : struct file *filp)
252 : : {
253 : : long err = -EINVAL;
254 : :
255 [ + - + + : 2370119 : switch (cmd) {
+ + + + -
- - - - -
+ + - +
+ ]
256 : : case F_DUPFD:
257 : 11637 : err = f_dupfd(arg, filp, 0);
258 : 11637 : break;
259 : : case F_DUPFD_CLOEXEC:
260 : 0 : err = f_dupfd(arg, filp, O_CLOEXEC);
261 : 0 : break;
262 : : case F_GETFD:
263 : 128621 : err = get_close_on_exec(fd) ? FD_CLOEXEC : 0;
264 : 128620 : break;
265 : : case F_SETFD:
266 : : err = 0;
267 : 150611 : set_close_on_exec(fd, arg & FD_CLOEXEC);
268 : 150614 : break;
269 : : case F_GETFL:
270 : 26211 : err = filp->f_flags;
271 : 26211 : break;
272 : : case F_SETFL:
273 : 6267 : err = setfl(fd, filp, arg);
274 : 6267 : break;
275 : : case F_GETLK:
276 : 425 : err = fcntl_getlk(filp, (struct flock __user *) arg);
277 : 425 : break;
278 : : case F_SETLK:
279 : : case F_SETLKW:
280 : 2046276 : err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg);
281 : 2046237 : break;
282 : : case F_GETOWN:
283 : : /*
284 : : * XXX If f_owner is a process group, the
285 : : * negative return value will get converted
286 : : * into an error. Oops. If we keep the
287 : : * current syscall conventions, the only way
288 : : * to fix this will be in libc.
289 : : */
290 : 0 : err = f_getown(filp);
291 : : force_successful_syscall_return();
292 : 0 : break;
293 : : case F_SETOWN:
294 : 0 : err = f_setown(filp, arg, 1);
295 : 0 : break;
296 : : case F_GETOWN_EX:
297 : 0 : err = f_getown_ex(filp, arg);
298 : 0 : break;
299 : : case F_SETOWN_EX:
300 : 0 : err = f_setown_ex(filp, arg);
301 : 0 : break;
302 : : case F_GETOWNER_UIDS:
303 : : err = f_getowner_uids(filp, arg);
304 : : break;
305 : : case F_GETSIG:
306 : 0 : err = filp->f_owner.signum;
307 : 0 : break;
308 : : case F_SETSIG:
309 : : /* arg == 0 restores default behaviour. */
310 [ # # ]: 0 : if (!valid_signal(arg)) {
311 : : break;
312 : : }
313 : : err = 0;
314 : 0 : filp->f_owner.signum = arg;
315 : 0 : break;
316 : : case F_GETLEASE:
317 : 8 : err = fcntl_getlease(filp);
318 : 8 : break;
319 : : case F_SETLEASE:
320 : 20 : err = fcntl_setlease(fd, filp, arg);
321 : 20 : break;
322 : : case F_NOTIFY:
323 : 0 : err = fcntl_dirnotify(fd, filp, arg);
324 : 0 : break;
325 : : case F_SETPIPE_SZ:
326 : : case F_GETPIPE_SZ:
327 : 2 : err = pipe_fcntl(filp, cmd, arg);
328 : 2 : break;
329 : : default:
330 : : break;
331 : : }
332 : 0 : return err;
333 : : }
334 : :
335 : 0 : static int check_fcntl_cmd(unsigned cmd)
336 : : {
337 [ # # ]: 0 : switch (cmd) {
338 : : case F_DUPFD:
339 : : case F_DUPFD_CLOEXEC:
340 : : case F_GETFD:
341 : : case F_SETFD:
342 : : case F_GETFL:
343 : : return 1;
344 : : }
345 : 0 : return 0;
346 : : }
347 : :
348 : 0 : SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
349 : : {
350 : : struct fd f = fdget_raw(fd);
351 : : long err = -EBADF;
352 : :
353 [ # # ]: 0 : if (!f.file)
354 : : goto out;
355 : :
356 [ # # ]: 0 : if (unlikely(f.file->f_mode & FMODE_PATH)) {
357 [ # # ]: 0 : if (!check_fcntl_cmd(cmd))
358 : : goto out1;
359 : : }
360 : :
361 : 0 : err = security_file_fcntl(f.file, cmd, arg);
362 [ # # ]: 0 : if (!err)
363 : 0 : err = do_fcntl(fd, cmd, arg, f.file);
364 : :
365 : : out1:
366 : : fdput(f);
367 : : out:
368 : : return err;
369 : : }
370 : :
371 : : #if BITS_PER_LONG == 32
372 : 0 : SYSCALL_DEFINE3(fcntl64, unsigned int, fd, unsigned int, cmd,
373 : : unsigned long, arg)
374 : : {
375 : : struct fd f = fdget_raw(fd);
376 : : long err = -EBADF;
377 : :
378 [ + + ]: 2384722 : if (!f.file)
379 : : goto out;
380 : :
381 [ - + ]: 2381452 : if (unlikely(f.file->f_mode & FMODE_PATH)) {
382 [ # # ]: 0 : if (!check_fcntl_cmd(cmd))
383 : : goto out1;
384 : : }
385 : :
386 : 2381394 : err = security_file_fcntl(f.file, cmd, arg);
387 [ + ]: 2381359 : if (err)
388 : : goto out1;
389 : :
390 [ + + + ]: 2381461 : switch (cmd) {
391 : : case F_GETLK64:
392 : 225 : err = fcntl_getlk64(f.file, (struct flock64 __user *) arg);
393 : : break;
394 : : case F_SETLK64:
395 : : case F_SETLKW64:
396 : 11164 : err = fcntl_setlk64(fd, f.file, cmd,
397 : : (struct flock64 __user *) arg);
398 : : break;
399 : : default:
400 : 2370072 : err = do_fcntl(fd, cmd, arg, f.file);
401 : : break;
402 : : }
403 : : out1:
404 : : fdput(f);
405 : : out:
406 : : return err;
407 : : }
408 : : #endif
409 : :
410 : : /* Table to convert sigio signal codes into poll band bitmaps */
411 : :
412 : : static const long band_table[NSIGPOLL] = {
413 : : POLLIN | POLLRDNORM, /* POLL_IN */
414 : : POLLOUT | POLLWRNORM | POLLWRBAND, /* POLL_OUT */
415 : : POLLIN | POLLRDNORM | POLLMSG, /* POLL_MSG */
416 : : POLLERR, /* POLL_ERR */
417 : : POLLPRI | POLLRDBAND, /* POLL_PRI */
418 : : POLLHUP | POLLERR /* POLL_HUP */
419 : : };
420 : :
421 : : static inline int sigio_perm(struct task_struct *p,
422 : : struct fown_struct *fown, int sig)
423 : : {
424 : : const struct cred *cred;
425 : : int ret;
426 : :
427 : : rcu_read_lock();
428 : 0 : cred = __task_cred(p);
429 [ # # ][ # # ]: 0 : ret = ((uid_eq(fown->euid, GLOBAL_ROOT_UID) ||
430 [ # # ][ # # ]: 0 : uid_eq(fown->euid, cred->suid) || uid_eq(fown->euid, cred->uid) ||
[ # # ][ # # ]
431 [ # # ]: 0 : uid_eq(fown->uid, cred->suid) || uid_eq(fown->uid, cred->uid)) &&
[ # # # # ]
[ # # ]
[ # # # # ]
432 : 0 : !security_file_send_sigiotask(p, fown, sig));
433 : : rcu_read_unlock();
434 : : return ret;
435 : : }
436 : :
437 : 0 : static void send_sigio_to_task(struct task_struct *p,
438 : : struct fown_struct *fown,
439 : : int fd, int reason, int group)
440 : : {
441 : : /*
442 : : * F_SETSIG can change ->signum lockless in parallel, make
443 : : * sure we read it once and use the same value throughout.
444 : : */
445 : 0 : int signum = ACCESS_ONCE(fown->signum);
446 : :
447 [ # # ]: 0 : if (!sigio_perm(p, fown, signum))
448 : 0 : return;
449 : :
450 [ # # ]: 0 : switch (signum) {
451 : : siginfo_t si;
452 : : default:
453 : : /* Queue a rt signal with the appropriate fd as its
454 : : value. We use SI_SIGIO as the source, not
455 : : SI_KERNEL, since kernel signals always get
456 : : delivered even if we can't queue. Failure to
457 : : queue in this case _should_ be reported; we fall
458 : : back to SIGIO in that case. --sct */
459 : 0 : si.si_signo = signum;
460 : 0 : si.si_errno = 0;
461 : 0 : si.si_code = reason;
462 : : /* Make sure we are called with one of the POLL_*
463 : : reasons, otherwise we could leak kernel stack into
464 : : userspace. */
465 [ # # ]: 0 : BUG_ON((reason & __SI_MASK) != __SI_POLL);
466 [ # # ]: 0 : if (reason - POLL_IN >= NSIGPOLL)
467 : 0 : si.si_band = ~0L;
468 : : else
469 : 0 : si.si_band = band_table[reason - POLL_IN];
470 : 0 : si.si_fd = fd;
471 [ # # ]: 0 : if (!do_send_sig_info(signum, &si, p, group))
472 : : break;
473 : : /* fall-through: fall back on the old plain SIGIO signal */
474 : : case 0:
475 : 0 : do_send_sig_info(SIGIO, SEND_SIG_PRIV, p, group);
476 : : }
477 : : }
478 : :
479 : 0 : void send_sigio(struct fown_struct *fown, int fd, int band)
480 : : {
481 : : struct task_struct *p;
482 : : enum pid_type type;
483 : : struct pid *pid;
484 : : int group = 1;
485 : :
486 : 0 : read_lock(&fown->lock);
487 : :
488 : 0 : type = fown->pid_type;
489 [ # # ]: 0 : if (type == PIDTYPE_MAX) {
490 : : group = 0;
491 : : type = PIDTYPE_PID;
492 : : }
493 : :
494 : 0 : pid = fown->pid;
495 [ # # ]: 0 : if (!pid)
496 : : goto out_unlock_fown;
497 : :
498 : 0 : read_lock(&tasklist_lock);
499 [ # # ][ # # ]: 0 : do_each_pid_task(pid, type, p) {
[ # # ][ # # ]
500 : 0 : send_sigio_to_task(p, fown, fd, band, group);
501 [ # # ]: 0 : } while_each_pid_task(pid, type, p);
502 : : read_unlock(&tasklist_lock);
503 : : out_unlock_fown:
504 : : read_unlock(&fown->lock);
505 : 0 : }
506 : :
507 : 0 : static void send_sigurg_to_task(struct task_struct *p,
508 : : struct fown_struct *fown, int group)
509 : : {
510 [ # # ]: 0 : if (sigio_perm(p, fown, SIGURG))
511 : 0 : do_send_sig_info(SIGURG, SEND_SIG_PRIV, p, group);
512 : 0 : }
513 : :
514 : 0 : int send_sigurg(struct fown_struct *fown)
515 : : {
516 : : struct task_struct *p;
517 : : enum pid_type type;
518 : : struct pid *pid;
519 : : int group = 1;
520 : : int ret = 0;
521 : :
522 : 0 : read_lock(&fown->lock);
523 : :
524 : 0 : type = fown->pid_type;
525 [ # # ]: 0 : if (type == PIDTYPE_MAX) {
526 : : group = 0;
527 : : type = PIDTYPE_PID;
528 : : }
529 : :
530 : 0 : pid = fown->pid;
531 [ # # ]: 0 : if (!pid)
532 : : goto out_unlock_fown;
533 : :
534 : : ret = 1;
535 : :
536 : 0 : read_lock(&tasklist_lock);
537 [ # # ][ # # ]: 0 : do_each_pid_task(pid, type, p) {
[ # # ][ # # ]
538 : 0 : send_sigurg_to_task(p, fown, group);
539 [ # # ]: 0 : } while_each_pid_task(pid, type, p);
540 : : read_unlock(&tasklist_lock);
541 : : out_unlock_fown:
542 : : read_unlock(&fown->lock);
543 : 0 : return ret;
544 : : }
545 : :
546 : : static DEFINE_SPINLOCK(fasync_lock);
547 : : static struct kmem_cache *fasync_cache __read_mostly;
548 : :
549 : 0 : static void fasync_free_rcu(struct rcu_head *head)
550 : : {
551 : 8 : kmem_cache_free(fasync_cache,
552 : 8 : container_of(head, struct fasync_struct, fa_rcu));
553 : 8 : }
554 : :
555 : : /*
556 : : * Remove a fasync entry. If successfully removed, return
557 : : * positive and clear the FASYNC flag. If no entry exists,
558 : : * do nothing and return 0.
559 : : *
560 : : * NOTE! It is very important that the FASYNC flag always
561 : : * match the state "is the filp on a fasync list".
562 : : *
563 : : */
564 : 0 : int fasync_remove_entry(struct file *filp, struct fasync_struct **fapp)
565 : : {
566 : : struct fasync_struct *fa, **fp;
567 : : int result = 0;
568 : :
569 : : spin_lock(&filp->f_lock);
570 : : spin_lock(&fasync_lock);
571 [ + + ]: 2098 : for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
572 [ - + ]: 8 : if (fa->fa_file != filp)
573 : 0 : continue;
574 : :
575 : : spin_lock_irq(&fa->fa_lock);
576 : 8 : fa->fa_file = NULL;
577 : : spin_unlock_irq(&fa->fa_lock);
578 : :
579 : 8 : *fp = fa->fa_next;
580 : 8 : call_rcu(&fa->fa_rcu, fasync_free_rcu);
581 : 8 : filp->f_flags &= ~FASYNC;
582 : : result = 1;
583 : 8 : break;
584 : : }
585 : : spin_unlock(&fasync_lock);
586 : : spin_unlock(&filp->f_lock);
587 : 2098 : return result;
588 : : }
589 : :
590 : 0 : struct fasync_struct *fasync_alloc(void)
591 : : {
592 : 12 : return kmem_cache_alloc(fasync_cache, GFP_KERNEL);
593 : : }
594 : :
595 : : /*
596 : : * NOTE! This can be used only for unused fasync entries:
597 : : * entries that actually got inserted on the fasync list
598 : : * need to be released by rcu - see fasync_remove_entry.
599 : : */
600 : 0 : void fasync_free(struct fasync_struct *new)
601 : : {
602 : 4 : kmem_cache_free(fasync_cache, new);
603 : 4 : }
604 : :
605 : : /*
606 : : * Insert a new entry into the fasync list. Return the pointer to the
607 : : * old one if we didn't use the new one.
608 : : *
609 : : * NOTE! It is very important that the FASYNC flag always
610 : : * match the state "is the filp on a fasync list".
611 : : */
612 : 0 : struct fasync_struct *fasync_insert_entry(int fd, struct file *filp, struct fasync_struct **fapp, struct fasync_struct *new)
613 : : {
614 : : struct fasync_struct *fa, **fp;
615 : :
616 : : spin_lock(&filp->f_lock);
617 : : spin_lock(&fasync_lock);
618 [ - + ]: 8 : for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
619 [ # # ]: 0 : if (fa->fa_file != filp)
620 : 0 : continue;
621 : :
622 : : spin_lock_irq(&fa->fa_lock);
623 : 0 : fa->fa_fd = fd;
624 : : spin_unlock_irq(&fa->fa_lock);
625 : : goto out;
626 : : }
627 : :
628 : 8 : spin_lock_init(&new->fa_lock);
629 : 8 : new->magic = FASYNC_MAGIC;
630 : 8 : new->fa_file = filp;
631 : 8 : new->fa_fd = fd;
632 : 8 : new->fa_next = *fapp;
633 : 8 : rcu_assign_pointer(*fapp, new);
634 : 8 : filp->f_flags |= FASYNC;
635 : :
636 : : out:
637 : : spin_unlock(&fasync_lock);
638 : : spin_unlock(&filp->f_lock);
639 : 8 : return fa;
640 : : }
641 : :
642 : : /*
643 : : * Add a fasync entry. Return negative on error, positive if
644 : : * added, and zero if did nothing but change an existing one.
645 : : */
646 : 0 : static int fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fapp)
647 : : {
648 : : struct fasync_struct *new;
649 : :
650 : : new = fasync_alloc();
651 [ # # ]: 0 : if (!new)
652 : : return -ENOMEM;
653 : :
654 : : /*
655 : : * fasync_insert_entry() returns the old (update) entry if
656 : : * it existed.
657 : : *
658 : : * So free the (unused) new entry and return 0 to let the
659 : : * caller know that we didn't add any new fasync entries.
660 : : */
661 [ # # ]: 0 : if (fasync_insert_entry(fd, filp, fapp, new)) {
662 : : fasync_free(new);
663 : 0 : return 0;
664 : : }
665 : :
666 : : return 1;
667 : : }
668 : :
669 : : /*
670 : : * fasync_helper() is used by almost all character device drivers
671 : : * to set up the fasync queue, and for regular files by the file
672 : : * lease code. It returns negative on error, 0 if it did no changes
673 : : * and positive if it added/deleted the entry.
674 : : */
675 : 0 : int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
676 : : {
677 [ + - ]: 2098 : if (!on)
678 : 2098 : return fasync_remove_entry(filp, fapp);
679 : 0 : return fasync_add_entry(fd, filp, fapp);
680 : : }
681 : :
682 : : EXPORT_SYMBOL(fasync_helper);
683 : :
684 : : /*
685 : : * rcu_read_lock() is held
686 : : */
687 : 0 : static void kill_fasync_rcu(struct fasync_struct *fa, int sig, int band)
688 : : {
689 [ # # ]: 0 : while (fa) {
690 : : struct fown_struct *fown;
691 : : unsigned long flags;
692 : :
693 [ # # ]: 0 : if (fa->magic != FASYNC_MAGIC) {
694 : 0 : printk(KERN_ERR "kill_fasync: bad magic number in "
695 : : "fasync_struct!\n");
696 : 0 : return;
697 : : }
698 : 0 : spin_lock_irqsave(&fa->fa_lock, flags);
699 [ # # ]: 0 : if (fa->fa_file) {
700 : 0 : fown = &fa->fa_file->f_owner;
701 : : /* Don't send SIGURG to processes which have not set a
702 : : queued signum: SIGURG has its own default signalling
703 : : mechanism. */
704 [ # # ][ # # ]: 0 : if (!(sig == SIGURG && fown->signum == 0))
705 : 0 : send_sigio(fown, fa->fa_fd, band);
706 : : }
707 : : spin_unlock_irqrestore(&fa->fa_lock, flags);
708 : 0 : fa = rcu_dereference(fa->fa_next);
709 : : }
710 : : }
711 : :
712 : 0 : void kill_fasync(struct fasync_struct **fp, int sig, int band)
713 : : {
714 : : /* First a quick test without locking: usually
715 : : * the list is empty.
716 : : */
717 [ - + ]: 1388763 : if (*fp) {
718 : : rcu_read_lock();
719 : 0 : kill_fasync_rcu(rcu_dereference(*fp), sig, band);
720 : : rcu_read_unlock();
721 : : }
722 : 0 : }
723 : : EXPORT_SYMBOL(kill_fasync);
724 : :
725 : 0 : static int __init fcntl_init(void)
726 : : {
727 : : /*
728 : : * Please add new bits here to ensure allocation uniqueness.
729 : : * Exceptions: O_NONBLOCK is a two bit define on parisc; O_NDELAY
730 : : * is defined as O_NONBLOCK on some platforms and not on others.
731 : : */
732 : : BUILD_BUG_ON(20 - 1 /* for O_RDONLY being 0 */ != HWEIGHT32(
733 : : O_RDONLY | O_WRONLY | O_RDWR |
734 : : O_CREAT | O_EXCL | O_NOCTTY |
735 : : O_TRUNC | O_APPEND | /* O_NONBLOCK | */
736 : : __O_SYNC | O_DSYNC | FASYNC |
737 : : O_DIRECT | O_LARGEFILE | O_DIRECTORY |
738 : : O_NOFOLLOW | O_NOATIME | O_CLOEXEC |
739 : : __FMODE_EXEC | O_PATH | __O_TMPFILE
740 : : ));
741 : :
742 : 0 : fasync_cache = kmem_cache_create("fasync_cache",
743 : : sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);
744 : 0 : return 0;
745 : : }
746 : :
747 : : module_init(fcntl_init)
|
