grow_fd() sets errno/errstr
[akaros.git] / kern / src / ns / sysfile.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 enum {
17         DIRSIZE = STATFIXLEN + 32 * 4,
18         DIRREADLIM = 2048,      /* should handle the largest reasonable directory entry */
19         DIRREADSIZE=8192,       /* Just read a lot. Memory is cheap, lots of bandwidth,
20                                  * and RPCs are very expensive. At the same time,
21                                  * let's not yet exceed a common MSIZE. */
22 };
23
24 static int growfd(struct fgrp *f, int fd)
25 {
26         int n;
27         struct chan **nfd, **ofd;
28
29         if (fd < f->nfd) {
30                 return 0;
31         }
32         /* want to grow by a reasonable amount (delta), but also make sure we can
33          * handle the fd we're asked for */
34         n = MAX(f->nfd, fd + 1) + DELTAFD;
35         if (n > MAXNFD)
36                 n = MAXNFD;
37         if (fd >= n) {
38                 set_errno(EMFILE);
39                 set_errstr("Asked for FD %d, more than %d\n", fd, MAXNFD);
40                 return -1;
41         }
42         nfd = kzmalloc(n * sizeof(struct chan *), 0);
43         if (nfd == NULL) {
44                 set_errno(ENOMEM);
45                 set_errstr("Failed to growfd for FD %d, OOM\n", fd);
46                 return -1;
47         }
48         ofd = f->fd;
49         memmove(nfd, ofd, f->nfd * sizeof(struct chan *));
50         f->fd = nfd;
51         f->nfd = n;
52         kfree(ofd);
53         return 0;
54 }
55
56 int newfd(struct chan *c)
57 {
58         int i;
59         struct fgrp *f = current->fgrp;
60
61         spin_lock(&f->lock);
62         if (f->closed) {
63                 spin_unlock(&f->lock);
64                 return -1;
65         }
66         /* VFS hack */
67         /* We'd like to ask it to start at f->minfd, but that would require us to
68          * know if we closed anything.  Since we share the FD numbers with the VFS,
69          * there is no way to know that. */
70 #if 1   // VFS hack
71         i = get_fd(&current->open_files, 0);
72 #else   // 9ns style
73         /* TODO: use a unique integer allocator */
74         for (i = f->minfd; i < f->nfd; i++)
75                 if (f->fd[i] == 0)
76                         break;
77 #endif
78         if (growfd(f, i) < 0) {
79                 spin_unlock(&f->lock);
80                 return -1;
81         }
82         assert(f->fd[i] == 0);
83         f->minfd = i + 1;
84         if (i > f->maxfd)
85                 f->maxfd = i;
86         f->fd[i] = c;
87         spin_unlock(&f->lock);
88         return i;
89 }
90
91 struct chan *fdtochan(struct fgrp *f, int fd, int mode, int chkmnt, int iref)
92 {
93         
94         struct chan *c;
95
96         c = 0;
97
98         spin_lock(&f->lock);
99         if (f->closed) {
100                 spin_unlock(&f->lock);
101                 error("File group closed");
102         }
103         if (fd < 0 || f->maxfd < fd || (c = f->fd[fd]) == 0) {
104                 spin_unlock(&f->lock);
105                 set_errno(EBADF);
106                 error("Bad FD %d\n", fd);
107         }
108         if (iref)
109                 chan_incref(c);
110         spin_unlock(&f->lock);
111
112         if (chkmnt && (c->flag & CMSG)) {
113                 if (iref)
114                         cclose(c);
115                 error(Ebadusefd);
116         }
117
118         if (mode < 0 || c->mode == ORDWR) {
119                 return c;
120         }
121
122         if ((mode & OTRUNC) && IS_RDONLY(c->mode)) {
123                 if (iref)
124                         cclose(c);
125                 error(Ebadusefd);
126         }
127
128         /* TODO: this is probably wrong.  if you get this from a dev, in the dev's
129          * open, you are probably saving mode directly, without passing it through
130          * openmode. */
131         if ((mode & ~OTRUNC) != c->mode) {
132                 warn("Trunc mode issue: mode %o, mode minus trunc %o, chan mode %o\n",
133                          mode, mode & ~OTRUNC, c->mode);
134                 if (iref)
135                         cclose(c);
136                 error(Ebadusefd);
137         }
138
139         return c;
140 }
141
142 long kchanio(void *vc, void *buf, int n, int mode)
143 {
144         ERRSTACK(1);
145         int r;
146         struct chan *c;
147
148         c = vc;
149         if (waserror()) {
150                 poperror();
151                 return -1;
152         }
153
154         if (IS_RDONLY(mode))
155                 r = devtab[c->type].read(c, buf, n, c->offset);
156         else
157                 r = devtab[c->type].write(c, buf, n, c->offset);
158
159         spin_lock(&c->lock);
160         c->offset += r;
161         spin_unlock(&c->lock);
162         poperror();
163         return r;
164 }
165
166 int openmode(uint32_t omode)
167 {
168 /* GIANT WARNING: if this ever throws, ipopen (and probably many others) will
169  * screw up refcnts of Qctl, err, data, etc */
170 #if 0
171         /* this is the old plan9 style.  i think they want to turn exec into read,
172          * and strip off anything higher, and just return the RD/WR style bits.  not
173          * stuff like ORCLOSE.  the lack of OEXCL might be a bug on their part (it's
174          * the only one of their non-RW-related flags that isn't masked out) */
175         if (o >= (OTRUNC | OCEXEC | ORCLOSE | OEXEC))
176                 error(Ebadarg);
177         o &= ~(OTRUNC | OCEXEC | ORCLOSE);
178         if (o > OEXEC)
179                 error(Ebadarg);
180         if (o == OEXEC)
181                 return OREAD;
182         return o;
183 #endif
184         /* no error checking (we have a shitload of flags anyway), and we return the
185          * basic access modes (RD/WR/ETC) */
186         if (omode == O_EXEC) {
187         return O_RDONLY;
188         }
189         return omode & O_ACCMODE;
190 }
191
192 void fdclose(struct fgrp *f, int fd)
193 {
194         
195         int i;
196         struct chan *c;
197
198         spin_lock(&f->lock);
199         if (f->closed) {
200                 spin_unlock(&f->lock);
201                 return;
202         }
203         c = f->fd[fd];
204         if (c == 0) {
205                 /* can happen for users with shared fd tables */
206                 spin_unlock(&f->lock);
207                 return;
208         }
209         f->fd[fd] = 0;
210         if (fd == f->maxfd)
211                 for (i = fd; --i >= 0 && f->fd[i] == 0;)
212                         f->maxfd = i;
213         if (fd < f->minfd)
214                 f->minfd = fd;
215         /* VFS hack: give the FD back to VFS */
216         put_fd(&current->open_files, fd);
217         spin_unlock(&f->lock);
218         cclose(c);
219 }
220
221 int syschdir(char *path)
222 {
223         ERRSTACK(1);
224         struct chan *c;
225         struct pgrp *pg;
226
227         if (waserror()) {
228                 poperror();
229                 return -1;
230         }
231
232         c = namec(path, Atodir, 0, 0);
233         pg = current->pgrp;
234         cclose(pg->dot);
235         pg->dot = c;
236         poperror();
237         return 0;
238 }
239
240 int fgrpclose(struct fgrp *f, int fd)
241 {
242         ERRSTACK(1);
243         if (waserror()) {
244                 poperror();
245                 return -1;
246         }
247
248         /*
249          * Take no reference on the chan because we don't really need the
250          * data structure, and are calling fdtochan only for error checks.
251          * fdclose takes care of processes racing through here.
252          */
253         fdtochan(f, fd, -1, 0, 0);
254         fdclose(f, fd);
255         poperror();
256         return 0;
257 }
258
259 int sysclose(int fd)
260 {
261         return fgrpclose(current->fgrp, fd);
262 }
263
264 int syscreate(char *path, int mode, uint32_t perm)
265 {
266         ERRSTACK(2);
267         int fd;
268         struct chan *c;
269
270         if (waserror()) {
271                 poperror();
272                 return -1;
273         }
274
275         openmode(mode & ~OEXCL);        /* error check only; OEXCL okay here */
276         c = namec(path, Acreate, mode, perm);
277         if (waserror()) {
278                 cclose(c);
279                 nexterror();
280         }
281         fd = newfd(c);
282         if (fd < 0)
283                 error(Enofd);
284         poperror();
285
286         poperror();
287         return fd;
288 }
289
290 // This is in need of rework but for now just copy and convert.
291 int sysdup(int old, int new)
292 {
293         ERRSTACK(2);
294         int fd;
295         struct chan *c, *oc;
296         struct fgrp *f = current->fgrp;
297
298         if (waserror()) {
299                 poperror();
300                 return -1;
301         }
302
303         c = fdtochan(current->fgrp, old, -1, 0, 1);
304         if (c->qid.type & QTAUTH) {
305                 cclose(c);
306                 error(Eperm);
307         }
308         fd = new;
309         if (fd != -1) {
310                 /* ideally we'll be done with the VFS before we fix this */
311                 /* double check the ccloses when you fix this */
312                 panic("Need to sync with the VFS");
313                 spin_lock(&f->lock);
314                 if (f->closed) {
315                         spin_unlock(&f->lock);
316                         cclose(c);
317                         return -1;
318                 }
319                 if (fd < 0) {
320                         spin_unlock(&f->lock);
321                         cclose(c);
322                         set_errno(EBADF);
323                         error("Bad FD %d\n", fd);
324                 }
325                 if (growfd(f, fd) < 0) {
326                         spin_unlock(&f->lock);
327                         cclose(c);
328                         error(current_errstr());
329                 }
330                 if (fd > f->maxfd)
331                         f->maxfd = fd;
332                 oc = f->fd[fd];
333                 f->fd[fd] = c;
334                 spin_unlock(&f->lock);
335                 if (oc)
336                         cclose(oc);
337         } else {
338                 if (waserror()) {
339                         cclose(c);
340                         nexterror();
341                 }
342                 fd = newfd(c);
343                 if (fd < 0)
344                         error(Enofd);
345                 poperror();
346         }
347         poperror();
348         return fd;
349 }
350
351 /* Could pass in the fgrp instead of the proc, but we need the to_proc for now
352  * so we can claim a VFS FD */
353 int sys_dup_to(struct proc *from_proc, unsigned int from_fd,
354                struct proc *to_proc, unsigned int to_fd)
355 {
356         ERRSTACK(1);
357         struct chan *c, *old_chan;
358         struct fgrp *to_fgrp = to_proc->fgrp;
359
360         if (waserror()) {
361                 poperror();
362                 return -1;
363         }
364
365         c = fdtochan(from_proc->fgrp, from_fd, -1, 0, 1);
366         if (c->qid.type & QTAUTH) {
367                 cclose(c);
368                 error(Eperm);
369         }
370
371         spin_lock(&to_fgrp->lock);
372         if (to_fgrp->closed) {
373                 spin_unlock(&to_fgrp->lock);
374                 cclose(c);
375                 error("Can't dup, FGRP closed");
376         }
377         if (claim_fd(&to_proc->open_files, to_fd)) {
378                 spin_unlock(&to_fgrp->lock);
379                 cclose(c);
380                 error("Can't claim FD %d", to_fd);
381         }
382         if (growfd(to_fgrp, to_fd) < 0) {
383                 spin_unlock(&to_fgrp->lock);
384                 cclose(c);
385                 error(current_errstr());
386         }
387         if (to_fd > to_fgrp->maxfd)
388                 to_fgrp->maxfd = to_fd;
389         old_chan = to_fgrp->fd[to_fd];
390         to_fgrp->fd[to_fd] = c;
391         spin_unlock(&to_fgrp->lock);
392         if (old_chan)
393                 cclose(old_chan);
394
395         poperror();
396         return 0;
397 }
398
399 char *sysfd2path(int fd)
400 {
401         ERRSTACK(1);
402         struct chan *c;
403         char *s;
404
405         if (waserror()) {
406                 poperror();
407                 return NULL;
408         }
409         c = fdtochan(current->fgrp, fd, -1, 0, 1);
410         s = NULL;
411         if (c->name != NULL) {
412                 s = kzmalloc(c->name->len + 1, 0);
413                 if (s == NULL) {
414                         cclose(c);
415                         error(Enomem);
416                 }
417                 memmove(s, c->name->s, c->name->len + 1);
418         }
419         cclose(c);
420         poperror();
421         return s;
422 }
423
424 int sysfauth(int fd, char *aname)
425 {
426         ERRSTACK(2);
427         struct chan *c, *ac;
428
429         if (waserror()) {
430                 poperror();
431                 return -1;
432         }
433
434         validname(aname, 0);
435         c = fdtochan(current->fgrp, fd, ORDWR, 0, 1);
436         if (waserror()) {
437                 cclose(c);
438                 nexterror();
439         }
440
441         ac = mntauth(c, aname);
442
443         /* at this point ac is responsible for keeping c alive */
444         poperror();     /* c */
445         cclose(c);
446
447         if (waserror()) {
448                 cclose(ac);
449                 nexterror();
450         }
451
452         fd = newfd(ac);
453         if (fd < 0)
454                 error(Enofd);
455         poperror();     /* ac */
456
457         poperror();
458
459         return fd;
460 }
461
462 int sysfversion(int fd, unsigned int msize, char *vers, unsigned int arglen)
463 {
464         ERRSTACK(2);
465         int m;
466         struct chan *c;
467
468         if (waserror()) {
469                 poperror();
470                 return -1;
471         }
472
473         /* check there's a NUL in the version string */
474         if (arglen == 0 || memchr(vers, 0, arglen) == 0)
475                 error(Ebadarg);
476
477         c = fdtochan(current->fgrp, fd, ORDWR, 0, 1);
478         if (waserror()) {
479                 cclose(c);
480                 nexterror();
481         }
482
483         m = mntversion(c, vers, msize, arglen);
484
485         poperror();
486         cclose(c);
487
488         poperror();
489         return m;
490 }
491
492 int syspipe(int fd[2])
493 {
494         ERRSTACK(1);
495         struct dev *d;
496         struct fgrp *f;
497         struct chan *c[2];
498         static char *names[] = { "data", "data1" };
499
500         f = current->fgrp;
501
502         d = &devtab[devno('|', 0)];
503         c[0] = namec("#|", Atodir, 0, 0);
504         c[1] = 0;
505         fd[0] = -1;
506         fd[1] = -1;
507         if (waserror()) {
508                 if (c[0] != 0)
509                         cclose(c[0]);
510                 if (c[1] != 0)
511                         cclose(c[1]);
512                 if (fd[0] >= 0) {
513                         /* VFS hack */
514                         f->fd[fd[0]] = 0;
515                         put_fd(&current->open_files, fd[0]);
516                 }
517                 if (fd[1] >= 0) {
518                         /* VFS hack */
519                         f->fd[fd[1]] = 0;
520                         put_fd(&current->open_files, fd[1]);
521                 }
522                 poperror();
523                 return -1;
524         }
525         c[1] = cclone(c[0]);
526         if (walk(&c[0], &names[0], 1, 1, NULL) < 0)
527                 error(Egreg);
528         if (walk(&c[1], &names[1], 1, 1, NULL) < 0)
529                 error(Egreg);
530         c[0] = d->open(c[0], ORDWR);
531         c[1] = d->open(c[1], ORDWR);
532         fd[0] = newfd(c[0]);
533         if (fd[0] < 0)
534                 error(Enofd);
535         fd[1] = newfd(c[1]);
536         if (fd[1] < 0)
537                 error(Enofd);
538         poperror();
539         return 0;
540 }
541
542 int sysfwstat(int fd, uint8_t * buf, int n)
543 {
544         ERRSTACK(2);
545         struct chan *c;
546
547         if (waserror()) {
548                 poperror();
549                 return -1;
550         }
551
552         validstat(buf, n, 0);
553         c = fdtochan(current->fgrp, fd, -1, 1, 1);
554         if (waserror()) {
555                 cclose(c);
556                 nexterror();
557         }
558         n = devtab[c->type].wstat(c, buf, n);
559         poperror();
560         cclose(c);
561
562         poperror();
563         return n;
564 }
565
566 long bindmount(struct chan *c, char *old, int flag, char *spec)
567 {
568         ERRSTACK(1);
569         int ret;
570         struct chan *c1;
571
572         if (flag > MMASK || (flag & MORDER) == (MBEFORE | MAFTER))
573                 error(Ebadarg);
574
575         c1 = namec(old, Amount, 0, 0);
576         if (waserror()) {
577                 cclose(c1);
578                 nexterror();
579         }
580         ret = cmount(c, c1, flag, spec);
581
582         poperror();
583         cclose(c1);
584         return ret;
585 }
586
587 int sysbind(char *new, char *old, int flags)
588 {
589         ERRSTACK(2);
590         long r;
591         struct chan *c0;
592
593         if (waserror()) {
594                 poperror();
595                 return -1;
596         }
597
598         c0 = namec(new, Abind, 0, 0);
599         if (waserror()) {
600                 cclose(c0);
601                 nexterror();
602         }
603         r = bindmount(c0, old, flags, "");
604         poperror();
605         cclose(c0);
606
607         poperror();
608         return r;
609 }
610
611 int sysmount(int fd, int afd, char *old, int flags, char *spec)
612 {
613         ERRSTACK(1);
614         long r;
615         volatile struct {
616                 struct chan *c;
617         } c0;
618         volatile struct {
619                 struct chan *c;
620         } bc;
621         volatile struct {
622                 struct chan *c;
623         } ac;
624         struct mntparam mntparam;
625
626         ac.c = NULL;
627         bc.c = NULL;
628         c0.c = NULL;
629         if (waserror()) {
630                 cclose(ac.c);
631                 cclose(bc.c);
632                 cclose(c0.c);
633                 poperror();
634                 return -1;
635         }
636         bc.c = fdtochan(current->fgrp, fd, ORDWR, 0, 1);
637         if (afd >= 0)
638                 ac.c = fdtochan(current->fgrp, afd, ORDWR, 0, 1);
639         mntparam.chan = bc.c;
640         mntparam.authchan = ac.c;
641         mntparam.spec = spec;
642         mntparam.flags = flags;
643         c0.c = devtab[devno('M', 0)].attach((char *)&mntparam);
644
645         r = bindmount(c0.c, old, flags, spec);
646         poperror();
647         cclose(ac.c);
648         cclose(bc.c);
649         cclose(c0.c);
650
651         return r;
652 }
653
654 int sysunmount(char *old, char *new)
655 {
656         ERRSTACK(1);
657         volatile struct {
658                 struct chan *c;
659         } cmount;
660         volatile struct {
661                 struct chan *c;
662         } cmounted;
663
664         cmount.c = NULL;
665         cmounted.c = NULL;
666         if (waserror()) {
667                 cclose(cmount.c);
668                 cclose(cmounted.c);
669                 poperror();
670                 return -1;
671         }
672
673         cmount.c = namec(new, Amount, 0, 0);
674         if (old != NULL && old[0] != '\0') {
675                 /*
676                  * This has to be namec(..., Aopen, ...) because
677                  * if arg[0] is something like /srv/cs or /fd/0,
678                  * opening it is the only way to get at the real
679                  * Chan underneath.
680                  */
681                 cmounted.c = namec(old, Aopen, OREAD, 0);
682         }
683
684         cunmount(cmount.c, cmounted.c);
685         poperror();
686         cclose(cmount.c);
687         cclose(cmounted.c);
688         return 0;
689 }
690
691 int sysopen(char *path, int vfs_flags)
692 {
693         ERRSTACK(2);
694         int fd;
695         struct chan *c;
696
697         if (waserror()) {
698                 poperror();
699                 return -1;
700         }
701
702         openmode(vfs_flags);    /* error check only */
703         c = namec(path, Aopen, vfs_flags, 0);
704         if (waserror()) {
705                 cclose(c);
706                 nexterror();
707         }
708         fd = newfd(c);
709         if (fd < 0)
710                 error(Enofd);
711         poperror();
712
713         poperror();
714         return fd;
715 }
716
717 long unionread(struct chan *c, void *va, long n)
718 {
719         ERRSTACK(1);
720         int i;
721         long nr;
722         struct mhead *m;
723         struct mount *mount;
724
725         qlock(&c->umqlock);
726         m = c->umh;
727         rlock(&m->lock);
728         mount = m->mount;
729         /* bring mount in sync with c->uri and c->umc */
730         for (i = 0; mount != NULL && i < c->uri; i++)
731                 mount = mount->next;
732
733         nr = 0;
734         while (mount != NULL) {
735                 /* Error causes component of union to be skipped */
736                 if (mount->to) {
737                         /* normally we want to discard the error, but for our ghetto kdirent
738                          * hack, we need to repeat unionread if we saw a Eshort */
739                         if (waserror()) {
740                                 if (!strcmp(current_errstr(), Eshort)) {
741                                         runlock(&m->lock);
742                                         qunlock(&c->umqlock);
743                                         nexterror();
744                                 }
745                                 /* poperror done below for either branch */
746                         } else {
747                                 if (c->umc == NULL) {
748                                         c->umc = cclone(mount->to);
749                                         c->umc = devtab[c->umc->type].open(c->umc, OREAD);
750                                 }
751
752                                 nr = devtab[c->umc->type].read(c->umc, va, n, c->umc->offset);
753                                 if (nr < 0)
754                                         nr = 0; /* dev.c can return -1 */
755                                 c->umc->offset += nr;
756                         }
757                         poperror();     /* pop regardless */
758                 }
759                 if (nr > 0)
760                         break;
761
762                 /* Advance to next element */
763                 c->uri++;
764                 if (c->umc) {
765                         cclose(c->umc);
766                         c->umc = NULL;
767                 }
768                 mount = mount->next;
769         }
770         runlock(&m->lock);
771         qunlock(&c->umqlock);
772         return nr;
773 }
774
775 static void unionrewind(struct chan *c)
776 {
777         qlock(&c->umqlock);
778         c->uri = 0;
779         if (c->umc) {
780                 cclose(c->umc);
781                 c->umc = NULL;
782         }
783         qunlock(&c->umqlock);
784 }
785
786 static long rread(int fd, void *va, long n, int64_t * offp)
787 {
788         ERRSTACK(3);
789         int dir;
790         struct chan *c;
791         int64_t off;
792
793         /* dirty dirent hack */
794         void *real_va = va;
795
796         if (waserror()) {
797                 poperror();
798                 return -1;
799         }
800
801         c = fdtochan(current->fgrp, fd, OREAD, 1, 1);
802         if (waserror()) {
803                 cclose(c);
804                 nexterror();
805         }
806
807         if (n < 0)
808                 error(Etoosmall);
809
810         dir = c->qid.type & QTDIR;
811
812         /* kdirent hack: userspace is expecting kdirents, but all of 9ns
813          * produces Ms.  Just save up what we don't use and append the
814          * new stuff later. Allocate DIRREADSIZE bytes for that purpose.
815          */
816         if (dir) {
817                 int amt;
818                 /* expecting only one dirent at a time, o/w we're busted */
819                 assert(n >= sizeof(struct kdirent));
820                 if (!c->buf) {
821                         c->buf=kmalloc(DIRREADSIZE, KMALLOC_WAIT);
822                         c->bufused = 0;
823                 }
824                 /* Attempt to extract an M, in case there was some already */
825                 amt = convM2kdirent(c->buf, c->bufused, real_va, 0);
826                 if (amt) {
827                         c->bufused -= amt;
828                         memmove(c->buf, c->buf + amt, c->bufused);
829                         n = sizeof(struct kdirent);
830                         goto out;
831                 }
832                 /* debugging */
833                 if (waserror()) {
834                         printk("Well, sysread of a dir sucks.%s \n", current_errstr());
835                         nexterror();
836                 }
837                 va = c->buf + c->bufused;
838                 n = DIRREADSIZE - c->bufused;
839         }
840
841         /* this is the normal plan9 read */
842         if (dir && c->umh)
843                 n = unionread(c, va, n);
844         else {
845                 if (offp == NULL) {
846                         spin_lock(&c->lock);    /* lock for int64_t assignment */
847                         off = c->offset;
848                         spin_unlock(&c->lock);
849                 } else
850                         off = *offp;
851                 if (off < 0)
852                         error(Enegoff);
853                 if (off == 0) {
854                         if (offp == NULL) {
855                                 spin_lock(&c->lock);
856                                 c->offset = 0;
857                                 c->dri = 0;
858                                 spin_unlock(&c->lock);
859                         }
860                         unionrewind(c);
861                 }
862                 if (! c->ateof) {
863                         n = devtab[c->type].read(c, va, n, off);
864                         if (n == 0 && dir)
865                                 c->ateof = 1;
866                 } else {
867                         n = 0;
868                 }
869                 spin_lock(&c->lock);
870                 c->offset += n;
871                 spin_unlock(&c->lock);
872         }
873
874         /* dirty kdirent hack */
875         if (dir) {
876                 int amt;
877                 c->bufused = c->bufused + n;
878                 /* extract an M from the front, then shift the remainder back */
879                 amt = convM2kdirent(c->buf, c->bufused, real_va, 0);
880                 c->bufused -= amt;
881                 memmove(c->buf, c->buf + amt, c->bufused);
882                 n = amt ? sizeof(struct kdirent) : 0;
883                 poperror();     /* matching our debugging waserror */
884         }
885
886 out:
887         poperror();
888         cclose(c);
889
890         poperror();
891         return n;
892 }
893
894 long sysread(int fd, void *va, long n)
895 {
896         return rread(fd, va, n, NULL);
897 }
898
899 long syspread(int fd, void *va, long n, int64_t off)
900 {
901         return rread(fd, va, n, &off);
902 }
903
904 int sysremove(char *path)
905 {
906         ERRSTACK(2);
907         struct chan *c;
908
909         if (waserror()) {
910                 poperror();
911                 return -1;
912         }
913
914         c = namec(path, Aremove, 0, 0);
915         if (waserror()) {
916                 c->type = -1;   /* see below */
917                 cclose(c);
918                 nexterror();
919         }
920         devtab[c->type].remove(c);
921         /*
922          * Remove clunks the fid, but we need to recover the Chan
923          * so fake it up.  -1 aborts the dev's close.
924          */
925         c->type = -1;
926         poperror();
927         cclose(c);
928
929         poperror();
930         return 0;
931 }
932
933 int64_t sysseek(int fd, int64_t off, int whence)
934 {
935         ERRSTACK(2);
936         struct dir *dir;
937         struct chan *c;
938
939         if (waserror()) {
940                 poperror();
941                 return -1;
942         }
943
944         c = fdtochan(current->fgrp, fd, -1, 1, 1);
945         if (waserror()) {
946                 cclose(c);
947                 nexterror();
948         }
949
950         if (devtab[c->type].dc == '|')
951                 error(Eisstream);
952
953         switch (whence) {
954                 case 0:
955                         if (c->qid.type & QTDIR) {
956                                 if (off != 0)
957                                         error(Eisdir);
958                                 unionrewind(c);
959                         } else if (off < 0)
960                                 error(Enegoff);
961                         spin_lock(&c->lock);    /* lock for int64_t assignment */
962                         c->offset = off;
963                         spin_unlock(&c->lock);
964                         break;
965
966                 case 1:
967                         if (c->qid.type & QTDIR)
968                                 error(Eisdir);
969                         spin_lock(&c->lock);    /* lock for read/write update */
970                         off += c->offset;
971                         if (off < 0) {
972                                 spin_unlock(&c->lock);
973                                 error(Enegoff);
974                         }
975                         c->offset = off;
976                         spin_unlock(&c->lock);
977                         break;
978
979                 case 2:
980                         if (c->qid.type & QTDIR)
981                                 error(Eisdir);
982                         dir = chandirstat(c);
983                         if (dir == NULL)
984                                 error("internal error: stat error in seek");
985                         off += dir->length;
986                         kfree(dir);
987                         if (off < 0)
988                                 error(Enegoff);
989                         spin_lock(&c->lock);    /* lock for read/write update */
990                         c->offset = off;
991                         spin_unlock(&c->lock);
992                         break;
993
994                 default:
995                         error(Ebadarg);
996                         break;
997         }
998         poperror();
999         c->dri = 0;
1000         cclose(c);
1001         poperror();
1002         return off;
1003 }
1004
1005 void validstat(uint8_t * s, int n, int slashok)
1006 {
1007         
1008         int m;
1009         char buf[64];
1010
1011         if (statcheck(s, n) < 0)
1012                 error(Ebadstat);
1013         /* verify that name entry is acceptable */
1014         s += STATFIXLEN - 4 * BIT16SZ;  /* location of first string */
1015         /*
1016          * s now points at count for first string.
1017          * if it's too long, let the server decide; this is
1018          * only for his protection anyway. otherwise
1019          * we'd have to allocate and waserror.
1020          */
1021         m = GBIT16(s);
1022         s += BIT16SZ;
1023         if (m + 1 > sizeof buf) {
1024                 return;
1025         }
1026         memmove(buf, s, m);
1027         buf[m] = '\0';
1028         /* name could be '/' */
1029         if (strcmp(buf, "/") != 0)
1030                 validname(buf, slashok);
1031 }
1032
1033 int sysfstat(int fd, uint8_t *buf, int n)
1034 {
1035         ERRSTACK(2);
1036         struct chan *c;
1037
1038         if (waserror()) {
1039                 poperror();
1040                 return -1;
1041         }
1042
1043         c = fdtochan(current->fgrp, fd, -1, 0, 1);
1044         if (waserror()) {
1045                 cclose(c);
1046                 nexterror();
1047         }
1048         devtab[c->type].stat(c, buf, n);
1049
1050         poperror();
1051         cclose(c);
1052
1053         poperror();
1054         return n;
1055 }
1056
1057 int sysfstatakaros(int fd, struct kstat *ks)
1058 {
1059         
1060         int n = 4096;
1061         uint8_t *buf;
1062         buf = kmalloc(n, KMALLOC_WAIT);
1063         n = sysfstat(fd, buf, n);
1064         if (n > 0) {
1065                 convM2kstat(buf, n, ks);
1066                 n = 0;
1067         }
1068         kfree(buf);
1069         return n;
1070 }
1071
1072 int sysstat(char *path, uint8_t *buf, int n)
1073 {
1074         ERRSTACK(2);
1075         struct chan *c;
1076
1077         if (waserror()) {
1078                 poperror();
1079                 return -1;
1080         }
1081
1082         c = namec(path, Aaccess, 0, 0);
1083         if (waserror()) {
1084                 cclose(c);
1085                 nexterror();
1086         }
1087         devtab[c->type].stat(c, buf, n);
1088         poperror();
1089         cclose(c);
1090
1091         poperror();
1092
1093         return n;
1094 }
1095
1096 int sysstatakaros(char *path, struct kstat *ks)
1097 {
1098         
1099         int n = 4096;
1100         uint8_t *buf;
1101         buf = kmalloc(n, KMALLOC_WAIT);
1102         n = sysstat(path, buf, n);
1103         if (n > 0) {
1104                 convM2kstat(buf, n, ks);
1105                 n = 0;
1106         }
1107         kfree(buf);
1108         return n;
1109 }
1110
1111 static long rwrite(int fd, void *va, long n, int64_t * offp)
1112 {
1113         ERRSTACK(3);
1114         struct chan *c;
1115         struct dir *dir;
1116         int64_t off;
1117         long m;
1118
1119         if (waserror()) {
1120                 poperror();
1121                 return -1;
1122         }
1123         c = fdtochan(current->fgrp, fd, OWRITE, 1, 1);
1124         if (waserror()) {
1125                 cclose(c);
1126                 nexterror();
1127         }
1128         if (c->qid.type & QTDIR)
1129                 error(Eisdir);
1130
1131         if (n < 0)
1132                 error(Etoosmall);
1133
1134         if (offp == NULL) {
1135                 /* append changes the offset to the end, and even if we fail later, this
1136                  * change will persist */
1137                 if (c->flag & CAPPEND) {
1138                         dir = chandirstat(c);
1139                         if (!dir)
1140                                 error("internal error: stat error in append write");
1141                         spin_lock(&c->lock);    /* legacy lock for int64 assignment */
1142                         c->offset = dir->length;
1143                         spin_unlock(&c->lock);
1144                         kfree(dir);
1145                 }
1146                 spin_lock(&c->lock);
1147                 off = c->offset;
1148                 c->offset += n;
1149                 spin_unlock(&c->lock);
1150         } else
1151                 off = *offp;
1152
1153         if (waserror()) {
1154                 if (offp == NULL) {
1155                         spin_lock(&c->lock);
1156                         c->offset -= n;
1157                         spin_unlock(&c->lock);
1158                 }
1159                 nexterror();
1160         }
1161         if (off < 0)
1162                 error(Enegoff);
1163         m = devtab[c->type].write(c, va, n, off);
1164         poperror();
1165
1166         if (offp == NULL && m < n) {
1167                 spin_lock(&c->lock);
1168                 c->offset -= n - m;
1169                 spin_unlock(&c->lock);
1170         }
1171
1172         poperror();
1173         cclose(c);
1174
1175         poperror();
1176         return n;
1177 }
1178
1179 long syswrite(int fd, void *va, long n)
1180 {
1181         return rwrite(fd, va, n, NULL);
1182 }
1183
1184 long syspwrite(int fd, void *va, long n, int64_t off)
1185 {
1186         return rwrite(fd, va, n, &off);
1187 }
1188
1189 int syswstat(char *path, uint8_t * buf, int n)
1190 {
1191         ERRSTACK(2);
1192         struct chan *c;
1193
1194         if (waserror()) {
1195                 poperror();
1196                 return -1;
1197         }
1198
1199         validstat(buf, n, 0);
1200         c = namec(path, Aaccess, 0, 0);
1201         if (waserror()) {
1202                 cclose(c);
1203                 nexterror();
1204         }
1205         n = devtab[c->type].wstat(c, buf, n);
1206         poperror();
1207         cclose(c);
1208
1209         poperror();
1210         return n;
1211 }
1212
1213 struct dir *chandirstat(struct chan *c)
1214 {
1215         ERRSTACK(1);
1216         struct dir *d;
1217         uint8_t *buf;
1218         int n, nd, i;
1219
1220         nd = DIRSIZE;
1221         for (i = 0; i < 2; i++) {       /* should work by the second try */
1222                 d = kzmalloc(sizeof(struct dir) + nd, 0);
1223                 buf = (uint8_t *) & d[1];
1224                 if (waserror()) {
1225                         kfree(d);
1226                         poperror();
1227                         return NULL;
1228                 }
1229                 n = devtab[c->type].stat(c, buf, nd);
1230                 poperror();
1231                 if (n < BIT16SZ) {
1232                         kfree(d);
1233                         return NULL;
1234                 }
1235                 nd = GBIT16((uint8_t *) buf) + BIT16SZ; /* size needed to store whole stat buffer including count */
1236                 if (nd <= n) {
1237                         convM2D(buf, n, d, (char *)&d[1]);
1238                         return d;
1239                 }
1240                 /* else sizeof(Dir)+nd is plenty */
1241                 kfree(d);
1242         }
1243         return NULL;
1244
1245 }
1246
1247 struct dir *sysdirstat(char *name)
1248 {
1249         ERRSTACK(2);
1250         struct chan *c;
1251         struct dir *d;
1252
1253         if (waserror()) {
1254                 poperror();
1255                 return NULL;
1256         }
1257
1258         c = namec(name, Aaccess, 0, 0);
1259         if (waserror()) {
1260                 cclose(c);
1261                 nexterror();
1262         }
1263         d = chandirstat(c);
1264         poperror();
1265         cclose(c);
1266
1267         poperror();
1268         return d;
1269 }
1270
1271 struct dir *sysdirfstat(int fd)
1272 {
1273         ERRSTACK(2);
1274         struct chan *c;
1275         struct dir *d;
1276
1277         if (waserror()) {
1278                 poperror();
1279                 return NULL;
1280         }
1281
1282         c = fdtochan(current->fgrp, fd, -1, 0, 1);
1283         if (waserror()) {
1284                 cclose(c);
1285                 nexterror();
1286         }
1287         d = chandirstat(c);
1288         poperror();
1289         cclose(c);
1290
1291         poperror();
1292         return d;
1293 }
1294
1295 int sysdirwstat(char *name, struct dir *dir)
1296 {
1297         
1298         uint8_t *buf;
1299         int r;
1300
1301         r = sizeD2M(dir);
1302         buf = kzmalloc(r, 0);
1303         convD2M(dir, buf, r);
1304         r = syswstat(name, buf, r);
1305         kfree(buf);
1306         return r < 0 ? r : 0;
1307 }
1308
1309 int sysdirfwstat(int fd, struct dir *dir)
1310 {
1311         
1312         uint8_t *buf;
1313         int r;
1314
1315         r = sizeD2M(dir);
1316         buf = kzmalloc(r, 0);
1317         convD2M(dir, buf, r);
1318         r = sysfwstat(fd, buf, r);
1319         kfree(buf);
1320         return r < 0 ? r : 0;
1321 }
1322
1323 static long dirpackage(uint8_t * buf, long ts, struct kdirent **d)
1324 {
1325         
1326         char *s;
1327         long ss, i, n, nn, m = 0;
1328
1329         *d = NULL;
1330         if (ts <= 0) {
1331                 return ts;
1332         }
1333
1334         /*
1335          * first find number of all stats, check they look like stats, & size all associated strings
1336          */
1337         ss = 0;
1338         n = 0;
1339         for (i = 0; i < ts; i += m) {
1340                 m = BIT16SZ + GBIT16(&buf[i]);
1341                 if (statcheck(&buf[i], m) < 0)
1342                         break;
1343                 ss += m;
1344                 n++;
1345         }
1346
1347         if (i != ts)
1348                 error("bad directory format");
1349
1350         *d = kzmalloc(n * sizeof(**d) + ss, 0);
1351         if (*d == NULL)
1352                 error(Enomem);
1353
1354         /*
1355          * then convert all buffers
1356          */
1357         s = (char *)*d + n * sizeof(**d);
1358         nn = 0;
1359         for (i = 0; i < ts; i += m) {
1360                 m = BIT16SZ + GBIT16((uint8_t *) & buf[i]);
1361                 if (nn >= n || /*convM2D */ convM2kdirent(&buf[i], m, *d + nn, s) != m) {
1362                         kfree(*d);
1363                         *d = NULL;
1364                         error("bad directory entry");
1365                 }
1366                 nn++;
1367                 s += m;
1368         }
1369
1370         return nn;
1371 }
1372
1373 long sysdirread(int fd, struct kdirent **d)
1374 {
1375         ERRSTACK(2);
1376         uint8_t *buf;
1377         long ts;
1378
1379         *d = NULL;
1380         if (waserror()) {
1381                 poperror();
1382                 return -1;
1383         }
1384         buf = kzmalloc(DIRREADLIM, 0);
1385         if (buf == NULL)
1386                 error(Enomem);
1387         if (waserror()) {
1388                 kfree(buf);
1389                 nexterror();
1390         }
1391         ts = sysread(fd, buf, DIRREADLIM);
1392         if (ts >= 0)
1393                 ts = dirpackage(buf, ts, d);
1394         poperror();
1395         kfree(buf);
1396         poperror();
1397         return ts;
1398 }
1399
1400 int sysiounit(int fd)
1401 {
1402         ERRSTACK(1);
1403         struct chan *c;
1404         int n;
1405
1406         c = fdtochan(current->fgrp, fd, -1, 0, 1);
1407         if (waserror()) {
1408                 cclose(c);
1409                 poperror();
1410                 return 0;       /* n.b. */
1411         }
1412         n = c->iounit;
1413         poperror();
1414         cclose(c);
1415         return n;
1416 }
1417
1418 /* Notes on concurrency:
1419  * - Can't hold spinlocks while we call cclose, since it might sleep eventually.
1420  * - We're called from proc_destroy, so we could have concurrent openers trying
1421  *   to add to the group (other syscalls), hence the "closed" flag.
1422  * - dot and slash chans are dealt with in proc_free.  its difficult to close
1423  *   and zero those with concurrent syscalls, since those are a source of krefs.
1424  * - the memory is freed in proc_free().  need to wait to do it, since we can
1425  *   have concurrent accesses to fgrp before free.
1426  * - Once we lock and set closed, no further additions can happen.  To simplify
1427  *   our closes, we also allow multiple calls to this func (though that should
1428  *   never happen with the current code). */
1429 void close_9ns_files(struct proc *p, bool only_cloexec)
1430 {
1431         
1432         struct fgrp *f = p->fgrp;
1433
1434         spin_lock(&f->lock);
1435         if (f->closed) {
1436                 spin_unlock(&f->lock);
1437                 warn("Unexpected double-close");
1438                 return;
1439         }
1440         if (!only_cloexec)
1441                 f->closed = TRUE;
1442         spin_unlock(&f->lock);
1443
1444         /* maxfd is a legit val, not a +1 */
1445         for (int i = 0; i <= f->maxfd; i++) {
1446                 if (!f->fd[i])
1447                         continue;
1448                 if (only_cloexec && !(f->fd[i]->flag & CCEXEC))
1449                         continue;
1450                 cclose(f->fd[i]);
1451                 f->fd[i] = 0;
1452         }
1453 }
1454
1455 void print_chaninfo(struct chan *c)
1456 {
1457         
1458         char buf[64] = { 0 };
1459         bool has_dev = c->type != -1;
1460         if (has_dev && !devtab[c->type].chaninfo) {
1461                 printk("Chan type %d has no chaninfo!\n", c->type);
1462                 has_dev = FALSE;
1463         }
1464         printk("Chan pathname: %s ref %d, Dev: %s, Devinfo: %s",
1465                    c->name ? c->name->s : "no cname",
1466                    kref_refcnt(&c->ref),
1467                    has_dev ? devtab[c->type].name : "no dev",
1468                    has_dev ? devtab[c->type].chaninfo(c, buf, sizeof(buf)) : "");
1469         if (!has_dev)
1470                 printk("qid.path: %p\n", c->qid.path);
1471         printk("\n");
1472 }
1473
1474 void print_9ns_files(struct proc *p)
1475 {
1476         
1477         struct fgrp *f = p->fgrp;
1478         spin_lock(&f->lock);
1479         printk("9ns files for proc %d:\n", p->pid);
1480         /* maxfd is a legit val, not a +1 */
1481         for (int i = 0; i <= f->maxfd; i++) {
1482                 if (!f->fd[i])
1483                         continue;
1484                 printk("\t9fs %4d, ", i);
1485                 print_chaninfo(f->fd[i]);
1486         }
1487         spin_unlock(&f->lock);
1488 }
1489
1490 /* TODO: 9ns ns inheritance flags: Shared, copied, or empty.  Looks like we're
1491  * copying the fgrp, and sharing the pgrp. */
1492 int plan9setup(struct proc *new_proc, struct proc *parent, int flags)
1493 {
1494         
1495         struct proc *old_current;
1496         struct kref *new_dot_ref;
1497         ERRSTACK(1);
1498         if (waserror()) {
1499                 printk("plan9setup failed, %s\n", current_errstr());
1500                 poperror();
1501                 return -1;
1502         }
1503         if (!parent) {
1504                 /* We are probably spawned by the kernel directly, and have no parent to
1505                  * inherit from.  Be sure to set up fgrp/pgrp before calling namec().
1506                  *
1507                  * TODO: One problem is namec wants a current set for things like
1508                  * genbuf.  So we'll use new_proc for this bootstrapping.  Note
1509                  * switch_to() also loads the cr3. */
1510                 new_proc->fgrp = newfgrp();
1511                 new_proc->pgrp = newpgrp();
1512                 old_current = switch_to(new_proc);
1513                 new_proc->slash = namec("#r", Atodir, 0, 0);
1514                 if (!new_proc->slash)
1515                         panic("no root device");
1516                 switch_back(new_proc, old_current);
1517                 /* Want the name to be "/" instead of "#r" */
1518                 cnameclose(new_proc->slash->name);
1519                 new_proc->slash->name = newcname("/");
1520                 new_proc->dot = cclone(new_proc->slash);
1521                 poperror();
1522                 return 0;
1523         }
1524         /* When we use the old fgrp, we have copy semantics: do not change this
1525          * without revisiting proc_destroy, close_9ns_files, and closefgrp. */
1526         if (flags & PROC_DUP_FGRP)
1527                 new_proc->fgrp = dupfgrp(new_proc, parent->fgrp);
1528         else
1529                 new_proc->fgrp = newfgrp();
1530         /* Shared semantics */
1531         kref_get(&parent->pgrp->ref, 1);
1532         new_proc->pgrp = parent->pgrp;
1533         /* copy semantics on / and . (doesn't make a lot of sense in akaros o/w) */
1534         /* / should never disappear while we hold a ref to parent */
1535         chan_incref(parent->slash);
1536         new_proc->slash = parent->slash;
1537         /* dot could change concurrently, and we could fail to gain a ref if whoever
1538          * decref'd dot triggered the release.  if that did happen, new_proc->dot
1539          * should update and we can try again. */
1540         while (!(new_dot_ref = kref_get_not_zero(&parent->dot->ref, 1)))
1541                 cpu_relax();
1542         /* And now, we can't trust parent->dot, and need to determine our dot from
1543          * the ref we obtained. */
1544         new_proc->dot = container_of(new_dot_ref, struct chan, ref);
1545         poperror();
1546         return 0;
1547 }
1548
1549 /* Open flags, create modes, access types, file flags, and all that...
1550  *
1551  * there are a bunch of things here:
1552  *              1) file creation flags (e.g. O_TRUNC)
1553  *              2) file status flags (e.g. O_APPEND)
1554  *              3) file open modes (e.g. O_RDWR)
1555  *              4) file descriptor flags (e.g. CLOEXEC)
1556  *              5) file creation mode (e.g. S_IRWXU)
1557  * the 1-4 are passed in via open's vfs_flags, and the 5 via mode only when
1558  * O_CREATE is set.
1559  *
1560  * file creation flags (1) only matter when creating, but aren't permanent.
1561  * O_EXCL, O_DIRECTORY, O_TRUNC, etc.
1562  *
1563  * file status flags (2) are per struct file/chan.  stuff like O_APPEND,
1564  * O_ASYNC, etc.  we convert those to an internal flag bit and store in c->flags
1565  *
1566  * the open mode (3) matters for a given FD/chan (chan->mode), and should be
1567  * stored in the chan. (c->mode) stuff like O_RDONLY.
1568  *
1569  * the file descriptor flags (4) clearly are in the FD.  note that the same
1570  * file/chan can be opened by two different FDs, with different flags.  the only
1571  * one anyone uses is CLOEXEC.  while exec may not last long in akaros, i can
1572  * imagine similar "never pass to children" flags/meanings.
1573  *
1574  * the file creation mode (5) matters for the device's permissions; given this,
1575  * it should be stored in the device/inode.  ACLs fall under this category.
1576  *
1577  * finally, only certain categories can be edited afterwards: file status flags
1578  * (2), FD flags (4), and file permissions (5). */
1579 int fd_getfl(int fd)
1580 {
1581         ERRSTACK(1);
1582         struct chan *c;
1583         int ret;
1584
1585         if (waserror()) {
1586                 poperror();
1587                 return -1;
1588         }
1589         c = fdtochan(current->fgrp, fd, -1, 0, 1);
1590
1591         ret = c->mode;
1592         if (c->flag & CAPPEND)
1593                 ret |= O_APPEND;
1594
1595         cclose(c);
1596         poperror();
1597         return ret;
1598 }
1599
1600 int fd_setfl(int fd, int flags)
1601 {
1602         ERRSTACK(1);
1603         struct chan *c;
1604
1605         if (waserror()) {
1606                 poperror();
1607                 return -1;
1608         }
1609         c = fdtochan(current->fgrp, fd, -1, 0, 1);
1610
1611         if (flags & O_APPEND)
1612                 c->flag |= CAPPEND;
1613
1614         cclose(c);
1615         poperror();
1616         return 0;
1617 }