a2db8bfb3637f86b0dd7fbb3501f7f3aff72d914
[akaros.git] / kern / src / ns / dev.c
1 // INFERNO
2 #include <vfs.h>
3 #include <kfs.h>
4 #include <slab.h>
5 #include <kmalloc.h>
6 #include <kref.h>
7 #include <string.h>
8 #include <stdio.h>
9 #include <assert.h>
10 #include <error.h>
11 #include <cpio.h>
12 #include <pmap.h>
13 #include <smp.h>
14 #include <ip.h>
15
16 extern uint32_t kerndate;
17 extern char *eve;
18
19 void mkqid(struct qid *q, int64_t path, uint32_t vers, int type)
20 {
21         q->type = type;
22         q->vers = vers;
23         q->path = path;
24 }
25
26 int devno(const char *name, int user)
27 {
28         int i;
29
30         for (i = 0; &devtab[i] < __devtabend; i++) {
31                 if (!strcmp(devtab[i].name, name))
32                         return i;
33         }
34         if (user == 0)
35                 panic("Lookup of dev :%s: failed", name);
36
37         return -1;
38 }
39
40 void
41 devdir(struct chan *c, struct qid qid, char *n,
42            int64_t length, char *user, long perm, struct dir *db)
43 {
44         db->name = n;
45         if (c->flag & CMSG)
46                 qid.type |= QTMOUNT;
47         db->qid = qid;
48         db->type = c->type;     /* used to use the dev's dc here */
49         db->dev = c->dev;
50         db->mode = perm;
51         db->mode |= qid.type << 24;
52         db->atime = seconds();
53         db->mtime = kerndate;
54         db->length = length;
55         db->uid = user;
56         db->gid = eve;
57         db->muid = user;
58 }
59
60 /*
61  * the zeroth element of the table MUST be the directory itself for ..
62  * Any entry with qid vers of -1 will return 0, indicating that the value is
63  * valid but there is nothing there continue walk.
64  * TODO(gvdl): Update akaros devgen man page.
65 */
66 int
67 devgen(struct chan *c, char *unused_char_p_t, struct dirtab *tab, int ntab,
68            int i, struct dir *dp)
69 {
70         if (tab == 0)
71                 return -1;
72         if (i != DEVDOTDOT) {
73                 /* skip over the first element, that for . itself */
74                 i++;
75                 if (i >= ntab)
76                         return -1;
77                 tab += i;
78         }
79         int ret = (tab->qid.vers == -1)? 0 : 1;
80         if (ret)
81                 devdir(c, tab->qid, tab->name, tab->length, eve, tab->perm, dp);
82         return ret;
83 }
84
85 void devreset(void)
86 {
87 }
88
89 void devinit(void)
90 {
91 }
92
93 void devshutdown(void)
94 {
95 }
96
97 struct chan *devattach(const char *name, char *spec)
98 {
99         struct chan *c;
100         char *buf;
101         size_t buflen;
102
103         c = newchan();
104         mkqid(&c->qid, 0, 0, QTDIR);
105         c->type = devno(name, 0);
106         if (spec == NULL)
107                 spec = "";
108         /* 1 for #, 1 for ., 1 for \0 */
109         buflen = strlen(name) + strlen(spec) + 3;
110         buf = kzmalloc(buflen, KMALLOC_WAIT);
111         snprintf(buf, sizeof(buf), "#%s.%s", name, spec);
112         c->name = newcname(buf);
113         kfree(buf);
114         return c;
115 }
116
117 struct chan *devclone(struct chan *c)
118 {
119         struct chan *nc;
120
121         /* In plan 9, you couldn't clone an open chan.  We're allowing it, possibly
122          * foolishly.  The new chan is a non-open, "kernel internal" chan.  Note
123          * that c->flag isn't set, for instance.  c->mode is, which might be a
124          * problem.  The newchan should eventually have a device's open called on
125          * it, at which point it upgrades from a kernel internal chan to one that
126          * can refer to an object in the device (e.g. grab a refcnt on a
127          * conversation in #ip).
128          *
129          * Either we allow devclones of open chans, or O_PATH walks do not open a
130          * file.  It's nice to allow the device to do something for O_PATH, but
131          * perhaps that is not critical.  However, if we can't clone an opened chan,
132          * then we can *only* openat from an FD that is O_PATH, which is not the
133          * spec (and not as useful). */
134         if ((c->flag & COPEN) && !(c->flag & O_PATH))
135                 panic("clone of non-O_PATH open file type %s\n", devtab[c->type].name);
136
137         nc = newchan();
138         nc->type = c->type;
139         nc->dev = c->dev;
140         nc->mode = c->mode;
141         nc->qid = c->qid;
142         nc->offset = c->offset;
143         nc->umh = NULL;
144         nc->mountid = c->mountid;
145         nc->aux = c->aux;
146         nc->mqid = c->mqid;
147         nc->mcp = c->mcp;
148         return nc;
149 }
150
151 struct walkqid *devwalk(struct chan *c,
152                                                 struct chan *nc, char **name, int nname,
153                                                 struct dirtab *tab, int ntab, Devgen * gen)
154 {
155         ERRSTACK(1);
156         int i, j;
157         volatile int alloc;                     /* to keep waserror from optimizing this out */
158         struct walkqid *wq;
159         char *n;
160         struct dir dir;
161
162         if (nname > 0)
163                 isdir(c);
164
165         alloc = 0;
166         wq = kzmalloc(sizeof(struct walkqid) + nname * sizeof(struct qid),
167                                   KMALLOC_WAIT);
168         if (waserror()) {
169                 if (alloc && wq->clone != NULL)
170                         cclose(wq->clone);
171                 kfree(wq);
172                 poperror();
173                 return NULL;
174         }
175         if (nc == NULL) {
176                 nc = devclone(c);
177                 /* inferno was setting this to 0, assuming it was devroot.  lining up
178                  * with chanrelease and newchan */
179                 nc->type = -1;  /* device doesn't know about this channel yet */
180                 alloc = 1;
181         }
182         wq->clone = nc;
183
184         dir.qid.path = 0;
185         for (j = 0; j < nname; j++) {
186                 if (!(nc->qid.type & QTDIR)) {
187                         if (j == 0)
188                                 error(ENOTDIR, NULL);
189                         goto Done;
190                 }
191                 n = name[j];
192                 if (strcmp(n, ".") == 0) {
193 Accept:
194                         wq->qid[wq->nqid++] = nc->qid;
195                         continue;
196                 }
197                 if (strcmp(n, "..") == 0) {
198                         (*gen) (nc, NULL, tab, ntab, DEVDOTDOT, &dir);
199                         nc->qid = dir.qid;
200                         goto Accept;
201                 }
202                 /*
203                  * Ugly problem: If we're using devgen, make sure we're
204                  * walking the directory itself, represented by the first
205                  * entry in the table, and not trying to step into a sub-
206                  * directory of the table, e.g. /net/net. Devgen itself
207                  * should take care of the problem, but it doesn't have
208                  * the necessary information (that we're doing a walk).
209                  */
210                 if (gen == devgen && nc->qid.path != tab[0].qid.path)
211                         goto Notfound;
212                 dir.qid.path = 0;
213                 for (i = 0;; i++) {
214                         switch ((*gen) (nc, n, tab, ntab, i, &dir)) {
215                                 case -1:
216                                         printd("DEVWALK -1, i was %d, want path %p\n", i,
217                                                    c->qid.path);
218 Notfound:
219                                         if (j == 0)
220                                                 error(ENODEV, NULL);
221                                         set_error(ENOENT, NULL);
222                                         goto Done;
223                                 case 0:
224                                         printd("DEVWALK continue, i was %d\n", i);
225                                         continue;
226                                 case 1:
227                                         printd
228                                                 ("DEVWALK gen returns path %p name %s, want path %p\n",
229                                                  dir.qid.path, dir.name, c->qid.path);
230                                         if (strcmp(n, dir.name) == 0) {
231                                                 nc->qid = dir.qid;
232                                                 goto Accept;
233                                         }
234                                         continue;
235                         }
236                 }
237         }
238         /*
239          * We processed at least one name, so will return some data.
240          * If we didn't process all nname entries succesfully, we drop
241          * the cloned channel and return just the Qids of the walks.
242          */
243 Done:
244         poperror();
245         if (wq->nqid < nname) {
246                 if (alloc)
247                         cclose(wq->clone);
248                 wq->clone = NULL;
249         } else if (wq->clone) {
250                 /* attach cloned channel to same device */
251                 wq->clone->type = c->type;
252         }
253         return wq;
254 }
255
256 int
257 devstat(struct chan *c, uint8_t * db, int n,
258                 struct dirtab *tab, int ntab, Devgen * gen)
259 {
260         int i;
261         struct dir dir;
262         char *p, *elem;
263
264         dir.qid.path = 0;
265         for (i = 0;; i++)
266                 switch ((*gen) (c, NULL, tab, ntab, i, &dir)) {
267                         case -1:
268                                 if (c->qid.type & QTDIR) {
269                                         printd("DEVSTAT got a dir: %llu\n", c->qid.path);
270                                         if (c->name == NULL)
271                                                 elem = "???";
272                                         else if (strcmp(c->name->s, "/") == 0)
273                                                 elem = "/";
274                                         else
275                                                 for (elem = p = c->name->s; *p; p++)
276                                                         if (*p == '/')
277                                                                 elem = p + 1;
278                                         devdir(c, c->qid, elem, 0, eve, DMDIR | 0555, &dir);
279                                         n = convD2M(&dir, db, n);
280                                         if (n == 0)
281                                                 error(EINVAL, NULL);
282                                         return n;
283                                 }
284                                 printd("DEVSTAT fails:%s %llu\n", devtab[c->type].name,
285                                            c->qid.path);
286                                 set_errno(ENOENT);
287                                 error(ENODEV, NULL);
288                         case 0:
289                                 printd("DEVSTAT got 0\n");
290                                 break;
291                         case 1:
292                                 printd("DEVSTAT gen returns path %p name %s, want path %p\n",
293                                            dir.qid.path, dir.name, c->qid.path);
294                                 if (c->qid.path == dir.qid.path) {
295                                         if (c->flag & CMSG)
296                                                 dir.mode |= DMMOUNT;
297                                         n = convD2M(&dir, db, n);
298                                         if (n == 0)
299                                                 error(EINVAL, NULL);
300                                         return n;
301                                 }
302                                 break;
303                 }
304 }
305
306 long
307 devdirread(struct chan *c, char *d, long n,
308                    struct dirtab *tab, int ntab, Devgen * gen)
309 {
310         long m, dsz;
311         /* this is gross. Make it 2 so we have room at the end for
312          * bad things.
313          */
314         struct dir dir[4];
315
316         dir[0].qid.path = 0;
317         for (m = 0; m < n; c->dri++) {
318                 switch ((*gen) (c, NULL, tab, ntab, c->dri, &dir[0])) {
319                         case -1:
320                                 printd("DEVDIRREAD got -1, asked for s = %d\n", c->dri);
321                                 return m;
322
323                         case 0:
324                                 printd("DEVDIRREAD got 0, asked for s = %d\n", c->dri);
325                                 break;
326
327                         case 1:
328                                 printd("DEVDIRREAD got 1, asked for s = %d\n", c->dri);
329                                 dsz = convD2M(&dir[0], (uint8_t *) d, n - m);
330                                 if (dsz <= BIT16SZ) {   /* <= not < because this isn't stat; read is stuck */
331                                         if (m == 0)
332                                                 error(ENODATA, NULL);
333                                         return m;
334                                 }
335                                 m += dsz;
336                                 d += dsz;
337                                 break;
338                 }
339         }
340
341         return m;
342 }
343
344 /*
345  * error(EPERM, NULL) if open permission not granted for up->env->user.
346  */
347 void devpermcheck(char *fileuid, uint32_t perm, int omode)
348 {
349         int rwx;
350         /* select user, group, or other from the traditional rwxrwxrwx, shifting
351          * into the upper-most position */
352         if (strcmp(current->user, fileuid) == 0)
353                 perm <<= 0;
354         else if (strcmp(current->user, eve) == 0)
355                 perm <<= 3;
356         else
357                 perm <<= 6;
358         /* translate omode into things like S_IRUSR (just one set of rwx------).
359          * Plan 9 originally only returned 0400 0200 0600 and 0100 here; it didn't
360          * seem to handle O_EXEC being mixed readable or writable. */
361         rwx = omode_to_rwx(omode);
362         if ((rwx & perm) != rwx)
363                 error(EPERM, "devpermcheck(%s, 0%o, 0%o) failed", fileuid, perm, omode);
364 }
365
366 struct chan *devopen(struct chan *c, int omode, struct dirtab *tab, int ntab,
367                                          Devgen * gen)
368 {
369         int i;
370         struct dir dir;
371
372         dir.qid.path = 0;
373         for (i = 0;; i++) {
374                 switch ((*gen) (c, NULL, tab, ntab, i, &dir)) {
375                         case -1:
376                                 goto Return;
377                         case 0:
378                                 break;
379                         case 1:
380                                 if (c->qid.path == dir.qid.path) {
381                                         devpermcheck(dir.uid, dir.mode, omode);
382                                         goto Return;
383                                 }
384                                 break;
385                 }
386         }
387 Return:
388         c->offset = 0;
389         if ((c->qid.type & QTDIR) && (omode & O_WRITE))
390                 error(EACCES, "Tried opening dir with non-read-only mode %o", omode);
391         c->mode = openmode(omode);
392         c->flag |= COPEN;
393         return c;
394 }
395
396 void
397 devcreate(struct chan *c, char *unused_char_p_t, int unused_int, uint32_t u)
398 {
399         error(EPERM, NULL);
400 }
401
402 struct block *devbread(struct chan *c, long n, uint32_t offset)
403 {
404         ERRSTACK(1);
405         struct block *bp;
406
407         bp = allocb(n);
408         if (bp == 0)
409                 error(ENOMEM, NULL);
410         if (waserror()) {
411                 freeb(bp);
412                 nexterror();
413         }
414         bp->wp += devtab[c->type].read(c, bp->wp, n, offset);
415         poperror();
416         return bp;
417 }
418
419 long devbwrite(struct chan *c, struct block *bp, uint32_t offset)
420 {
421         ERRSTACK(1);
422         long n;
423
424         if (waserror()) {
425                 freeb(bp);
426                 nexterror();
427         }
428         n = devtab[c->type].write(c, bp->rp, BLEN(bp), offset);
429         poperror();
430         freeb(bp);
431
432         return n;
433 }
434
435 void devremove(struct chan *c)
436 {
437         error(EPERM, NULL);
438 }
439
440 int devwstat(struct chan *c, uint8_t * unused_uint8_p_t, int i)
441 {
442         error(EPERM, NULL);
443         return 0;
444 }
445
446 void devpower(int i)
447 {
448         error(EPERM, NULL);
449 }
450
451 #if 0
452 int devconfig(int unused_int, char *c, DevConf *)
453 {
454         error(EPERM, NULL);
455         return 0;
456 }
457 #endif
458
459 char *devchaninfo(struct chan *chan, char *ret, size_t ret_l)
460 {
461         snprintf(ret, ret_l, "qid.path: %p, qid.type: %02x", chan->qid.path,
462                          chan->qid.type);
463         return ret;
464 }
465
466 /*
467  * check that the name in a wstat is plausible
468  */
469 void validwstatname(char *name)
470 {
471         validname(name, 0);
472         if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
473                 error(EINVAL, NULL);
474 }
475
476 struct dev *devbyname(char *name)
477 {
478         int i;
479
480         for (i = 0; &devtab[i] < __devtabend; i++)
481                 if (strcmp(devtab[i].name, name) == 0)
482                         return &devtab[i];
483         return NULL;
484 }