4c93e5a975e313415a340d3b581794bf3f649557
[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 <vfs.h>
10 #include <event.h>
11 #include <kmalloc.h>
12 #include <syscall.h>
13 #include <error.h>
14
15
16 static void tap_min_release(struct kref *kref)
17 {
18         struct fd_tap *tap = container_of(kref, struct fd_tap, kref);
19         cclose(tap->chan);
20         kfree(tap);
21 }
22
23 static void tap_full_release(struct kref *kref)
24 {
25         struct fd_tap *tap = container_of(kref, struct fd_tap, kref);
26         devtab[tap->chan->type].tapfd(tap->chan, tap, FDTAP_CMD_REM);
27         tap_min_release(kref);
28 }
29
30 /* Adds a tap with the file/qid of the underlying device for the requested FD.
31  * The FD must be a chan, and the device must support the filter requested.
32  *
33  * Returns -1 or some other device-specific non-zero number on failure, 0 on
34  * success. */
35 int add_fd_tap(struct proc *p, struct fd_tap_req *tap_req)
36 {
37         struct fd_table *fdt = &p->open_files;
38         struct fd_tap *tap;
39         int ret = 0;
40         struct chan *chan;
41         int fd = tap_req->fd;
42
43         if (fd < 0) {
44                 set_errno(EBADF);
45                 return -1;
46         }
47         tap = kzmalloc(sizeof(struct fd_tap), KMALLOC_WAIT);
48         tap->proc = p;
49         tap->fd = fd;
50         tap->filter = tap_req->filter;
51         tap->ev_q = tap_req->ev_q;
52         tap->ev_id = tap_req->ev_id;
53         tap->data = tap_req->data;
54
55         spin_lock(&fdt->lock);
56         if (fd >= fdt->max_fdset) {
57                 set_errno(ENFILE);
58                 goto out_with_lock;
59         }
60         if (!GET_BITMASK_BIT(fdt->open_fds->fds_bits, fd)) {
61                 set_errno(EBADF);
62                 goto out_with_lock;
63         }
64         if (!fdt->fd[fd].fd_chan) {
65                 set_errno(EINVAL);
66                 set_errstr("Can't tap a VFS file");
67                 goto out_with_lock;
68         }
69         chan = fdt->fd[fd].fd_chan;
70         if (fdt->fd[fd].fd_tap) {
71                 set_errno(EBUSY);
72                 set_errstr("FD %d already has a tap", fd);
73                 goto out_with_lock;
74         }
75         if (!devtab[chan->type].tapfd) {
76                 set_errno(ENOSYS);
77                 set_errstr("Device %s does not handle taps", devtab[chan->type].name);
78                 goto out_with_lock;
79         }
80         /* need to keep chan alive for our call to the device.  someone else
81          * could come in and close the FD and the chan, once we unlock */
82         chan_incref(chan);
83         tap->chan = chan;
84         /* One for the FD table, one for us to keep the removal of *this* tap from
85          * happening until we've attempted to register with the device. */
86         kref_init(&tap->kref, tap_full_release, 2);
87         fdt->fd[fd].fd_tap = tap;
88         /* As soon as we unlock, another thread can come in and remove our old tap
89          * from the table and decref it.  Our ref keeps us from removing it yet,
90          * as well as keeps the memory safe.  However, a new tap can be installed
91          * and registered with the device before we even attempt to register.  The
92          * devices should be able to handle multiple, distinct taps, even if they
93          * happen to have the same {proc, fd} tuple. */
94         spin_unlock(&fdt->lock);
95         /* For refcnting fans, the tap ref is weak/uncounted.  We'll protect the
96          * memory and call the device when tap is being released. */
97         ret = devtab[chan->type].tapfd(chan, tap, FDTAP_CMD_ADD);
98         if (ret) {
99                 /* we failed, so we need to make sure *our* tap is removed.  We haven't
100                  * decreffed, so we know our tap pointer is unique. */
101                 spin_lock(&fdt->lock);
102                 if (fdt->fd[fd].fd_tap == tap) {
103                         fdt->fd[fd].fd_tap = 0;
104                         /* normally we can't decref a tap while holding a lock, but we
105                          * know we have another reference so this won't trigger a release */
106                         kref_put(&tap->kref);
107                 }
108                 spin_unlock(&fdt->lock);
109                 /* Regardless of whether someone else removed it or not, *we* are the
110                  * only ones that know that registration failed and that we shouldn't
111                  * remove it.  Since we still hold a ref, we can change the release
112                  * method to skip the device dereg. */
113                 tap->kref.release = tap_min_release;
114         }
115         kref_put(&tap->kref);
116         return ret;
117 out_with_lock:
118         spin_unlock(&fdt->lock);
119         kfree(tap);
120         return -1;
121 }
122
123 /* Removes the FD tap associated with FD.  Returns 0 on success, -1 with
124  * errno/errstr on failure. */
125 int remove_fd_tap(struct proc *p, int fd)
126 {
127         struct fd_table *fdt = &p->open_files;
128         struct fd_tap *tap;
129
130         spin_lock(&fdt->lock);
131         tap = fdt->fd[fd].fd_tap;
132         fdt->fd[fd].fd_tap = 0;
133         spin_unlock(&fdt->lock);
134         if (tap) {
135                 kref_put(&tap->kref);
136                 return 0;
137         } else {
138                 set_errno(EBADF);
139                 set_errstr("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 }