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