vfs: Remove KFS, blockdev and devfs
[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 <slab.h>
31 #include <kmalloc.h>
32 #include <kref.h>
33 #include <string.h>
34 #include <stdio.h>
35 #include <assert.h>
36 #include <error.h>
37 #include <cpio.h>
38 #include <pmap.h>
39 #include <smp.h>
40 #include <net/ip.h>
41
42 extern uint32_t kerndate;
43 extern struct username eve;
44
45 void mkqid(struct qid *q, int64_t path, uint32_t vers, int type)
46 {
47         q->type = type;
48         q->vers = vers;
49         q->path = path;
50 }
51
52 int devno(const char *name, int user)
53 {
54         int i;
55
56         for (i = 0; &devtab[i] < __devtabend; i++) {
57                 if (!strcmp(devtab[i].name, name))
58                         return i;
59         }
60         if (user == 0)
61                 panic("Lookup of dev :%s: failed", name);
62
63         return -1;
64 }
65
66 void
67 devdir(struct chan *c, struct qid qid, char *n,
68            int64_t length, char *user, long perm, struct dir *db)
69 {
70         struct timespec now = nsec2timespec(epoch_nsec());
71
72         db->name = n;
73         if (c->flag & CMSG)
74                 qid.type |= QTMOUNT;
75         db->qid = qid;
76         db->type = c->type;     /* used to use the dev's dc here */
77         db->dev = c->dev;
78         db->mode = perm;
79         db->mode |= qid.type << 24;
80         db->length = length;
81         db->uid = user;
82         db->gid = eve.name;
83         db->muid = user;
84         db->ext = NULL;
85         /* TODO: once we figure out what to do for uid/gid, then we can try to tie
86          * that to the n_uid.  Or just ignore it, and only use that as a
87          * pass-through for 9p2000.u. */
88         db->n_uid = 0;
89         db->n_gid = 0;
90         db->n_muid = 0;
91         /* TODO: what does devdir really want? */
92         db->atime = now;
93         db->btime = now;
94         db->ctime = now;
95         db->mtime = now;
96 }
97
98 /*
99  * The zeroth element of the table MUST be the directory itself, or '.' (dot),
100  * for processing '..' (dot-dot). Specifically, if i==DEVDOTDOT, we call devdir
101  * on the *directory* (that is, dot), as opposed to children of the directory.
102  * The rest of the system assumes that the first entry in the table refers to
103  * the directory, and by convention this is named '.' (dot). This is confusing.
104  *
105  * Any entry with qid verion of -1 will return 0, indicating that the value is
106  * valid but there is nothing there, so continue walking.
107  *
108  * TODO(cross): Document devgen and clean this mess up. Devgen should probably
109  * be removed and replaced with a smarter data structure.
110  *
111  * Keep in mind that the expected behavior of gen functions that interoperate
112  * with dev functions (e.g. devdirread()) is that files are directly genned, but
113  * not directories.  Directories will fail to gen, and devstat() just makes
114  * something up.  See also:
115  * https://github.com/brho/plan9/blob/89d43d2262ad43eb4b26c2a8d6a27cfeddb33828/nix/sys/src/nix/port/dev.c#L74
116  *
117  * The comment about genning a file's siblings needs a grain of salt too.  Look
118  * through ipgen().  I think it's what I call "direct genning." */
119 int
120 devgen(struct chan *c, char *unused_name, struct dirtab *tab, int ntab,
121        int i, struct dir *dp)
122 {
123         if (tab == NULL)
124                 return -1;
125         if (i != DEVDOTDOT) {
126                 /* Skip over the first element, that for the directory itself. */
127                 i++;
128                 if (i < 0 || ntab <= i)
129                         return -1;
130                 tab += i;
131         }
132         if (tab->qid.vers == -1)
133                 return 0;
134         devdir(c, tab->qid, tab->name, tab->length, eve.name, tab->perm, dp);
135         return 1;
136 }
137
138 void devreset(void)
139 {
140 }
141
142 void devinit(void)
143 {
144 }
145
146 void devshutdown(void)
147 {
148 }
149
150 struct chan *devattach(const char *name, char *spec)
151 {
152         struct chan *c;
153         char *buf;
154         size_t buflen;
155
156         c = newchan();
157         mkqid(&c->qid, 0, 0, QTDIR);
158         c->type = devno(name, 0);
159         if (spec == NULL)
160                 spec = "";
161         /* 1 for #, 1 for ., 1 for \0 */
162         buflen = strlen(name) + strlen(spec) + 3;
163         buf = kzmalloc(buflen, MEM_WAIT);
164         snprintf(buf, sizeof(buf), "#%s.%s", name, spec);
165         c->name = newcname(buf);
166         kfree(buf);
167         return c;
168 }
169
170 struct chan *devclone(struct chan *c)
171 {
172         struct chan *nc;
173
174         /* In plan 9, you couldn't clone an open chan.  We're allowing it, possibly
175          * foolishly.  The new chan is a non-open, "kernel internal" chan.  Note
176          * that c->flag isn't set, for instance.  c->mode is, which might be a
177          * problem.  The newchan should eventually have a device's open called on
178          * it, at which point it upgrades from a kernel internal chan to one that
179          * can refer to an object in the device (e.g. grab a refcnt on a
180          * conversation in #ip).
181          *
182          * Either we allow devclones of open chans, or O_PATH walks do not open a
183          * file.  It's nice to allow the device to do something for O_PATH, but
184          * perhaps that is not critical.  However, if we can't clone an opened chan,
185          * then we can *only* openat from an FD that is O_PATH, which is not the
186          * spec (and not as useful). */
187         if ((c->flag & COPEN) && !(c->flag & O_PATH))
188                 panic("clone of non-O_PATH open file type %s\n", devtab[c->type].name);
189
190         nc = newchan();
191         nc->type = c->type;
192         nc->dev = c->dev;
193         nc->mode = c->mode;
194         nc->qid = c->qid;
195         nc->offset = c->offset;
196         nc->umh = NULL;
197         nc->mountid = c->mountid;
198         nc->aux = c->aux;
199         nc->mqid = c->mqid;
200         nc->mcp = c->mcp;
201         return nc;
202 }
203
204 struct walkqid *devwalk(struct chan *c,
205                                                 struct chan *nc, char **name, int nname,
206                                                 struct dirtab *tab, int ntab, Devgen * gen)
207 {
208         ERRSTACK(1);
209         int i, j;
210         volatile int alloc;                     /* to keep waserror from optimizing this out */
211         struct walkqid *wq;
212         char *n;
213         struct dir dir;
214
215         if (nname > 0)
216                 isdir(c);
217
218         alloc = 0;
219         wq = kzmalloc(sizeof(struct walkqid) + nname * sizeof(struct qid),
220                                   MEM_WAIT);
221         if (waserror()) {
222                 if (alloc && wq->clone != NULL)
223                         cclose(wq->clone);
224                 kfree(wq);
225                 poperror();
226                 return NULL;
227         }
228         if (nc == NULL) {
229                 nc = devclone(c);
230                 /* inferno was setting this to 0, assuming it was devroot.  lining up
231                  * with chanrelease and newchan */
232                 nc->type = -1;  /* device doesn't know about this channel yet */
233                 alloc = 1;
234         }
235         wq->clone = nc;
236
237         dir.qid.path = 0;
238         for (j = 0; j < nname; j++) {
239                 if (!(nc->qid.type & QTDIR)) {
240                         if (j == 0)
241                                 error(ENOTDIR, ERROR_FIXME);
242                         goto Done;
243                 }
244                 n = name[j];
245                 if (strcmp(n, ".") == 0) {
246 Accept:
247                         wq->qid[wq->nqid++] = nc->qid;
248                         continue;
249                 }
250                 if (strcmp(n, "..") == 0) {
251                         (*gen) (nc, NULL, tab, ntab, DEVDOTDOT, &dir);
252                         nc->qid = dir.qid;
253                         goto Accept;
254                 }
255                 /*
256                  * Ugly problem: If we're using devgen, make sure we're
257                  * walking the directory itself, represented by the first
258                  * entry in the table, and not trying to step into a sub-
259                  * directory of the table, e.g. /net/net. Devgen itself
260                  * should take care of the problem, but it doesn't have
261                  * the necessary information (that we're doing a walk).
262                  */
263                 if (gen == devgen && nc->qid.path != tab[0].qid.path)
264                         goto Notfound;
265                 dir.qid.path = 0;
266                 for (i = 0;; i++) {
267                         switch ((*gen) (nc, n, tab, ntab, i, &dir)) {
268                                 case -1:
269                                         printd("DEVWALK -1, i was %d, want path %p\n", i,
270                                                    c->qid.path);
271 Notfound:
272                                         set_error(ENOENT, "could not find name %s, dev %s", n,
273                                                       c->type == -1 ? "no dev" : devtab[c->type].name);
274                                         if (j == 0)
275                                                 error_jmp();
276                                         goto Done;
277                                 case 0:
278                                         printd("DEVWALK continue, i was %d\n", i);
279                                         continue;
280                                 case 1:
281                                         printd
282                                                 ("DEVWALK gen returns path %p name %s, want path %p\n",
283                                                  dir.qid.path, dir.name, c->qid.path);
284                                         if (strcmp(n, dir.name) == 0) {
285                                                 nc->qid = dir.qid;
286                                                 goto Accept;
287                                         }
288                                         continue;
289                         }
290                 }
291         }
292         /*
293          * We processed at least one name, so will return some data.
294          * If we didn't process all nname entries succesfully, we drop
295          * the cloned channel and return just the Qids of the walks.
296          */
297 Done:
298         poperror();
299         if (wq->nqid < nname) {
300                 if (alloc)
301                         cclose(wq->clone);
302                 wq->clone = NULL;
303         } else if (wq->clone) {
304                 /* attach cloned channel to same device */
305                 wq->clone->type = c->type;
306         } else {
307                 /* Not sure this is possible, would like to know. */
308                 warn_once("had enough names, but still no wq->clone");
309         }
310         return wq;
311 }
312
313 /* Helper, makes a stat in @dp, given @n bytes, from chan @c's contents in @dir.
314  * Throws on error, returns the size used on success. */
315 size_t dev_make_stat(struct chan *c, struct dir *dir, uint8_t *dp, size_t n)
316 {
317         if (c->flag & CMSG)
318                 dir->mode |= DMMOUNT;
319         n = convD2M(dir, dp, n);
320         if (n == 0)
321                 error(EINVAL, ERROR_FIXME);
322         return n;
323 }
324
325 size_t devstat(struct chan *c, uint8_t *db, size_t n, struct dirtab *tab,
326                int ntab, Devgen *gen)
327 {
328         int i;
329         struct dir dir;
330         char *p, *elem;
331
332         dir.qid.path = 0;
333         for (i = 0;; i++)
334                 switch ((*gen) (c, NULL, tab, ntab, i, &dir)) {
335                         case -1:
336                                 if (c->qid.type & QTDIR) {
337                                         printd("DEVSTAT got a dir: %llu\n", c->qid.path);
338                                         if (c->name == NULL)
339                                                 elem = "???";
340                                         else if (strcmp(c->name->s, "/") == 0)
341                                                 elem = "/";
342                                         else
343                                                 for (elem = p = c->name->s; *p; p++)
344                                                         if (*p == '/')
345                                                                 elem = p + 1;
346                                         devdir(c, c->qid, elem, 0, eve.name, DMDIR | 0555, &dir);
347                                         n = convD2M(&dir, db, n);
348                                         if (n == 0)
349                                                 error(EINVAL, ERROR_FIXME);
350                                         return n;
351                                 }
352                                 printd("DEVSTAT fails:%s %llu\n", devtab[c->type].name,
353                                            c->qid.path);
354                                 error(ENOENT, ERROR_FIXME);
355                         case 0:
356                                 printd("DEVSTAT got 0\n");
357                                 break;
358                         case 1:
359                                 printd("DEVSTAT gen returns path %p name %s, want path %p\n",
360                                            dir.qid.path, dir.name, c->qid.path);
361                                 if (c->qid.path == dir.qid.path)
362                                         return dev_make_stat(c, &dir, db, n);
363                                 break;
364                 }
365 }
366
367 long
368 devdirread(struct chan *c, char *d, long n,
369                    struct dirtab *tab, int ntab, Devgen * gen)
370 {
371         long m, dsz;
372         /* this is gross. Make it 2 so we have room at the end for
373          * bad things.
374          */
375         struct dir dir[4];
376
377         dir[0].qid.path = 0;
378         for (m = 0; m < n; c->dri++) {
379                 switch ((*gen) (c, NULL, tab, ntab, c->dri, &dir[0])) {
380                         case -1:
381                                 printd("DEVDIRREAD got -1, asked for s = %d\n", c->dri);
382                                 return m;
383
384                         case 0:
385                                 printd("DEVDIRREAD got 0, asked for s = %d\n", c->dri);
386                                 break;
387
388                         case 1:
389                                 printd("DEVDIRREAD got 1, asked for s = %d\n", c->dri);
390                                 dsz = convD2M(&dir[0], (uint8_t *) d, n - m);
391                                 if (dsz <= BIT16SZ) {   /* <= not < because this isn't stat; read is stuck */
392                                         if (m == 0)
393                                                 error(ENODATA, ERROR_FIXME);
394                                         return m;
395                                 }
396                                 m += dsz;
397                                 d += dsz;
398                                 break;
399                 }
400         }
401
402         return m;
403 }
404
405 /*
406  * Throws an error if open permission not granted for current->user.name
407  */
408 void devpermcheck(char *fileuid, uint32_t perm, int omode)
409 {
410         if (!caller_has_perms(fileuid, perm, omode))
411                 error(EPERM, "permcheck(user: %s, rwx: 0%o, omode 0%o) failed",
412                       fileuid, perm, omode);
413 }
414
415 struct chan *devopen(struct chan *c, int omode, struct dirtab *tab, int ntab,
416                                          Devgen * gen)
417 {
418         int i;
419         struct dir dir;
420
421         dir.qid.path = 0;
422         for (i = 0;; i++) {
423                 switch ((*gen) (c, NULL, tab, ntab, i, &dir)) {
424                         case -1:
425                                 goto Return;
426                         case 0:
427                                 break;
428                         case 1:
429                                 if (c->qid.path == dir.qid.path) {
430                                         devpermcheck(dir.uid, dir.mode, omode);
431                                         goto Return;
432                                 }
433                                 break;
434                 }
435         }
436 Return:
437         c->offset = 0;
438         if ((c->qid.type & QTDIR) && (omode & O_WRITE))
439                 error(EACCES, "Tried opening dir with non-read-only mode %o", omode);
440         c->mode = openmode(omode);
441         c->flag |= COPEN;
442         return c;
443 }
444
445 void devcreate(struct chan *c, char *unused_char_p_t, int unused_int,
446                uint32_t u, char *ext)
447 {
448         error(EPERM, ERROR_FIXME);
449 }
450
451 struct block *devbread(struct chan *c, size_t n, off64_t offset)
452 {
453         ERRSTACK(1);
454         struct block *bp;
455
456         bp = block_alloc(n, MEM_WAIT);
457         if (bp == 0)
458                 error(ENOMEM, ERROR_FIXME);
459         if (waserror()) {
460                 freeb(bp);
461                 nexterror();
462         }
463         bp->wp += devtab[c->type].read(c, bp->wp, n, offset);
464         poperror();
465         return bp;
466 }
467
468 size_t devbwrite(struct chan *c, struct block *bp, off64_t offset)
469 {
470         ERRSTACK(1);
471         long n;
472
473         if (waserror()) {
474                 freeb(bp);
475                 nexterror();
476         }
477         n = devtab[c->type].write(c, bp->rp, BLEN(bp), offset);
478         poperror();
479         freeb(bp);
480
481         return n;
482 }
483
484 void devremove(struct chan *c)
485 {
486         error(EPERM, ERROR_FIXME);
487 }
488
489 size_t devwstat(struct chan *c, uint8_t *unused_uint8_p_t, size_t i)
490 {
491         error(EPERM, ERROR_FIXME);
492         return 0;
493 }
494
495 void devpower(int i)
496 {
497         error(EPERM, ERROR_FIXME);
498 }
499
500 #if 0
501 int devconfig(int unused_int, char *c, DevConf *)
502 {
503         error(EPERM, ERROR_FIXME);
504         return 0;
505 }
506 #endif
507
508 char *devchaninfo(struct chan *chan, char *ret, size_t ret_l)
509 {
510         snprintf(ret, ret_l, "qid.path: %p, qid.type: %02x", chan->qid.path,
511                          chan->qid.type);
512         return ret;
513 }
514
515 /*
516  * check that the name in a wstat is plausible
517  */
518 void validwstatname(char *name)
519 {
520         validname(name, 0);
521         if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
522                 error(EINVAL, ERROR_FIXME);
523 }
524
525 struct dev *devbyname(char *name)
526 {
527         int i;
528
529         for (i = 0; &devtab[i] < __devtabend; i++)
530                 if (strcmp(devtab[i].name, name) == 0)
531                         return &devtab[i];
532         return NULL;
533 }