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