Add a bulk interface to sem_down()
[akaros.git] / kern / src / fdtap.c
1 /* Copyright (c) 2015 Google Inc
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * FD taps.  Allows the user to receive events when certain things happen to an
6  * FD's underlying device file/qid. */
7
8 #include <fdtap.h>
9 #include <event.h>
10 #include <kmalloc.h>
11 #include <syscall.h>
12 #include <error.h>
13 #include <umem.h>
14
15 static void tap_min_release(struct kref *kref)
16 {
17         struct fd_tap *tap = container_of(kref, struct fd_tap, kref);
18         cclose(tap->chan);
19         kfree(tap);
20 }
21
22 static void tap_full_release(struct kref *kref)
23 {
24         struct fd_tap *tap = container_of(kref, struct fd_tap, kref);
25         devtab[tap->chan->type].tapfd(tap->chan, tap, FDTAP_CMD_REM);
26         tap_min_release(kref);
27 }
28
29 /* Adds a tap with the file/qid of the underlying device for the requested FD.
30  * The FD must be a chan, and the device must support the filter requested.
31  *
32  * Returns -1 or some other device-specific non-zero number on failure, 0 on
33  * success. */
34 int add_fd_tap(struct proc *p, struct fd_tap_req *tap_req)
35 {
36         struct fd_table *fdt = &p->open_files;
37         struct fd_tap *tap;
38         int ret = 0;
39         struct chan *chan;
40         int fd = tap_req->fd;
41
42         if (fd < 0) {
43                 set_errno(EBADF);
44                 return -1;
45         }
46         tap = kzmalloc(sizeof(struct fd_tap), MEM_WAIT);
47         tap->proc = p;
48         tap->fd = fd;
49         tap->filter = tap_req->filter;
50         tap->ev_q = tap_req->ev_q;
51         tap->ev_id = tap_req->ev_id;
52         tap->data = tap_req->data;
53         if (!is_user_rwaddr(tap->ev_q, sizeof(struct event_queue))) {
54                 set_error(EINVAL, "Tap request with bad event_queue %p", tap->ev_q);
55                 kfree(tap);
56                 return -1;
57         }
58         spin_lock(&fdt->lock);
59         if (fd >= fdt->max_fdset) {
60                 set_errno(ENFILE);
61                 goto out_with_lock;
62         }
63         if (!GET_BITMASK_BIT(fdt->open_fds->fds_bits, fd)) {
64                 set_errno(EBADF);
65                 goto out_with_lock;
66         }
67         if (!fdt->fd[fd].fd_chan) {
68                 set_error(EINVAL, "Can't tap a VFS file");
69                 goto out_with_lock;
70         }
71         chan = fdt->fd[fd].fd_chan;
72         if (fdt->fd[fd].fd_tap) {
73                 set_error(EBUSY, "FD %d already has a tap", fd);
74                 goto out_with_lock;
75         }
76         if (!devtab[chan->type].tapfd) {
77                 set_error(ENOSYS, "Device %s does not handle taps",
78                                   devtab[chan->type].name);
79                 goto out_with_lock;
80         }
81         /* need to keep chan alive for our call to the device.  someone else
82          * could come in and close the FD and the chan, once we unlock */
83         chan_incref(chan);
84         tap->chan = chan;
85         /* One for the FD table, one for us to keep the removal of *this* tap from
86          * happening until we've attempted to register with the device. */
87         kref_init(&tap->kref, tap_full_release, 2);
88         fdt->fd[fd].fd_tap = tap;
89         /* As soon as we unlock, another thread can come in and remove our old tap
90          * from the table and decref it.  Our ref keeps us from removing it yet,
91          * as well as keeps the memory safe.  However, a new tap can be installed
92          * and registered with the device before we even attempt to register.  The
93          * devices should be able to handle multiple, distinct taps, even if they
94          * happen to have the same {proc, fd} tuple. */
95         spin_unlock(&fdt->lock);
96         /* For refcnting fans, the tap ref is weak/uncounted.  We'll protect the
97          * memory and call the device when tap is being released. */
98         ret = devtab[chan->type].tapfd(chan, tap, FDTAP_CMD_ADD);
99         if (ret) {
100                 /* we failed, so we need to make sure *our* tap is removed.  We haven't
101                  * decreffed, so we know our tap pointer is unique. */
102                 spin_lock(&fdt->lock);
103                 if (fdt->fd[fd].fd_tap == tap) {
104                         fdt->fd[fd].fd_tap = 0;
105                         /* normally we can't decref a tap while holding a lock, but we
106                          * know we have another reference so this won't trigger a release */
107                         kref_put(&tap->kref);
108                 }
109                 spin_unlock(&fdt->lock);
110                 /* Regardless of whether someone else removed it or not, *we* are the
111                  * only ones that know that registration failed and that we shouldn't
112                  * remove it.  Since we still hold a ref, we can change the release
113                  * method to skip the device dereg. */
114                 tap->kref.release = tap_min_release;
115         }
116         kref_put(&tap->kref);
117         return ret;
118 out_with_lock:
119         spin_unlock(&fdt->lock);
120         kfree(tap);
121         return -1;
122 }
123
124 /* Removes the FD tap associated with FD.  Returns 0 on success, -1 with
125  * errno/errstr on failure. */
126 int remove_fd_tap(struct proc *p, int fd)
127 {
128         struct fd_table *fdt = &p->open_files;
129         struct fd_tap *tap;
130
131         spin_lock(&fdt->lock);
132         tap = fdt->fd[fd].fd_tap;
133         fdt->fd[fd].fd_tap = 0;
134         spin_unlock(&fdt->lock);
135         if (tap) {
136                 kref_put(&tap->kref);
137                 return 0;
138         } else {
139                 set_error(EBADF, "FD %d was not tapped", fd);
140                 return -1;
141         }
142 }
143
144 /* Fires off tap, with the events of filter having occurred.  Returns -1 on
145  * error, though this need a little more thought.
146  *
147  * Some callers may require this to not block. */
148 int fire_tap(struct fd_tap *tap, int filter)
149 {
150         ERRSTACK(1);
151         struct event_msg ev_msg = {0};
152         int fire_filt = tap->filter & filter;
153
154         if (!fire_filt)
155                 return 0;
156         if (waserror()) {
157                 /* The process owning the tap could trigger a kernel PF, as with any
158                  * send_event() call.  Eventually we'll catch that with waserror. */
159                 warn("Tap for proc %d, fd %d, threw %s", tap->proc->pid, tap->fd,
160                      current_errstr());
161                 poperror();
162                 return -1;
163         }
164         ev_msg.ev_type = tap->ev_id;    /* e.g. CEQ idx */
165         ev_msg.ev_arg2 = fire_filt;             /* e.g. CEQ coalesce */
166         ev_msg.ev_arg3 = tap->data;             /* e.g. CEQ data */
167         send_event(tap->proc, tap->ev_q, &ev_msg, 0);
168         poperror();
169         return 0;
170 }