1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
|
void _assert(char*);
void accounttime(void);
Timer* addclock0link(void (*)(void), int);
int addphysseg(Physseg*);
void addbootfile(char*, uchar*, ulong);
void addwatchdog(Watchdog*);
Block* adjustblock(Block*, int);
void alarmkproc(void*);
Block* allocb(int);
int anyhigher(void);
int anyready(void);
Image* attachimage(int, Chan*, ulong, ulong);
Page* auxpage(void);
Block* bl2mem(uchar*, Block*, int);
int blocklen(Block*);
void bootlinks(void);
void cachedel(Image*, ulong);
void cachepage(Page*, Image*);
void callwithureg(void(*)(Ureg*));
char* chanpath(Chan*);
int canlock(Lock*);
int canpage(Proc*);
int canqlock(QLock*);
int canrlock(RWlock*);
void chandevinit(void);
void chandevreset(void);
void chandevshutdown(void);
void chanfree(Chan*);
void checkalarms(void);
void checkb(Block*, char*);
void cinit(void);
Chan* cclone(Chan*);
void cclose(Chan*);
void ccloseq(Chan*);
void closeegrp(Egrp*);
void closefgrp(Fgrp*);
void closepgrp(Pgrp*);
void closergrp(Rgrp*);
long clrfpintr(void);
void cmderror(Cmdbuf*, char*);
int cmount(Chan**, Chan*, int, char*);
void confinit(void);
int consactive(void);
void (*consdebug)(void);
void copen(Chan*);
Block* concatblock(Block*);
Block* copyblock(Block*, int);
void copypage(Page*, Page*);
void countpagerefs(ulong*, int);
int cread(Chan*, uchar*, int, vlong);
void cunmount(Chan*, Chan*);
void cupdate(Chan*, uchar*, int, vlong);
void cwrite(Chan*, uchar*, int, vlong);
ulong dbgpc(Proc*);
long decref(Ref*);
int decrypt(void*, void*, int);
void delay(int);
Proc* dequeueproc(Schedq*, Proc*);
Chan* devattach(int, char*);
Block* devbread(Chan*, long, ulong);
long devbwrite(Chan*, Block*, ulong);
Chan* devclone(Chan*);
int devconfig(int, char *, DevConf *);
void devcreate(Chan*, char*, int, ulong);
void devdir(Chan*, Qid, char*, vlong, char*, long, Dir*);
long devdirread(Chan*, char*, long, Dirtab*, int, Devgen*);
Devgen devgen;
void devinit(void);
int devno(int, int);
Chan* devopen(Chan*, int, Dirtab*, int, Devgen*);
void devpermcheck(char*, ulong, int);
void devpower(int);
void devremove(Chan*);
void devreset(void);
void devshutdown(void);
int devstat(Chan*, uchar*, int, Dirtab*, int, Devgen*);
Walkqid* devwalk(Chan*, Chan*, char**, int, Dirtab*, int, Devgen*);
int devwstat(Chan*, uchar*, int);
void drawactive(int);
void drawcmap(void);
void dumpaproc(Proc*);
void dumpregs(Ureg*);
void dumpstack(void);
Fgrp* dupfgrp(Fgrp*);
int duppage(Page*);
void dupswap(Page*);
void edfinit(Proc*);
char* edfadmit(Proc*);
int edfready(Proc*);
void edfrecord(Proc*);
void edfrun(Proc*, int);
void edfstop(Proc*);
void edfyield(void);
int emptystr(char*);
int encrypt(void*, void*, int);
void envcpy(Egrp*, Egrp*);
int eqchan(Chan*, Chan*, int);
int eqchantdqid(Chan*, int, int, Qid, int);
int eqqid(Qid, Qid);
void error(char*);
long execregs(ulong, ulong, ulong);
void exhausted(char*);
void exit(int);
uvlong fastticks(uvlong*);
uvlong fastticks2ns(uvlong);
uvlong fastticks2us(uvlong);
int fault(ulong, int);
void fdclose(int, int);
Chan* fdtochan(int, int, int, int);
int findmount(Chan**, Mhead**, int, int, Qid);
int fixfault(Segment*, ulong, int, int);
void flushmmu(void);
void forceclosefgrp(void);
void forkchild(Proc*, Ureg*);
void forkret(void);
void free(void*);
void freeb(Block*);
void freeblist(Block*);
int freebroken(void);
void freepte(Segment*, Pte*);
void getcolor(ulong, ulong*, ulong*, ulong*);
ulong getmalloctag(void*);
ulong getrealloctag(void*);
void gotolabel(Label*);
char* getconfenv(void);
int haswaitq(void*);
long hostdomainwrite(char*, int);
long hostownerwrite(char*, int);
void hzsched(void);
Block* iallocb(int);
void iallocsummary(void);
long ibrk(ulong, int);
void ilock(Lock*);
void iunlock(Lock*);
long incref(Ref*);
void initseg(void);
int iprint(char*, ...);
void isdir(Chan*);
int iseve(void);
int islo(void);
Segment* isoverlap(Proc*, ulong, int);
int ispages(void*);
int isphysseg(char*);
void ixsummary(void);
int kbdcr2nl(Queue*, int);
int kbdgetmap(uint, int*, int*, Rune*);
int kbdputc(Queue*, int);
void kbdputmap(ushort, ushort, Rune);
void kickpager(void);
void killbig(char*);
void kproc(char*, void(*)(void*), void*);
void kprocchild(Proc*, void (*)(void*), void*);
void (*kproftimer)(ulong);
void ksetenv(char*, char*, int);
void kstrcpy(char*, char*, int);
void kstrdup(char**, char*);
long latin1(Rune*, int);
int lock(Lock*);
void logopen(Log*);
void logclose(Log*);
char* logctl(Log*, int, char**, Logflag*);
void logn(Log*, int, void*, int);
long logread(Log*, void*, ulong, long);
void log(Log*, int, char*, ...);
Cmdtab* lookupcmd(Cmdbuf*, Cmdtab*, int);
Page* lookpage(Image*, ulong);
#define MS2NS(n) (((vlong)(n))*1000000LL)
void machinit(void);
void* mallocz(ulong, int);
void* malloc(ulong);
void* mallocalign(ulong, ulong, long, ulong);
void mallocsummary(void);
Block* mem2bl(uchar*, int);
void mfreeseg(Segment*, ulong, int);
void microdelay(int);
uvlong mk64fract(uvlong, uvlong);
void mkqid(Qid*, vlong, ulong, int);
void mmurelease(Proc*);
void mmuswitch(Proc*);
Chan* mntauth(Chan*, char*);
long mntversion(Chan*, char*, int, int);
void mouseresize(void);
void mountfree(Mount*);
ulong ms2tk(ulong);
ulong msize(void*);
ulong ms2tk(ulong);
uvlong ms2fastticks(ulong);
void mul64fract(uvlong*, uvlong, uvlong);
void muxclose(Mnt*);
Chan* namec(char*, int, int, ulong);
void nameerror(char*, char*);
Chan* newchan(void);
int newfd(Chan*);
Mhead* newmhead(Chan*);
Mount* newmount(Mhead*, Chan*, int, char*);
Page* newpage(int, Segment **, ulong);
Path* newpath(char*);
Pgrp* newpgrp(void);
Rgrp* newrgrp(void);
Proc* newproc(void);
void nexterror(void);
int notify(Ureg*);
int nrand(int);
uvlong ns2fastticks(uvlong);
int okaddr(ulong, ulong, int);
int openmode(ulong);
Block* packblock(Block*);
Block* padblock(Block*, int);
void pagechainhead(Page*);
void pageinit(void);
ulong pagenumber(Page*);
void pagersummary(void);
void panic(char*, ...);
Cmdbuf* parsecmd(char *a, int n);
void pathclose(Path*);
ulong perfticks(void);
void pexit(char*, int);
void pgrpcpy(Pgrp*, Pgrp*);
void pgrpnote(ulong, char*, long, int);
void pio(Segment *, ulong, ulong, Page **);
#define poperror() up->nerrlab--
void portcountpagerefs(ulong*, int);
int postnote(Proc*, int, char*, int);
int pprint(char*, ...);
int preempted(void);
void prflush(void);
void printinit(void);
ulong procalarm(ulong);
void procctl(Proc*);
void procdump(void);
int procfdprint(Chan*, int, int, char*, int);
int procindex(ulong);
void procinit0(void);
void procflushseg(Segment*);
void procpriority(Proc*, int, int);
Proc* proctab(int);
extern void (*proctrace)(Proc*, int, vlong);
void procwired(Proc*, int);
Pte* ptealloc(void);
Pte* ptecpy(Pte*);
int pullblock(Block**, int);
Block* pullupblock(Block*, int);
Block* pullupqueue(Queue*, int);
void putimage(Image*);
void putmhead(Mhead*);
void putmmu(ulong, ulong, Page*);
void putpage(Page*);
void putseg(Segment*);
void putstrn(char*, int);
void putswap(Page*);
ulong pwait(Waitmsg*);
void qaddlist(Queue*, Block*);
Block* qbread(Queue*, int);
long qbwrite(Queue*, Block*);
Queue* qbypass(void (*)(void*, Block*), void*);
int qcanread(Queue*);
void qclose(Queue*);
int qconsume(Queue*, void*, int);
Block* qcopy(Queue*, int, ulong);
int qdiscard(Queue*, int);
void qflush(Queue*);
void qfree(Queue*);
int qfull(Queue*);
Block* qget(Queue*);
void qhangup(Queue*, char*);
int qisclosed(Queue*);
int qiwrite(Queue*, void*, int);
int qlen(Queue*);
void qlock(QLock*);
Queue* qopen(int, int, void (*)(void*), void*);
int qpass(Queue*, Block*);
int qpassnolim(Queue*, Block*);
int qproduce(Queue*, void*, int);
void qputback(Queue*, Block*);
long qread(Queue*, void*, int);
Block* qremove(Queue*);
void qreopen(Queue*);
void qsetlimit(Queue*, int);
void qunlock(QLock*);
int qwindow(Queue*);
int qwrite(Queue*, void*, int);
void qnoblock(Queue*, int);
int rand(void);
void randominit(void);
ulong randomread(void*, ulong);
void rdb(void);
int readnum(ulong, char*, ulong, ulong, int);
int readstr(ulong, char*, ulong, char*);
void ready(Proc*);
void* realloc(void *v, ulong size);
void rebootcmd(int, char**);
void reboot(void*, void*, ulong);
void relocateseg(Segment*, ulong);
void renameuser(char*, char*);
void resched(char*);
void resrcwait(char*);
int return0(void*);
void rlock(RWlock*);
long rtctime(void);
void runlock(RWlock*);
Proc* runproc(void);
void savefpregs(FPsave*);
void sched(void);
void scheddump(void);
void schedinit(void);
void (*screenputs)(char*, int);
long seconds(void);
ulong segattach(Proc*, ulong, char *, ulong, ulong);
void segclock(ulong);
void segpage(Segment*, Page*);
int setcolor(ulong, ulong, ulong, ulong);
void setkernur(Ureg*, Proc*);
int setlabel(Label*);
void setmalloctag(void*, ulong);
void setrealloctag(void*, ulong);
void setregisters(Ureg*, char*, char*, int);
void setswapchan(Chan*);
char* skipslash(char*);
void sleep(Rendez*, int(*)(void*), void*);
void* smalloc(ulong);
int splhi(void);
int spllo(void);
void splx(int);
void splxpc(int);
char* srvname(Chan*);
int swapcount(ulong);
int swapfull(void);
void swapinit(void);
void timeradd(Timer*);
void timerdel(Timer*);
void timersinit(void);
void timerintr(Ureg*, Tval);
void timerset(Tval);
ulong tk2ms(ulong);
#define TK2MS(x) ((x)*(1000/HZ))
uvlong tod2fastticks(vlong);
vlong todget(vlong*);
void todsetfreq(vlong);
void todinit(void);
void todset(vlong, vlong, int);
Block* trimblock(Block*, int, int);
void tsleep(Rendez*, int (*)(void*), void*, ulong);
int uartctl(Uart*, char*);
int uartgetc(void);
void uartkick(void*);
void uartmouse(Uart*, int (*)(Queue*, int), int);
void uartsetmouseputc(Uart*, int (*)(Queue*, int));
void uartputc(int);
void uartputs(char*, int);
void uartrecv(Uart*, char);
int uartstageoutput(Uart*);
void unbreak(Proc*);
void uncachepage(Page*);
long unionread(Chan*, void*, long);
void unlock(Lock*);
uvlong us2fastticks(uvlong);
void userinit(void);
ulong userpc(void);
long userwrite(char*, int);
void validaddr(ulong, ulong, int);
void validname(char*, int);
char* validnamedup(char*, int);
void validstat(uchar*, int);
void* vmemchr(void*, int, int);
Proc* wakeup(Rendez*);
int walk(Chan**, char**, int, int, int*);
void wlock(RWlock*);
void wunlock(RWlock*);
void* xalloc(ulong);
void* xallocz(ulong, int);
void xfree(void*);
void xhole(ulong, ulong);
void xinit(void);
int xmerge(void*, void*);
void* xspanalloc(ulong, int, ulong);
void xsummary(void);
void yield(void);
Segment* data2txt(Segment*);
Segment* dupseg(Segment**, int, int);
Segment* newseg(int, ulong, ulong);
Segment* seg(Proc*, ulong, int);
void hnputv(void*, uvlong);
void hnputl(void*, uint);
void hnputs(void*, ushort);
uvlong nhgetv(void*);
uint nhgetl(void*);
ushort nhgets(void*);
ulong µs(void);
void _xinc(long*);
long _xdec(long*);
long lcycles(void);
#pragma varargck argpos iprint 1
#pragma varargck argpos panic 1
#pragma varargck argpos pprint 1
|
