9ns: Support setting FD flags (XCC)
[akaros.git] / kern / include / ns.h
1 /* Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
2  * Portions Copyright © 1997-1999 Vita Nuova Limited
3  * Portions Copyright © 2000-2007 Vita Nuova Holdings Limited
4  *                                (www.vitanuova.com)
5  * Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
6  *
7  * Modified for the Akaros operating system:
8  * Copyright (c) 2013-2014 The Regents of the University of California
9  * Copyright (c) 2013-2015 Google Inc.
10  *
11  * Permission is hereby granted, free of charge, to any person obtaining a copy
12  * of this software and associated documentation files (the "Software"), to deal
13  * in the Software without restriction, including without limitation the rights
14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15  * copies of the Software, and to permit persons to whom the Software is
16  * furnished to do so, subject to the following conditions:
17  *
18  * The above copyright notice and this permission notice shall be included in
19  * all copies or substantial portions of the Software.
20  *
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27  * SOFTWARE. */
28
29
30 #pragma once
31
32 #include <err.h>
33 #include <rendez.h>
34 #include <rwlock.h>
35 #include <linker_func.h>
36 #include <fdtap.h>
37 #include <ros/fs.h>
38 #include <bitmask.h>
39 #include <mm.h>
40 #include <sys/uio.h>
41 #include <time.h>
42
43 /*
44  * functions (possibly) linked in, complete, from libc.
45  */
46 enum {
47         UTFmax = 4,                                     /* maximum bytes per rune */
48         Runesync = 0x80,        /* cannot represent part of a UTF sequence (<) */
49         Runeself = 0x80,        /* rune and UTF sequences are the same (<) */
50         Runeerror = 0xFFFD,     /* decoding error in UTF */
51         Runemax = 0x10FFFF,     /* 21-bit rune */
52         Runemask = 0x1FFFFF,    /* bits used by runes (see grep) */
53         NUMSIZE32 = 10, /* max size of formatted 32 bit number (hex or decimal) */
54         NUMSIZE64 = 20, /* max size of formatted 64 bit number (hex or decimal) */
55 };
56
57 /*
58  * math
59  */
60 extern int isNaN(double);
61 extern int isInf(double, int);
62 extern double floor(double);
63 extern double frexp(double, int *);
64 extern double pow10(int);
65
66 /*
67  * one-of-a-kind
68  */
69 extern char *cleanname(char *unused_char_p_t);
70 //extern    uint32_t    getcallerpc(void*);
71 static inline uint32_t getcallerpc(void *v)
72 {
73         return 0;
74 }
75
76 extern int getfields(char *unused_char_p_t, char **unused_char_pp_t,
77                                          int unused_int, int, char *);
78 extern int tokenize(char *unused_char_p_t, char **unused_char_pp_t, int);
79 extern int dec64(uint8_t * unused_uint8_p_t, int unused_int,
80                                  char *unused_char_p_t, int);
81 extern void qsort(void *, long, long, int (*)(void *, void *));
82
83 extern int toupper(int);
84 extern int myetheraddr(uint8_t * unused_uint8_p_t, char *unused_char_p_t);
85 extern int parseether(uint8_t * unused_uint8_p_t, char *unused_char_p_t);
86
87 /*
88  * network dialling
89  */
90 #define NETPATHLEN      40
91
92 /*
93  * Syscall data structures
94  */
95 #define MORDER  0x0003  /* mask for bits defining order of mounting */
96 #define MREPL   0x0000  /* mount replaces object */
97 #define MBEFORE 0x0001  /* mount goes before others in union directory */
98 #define MAFTER  0x0002  /* mount goes after others in union directory */
99 #define MCREATE 0x0004  /* permit creation in mounted directory */
100 #define MCACHE  0x0010  /* cache some data */
101 #define MMASK   0x0017  /* all bits on */
102
103 #define NCONT   0       /* continue after note */
104 #define NDFLT   1       /* terminate after note */
105 #define NSAVE   2       /* clear note but hold state */
106 #define NRSTR   3       /* restore saved state */
107
108 #define STATMAX 65535U  /* max length of machine-independent stat structure */
109 #define ERRMAX                  128     /* max length of error string */
110 #define KNAMELEN                28      /* max length of name held in kernel */
111
112 /* bits in Qid.type */
113 #define QTDIR           0x80    /* type bit for directories */
114 #define QTAPPEND        0x40    /* type bit for append only files */
115 #define QTEXCL          0x20    /* type bit for exclusive use files */
116 #define QTMOUNT         0x10    /* type bit for mounted channel */
117 #define QTAUTH          0x08    /* type bit for authentication file */
118 #define QTSYMLINK       0x02    /* type bit for symlinks */
119 #define QTFILE          0x00    /* plain file.  Yeah, a zero.  Fucking 9p. */
120
121 /* bits in Dir.mode */
122 #define DMDIR           0x80000000      /* mode bit for directories */
123 #define DMAPPEND        0x40000000      /* mode bit for append only files */
124 #define DMEXCL          0x20000000      /* mode bit for exclusive use files */
125 #define DMMOUNT         0x10000000      /* mode bit for mounted channel */
126 #define DMWRITABLE      0x08000000      /* non-standard, for select() */
127 #define DMREADABLE      0x04000000      /* non-standard, for select() */
128 #define DMSYMLINK       0x02000000      /* symlink -- from 9p2000.u */
129 /* The lower parts of dir.mode are the three rwx perms (S_PMASK) */
130 #define DMMODE_BITS (DMDIR | DMAPPEND | DMEXCL | DMMOUNT | DMWRITABLE \
131                      | DMREADABLE | DMSYMLINK)
132
133 /* We don't need a GET_FL.  The caller has the chan / FID.  If you have the
134  * chan, you already have the flags.  It's not like when you have an FD and
135  * don't (yet) have the Unix struct file. */
136 #define CCTL_SET_FL                             1
137 #define CCTL_SYNC                               2
138
139 struct qid {
140         uint64_t path;
141         uint32_t vers;
142         uint8_t type;
143 };
144
145 static inline bool qid_is_file(struct qid q)
146 {
147         return (q.type & (QTDIR | QTSYMLINK)) == 0;
148 }
149
150 struct dir {
151         /* system-modified data */
152         uint16_t type;                          /* server type */
153         uint32_t dev;                   /* server subtype */
154         /* file data */
155         struct qid qid;                         /* unique id from server */
156         uint32_t mode;                          /* permissions */
157         /* 9p stat has u32 atime (seconds) here */
158         /* 9p stat has u32 mtime (seconds) here */
159         uint64_t length;                        /* file length: see <u.h> */
160         char *name;                                     /* last element of path */
161         char *uid;                                      /* owner name */
162         char *gid;                                      /* group name */
163         char *muid;                                     /* last modifier name */
164         char *ext;                                      /* extensions for special files (symlinks) */
165         uint32_t n_uid;                         /* numeric owner uid */
166         uint32_t n_gid;                         /* numeric group id */
167         uint32_t n_muid;                        /* numeric last modifier id */
168         struct timespec atime;          /* last access time */
169         struct timespec btime;          /* file creation time */
170         struct timespec ctime;          /* last attribute change time */
171         struct timespec mtime;          /* last data modification time */
172 };
173
174 struct waitmsg {
175         int pid;                                        /* of loved one */
176         uint32_t time[3];                       /* of loved one and descendants */
177         char msg[ERRMAX];                       /* actually variable-size in user mode */
178 };
179
180 #define VERSION9P       "9P2000"
181
182 #define MAXWELEM        16
183
184 typedef
185         struct fcall {
186         uint8_t type;
187         uint32_t fid;
188         uint16_t tag;
189         /* union { */
190         /* struct { */
191         uint32_t msize;                         /* Tversion, Rversion */
192         char *version;                          /* Tversion, Rversion */
193         /* }; */
194         /* struct { */
195         uint16_t oldtag;                        /* Tflush */
196         /* }; */
197         /* struct { */
198         char *ename;                            /* Rerror */
199         /* }; */
200         /* struct { */
201         struct qid qid;                         /* Rattach, Ropen, Rcreate */
202         uint32_t iounit;                        /* Ropen, Rcreate */
203         /* }; */
204         /* struct { */
205         struct qid aqid;                        /* Rauth */
206         /* }; */
207         /* struct { */
208         uint32_t afid;                          /* Tauth, Tattach */
209         char *uname;                            /* Tauth, Tattach */
210         char *aname;                            /* Tauth, Tattach */
211         /* }; */
212         /* struct { */
213         uint32_t perm;                          /* Tcreate */
214         char *name;                                     /* Tcreate */
215         uint8_t mode;                           /* Tcreate, Topen */
216         /* }; */
217         /* struct { */
218         uint32_t newfid;                        /* Twalk */
219         uint16_t nwname;                        /* Twalk */
220         char *wname[MAXWELEM];          /* Twalk */
221         /* }; */
222         /* struct { */
223         uint16_t nwqid;                         /* Rwalk */
224         struct qid wqid[MAXWELEM];      /* Rwalk */
225         /* }; */
226         /* struct { */
227         int64_t offset;                         /* Tread, Twrite */
228         uint32_t count;                         /* Tread, Twrite, Rread */
229         char *data;                                     /* Twrite, Rread */
230         /* }; */
231         /* struct { */
232         uint16_t nstat;                         /* Twstat, Rstat */
233         uint8_t *stat;                          /* Twstat, Rstat */
234         /* }; */
235         /* }; */
236 } fcall;
237
238 #define GBIT8(p)        ((p)[0])
239 #define GBIT16(p)       ((p)[0]|((p)[1]<<8))
240 #define GBIT32(p)       ((uint32_t)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)))
241 #define GBIT64(p)       ((uint32_t)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) |\
242                                 ((int64_t)((p)[4]|((p)[5]<<8)|((p)[6]<<16)|((p)[7]<<24)) << 32))
243
244 #define PBIT8(p,v)      (p)[0]=(v)
245 #define PBIT16(p,v)     (p)[0]=(v);(p)[1]=(v)>>8
246 #define PBIT32(p,v)     (p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24
247 #define PBIT64(p,v)     (p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24;\
248                         (p)[4]=(v)>>32;(p)[5]=(v)>>40;(p)[6]=(v)>>48;(p)[7]=(v)>>56
249
250 #define BIT8SZ          1
251 #define BIT16SZ         2
252 #define BIT32SZ         4
253 #define BIT64SZ         8
254 #define QIDSZ   (BIT8SZ+BIT32SZ+BIT64SZ)
255
256 /* The 9p STATFIXLENs include the leading 16-bit count.  The count, however,
257  * excludes itself; total size is BIT16SZ + count.  This is the amount of fixed
258  * length data in a stat buffer.  This does not include the strings, but it
259  * includes the string counts (u16s)
260  *
261  * STAT_FIX_LEN_9P is the original 9p stat message: type to length, including
262  * u32 atime and u32 mtime.  This is the bare minimum for a stat that we
263  * receive.  We check in e.g. convM2D for any extra fields.
264  *
265  * STAT_FIX_LEN_AK is the stat message used by Akaros, which includes Eric VH's
266  * extensions and full timespecs.  It is analogous to struct dir, including the
267  * u32s for the legacy atime/mtime.  We always send stats of this size, e.g. in
268  * convD2M.
269  *
270  * Note that the extended stat message has fixed data after the strings, but to
271  * get to this data, you have to jump through the string and their counts
272  * (u16s).  The counts are part of the fixed length, but not the strings.  Also
273  * note that the _AK version has an extra string. */
274 #define STAT_NR_STRINGS_9P 4
275 #define STAT_NR_STRINGS_AK 5
276 #define STAT_FIX_LEN_9P (BIT16SZ +                      /* size */             \
277                          BIT16SZ +                      /* type */             \
278                          BIT32SZ +                      /* dev */              \
279                          QIDSZ +                        /* qid */              \
280                          BIT32SZ +                      /* mode */             \
281                          BIT32SZ +                      /* atime u32 */        \
282                          BIT32SZ +                      /* mtime u32 */        \
283                          BIT64SZ +                      /* length */           \
284                          STAT_NR_STRINGS_9P * BIT16SZ + /* string counts */    \
285                                                  0)
286 #define __STAT_FIX_LEN_AK_NONSTRING (                                          \
287                          BIT32SZ +                      /* n_uid */            \
288                          BIT32SZ +                      /* n_gid */            \
289                          BIT32SZ +                      /* n_muid */           \
290                          2 * BIT64SZ +                  /* atime */            \
291                          2 * BIT64SZ +                  /* btime */            \
292                          2 * BIT64SZ +                  /* ctime */            \
293                          2 * BIT64SZ +                  /* mtime */            \
294                                                  0)
295 #define STAT_FIX_LEN_AK (STAT_FIX_LEN_9P +                                     \
296                          (STAT_NR_STRINGS_AK - STAT_NR_STRINGS_9P) * BIT16SZ + \
297                          __STAT_FIX_LEN_AK_NONSTRING +                         \
298                                                  0)
299
300 #define NOTAG           (uint16_t)~0U   /* Dummy tag */
301 #define NOFID           (uint32_t)~0U   /* Dummy fid */
302 #define IOHDRSZ         24      /* ample room for Twrite/Rread header (iounit) */
303
304 enum {
305         Tversion = 100,
306         Rversion,
307         Tauth = 102,
308         Rauth,
309         Tattach = 104,
310         Rattach,
311         Terror = 106,   /* illegal */
312         Rerror,
313         Tflush = 108,
314         Rflush,
315         Twalk = 110,
316         Rwalk,
317         Topen = 112,
318         Ropen,
319         Tcreate = 114,
320         Rcreate,
321         Tread = 116,
322         Rread,
323         Twrite = 118,
324         Rwrite,
325         Tclunk = 120,
326         Rclunk,
327         Tremove = 122,
328         Rremove,
329         Tstat = 124,
330         Rstat,
331         Twstat = 126,
332         Rwstat,
333         Tmax,
334 };
335
336 void init_empty_dir(struct dir *d);
337 unsigned int convM2S(uint8_t * unused_uint8_p_t, unsigned int unused_int,
338                                          struct fcall *);
339 unsigned int convS2M(struct fcall *, uint8_t * unused_uint8_p_t, unsigned int);
340 unsigned int sizeS2M(struct fcall *);
341
342 unsigned int convM2kdirent(uint8_t * buf, unsigned int nbuf, struct kdirent *kd,
343                                                    char *strs);
344 unsigned int convM2kstat(uint8_t * buf, unsigned int nbuf, struct kstat *ks);
345
346 int statcheck(uint8_t * abuf, unsigned int nbuf);
347 unsigned int convM2D(uint8_t * unused_uint8_p_t, unsigned int unused_int,
348                                          struct dir *, char *unused_char_p_t);
349 unsigned int convD2M(struct dir *, uint8_t * unused_uint8_p_t, unsigned int);
350 unsigned int sizeD2M(struct dir *);
351
352 int read9pmsg(int unused_int, void *, unsigned int);
353
354 struct ref {
355         spinlock_t l;
356         long ref;
357 };
358
359 struct rept {
360         spinlock_t l;
361         struct rendez r;
362         void *o;
363         int t;
364         int (*active) (void *);
365         int (*ck) (void *, int);
366         void (*f) (void *);                     /* called with VM acquire()'d */
367 };
368
369 enum {
370         Nopin = -1
371 };
372
373 struct talarm {
374         spinlock_t lock;
375         struct proc *list;
376 };
377
378 struct alarms {
379         qlock_t qlock;
380         struct proc *head;
381 };
382
383 /*
384  * Access types in namec & channel flags
385  */
386 enum {
387         Aaccess,                                        /* as in stat, wstat */
388         Abind,                                          /* for left-hand-side of bind */
389         Atodir,                                         /* as in chdir */
390         Aopen,                                          /* for i/o */
391         Amount,                                         /* to be mounted or mounted upon */
392         Acreate,                                        /* is to be created */
393         Aremove,                                        /* will be removed by caller */
394         Arename,                                        /* new_path of a rename */
395
396         /* internal chan flags, used by the kernel only */
397         COPEN =                 0x0001, /* for i/o */
398         CMSG =                  0x0002, /* the message channel for a mount */
399         CFREE =                 0x0004, /* not in use */
400         CCACHE =                0x0008, /* client cache */
401         CINTERNAL_FLAGS = (COPEN | CMSG | CFREE | CCACHE),
402
403         /* chan/file flags, getable via fcntl/getfl and setably via open and
404          * sometimes fcntl/setfl.  those that can't be set cause an error() in
405          * fd_setfl. */
406         CEXTERNAL_FLAGS = (
407             O_CLOEXEC      | /* (prob should be on the FD, 9ns has it here) */
408             O_REMCLO       | /* remove on close (also, maybe should be on FD) */
409             O_APPEND       | /* append on write */
410             O_NONBLOCK     | /* don't block, can't be set via setfl */
411             O_PATH         | /* path open, just the name, no I/O */
412             0),
413 };
414
415 #define NS_IPCK_SHIFT  2
416 #define NS_UDPCK_SHIFT 3
417 #define NS_TCPCK_SHIFT 4
418 #define NS_PKTCK_SHIFT 5
419 #define NS_TSO_SHIFT 6
420 #define NS_SHIFT_MAX 6
421
422 enum {
423         BFREE = (1 << 1),
424         Bipck = (1 << NS_IPCK_SHIFT),   /* ip checksum (rx) */
425         Budpck = (1 << NS_UDPCK_SHIFT), /* udp checksum (rx), needed (tx) */
426         Btcpck = (1 << NS_TCPCK_SHIFT), /* tcp checksum (rx), needed (tx) */
427         Bpktck = (1 << NS_PKTCK_SHIFT), /* packet checksum (rx, maybe) */
428         Btso = (1 << NS_TSO_SHIFT),             /* TSO desired (tx) */
429 };
430 #define BLOCK_META_FLAGS (Bipck | Budpck | Btcpck | Bpktck | Btso)
431 #define BLOCK_TRANS_TX_CSUM (Budpck | Btcpck)
432 #define BLOCK_RX_CSUM (Bipck | Budpck | Btcpck)
433
434 struct extra_bdata {
435         uintptr_t base;
436         /* using u32s for packing reasons.  this means no extras > 4GB */
437         uint32_t off;
438         uint32_t len;
439 };
440
441 struct block {
442         struct block *next;
443         struct block *list;
444         uint8_t *rp;                            /* first unconsumed byte */
445         uint8_t *wp;                            /* first empty byte */
446         uint8_t *lim;                           /* 1 past the end of the buffer */
447         uint8_t *base;                          /* start of the buffer */
448         void (*free) (struct block *);
449         uint16_t flag;
450         uint16_t mss;               /* TCP MSS for TSO */
451         uint16_t network_offset;        /* offset from start */
452         uint16_t transport_offset;      /* offset from start */
453         uint16_t tx_csum_offset;        /* offset from tx_offset to store csum */
454         /* might want something to track the next free extra_data slot */
455         size_t extra_len;
456         unsigned int nr_extra_bufs;
457         struct extra_bdata *extra_data;
458 };
459 #define BLEN(s) ((s)->wp - (s)->rp + (s)->extra_len)
460 #define BHLEN(s) ((s)->wp - (s)->rp)
461 #define BALLOC(s) ((s)->lim - (s)->base + (s)->extra_len)
462
463 struct chan {
464         spinlock_t lock;
465         struct kref ref;
466         struct chan *next;                      /* allocation */
467         struct chan *link;
468         int64_t offset;                         /* in file */
469         int type;                                       /* ID for device type, e.g. #mnt, #kfs, #ip */
470         uint32_t dev;                           /* device specific; can be an instance ID */
471         uint16_t mode;                          /* read/write */
472         int flag;
473         struct qid qid;
474         int fid;                                        /* for devmnt */
475         uint32_t iounit;                        /* chunk size for i/o; 0==default */
476         struct mhead *umh;                      /* mount point that derived Chan; used in unionread */
477         struct chan *umc;                       /* channel in union; held for union read */
478         qlock_t umqlock;                        /* serialize unionreads */
479         int uri;                                        /* union read index */
480         int dri;                                        /* devdirread index */
481         uint32_t mountid;
482         struct mntcache *mcp;           /* Mount cache pointer */
483         struct mnt *mux;                        /* Mnt for clients using me for messages */
484         union {
485                 void *aux;
486                 char tag[4];                    /* for iproute */
487         };
488         /* mountpoint, as discovered during walk.
489          * Used for rename at present.
490          */
491         struct chan *mountpoint;
492         struct chan *mchan;                     /* channel to mounted server */
493         struct qid mqid;                        /* qid of root of mount point */
494         struct cname *name;
495         /* hack for dir reads to try to get them right. */
496         int ateof;
497         void *buf;
498         int bufused;
499         /* A lot of synthetic files need something generated at open time, which the
500          * user can read from (including offsets) while the underlying file changes.
501          * Hang that buffer here. */
502         void *synth_buf;
503 };
504
505 extern struct chan *kern_slash;
506
507 struct cname {
508         struct kref ref;
509         int alen;                                       /* allocated length */
510         int len;                                        /* strlen(s) */
511         char *s;
512 };
513
514 struct fs_file;
515
516 struct dev {
517         char *name;
518
519         void (*reset)(void);
520         void (*init)(void);
521         void (*shutdown)(void);
522         struct chan *(*attach)(char *muxattach);
523         struct walkqid *(*walk)(struct chan *, struct chan *, char **name,
524                                 unsigned int);
525         size_t (*stat)(struct chan *, uint8_t *, size_t);
526         struct chan *(*open)(struct chan *, int);
527         void (*create)(struct chan *, char *, int, uint32_t, char *);
528         void (*close)(struct chan *);
529         size_t (*read)(struct chan *, void *, size_t, off64_t);
530         struct block *(*bread)(struct chan *, size_t, off64_t);
531         size_t (*write)(struct chan *, void *, size_t, off64_t);
532         size_t (*bwrite)(struct chan *, struct block *, off64_t);
533         void (*remove)(struct chan *);
534         void (*rename)(struct chan *, struct chan *, const char *, int);
535         size_t (*wstat)(struct chan *, uint8_t *, size_t);
536         void (*power)(int);             /* power mgt: power(1) → on, power (0) → off */
537 //  int (*config)( int unused_int, char *unused_char_p_t, DevConf*);
538         char *(*chaninfo)(struct chan *, char *, size_t);
539         int (*tapfd)(struct chan *, struct fd_tap *, int);
540         unsigned long (*chan_ctl)(struct chan *c, int op, unsigned long a1,
541                                   unsigned long a2, unsigned long a3,
542                                   unsigned long a4);
543         struct fs_file *(*mmap)(struct chan *, struct vm_region *, int, int);
544         /* we need to be aligned to 64 bytes for the linker tables. */
545 } __attribute__ ((aligned(64)));
546
547 struct dirtab {
548         char name[KNAMELEN];
549         struct qid qid;
550         int64_t length;
551         int perm;
552         /* we need to be aligned to 64 bytes for the linker tables. */
553 } __attribute__ ((aligned(64)));
554
555 struct walkqid {
556         struct chan *clone;
557         int nqid;
558         struct qid qid[1];
559 };
560
561 enum {
562         NSMAX = 1000,
563         NSLOG = 7,
564         NSCACHE = (1 << NSLOG),
565 };
566
567 struct mntwalk {                                /* state for /proc/#/ns */
568         int cddone;
569         uint32_t id;
570         struct mhead *mh;
571         struct mount *cm;
572 };
573
574 struct mount {
575         uint32_t mountid;
576         struct mount *next;
577         struct mhead *head;
578         struct mount *copy;
579         struct mount *order;
580         struct chan *to;                        /* channel replacing channel */
581         int mflag;
582         char *spec;
583 };
584
585 struct mhead {
586         struct kref ref;
587         struct rwlock lock;
588         struct chan *from;                      /* channel mounted upon */
589         struct mount *mount;            /* what's mounted upon it */
590         struct mhead *hash;                     /* Hash chain */
591 };
592
593 struct mnt {
594         spinlock_t lock;
595         /* references are counted using c->ref; channels on this mount point incref(c->mchan) == Mnt.c */
596         struct chan *c;                         /* Channel to file service */
597         struct proc *rip;                       /* Reader in progress */
598         struct mntrpc *queue;           /* Queue of pending requests on this channel */
599         uint32_t id;                            /* Multiplexer id for channel check */
600         struct mnt *list;                       /* Free list */
601         int flags;                                      /* cache */
602         int msize;                                      /* data + IOHDRSZ */
603         char *version;                          /* 9P version */
604         struct queue *q;                        /* input queue */
605 };
606
607 enum {
608         RENDLOG = 5,
609         RENDHASH = 1 << RENDLOG,        /* Hash to lookup rendezvous tags */
610         MNTLOG = 5,
611         MNTHASH = 1 << MNTLOG,  /* Hash to walk mount table */
612         DELTAFD = 20,   /* allocation quantum for process file descriptors */
613         MAXNFD = 4000,  /* max per process file descriptors */
614         MAXKEY = 8,     /* keys for signed modules */
615 };
616 #define MOUNTH(p,qid)   ((p)->mnthash[(qid).path&((1<<MNTLOG)-1)])
617
618 struct mntparam {
619         struct chan *chan;
620         struct chan *authchan;
621         char *spec;
622         int flags;
623 };
624
625 struct pgrp {
626         struct kref ref;                        /* also used as a lock when mounting */
627         uint32_t pgrpid;
628         qlock_t debug;                          /* single access via devproc.c */
629         struct rwlock ns;                       /* Namespace n read/one write lock */
630         qlock_t nsh;
631         struct mhead *mnthash[MNTHASH];
632         int progmode;
633         int nodevs;
634         int pin;
635 };
636
637 struct evalue {
638         char *var;
639         char *val;
640         int len;
641         struct qid qid;
642         struct evalue *next;
643 };
644
645 struct egrp {
646         struct kref ref;
647         qlock_t qlock;
648         struct evalue *entries;
649         uint32_t path;                          /* qid.path of next Evalue to be allocated */
650         uint32_t vers;                          /* of Egrp */
651 };
652
653 struct signerkey {
654         struct kref ref;
655         char *owner;
656         uint16_t footprint;
657         uint32_t expires;
658         void *alg;
659         void *pk;
660         void (*pkfree) (void *);
661 };
662
663 struct skeyset {
664         struct kref ref;
665         qlock_t qlock;
666         uint32_t flags;
667         char *devs;
668         int nkey;
669         struct signerkey *keys[MAXKEY];
670 };
671
672 /*
673  * fasttick timer interrupts
674  */
675 enum {
676         /* Mode */
677         Trelative,                                      /* timer programmed in ns from now */
678         Tabsolute,                                      /* timer programmed in ns since epoch */
679         Tperiodic,                                      /* periodic timer, period in ns */
680 };
681
682 enum {
683         PRINTSIZE = 256,
684         NUMSIZE = 12,   /* size of formatted number */
685         MB = (1024 * 1024),
686         READSTR = 2000, /* temporary buffer size for device reads */
687 };
688
689 extern struct dev devtab[];
690 extern struct dev __devtabend[];
691
692 struct cmdbuf {
693         char *buf;
694         char **f;
695         int nf;
696 };
697
698 struct cmdtab {
699         int index;                                      /* used by client to switch on result */
700         char *cmd;                                      /* command name */
701         int narg;                                       /* expected #args; 0 ==> variadic */
702 };
703
704 /* queue state bits, all can be set in qopen (Qstarve is always set) */
705 enum {
706         Qmsg                    = (1 << 1),     /* message stream */
707         Qclosed                 = (1 << 2),     /* queue has been closed/hungup */
708         Qcoalesce               = (1 << 3),     /* coalesce empty packets on read */
709         Qkick                   = (1 << 4),     /* always call the kick routine after qwrite */
710         Qdropoverflow   = (1 << 5),     /* writes that would block will be dropped */
711 };
712
713 /* Per-process structs */
714 #define NR_OPEN_FILES_DEFAULT 32
715 #define NR_FILE_DESC_DEFAULT 32
716
717 /* Bitmask for file descriptors, big for when we exceed the initial small.  We
718  * could just use the fd_array to check for openness instead of the bitmask,
719  * but eventually we might want to use the bitmasks for other things (like
720  * which files are close_on_exec. */
721
722 typedef struct fd_set {
723     uint8_t fds_bits[BYTES_FOR_BITMASK(NR_FILE_DESC_MAX)];
724 } fd_set;
725
726
727 struct small_fd_set {
728     uint8_t fds_bits[BYTES_FOR_BITMASK(NR_FILE_DESC_DEFAULT)];
729 };
730
731 /* Helper macros to manage fd_sets */
732 #define FD_SET(n, p)    ((p)->fds_bits[(n) / 8] |=  (1 << ((n) & 7)))
733 #define FD_CLR(n, p)    ((p)->fds_bits[(n) / 8] &= ~(1 << ((n) & 7)))
734 #define FD_ISSET(n, p)  ((p)->fds_bits[(n) / 8] &   (1 << ((n) & 7)))
735 #define FD_ZERO(p)              memset((void*)(p), 0, sizeof(*(p)))
736
737 /* Describes an open file.  We need this, since the FD flags are supposed to be
738  * per file descriptor, not per file (like the file status flags). */
739 struct file_desc {
740         struct chan                                     *fd_chan;
741         unsigned int                            fd_flags;
742         struct fd_tap                           *fd_tap;
743 };
744
745 /* All open files for a process */
746 struct fd_table {
747         spinlock_t                                      lock;
748         bool                                            closed;
749         int                                                     max_files;              /* max files ptd to by fd */
750         int                                                     max_fdset;              /* max of the current fd_set */
751         int                                                     hint_min_fd;    /* <= min available fd */
752         struct file_desc                        *fd;                    /* initially pts to fd_array */
753         struct fd_set                           *open_fds;              /* init, pts to open_fds_init */
754         struct small_fd_set                     open_fds_init;
755         struct file_desc                        fd_array[NR_OPEN_FILES_DEFAULT];
756 };
757
758 ssize_t kread_file(struct file_or_chan *file, void *buf, size_t sz);
759 void *kread_whole_file(struct file_or_chan *file);
760
761 /* Process-related File management functions */
762 void *lookup_fd(struct fd_table *fdt, int fd, bool incref);
763 int insert_obj_fdt(struct fd_table *fdt, void *obj, int low_fd, int fd_flags,
764                    bool must_use_low);
765 bool close_fd(struct fd_table *fdt, int fd);
766 void close_fdt(struct fd_table *open_files, bool cloexec);
767 void clone_fdt(struct fd_table *src, struct fd_table *dst);
768
769 #define DEVDOTDOT -1
770
771 typedef int Devgen(struct chan *, char *unused_char_p_t, struct dirtab *,
772                                    int unused_int, int, struct dir *);
773
774 /* inferno portfns.h. Not all these are needed. */
775 #define         FPinit() fpinit()       /* remove this if math lib is linked */
776 void FPrestore(void *);
777 void FPsave(void *);
778 struct cname *addelem(struct cname *, char *unused_char_p_t);
779 void addprog(struct proc *);
780 void addrootfile(char *unused_char_p_t, uint8_t * unused_uint8_p_t, uint32_t);
781 struct block *adjustblock(struct block *, int);
782 struct block *block_alloc(size_t, int);
783 int block_add_extd(struct block *b, unsigned int nr_bufs, int mem_flags);
784 int block_append_extra(struct block *b, uintptr_t base, uint32_t off,
785                        uint32_t len, int mem_flags);
786 void block_copy_metadata(struct block *new_b, struct block *old_b);
787 void block_reset_metadata(struct block *b);
788 int anyhigher(void);
789 int anyready(void);
790 void _assert(char *unused_char_p_t);
791 struct block *bl2mem(uint8_t * unused_uint8_p_t, struct block *, int);
792 int blocklen(struct block *);
793 char *channame(struct chan *);
794 void cclose(struct chan *);
795 void chan_incref(struct chan *);
796 void chandevinit(void);
797 void chandevreset(void);
798 void chandevshutdown(void);
799 void chanfree(struct chan *);
800 void chanrec(struct mnt *);
801 void checkalarms(void);
802 void checkb(struct block *, char *unused_char_p_t);
803 struct chan *cclone(struct chan *);
804 void cclose(struct chan *);
805 void closeegrp(struct egrp *);
806 void closemount(struct mount *);
807 void closepgrp(struct pgrp *);
808 void closesigs(struct skeyset *);
809 void debugcmd(struct cmdbuf *cb);
810 struct mhead *newmhead(struct chan *from);
811 int cmount(struct chan *, struct chan *, int unused_int, char *unused_char_p_t);
812 void cnameclose(struct cname *);
813 struct block *concatblock(struct block *);
814 struct block *linearizeblock(struct block *b);
815 void confinit(void);
816 void cons_add_char(char c);
817 struct block *copyblock(struct block *b, int mem_flags);
818 struct chan *cunique(struct chan *);
819 struct chan *createdir(struct chan *, struct mhead *);
820 void cunmount(struct chan *, struct chan *);
821 void cursorenable(void);
822 void cursordisable(void);
823 int cursoron(int);
824 void cursoroff(int);
825 struct chan *devattach(const char *name, char *spec);
826 struct block *devbread(struct chan *, size_t, off64_t);
827 size_t devbwrite(struct chan *, struct block *, off64_t);
828 struct chan *devclone(struct chan *);
829 void devcreate(struct chan *, char *name, int mode, uint32_t perm, char *ext);
830 void devdir(struct chan *, struct qid, char *, int64_t, char *, long,
831                         struct dir *);
832 long devdirread(struct chan *, char *, long, struct dirtab *, int, Devgen *);
833 Devgen devgen;
834 void devinit(void);
835 int devno(const char *name, int user);
836 void devpower(int);
837 struct dev *devbyname(char *unused_char_p_t);
838 struct chan *devopen(struct chan *, int unused_int,
839                                          struct dirtab *, int unused_int2, Devgen *);
840 void devpermcheck(char *unused_char_p_t, uint32_t, int);
841 void devremove(struct chan *);
842 void devreset(void);
843 void devshutdown(void);
844 size_t dev_make_stat(struct chan *c, struct dir *dir, uint8_t *dp, size_t n);
845 size_t devstat(struct chan *, uint8_t *db, size_t n, struct dirtab *,
846                int ntab, Devgen *);
847 struct walkqid *devwalk(struct chan *,
848                                                 struct chan *, char **unused_char_pp_t, int unused_int,
849                                                 struct dirtab *, int unused_intw, Devgen *);
850 size_t devwstat(struct chan *, uint8_t *, size_t);
851 char *devchaninfo(struct chan *chan, char *ret, size_t ret_l);
852 void disinit(void *);
853 void disfault(void *, char *unused_char_p_t);
854 int domount(struct chan **, struct mhead **);
855 void drawactive(int);
856 void drawcmap(void);
857 void dumpstack(void);
858 void egrpcpy(struct egrp *, struct egrp *);
859 int emptystr(char *unused_char_p_t);
860 int eqchan(struct chan *, struct chan *, int);
861 int eqqid(struct qid, struct qid);
862
863 void errstr(char *unused_char_p_t, int);
864 void excinit(void);
865 void exit(int);
866 void reboot(void);
867 void halt(void);
868 int export(int unused_int, char *unused_char_p_t, int);
869 uint64_t fastticks(uint64_t *);
870 uint64_t fastticks2ns(uint64_t);
871 int findmount(struct chan **, struct mhead **, int unused_int, int, struct qid);
872 void free_block_extra(struct block *);
873 size_t freeb(struct block *b);
874 size_t freeblist(struct block *b);
875 void freeskey(struct signerkey *);
876 void getcolor(uint32_t, uint32_t *, uint32_t *, uint32_t *);
877 uint32_t getmalloctag(void *);
878 uint32_t getrealloctag(void *);
879 void printblock(struct block *b);
880 void ilock(spinlock_t *);
881 int iprint(char *unused_char_p_t, ...);
882 void isdir(struct chan *);
883 int islo(void);
884 void iunlock(spinlock_t *);
885 void ixsummary(void);
886 void kbdclock(void);
887 int kbdcr2nl(struct queue *, int);
888 int kbdputc(struct queue *, int);
889 void kbdrepeat(int);
890 void kproc(char *unused_char_p_t, void (*)(void *), void *, int);
891 void kprocchild(struct proc *, void (*)(void *), void *);
892 void (*kproftick) (uint32_t);
893 void ksetenv(char *unused_char_p_t, char *, int);
894 void kstrdup(char **cp, char *name);
895
896 struct block *mem2bl(uint8_t * unused_uint8_p_t, int);
897 int memusehigh(void);
898 void microdelay(int);
899 uint64_t mk64fract(uint64_t, uint64_t);
900 void mkqid(struct qid *, int64_t, uint32_t, int);
901 void modinit(void);
902 struct chan *mntauth(struct chan *, char *unused_char_p_t);
903 long mntversion(struct chan *, char *unused_char_p_t, int unused_int, int);
904 void mountfree(struct mount *);
905 void mousetrack(int unused_int, int, int, int);
906 uint64_t ms2fastticks(uint32_t);
907 void mul64fract(uint64_t *, uint64_t, uint64_t);
908 void muxclose(struct mnt *);
909 struct chan *namec(char *unused_char_p_t, int unused_int, int, uint32_t,
910                    void *ext);
911 struct chan *namec_from(struct chan *c, char *name, int amode, int omode,
912                         uint32_t perm, void *ext);
913 struct chan *newchan(void);
914 struct egrp *newegrp(void);
915 struct mount *newmount(struct mhead *, struct chan *, int unused_int,
916                                            char *unused_char_p_t);
917 struct pgrp *newpgrp(void);
918 struct proc *newproc(void);
919 char *nextelem(char *unused_char_p_t, char *);
920
921 struct cname *newcname(char *unused_char_p_t);
922 void notkilled(void);
923 uint32_t random_read(void *xp, uint32_t n);
924 uint32_t urandom_read(void *xp, uint32_t n);
925 uint64_t ns2fastticks(uint64_t);
926 int okaddr(uint32_t, uint32_t, int);
927 int omode_to_rwx(int);
928 int omode_to_9p_accmode(int open_flags);
929 int access_bits_to_omode(int access_bits);
930 struct block *packblock(struct block *);
931 struct block *padblock(struct block *, int);
932
933 void pgrpcpy(struct pgrp *, struct pgrp *);
934
935 int progfdprint(struct chan *, int unused_int, int, char *unused_char_p_t,
936                                 int i);
937 int pullblock(struct block **, int);
938 struct block *pullupblock(struct block *, int);
939 struct block *pullupqueue(struct queue *, int);
940 void putmhead(struct mhead *);
941 void putstrn(char *unused_char_p_t, int);
942 void qaddlist(struct queue *, struct block *);
943 struct block *qbread(struct queue *q, size_t len);
944 struct block *qbread_nonblock(struct queue *q, size_t len);
945 ssize_t qbwrite(struct queue *, struct block *);
946 ssize_t qbwrite_nonblock(struct queue *, struct block *);
947 ssize_t qibwrite(struct queue *q, struct block *b);
948 struct queue *qbypass(void (*)(void *, struct block *), void *);
949 int qcanread(struct queue *);
950 void qclose(struct queue *);
951 struct block *qcopy(struct queue *, int unused_int, uint32_t);
952 struct block *qclone(struct queue *q, int header_len, int len,
953                      uint32_t offset);
954 struct block *blist_clone(struct block *blist, int header_len, int len,
955                           uint32_t offset);
956 size_t qdiscard(struct queue *q, size_t len);
957 void qflush(struct queue *);
958 void qfree(struct queue *);
959 int qfull(struct queue *);
960 struct block *qget(struct queue *);
961 void qhangup(struct queue *, char *unused_char_p_t);
962 int qisclosed(struct queue *);
963 ssize_t qiwrite(struct queue *, void *, int);
964 int qlen(struct queue *);
965 size_t q_bytes_read(struct queue *q);
966 void qdropoverflow(struct queue *, bool);
967 void q_toggle_qmsg(struct queue *q, bool onoff);
968 void q_toggle_qcoalesce(struct queue *q, bool onoff);
969 struct queue *qopen(int unused_int, int, void (*)(void *), void *);
970 ssize_t qpass(struct queue *, struct block *);
971 ssize_t qpassnolim(struct queue *, struct block *);
972 void qputback(struct queue *, struct block *);
973 size_t qread(struct queue *q, void *va, size_t len);
974 size_t qread_nonblock(struct queue *q, void *va, size_t len);
975 void qreopen(struct queue *);
976 void qsetlimit(struct queue *, size_t);
977 size_t qgetlimit(struct queue *);
978 int qwindow(struct queue *);
979 ssize_t qwrite(struct queue *, void *, int);
980 ssize_t qwrite_nonblock(struct queue *, void *, int);
981 typedef void (*qio_wake_cb_t)(struct queue *q, void *data, int filter);
982 void qio_set_wake_cb(struct queue *q, qio_wake_cb_t func, void *data);
983 bool qreadable(struct queue *q);
984 bool qwritable(struct queue *q);
985
986 void *realloc(void *, uint32_t);
987 int readmem(unsigned long offset, char *buf, unsigned long n,
988                         const void *mem, size_t mem_len);
989 int readnum(unsigned long off, char *buf, unsigned long n, unsigned long val,
990                         size_t size);
991 int readnum_hex(unsigned long off, char *buf, unsigned long n,
992                 unsigned long val, size_t size);
993 int readstr(unsigned long offset, char *buf, unsigned long n, const char *str);
994 int readnum_int64_t(uint32_t, char *unused_char_p_t, uint32_t, int64_t, int);
995 unsigned long strtoul_from_ubuf(void *ubuf, size_t count, int base);
996 void ready(struct proc *);
997 void renameproguser(char *unused_char_p_t, char *);
998 void renameuser(char *unused_char_p_t, char *);
999 void resrcwait(char *unused_char_p_t);
1000 struct proc *runproc(void);
1001 void (*serwrite) (char *unused_char_p_t, int);
1002 int setcolor(uint32_t, uint32_t, uint32_t, uint32_t);
1003
1004 void setmalloctag(void *, uint32_t);
1005 int setpri(int);
1006 void setrealloctag(void *, uint32_t);
1007 char *skipslash(char *unused_char_p_t);
1008 void *smalloc(uint32_t);
1009 int splhi(void);
1010 int spllo(void);
1011 void splx(int);
1012 void splxpc(int);
1013 void swiproc(struct proc *, int);
1014 uint32_t _tas(uint32_t *);
1015 uint32_t tk2ms(uint32_t);
1016 #define         TK2MS(x) ((x)*(1000/HZ))
1017 uint64_t tod2fastticks(int64_t);
1018 int64_t todget(int64_t *);
1019 void todfix(void);
1020 void todsetfreq(int64_t);
1021 void todinit(void);
1022 void todset(int64_t, int64_t, int);
1023 int tready(void *);
1024 struct block *trimblock(struct block *, int unused_int, int);
1025 int uartgetc(void);
1026 void uartputc(int);
1027 void uartputs(char *unused_char_p_t, int);
1028 void unlock(spinlock_t *);
1029 void userinit(void);
1030 uint32_t userpc(void);
1031 void validname(char *, int);
1032 void validwstatname(char *);
1033 void *xalloc(uint32_t);
1034 void *xallocz(uint32_t, int);
1035 void xfree(void *);
1036 void xhole(uint32_t, uint32_t);
1037 void xinit(void);
1038 int xmerge(void *, void *);
1039 void *xspanalloc(uint32_t, int unused_int, uint32_t);
1040 void xsummary(void);
1041
1042 void validaddr(void *, uint32_t, int);
1043 void *vmemchr(void *, int unused_int, int);
1044 void hnputv(void *, int64_t);
1045 void hnputl(void *, uint32_t);
1046 void hnputs(void *, uint16_t);
1047 int64_t nhgetv(void *);
1048 uint32_t nhgetl(void *);
1049 uint16_t nhgets(void *);
1050
1051 char *get_cur_genbuf(void);
1052
1053 static inline const char *chan_dev_name(struct chan *c)
1054 {
1055         return devtab[c->type].name;
1056 }
1057
1058 /* hack for now. */
1059 #define NOW     tsc2msec(read_tsc())
1060 #define seconds() tsc2sec(read_tsc())
1061 #define milliseconds() tsc2msec(read_tsc())
1062
1063 /* kern/drivers/dev/tab.c */
1064 void devtabinit();
1065 void devtabreset();
1066
1067 /* kern/src/ns/parse.c */
1068 struct cmdbuf *parsecmd(char *p, int n);
1069 void cmderror(struct cmdbuf *cb, char *s);
1070 struct cmdtab *lookupcmd(struct cmdbuf *cb, struct cmdtab *ctab, int nctab);
1071
1072 /* kern/src/ns/sysfile.c */
1073 int newfd(struct chan *c, int low_fd, int oflags, bool must_use_low);
1074 struct chan *fdtochan(struct fd_table *fdt, int fd, int mode, int chkmnt,
1075                       int iref);
1076 long kchanio(void *vc, void *buf, int n, int mode);
1077 int openmode(uint32_t o);
1078 void fdclose(struct fd_table *fdt, int fd);
1079 int syschdir(char *path);
1080 int sysfchdir(int fd);
1081 int grpclose(struct fd_table *fdt, int fd);
1082 int sysclose(int fd);
1083 int syscreate(char *path, int mode, uint32_t perm);
1084 int sysdup(int old, int low_fd, bool must_use_low);
1085 int sys_dup_to(struct proc *from_proc, unsigned int from_fd,
1086                struct proc *to_proc, unsigned int to_fd);
1087 int sysfstat(int fd, uint8_t*, int n);
1088 int sysfstatakaros(int fd, struct kstat *);
1089 char *sysfd2path(int fd);
1090 char *sysgetcwd(void);
1091 int sysfauth(int fd, char *aname);
1092 int sysfversion(int fd, unsigned int msize, char *vers, unsigned int arglen);
1093 int sysfwstat(int fd, uint8_t * buf, int n);
1094 long bindmount(struct chan *c, char *old, int flag, char *spec);
1095 int sysbind(char *new, char *old, int flags);
1096 int syssymlink(char *new_path, char *old_path);
1097 int sysmount(int fd, int afd, char *old, int flags, char *spec);
1098 int sysunmount(char *old, char *new);
1099 int sysopenat(int dirfd, char *path, int vfs_flags);
1100 int sysopen(char *path, int vfs_flags);
1101 long unionread(struct chan *c, void *va, long n);
1102 void read_exactly_n(struct chan *c, void *vp, long n);
1103 long sysread(int fd, void *va, long n);
1104 long syspread(int fd, void *va, long n, int64_t off);
1105 int sysremove(char *path);
1106 int sysrename(char *from_path, char *to_path);
1107 int64_t sysseek(int fd, int64_t off, int whence);
1108 void validstat(uint8_t * s, int n, int slashok);
1109 int sysstat(char *path, uint8_t*, int n);
1110 int syslstat(char *path, uint8_t*, int n);
1111 int sysstatakaros(char *path, struct kstat *, int flags);
1112 long syswrite(int fd, void *va, long n);
1113 long syspwrite(int fd, void *va, long n, int64_t off);
1114 int syswstat(char *path, uint8_t * buf, int n);
1115 struct dir *chandirstat(struct chan *c);
1116 struct dir *sysdirstat(char *name);
1117 struct dir *sysdirlstat(char *name);
1118 struct dir *sysdirfstat(int fd);
1119 int sysdirwstat(char *name, struct dir *dir);
1120 int sysdirfwstat(int fd, struct dir *dir);
1121 long sysdirread(int fd, struct kdirent **d);
1122 int sysiounit(int fd);
1123 void print_chaninfo(struct chan *ch);
1124 int plan9setup(struct proc *new_proc, struct proc *parent, int flags);
1125 int iseve(void);
1126 int fd_getfl(int fd);
1127 int fd_setfl(int fd, int flags);
1128 int fd_sync(int fd);
1129 int fd_get_fd_flags(struct fd_table *fdt, int fd);
1130 int fd_set_fd_flags(struct fd_table *fdt, int fd, int new_fl);
1131
1132 /* kern/drivers/dev/srv.c */
1133 char *srvname(struct chan *c);
1134
1135 /* kern/src/eipconv.c. Put them here or face real include hell. */
1136 void printqid(void (*putch) (int, void **), void **putdat, struct qid *q);
1137 void printcname(void (*putch) (int, void **), void **putdat, struct cname *c);
1138 void printchan(void (*putch) (int, void **), void **putdat, struct chan *c);
1139
1140 /* kern/src/ns/util.c */
1141 bool caller_is_username(char *uid);
1142 bool caller_has_perms(char *fileuid, uint32_t perm, int omode);
1143 bool caller_has_dir_perms(struct dir *dir, int omode);
1144 void dir_perm_check(struct dir *dir, int omode);
1145
1146 static inline int abs(int a)
1147 {
1148         if (a < 0)
1149                 return -a;
1150         return a;
1151 }
1152
1153 extern struct username eve;
1154 extern unsigned int qiomaxatomic;
1155
1156 /* special sections */
1157 #define __devtab  __attribute__((__section__(".devtab")))
1158
1159 #define DEVVARS_ENTRY(name, fmt)                                               \
1160 struct dirtab __attribute__((__section__("devvars"))) __devvars_##name =       \
1161               {#name "!" fmt,                                                  \
1162                {(uint64_t)&(name), 0, QTFILE},                                 \
1163                sizeof((name)),                                                 \
1164                0444}