Properly convert open mode flags to rwx [3/7]
[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(int c, int user)
27 {
28         int i;
29
30         for (i = 0; &devtab[i] < __devtabend; i++) {
31                 if (devtab[i].dc == c)
32                         return i;
33         }
34         if (user == 0)
35                 panic("devno %c 0x%u", c, c);
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 = devtab[c->type].dc;
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(int tc, char *spec)
98 {
99         struct chan *c;
100         char *buf;
101
102         c = newchan();
103         mkqid(&c->qid, 0, 0, QTDIR);
104         c->type = devno(tc, 0);
105         if (spec == NULL)
106                 spec = "";
107         /* 2 for #c, 1 for \0 */
108         buf = kzmalloc(2 + strlen(spec) + 1, KMALLOC_WAIT);
109         snprintf(buf, sizeof(buf), "#%c%s", tc, spec);
110         c->name = newcname(buf);
111         kfree(buf);
112         return c;
113 }
114
115 struct chan *devclone(struct chan *c)
116 {
117         struct chan *nc;
118
119         if (c->flag & COPEN)
120                 panic("clone of open file type %c\n", devtab[c->type].dc);
121
122         nc = newchan();
123
124         nc->type = c->type;
125         nc->dev = c->dev;
126         nc->mode = c->mode;
127         nc->qid = c->qid;
128         nc->offset = c->offset;
129         nc->umh = NULL;
130         nc->mountid = c->mountid;
131         nc->aux = c->aux;
132         nc->mqid = c->mqid;
133         nc->mcp = c->mcp;
134         return nc;
135 }
136
137 struct walkqid *devwalk(struct chan *c,
138                                                 struct chan *nc, char **name, int nname,
139                                                 struct dirtab *tab, int ntab, Devgen * gen)
140 {
141         ERRSTACK(1);
142         int i, j;
143         volatile int alloc;                     /* to keep waserror from optimizing this out */
144         struct walkqid *wq;
145         char *n;
146         struct dir dir;
147
148         if (nname > 0)
149                 isdir(c);
150
151         alloc = 0;
152         wq = kzmalloc(sizeof(struct walkqid) + nname * sizeof(struct qid),
153                                   KMALLOC_WAIT);
154         if (waserror()) {
155                 if (alloc && wq->clone != NULL)
156                         cclose(wq->clone);
157                 kfree(wq);
158                 poperror();
159                 return NULL;
160         }
161         if (nc == NULL) {
162                 nc = devclone(c);
163                 /* inferno was setting this to 0, assuming it was devroot.  lining up
164                  * with chanrelease and newchan */
165                 nc->type = -1;  /* device doesn't know about this channel yet */
166                 alloc = 1;
167         }
168         wq->clone = nc;
169
170         dir.qid.path = 0;
171         for (j = 0; j < nname; j++) {
172                 if (!(nc->qid.type & QTDIR)) {
173                         if (j == 0)
174                                 error(Enotdir);
175                         goto Done;
176                 }
177                 n = name[j];
178                 if (strcmp(n, ".") == 0) {
179 Accept:
180                         wq->qid[wq->nqid++] = nc->qid;
181                         continue;
182                 }
183                 if (strcmp(n, "..") == 0) {
184                         (*gen) (nc, NULL, tab, ntab, DEVDOTDOT, &dir);
185                         nc->qid = dir.qid;
186                         goto Accept;
187                 }
188                 /*
189                  * Ugly problem: If we're using devgen, make sure we're
190                  * walking the directory itself, represented by the first
191                  * entry in the table, and not trying to step into a sub-
192                  * directory of the table, e.g. /net/net. Devgen itself
193                  * should take care of the problem, but it doesn't have
194                  * the necessary information (that we're doing a walk).
195                  */
196                 if (gen == devgen && nc->qid.path != tab[0].qid.path)
197                         goto Notfound;
198                 dir.qid.path = 0;
199                 for (i = 0;; i++) {
200                         switch ((*gen) (nc, n, tab, ntab, i, &dir)) {
201                                 case -1:
202                                         printd("DEVWALK -1, i was %d, want path %p\n", i,
203                                                    c->qid.path);
204 Notfound:
205                                         set_errno(ENOENT);
206                                         if (j == 0)
207                                                 error(Enonexist);
208                                         set_errstr(Enonexist);
209                                         goto Done;
210                                 case 0:
211                                         printd("DEVWALK continue, i was %d\n", i);
212                                         continue;
213                                 case 1:
214                                         printd
215                                                 ("DEVWALK gen returns path %p name %s, want path %p\n",
216                                                  dir.qid.path, dir.name, c->qid.path);
217                                         if (strcmp(n, dir.name) == 0) {
218                                                 nc->qid = dir.qid;
219                                                 goto Accept;
220                                         }
221                                         continue;
222                         }
223                 }
224         }
225         /*
226          * We processed at least one name, so will return some data.
227          * If we didn't process all nname entries succesfully, we drop
228          * the cloned channel and return just the Qids of the walks.
229          */
230 Done:
231         poperror();
232         if (wq->nqid < nname) {
233                 if (alloc)
234                         cclose(wq->clone);
235                 wq->clone = NULL;
236         } else if (wq->clone) {
237                 /* attach cloned channel to same device */
238                 wq->clone->type = c->type;
239         }
240         return wq;
241 }
242
243 int
244 devstat(struct chan *c, uint8_t * db, int n,
245                 struct dirtab *tab, int ntab, Devgen * gen)
246 {
247         int i;
248         struct dir dir;
249         char *p, *elem;
250
251         dir.qid.path = 0;
252         for (i = 0;; i++)
253                 switch ((*gen) (c, NULL, tab, ntab, i, &dir)) {
254                         case -1:
255                                 if (c->qid.type & QTDIR) {
256                                         printd("DEVSTAT got a dir: %llu\n", c->qid.path);
257                                         if (c->name == NULL)
258                                                 elem = "???";
259                                         else if (strcmp(c->name->s, "/") == 0)
260                                                 elem = "/";
261                                         else
262                                                 for (elem = p = c->name->s; *p; p++)
263                                                         if (*p == '/')
264                                                                 elem = p + 1;
265                                         devdir(c, c->qid, elem, 0, eve, DMDIR | 0555, &dir);
266                                         n = convD2M(&dir, db, n);
267                                         if (n == 0)
268                                                 error(Ebadarg);
269                                         return n;
270                                 }
271                                 printd("DEVSTAT fails:%c %llu\n", devtab[c->type].dc,
272                                            c->qid.path);
273                                 set_errno(ENOENT);
274                                 error(Enonexist);
275                         case 0:
276                                 printd("DEVSTAT got 0\n");
277                                 break;
278                         case 1:
279                                 printd("DEVSTAT gen returns path %p name %s, want path %p\n",
280                                            dir.qid.path, dir.name, c->qid.path);
281                                 if (c->qid.path == dir.qid.path) {
282                                         if (c->flag & CMSG)
283                                                 dir.mode |= DMMOUNT;
284                                         n = convD2M(&dir, db, n);
285                                         if (n == 0)
286                                                 error(Ebadarg);
287                                         return n;
288                                 }
289                                 break;
290                 }
291 }
292
293 long
294 devdirread(struct chan *c, char *d, long n,
295                    struct dirtab *tab, int ntab, Devgen * gen)
296 {
297         long m, dsz;
298         /* this is gross. Make it 2 so we have room at the end for
299          * bad things.
300          */
301         struct dir dir[4];
302
303         dir[0].qid.path = 0;
304         for (m = 0; m < n; c->dri++) {
305                 switch ((*gen) (c, NULL, tab, ntab, c->dri, &dir[0])) {
306                         case -1:
307                                 printd("DEVDIRREAD got -1, asked for s = %d\n", c->dri);
308                                 return m;
309
310                         case 0:
311                                 printd("DEVDIRREAD got 0, asked for s = %d\n", c->dri);
312                                 break;
313
314                         case 1:
315                                 printd("DEVDIRREAD got 1, asked for s = %d\n", c->dri);
316                                 dsz = convD2M(&dir[0], (uint8_t *) d, n - m);
317                                 if (dsz <= BIT16SZ) {   /* <= not < because this isn't stat; read is stuck */
318                                         if (m == 0)
319                                                 error(Eshort);
320                                         return m;
321                                 }
322                                 m += dsz;
323                                 d += dsz;
324                                 break;
325                 }
326         }
327
328         return m;
329 }
330
331 /*
332  * error(Eperm) if open permission not granted for up->env->user.
333  */
334 void devpermcheck(char *fileuid, uint32_t perm, int omode)
335 {
336         int rwx;
337         /* select user, group, or other from the traditional rwxrwxrwx, shifting
338          * into the upper-most position */
339         if (strcmp(current->user, fileuid) == 0)
340                 perm <<= 0;
341         else if (strcmp(current->user, eve) == 0)
342                 perm <<= 3;
343         else
344                 perm <<= 6;
345         /* translate omode into things like S_IRUSR (just one set of rwx------).
346          * Plan 9 originally only returned 0400 0200 0600 and 0100 here; it didn't
347          * seem to handle O_EXEC being mixed readable or writable. */
348         rwx = omode_to_rwx(omode);
349         if ((rwx & perm) != rwx)
350                 error("%s: devpermcheck(%s,0x%x,0x%x) failed", Eperm, fileuid, perm,
351                           omode);
352 }
353
354 struct chan *devopen(struct chan *c, int omode, struct dirtab *tab, int ntab,
355                                          Devgen * gen)
356 {
357         int i;
358         struct dir dir;
359
360         dir.qid.path = 0;
361         for (i = 0;; i++) {
362                 switch ((*gen) (c, NULL, tab, ntab, i, &dir)) {
363                         case -1:
364                                 goto Return;
365                         case 0:
366                                 break;
367                         case 1:
368                                 if (c->qid.path == dir.qid.path) {
369                                         devpermcheck(dir.uid, dir.mode, omode);
370                                         goto Return;
371                                 }
372                                 break;
373                 }
374         }
375 Return:
376         c->offset = 0;
377         if ((c->qid.type & QTDIR) && !IS_RDONLY(omode))
378                 error("Tried opening dir with non-read-only mode %o", omode);
379         c->mode = openmode(omode);
380         c->flag |= COPEN;
381         return c;
382 }
383
384 void
385 devcreate(struct chan *c, char *unused_char_p_t, int unused_int, uint32_t u)
386 {
387         error(Eperm);
388 }
389
390 struct block *devbread(struct chan *c, long n, uint32_t offset)
391 {
392         ERRSTACK(1);
393         struct block *bp;
394
395         bp = allocb(n);
396         if (bp == 0)
397                 error(Enomem);
398         if (waserror()) {
399                 freeb(bp);
400                 nexterror();
401         }
402         bp->wp += devtab[c->type].read(c, bp->wp, n, offset);
403         poperror();
404         return bp;
405 }
406
407 long devbwrite(struct chan *c, struct block *bp, uint32_t offset)
408 {
409         ERRSTACK(1);
410         long n;
411
412         if (waserror()) {
413                 freeb(bp);
414                 nexterror();
415         }
416         n = devtab[c->type].write(c, bp->rp, BLEN(bp), offset);
417         poperror();
418         freeb(bp);
419
420         return n;
421 }
422
423 void devremove(struct chan *c)
424 {
425         error(Eperm);
426 }
427
428 int devwstat(struct chan *c, uint8_t * unused_uint8_p_t, int i)
429 {
430         error(Eperm);
431         return 0;
432 }
433
434 void devpower(int i)
435 {
436         error(Eperm);
437 }
438
439 #if 0
440 int devconfig(int unused_int, char *c, DevConf *)
441 {
442         error(Eperm);
443         return 0;
444 }
445 #endif
446
447 char *devchaninfo(struct chan *chan, char *ret, size_t ret_l)
448 {
449         snprintf(ret, ret_l, "qid.path: %p, qid.type: %02x", chan->qid.path,
450                          chan->qid.type);
451         return ret;
452 }
453
454 /*
455  * check that the name in a wstat is plausible
456  */
457 void validwstatname(char *name)
458 {
459         validname(name, 0);
460         if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
461                 error(Efilename);
462 }
463
464 struct dev *devbyname(char *name)
465 {
466         int i;
467
468         for (i = 0; &devtab[i] < __devtabend; i++)
469                 if (strcmp(devtab[i].name, name) == 0)
470                         return &devtab[i];
471         return NULL;
472 }