Remove struct dev's dc [3/3]
[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 <error.h>
13
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), KMALLOC_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
54         spin_lock(&fdt->lock);
55         if (fd >= fdt->max_fdset) {
56                 set_errno(ENFILE);
57                 goto out_with_lock;
58         }
59         if (!GET_BITMASK_BIT(fdt->open_fds->fds_bits, fd)) {
60                 set_errno(EBADF);
61                 goto out_with_lock;
62         }
63         if (!fdt->fd[fd].fd_chan) {
64                 set_errno(EINVAL);
65                 set_errstr("Can't tap a VFS file");
66                 goto out_with_lock;
67         }
68         chan = fdt->fd[fd].fd_chan;
69         if (fdt->fd[fd].fd_tap) {
70                 set_errno(EBUSY);
71                 set_errstr("FD %d already has a tap", fd);
72                 goto out_with_lock;
73         }
74         if (!devtab[chan->type].tapfd) {
75                 set_errno(ENOSYS);
76                 set_errstr("Device %s does not handle taps", devtab[chan->type].name);
77                 goto out_with_lock;
78         }
79         /* need to keep chan alive for our call to the device.  someone else
80          * could come in and close the FD and the chan, once we unlock */
81         chan_incref(chan);
82         tap->chan = chan;
83         /* One for the FD table, one for us to keep the removal of *this* tap from
84          * happening until we've attempted to register with the device. */
85         kref_init(&tap->kref, tap_full_release, 2);
86         fdt->fd[fd].fd_tap = tap;
87         /* As soon as we unlock, another thread can come in and remove our old tap
88          * from the table and decref it.  Our ref keeps us from removing it yet,
89          * as well as keeps the memory safe.  However, a new tap can be installed
90          * and registered with the device before we even attempt to register.  The
91          * devices should be able to handle multiple, distinct taps, even if they
92          * happen to have the same {proc, fd} tuple. */
93         spin_unlock(&fdt->lock);
94         /* For refcnting fans, the tap ref is weak/uncounted.  We'll protect the
95          * memory and call the device when tap is being released. */
96         ret = devtab[chan->type].tapfd(chan, tap, FDTAP_CMD_ADD);
97         if (ret) {
98                 /* we failed, so we need to make sure *our* tap is removed.  We haven't
99                  * decreffed, so we know our tap pointer is unique. */
100                 spin_lock(&fdt->lock);
101                 if (fdt->fd[fd].fd_tap == tap) {
102                         fdt->fd[fd].fd_tap = 0;
103                         /* normally we can't decref a tap while holding a lock, but we
104                          * know we have another reference so this won't trigger a release */
105                         kref_put(&tap->kref);
106                 }
107                 spin_unlock(&fdt->lock);
108                 /* Regardless of whether someone else removed it or not, *we* are the
109                  * only ones that know that registration failed and that we shouldn't
110                  * remove it.  Since we still hold a ref, we can change the release
111                  * method to skip the device dereg. */
112                 tap->kref.release = tap_min_release;
113         }
114         kref_put(&tap->kref);
115         return ret;
116 out_with_lock:
117         spin_unlock(&fdt->lock);
118         kfree(tap);
119         return -1;
120 }
121
122 /* Removes the FD tap associated with FD.  Returns 0 on success, -1 with
123  * errno/errstr on failure. */
124 int remove_fd_tap(struct proc *p, int fd)
125 {
126         struct fd_table *fdt = &p->open_files;
127         struct fd_tap *tap;
128
129         spin_lock(&fdt->lock);
130         tap = fdt->fd[fd].fd_tap;
131         fdt->fd[fd].fd_tap = 0;
132         spin_unlock(&fdt->lock);
133         if (tap) {
134                 kref_put(&tap->kref);
135                 return 0;
136         } else {
137                 set_errno(EBADF);
138                 set_errstr("FD %d was not tapped", fd);
139                 return -1;
140         }
141 }
142
143 /* Fires off tap, with the events of filter having occurred.  Returns -1 on
144  * error, though this need a little more thought.
145  *
146  * Some callers may require this to not block. */
147 int fire_tap(struct fd_tap *tap, int filter)
148 {
149         ERRSTACK(1);
150         struct event_msg ev_msg = {0};
151         int fire_filt = tap->filter & filter;
152
153         if (!fire_filt)
154                 return 0;
155         if (waserror()) {
156                 /* The process owning the tap could trigger a kernel PF, as with any
157                  * send_event() call.  Eventually we'll catch that with waserror. */
158                 warn("Tap for proc %d, fd %d, threw %s", tap->proc->pid, tap->fd,
159                      current_errstr());
160                 poperror();
161                 return -1;
162         }
163         ev_msg.ev_type = tap->ev_id;    /* e.g. CEQ idx */
164         ev_msg.ev_arg2 = fire_filt;             /* e.g. CEQ coalesce */
165         ev_msg.ev_arg3 = tap->data;             /* e.g. CEQ data */
166         send_event(tap->proc, tap->ev_q, &ev_msg, 0);
167         poperror();
168         return 0;
169 }