Set CEXTERNAL_FLAGS early on create()
[akaros.git] / kern / src / ns / dev.c
1 /* Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
2  * Portions Copyright © 1997-1999 Vita Nuova Limited
3  * Portions Copyright © 2000-2007 Vita Nuova Holdings Limited
4  *                                (www.vitanuova.com)
5  * Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
6  *
7  * Modified for the Akaros operating system:
8  * Copyright (c) 2013-2014 The Regents of the University of California
9  * Copyright (c) 2013-2015 Google Inc.
10  *
11  * Permission is hereby granted, free of charge, to any person obtaining a copy
12  * of this software and associated documentation files (the "Software"), to deal
13  * in the Software without restriction, including without limitation the rights
14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15  * copies of the Software, and to permit persons to whom the Software is
16  * furnished to do so, subject to the following conditions:
17  *
18  * The above copyright notice and this permission notice shall be included in
19  * all copies or substantial portions of the Software.
20  *
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27  * SOFTWARE. */
28
29 #include <vfs.h>
30 #include <kfs.h>
31 #include <slab.h>
32 #include <kmalloc.h>
33 #include <kref.h>
34 #include <string.h>
35 #include <stdio.h>
36 #include <assert.h>
37 #include <error.h>
38 #include <cpio.h>
39 #include <pmap.h>
40 #include <smp.h>
41 #include <ip.h>
42
43 extern uint32_t kerndate;
44 extern char *eve;
45
46 void mkqid(struct qid *q, int64_t path, uint32_t vers, int type)
47 {
48         q->type = type;
49         q->vers = vers;
50         q->path = path;
51 }
52
53 int devno(const char *name, int user)
54 {
55         int i;
56
57         for (i = 0; &devtab[i] < __devtabend; i++) {
58                 if (!strcmp(devtab[i].name, name))
59                         return i;
60         }
61         if (user == 0)
62                 panic("Lookup of dev :%s: failed", name);
63
64         return -1;
65 }
66
67 void
68 devdir(struct chan *c, struct qid qid, char *n,
69            int64_t length, char *user, long perm, struct dir *db)
70 {
71         db->name = n;
72         if (c->flag & CMSG)
73                 qid.type |= QTMOUNT;
74         db->qid = qid;
75         db->type = c->type;     /* used to use the dev's dc here */
76         db->dev = c->dev;
77         db->mode = perm;
78         db->mode |= qid.type << 24;
79         db->atime = seconds();
80         db->mtime = kerndate;
81         db->length = length;
82         db->uid = user;
83         db->gid = eve;
84         db->muid = user;
85 }
86
87 /*
88  * The zeroth element of the table MUST be the directory itself, or '.' (dot),
89  * for processing '..' (dot-dot). Specifically, if i==DEVDOTDOT, we call devdir
90  * on the *directory* (that is, dot), as opposed to children of the directory.
91  * The rest of the system assumes that the first entry in the table refers to
92  * the directory, and by convention this is named '.' (dot). This is confusing.
93  *
94  * Any entry with qid verion of -1 will return 0, indicating that the value is
95  * valid but there is nothing there, so continue walking.
96  *
97  * TODO(cross): Document devgen and clean this mess up. Devgen should probably
98  * be removed and replaced with a smarter data structure.
99  */
100 int
101 devgen(struct chan *c, char *unused_name, struct dirtab *tab, int ntab,
102        int i, struct dir *dp)
103 {
104         if (tab == NULL)
105                 return -1;
106         if (i != DEVDOTDOT) {
107                 /* Skip over the first element, that for the directory itself. */
108                 i++;
109                 if (i < 0 || ntab <= i)
110                         return -1;
111                 tab += i;
112         }
113         if (tab->qid.vers == -1)
114                 return 0;
115         devdir(c, tab->qid, tab->name, tab->length, eve, tab->perm, dp);
116         return 1;
117 }
118
119 void devreset(void)
120 {
121 }
122
123 void devinit(void)
124 {
125 }
126
127 void devshutdown(void)
128 {
129 }
130
131 struct chan *devattach(const char *name, char *spec)
132 {
133         struct chan *c;
134         char *buf;
135         size_t buflen;
136
137         c = newchan();
138         mkqid(&c->qid, 0, 0, QTDIR);
139         c->type = devno(name, 0);
140         if (spec == NULL)
141                 spec = "";
142         /* 1 for #, 1 for ., 1 for \0 */
143         buflen = strlen(name) + strlen(spec) + 3;
144         buf = kzmalloc(buflen, MEM_WAIT);
145         snprintf(buf, sizeof(buf), "#%s.%s", name, spec);
146         c->name = newcname(buf);
147         kfree(buf);
148         return c;
149 }
150
151 struct chan *devclone(struct chan *c)
152 {
153         struct chan *nc;
154
155         /* In plan 9, you couldn't clone an open chan.  We're allowing it, possibly
156          * foolishly.  The new chan is a non-open, "kernel internal" chan.  Note
157          * that c->flag isn't set, for instance.  c->mode is, which might be a
158          * problem.  The newchan should eventually have a device's open called on
159          * it, at which point it upgrades from a kernel internal chan to one that
160          * can refer to an object in the device (e.g. grab a refcnt on a
161          * conversation in #ip).
162          *
163          * Either we allow devclones of open chans, or O_PATH walks do not open a
164          * file.  It's nice to allow the device to do something for O_PATH, but
165          * perhaps that is not critical.  However, if we can't clone an opened chan,
166          * then we can *only* openat from an FD that is O_PATH, which is not the
167          * spec (and not as useful). */
168         if ((c->flag & COPEN) && !(c->flag & O_PATH))
169                 panic("clone of non-O_PATH open file type %s\n", devtab[c->type].name);
170
171         nc = newchan();
172         nc->type = c->type;
173         nc->dev = c->dev;
174         nc->mode = c->mode;
175         nc->qid = c->qid;
176         nc->offset = c->offset;
177         nc->umh = NULL;
178         nc->mountid = c->mountid;
179         nc->aux = c->aux;
180         nc->mqid = c->mqid;
181         nc->mcp = c->mcp;
182         return nc;
183 }
184
185 struct walkqid *devwalk(struct chan *c,
186                                                 struct chan *nc, char **name, int nname,
187                                                 struct dirtab *tab, int ntab, Devgen * gen)
188 {
189         ERRSTACK(1);
190         int i, j;
191         volatile int alloc;                     /* to keep waserror from optimizing this out */
192         struct walkqid *wq;
193         char *n;
194         struct dir dir;
195
196         if (nname > 0)
197                 isdir(c);
198
199         alloc = 0;
200         wq = kzmalloc(sizeof(struct walkqid) + nname * sizeof(struct qid),
201                                   MEM_WAIT);
202         if (waserror()) {
203                 if (alloc && wq->clone != NULL)
204                         cclose(wq->clone);
205                 kfree(wq);
206                 poperror();
207                 return NULL;
208         }
209         if (nc == NULL) {
210                 nc = devclone(c);
211                 /* inferno was setting this to 0, assuming it was devroot.  lining up
212                  * with chanrelease and newchan */
213                 nc->type = -1;  /* device doesn't know about this channel yet */
214                 alloc = 1;
215         }
216         wq->clone = nc;
217
218         dir.qid.path = 0;
219         for (j = 0; j < nname; j++) {
220                 if (!(nc->qid.type & QTDIR)) {
221                         if (j == 0)
222                                 error(ENOTDIR, ERROR_FIXME);
223                         goto Done;
224                 }
225                 n = name[j];
226                 if (strcmp(n, ".") == 0) {
227 Accept:
228                         wq->qid[wq->nqid++] = nc->qid;
229                         continue;
230                 }
231                 if (strcmp(n, "..") == 0) {
232                         (*gen) (nc, NULL, tab, ntab, DEVDOTDOT, &dir);
233                         nc->qid = dir.qid;
234                         goto Accept;
235                 }
236                 /*
237                  * Ugly problem: If we're using devgen, make sure we're
238                  * walking the directory itself, represented by the first
239                  * entry in the table, and not trying to step into a sub-
240                  * directory of the table, e.g. /net/net. Devgen itself
241                  * should take care of the problem, but it doesn't have
242                  * the necessary information (that we're doing a walk).
243                  */
244                 if (gen == devgen && nc->qid.path != tab[0].qid.path)
245                         goto Notfound;
246                 dir.qid.path = 0;
247                 for (i = 0;; i++) {
248                         switch ((*gen) (nc, n, tab, ntab, i, &dir)) {
249                                 case -1:
250                                         printd("DEVWALK -1, i was %d, want path %p\n", i,
251                                                    c->qid.path);
252 Notfound:
253                                         if (j == 0)
254                                                 error(ENOENT, "could not find name %s, dev %s", n,
255                                                       c->type == -1 ? "no dev" : devtab[c->type].name);
256                                         /* TODO: I think we don't need to just set_error here */
257                                         set_error(ENOENT, "tell brho you saw this in an error");
258                                         goto Done;
259                                 case 0:
260                                         printd("DEVWALK continue, i was %d\n", i);
261                                         continue;
262                                 case 1:
263                                         printd
264                                                 ("DEVWALK gen returns path %p name %s, want path %p\n",
265                                                  dir.qid.path, dir.name, c->qid.path);
266                                         if (strcmp(n, dir.name) == 0) {
267                                                 nc->qid = dir.qid;
268                                                 goto Accept;
269                                         }
270                                         continue;
271                         }
272                 }
273         }
274         /*
275          * We processed at least one name, so will return some data.
276          * If we didn't process all nname entries succesfully, we drop
277          * the cloned channel and return just the Qids of the walks.
278          */
279 Done:
280         poperror();
281         if (wq->nqid < nname) {
282                 if (alloc)
283                         cclose(wq->clone);
284                 wq->clone = NULL;
285         } else if (wq->clone) {
286                 /* attach cloned channel to same device */
287                 wq->clone->type = c->type;
288         }
289         return wq;
290 }
291
292 /* Helper, makes a stat in @dp, given @n bytes, from chan @c's contents in @dir.
293  * Throws on error, returns the size used on success. */
294 size_t dev_make_stat(struct chan *c, struct dir *dir, uint8_t *dp, size_t n)
295 {
296         if (c->flag & CMSG)
297                 dir->mode |= DMMOUNT;
298         n = convD2M(dir, dp, n);
299         if (n == 0)
300                 error(EINVAL, ERROR_FIXME);
301         return n;
302 }
303
304 int
305 devstat(struct chan *c, uint8_t * db, int n,
306                 struct dirtab *tab, int ntab, Devgen * gen)
307 {
308         int i;
309         struct dir dir;
310         char *p, *elem;
311
312         dir.qid.path = 0;
313         for (i = 0;; i++)
314                 switch ((*gen) (c, NULL, tab, ntab, i, &dir)) {
315                         case -1:
316                                 if (c->qid.type & QTDIR) {
317                                         printd("DEVSTAT got a dir: %llu\n", c->qid.path);
318                                         if (c->name == NULL)
319                                                 elem = "???";
320                                         else if (strcmp(c->name->s, "/") == 0)
321                                                 elem = "/";
322                                         else
323                                                 for (elem = p = c->name->s; *p; p++)
324                                                         if (*p == '/')
325                                                                 elem = p + 1;
326                                         devdir(c, c->qid, elem, 0, eve, DMDIR | 0555, &dir);
327                                         n = convD2M(&dir, db, n);
328                                         if (n == 0)
329                                                 error(EINVAL, ERROR_FIXME);
330                                         return n;
331                                 }
332                                 printd("DEVSTAT fails:%s %llu\n", devtab[c->type].name,
333                                            c->qid.path);
334                                 error(ENOENT, ERROR_FIXME);
335                         case 0:
336                                 printd("DEVSTAT got 0\n");
337                                 break;
338                         case 1:
339                                 printd("DEVSTAT gen returns path %p name %s, want path %p\n",
340                                            dir.qid.path, dir.name, c->qid.path);
341                                 if (c->qid.path == dir.qid.path)
342                                         return dev_make_stat(c, &dir, db, n);
343                                 break;
344                 }
345 }
346
347 long
348 devdirread(struct chan *c, char *d, long n,
349                    struct dirtab *tab, int ntab, Devgen * gen)
350 {
351         long m, dsz;
352         /* this is gross. Make it 2 so we have room at the end for
353          * bad things.
354          */
355         struct dir dir[4];
356
357         dir[0].qid.path = 0;
358         for (m = 0; m < n; c->dri++) {
359                 switch ((*gen) (c, NULL, tab, ntab, c->dri, &dir[0])) {
360                         case -1:
361                                 printd("DEVDIRREAD got -1, asked for s = %d\n", c->dri);
362                                 return m;
363
364                         case 0:
365                                 printd("DEVDIRREAD got 0, asked for s = %d\n", c->dri);
366                                 break;
367
368                         case 1:
369                                 printd("DEVDIRREAD got 1, asked for s = %d\n", c->dri);
370                                 dsz = convD2M(&dir[0], (uint8_t *) d, n - m);
371                                 if (dsz <= BIT16SZ) {   /* <= not < because this isn't stat; read is stuck */
372                                         if (m == 0)
373                                                 error(ENODATA, ERROR_FIXME);
374                                         return m;
375                                 }
376                                 m += dsz;
377                                 d += dsz;
378                                 break;
379                 }
380         }
381
382         return m;
383 }
384
385 /*
386  * error(EPERM, ERROR_FIXME) if open permission not granted for up->env->user.
387  */
388 void devpermcheck(char *fileuid, uint32_t perm, int omode)
389 {
390         int rwx;
391
392         /* TODO: Implement permission checking, for now permission is always
393          * granted. */
394         return;
395         /* select user, group, or other from the traditional rwxrwxrwx, shifting
396          * into the upper-most position */
397         if (strcmp(current->user, fileuid) == 0)
398                 perm <<= 0;
399         else if (strcmp(current->user, eve) == 0)
400                 perm <<= 3;
401         else
402                 perm <<= 6;
403         /* translate omode into things like S_IRUSR (just one set of rwx------).
404          * Plan 9 originally only returned 0400 0200 0600 and 0100 here; it didn't
405          * seem to handle O_EXEC being mixed readable or writable. */
406         rwx = omode_to_rwx(omode);
407         if ((rwx & perm) != rwx)
408                 error(EPERM, "devpermcheck(%s, 0%o, 0%o) failed", fileuid, perm, omode);
409 }
410
411 struct chan *devopen(struct chan *c, int omode, struct dirtab *tab, int ntab,
412                                          Devgen * gen)
413 {
414         int i;
415         struct dir dir;
416
417         dir.qid.path = 0;
418         for (i = 0;; i++) {
419                 switch ((*gen) (c, NULL, tab, ntab, i, &dir)) {
420                         case -1:
421                                 goto Return;
422                         case 0:
423                                 break;
424                         case 1:
425                                 if (c->qid.path == dir.qid.path) {
426                                         devpermcheck(dir.uid, dir.mode, omode);
427                                         goto Return;
428                                 }
429                                 break;
430                 }
431         }
432 Return:
433         c->offset = 0;
434         if ((c->qid.type & QTDIR) && (omode & O_WRITE))
435                 error(EACCES, "Tried opening dir with non-read-only mode %o", omode);
436         c->mode = openmode(omode);
437         c->flag |= COPEN;
438         return c;
439 }
440
441 void
442 devcreate(struct chan *c, char *unused_char_p_t, int unused_int, uint32_t u)
443 {
444         error(EPERM, ERROR_FIXME);
445 }
446
447 struct block *devbread(struct chan *c, long n, uint32_t offset)
448 {
449         ERRSTACK(1);
450         struct block *bp;
451
452         bp = block_alloc(n, MEM_WAIT);
453         if (bp == 0)
454                 error(ENOMEM, ERROR_FIXME);
455         if (waserror()) {
456                 freeb(bp);
457                 nexterror();
458         }
459         bp->wp += devtab[c->type].read(c, bp->wp, n, offset);
460         poperror();
461         return bp;
462 }
463
464 long devbwrite(struct chan *c, struct block *bp, uint32_t offset)
465 {
466         ERRSTACK(1);
467         long n;
468
469         if (waserror()) {
470                 freeb(bp);
471                 nexterror();
472         }
473         n = devtab[c->type].write(c, bp->rp, BLEN(bp), offset);
474         poperror();
475         freeb(bp);
476
477         return n;
478 }
479
480 void devremove(struct chan *c)
481 {
482         error(EPERM, ERROR_FIXME);
483 }
484
485 int devwstat(struct chan *c, uint8_t * unused_uint8_p_t, int i)
486 {
487         error(EPERM, ERROR_FIXME);
488         return 0;
489 }
490
491 void devpower(int i)
492 {
493         error(EPERM, ERROR_FIXME);
494 }
495
496 #if 0
497 int devconfig(int unused_int, char *c, DevConf *)
498 {
499         error(EPERM, ERROR_FIXME);
500         return 0;
501 }
502 #endif
503
504 char *devchaninfo(struct chan *chan, char *ret, size_t ret_l)
505 {
506         snprintf(ret, ret_l, "qid.path: %p, qid.type: %02x", chan->qid.path,
507                          chan->qid.type);
508         return ret;
509 }
510
511 /*
512  * check that the name in a wstat is plausible
513  */
514 void validwstatname(char *name)
515 {
516         validname(name, 0);
517         if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
518                 error(EINVAL, ERROR_FIXME);
519 }
520
521 struct dev *devbyname(char *name)
522 {
523         int i;
524
525         for (i = 0; &devtab[i] < __devtabend; i++)
526                 if (strcmp(devtab[i].name, name) == 0)
527                         return &devtab[i];
528         return NULL;
529 }