xfnw/plan9fox
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
plan9fox/sys/src/9/port/portfns.h

415 lines
12 KiB
C
Raw Normal View History

Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void _assert(char*);
void accounttime(void);
Timer* addclock0link(void (*)(void), int);
zynq: introduce SG_FAULT to prevent access to AXI segment while PL is not ready access to the axi segment hangs the machine when the fpga is not programmed yet. to prevent access, we introduce a new SG_FAULT flag, that when set on the Segment.type or Physseg.attr, causes the fault handler to immidiately return with an error (as if the segment would not be mapped). during programming, we temporarily set the SG_FAULT flag on the axi physseg, flush all processes tlb's that have the segment mapped and when programming is done, we clear the flag again.
2016-03-27 18:57:01 +00:00
Physseg* addphysseg(Physseg*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void addbootfile(char*, uchar*, ulong);
void addwatchdog(Watchdog*);
Block* adjustblock(Block*, int);
void alarmkproc(void*);
Block* allocb(int);
int anyhigher(void);
int anyready(void);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
Image* attachimage(int, Chan*, uintptr, ulong);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
int blocklen(Block*);
void bootlinks(void);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
void cachedel(Image*, uintptr);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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);
kernel: cleanup exit()/shutdown()/reboot() code introduce cpushutdown() function that does the common operation of initiating shutdown, returning once all cpu's got the message and are about to shutdown. this avoids duplicated code which isnt really machine specific. automatic reboot on panic only when *debug= is not set and the machine is a cpu server or has no display, otherwise just hang.
2015-11-30 13:56:00 +00:00
void cpushutdown(void);
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
int copen(Chan*);
kernel: pipelined read ahead for the mount cache this changes devmnt adding mntrahread() function and some helpers for it to do pipelined sequential read ahead for the mount cache. basically, cread() calls mntrahread() with Mntrah structure and it figures out if we where reading sequentially and if thats the case issues reads of c->iounit size in advance. the read ahead state (Mntrah) is kept in the mount cache so we can handle (read ahead) cache invalidation in the presence of writes.
2015-07-26 03:43:26 +00:00
void cclunk(Chan*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
Block* concatblock(Block*);
Block* copyblock(Block*, int);
void copypage(Page*, Page*);
void countpagerefs(ulong*, int);
int cread(Chan*, uchar*, int, vlong);
kernel: make the mntcache robust against fileserver like fossil that do not change the qid.vers on wstat introducing new ctrunc() function that invalidates any caches for the passed in chan, invoked when handling wstat with a specified file length or on file creation/truncation. test program to reproduce the problem: #include <u.h> #include <libc.h> #include <libsec.h> void main(int argc, char *argv[]) { int fd; Dir *d, nd; fd = create("xxx", ORDWR, 0666); write(fd, "1234", 4); d = dirstat("xxx"); assert(d->length == 4); nulldir(&nd); nd.length = 0; dirwstat("xxx", &nd); d = dirstat("xxx"); assert(d->length == 0); fd = open("xxx", OREAD); assert(read(fd, (void*)&d, 4) == 0); }
2017-01-12 19:13:20 +00:00
void ctrunc(Chan*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void cunmount(Chan*, Chan*);
void cupdate(Chan*, uchar*, int, vlong);
void cwrite(Chan*, uchar*, int, vlong);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
uintptr dbgpc(Proc*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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 *);
change definition of Chan.create to return a chan like open
2011-08-17 21:27:31 +00:00
Chan* devcreate(Chan*, char*, int, ulong);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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*);
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*);
added eqlock(), a interruptable version of qlock. addresses issue #81
2011-08-10 14:21:17 +00:00
void eqlock(QLock*);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
uintptr execregs(uintptr, ulong, ulong);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void exhausted(char*);
void exit(int);
uvlong fastticks(uvlong*);
uvlong fastticks2ns(uvlong);
uvlong fastticks2us(uvlong);
kernel: catch execution read fault on SG_NOEXEC segment fault() now has an additional pc argument that is used to detect fault on a non-executable segment. that is, we check on read fault if the segment has the SG_NOEXEC attribute and the program counter is within faulting page.
2019-08-27 01:47:18 +00:00
int fault(uintptr, uintptr, int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void fdclose(int, int);
Chan* fdtochan(int, int, int, int);
int findmount(Chan**, Mhead**, int, int, Qid);
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);
kernel: export freepages() function so it can be used in mmurelease()
2019-05-01 08:07:39 +00:00
void freepages(Page*, Page*, ulong);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void freepte(Segment*, Pte*);
void getcolor(ulong, ulong*, ulong*, ulong*);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
uintptr getmalloctag(void*);
uintptr getrealloctag(void*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void gotolabel(Label*);
char* getconfenv(void);
long hostdomainwrite(char*, int);
long hostownerwrite(char*, int);
kernel: switch to fast portable chacha based seed-once random number generator
2016-08-27 18:42:31 +00:00
void (*hwrandbuf)(void*, ulong);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void hzsched(void);
Block* iallocb(int);
kernel: missing changes for ibrk() prototype
2015-12-21 03:49:29 +00:00
uintptr ibrk(uintptr, int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void ilock(Lock*);
kernel: always reset notepending in eqlock, handle forceclosefgrp in eqlocks
2014-04-29 19:17:07 +00:00
void interrupted(void);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void iunlock(Lock*);
stats: show amount of reclaimable pages (add -r flag) reclaimable pages are user pages that are used for caches like the image cache, mount cache and swap cache.
2018-01-04 23:52:14 +00:00
ulong imagecached(void);
kernel: improve page reclaimation strategy and locking when reclaiming pages from an image, always reclaim all the hash chains equally. that way, we avoid being biased towards the chains at the start of the Image.pghash[] array. images can be in two states: active or inactive. inactive images are the ones which are not used by program while active ones aare. when reclaiming pages, we should try to reclaim pages from inactive images first and only if that set becomes exhausted attempt to release text pages and attempt to reclaim pages from active images. when we run out of Image structures, it makes only sense to reclaim pages from inactive images, as reclaiming pages from active ones will never free any Image structures. change putimage() to require a image already locked and make it unlock the image. this avoids many pointless unlock()/lock() sequences as all callers of putimage() already had the image locked.
2020-04-26 17:54:46 +00:00
ulong imagereclaim(int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
long incref(Ref*);
kernel: implement portable userinit() and simplify process creation replace machine specific userinit() by a portable implemntation that uses kproc() to create the first process. the initcode text is mapped using kmap(), so there is no need for machine specific tmpmap() functions. initcode stack preparation should be done in init0() where the stack is mapped and can be accessed directly. replacing the machine specific userinit() allows some big simplifications as sysrfork() and kproc() are now the only callers of newproc() and we can avoid initializing fields that we know are being initialized by these callers. rename autogenerated init.h and reboot.h headers. the initcode[] and rebootcode[] blobs are now in *.i files and hex generation was moved to portmkfile. the machine specific mkfile only needs to specify how to build rebootcode.out and initcode.out.
2020-01-26 18:01:36 +00:00
void init0(void);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void initseg(void);
pc, pc64: allocate i/o port space for unassigned pci bars, move ioalloc() to port/iomap.c With some newer UEFI firmware, not all pci bars get programmed and we have to assign them ourselfs. This was already done for memory bars. This change adds the same for i/o port space, by providing a ioreservewin() function which can be used to allocate port space within the parent pci-pci bridge window. Also, the pci code now allocates the pci config space i/o ports 0xCF8/0xCFC so userspace needs to use devpnp to access pci config space now. (see latest realemu change). Also, this moves the ioalloc()/iofree() code out of devarch into port/iomap.c as it can be shared with the ppc mtx kernel.
2020-11-03 19:46:09 +00:00
int ioalloc(ulong, ulong, ulong, char*);
void iofree(ulong);
void iomapinit(ulong);
int ioreserve(ulong, ulong, ulong, char*);
int ioreservewin(ulong, ulong, ulong, ulong, char*);
int iounused(ulong, ulong);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
int iprint(char*, ...);
void isdir(Chan*);
int iseve(void);
int islo(void);
devsegment: cleanups - return distinct error message when attempting to create Globalseg with physseg name - copy directory name to up->genbuf so it stays valid after we unlock(&glogalseglock) - cleanup wstat() handling, allow changing uid - make sure global segment size is below SEGMAXSIZE - move isoverlap() check from globalsegattach() into segattach() - remove Proc* argument from globalsegattach(), segattach() and isoverlap() - make Physseg.attr and segattach attr parameter an int for consistency
2016-03-30 20:49:13 +00:00
Segment* isoverlap(uintptr, uintptr);
zynq: introduce SG_FAULT to prevent access to AXI segment while PL is not ready access to the axi segment hangs the machine when the fpga is not programmed yet. to prevent access, we introduce a new SG_FAULT flag, that when set on the Segment.type or Physseg.attr, causes the fault handler to immidiately return with an error (as if the segment would not be mapped). during programming, we temporarily set the SG_FAULT flag on the axi physseg, flush all processes tlb's that have the segment mapped and when programming is done, we clear the flag again.
2016-03-27 18:57:01 +00:00
Physseg* findphysseg(char*);
kernel: handle tos and per process pcycle counters in port/ we might as well handle the per process cycle counter in the portable part instead of duplicating the code in every arch and have inconsistent implementations. we now have a portable kenter() and kexit() function, that is ment to be used in trap/syscall from user, which updates the counters. some kernels missed initializing Mach.cyclefreq.
2020-12-20 21:34:41 +00:00
int kenter(Ureg*);
void kexit(Ureg*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void kickpager(void);
void killbig(char*);
void kproc(char*, void(*)(void*), void*);
kernel: handle tos and per process pcycle counters in port/ we might as well handle the per process cycle counter in the portable part instead of duplicating the code in every arch and have inconsistent implementations. we now have a portable kenter() and kexit() function, that is ment to be used in trap/syscall from user, which updates the counters. some kernels missed initializing Mach.cyclefreq.
2020-12-20 21:34:41 +00:00
void kprocchild(Proc*, void (*)(void));
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
void (*kproftimer)(uintptr);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void ksetenv(char*, char*, int);
void kstrcpy(char*, char*, int);
void kstrdup(char**, char*);
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);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
Page* lookpage(Image*, uintptr);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
#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);
kernel: add portable memory map code (port/memmap.c) This is a generic memory map for physical addresses. Entries can be added with memmapadd() giving a range and a type. Ranges can be allocated and freed from the map. The code automatically resolves overlapping ranges by type priority.
2020-04-04 14:04:27 +00:00
void memmapdump(void);
uvlong memmapnext(uvlong, ulong);
uvlong memmapsize(uvlong, uvlong);
void memmapadd(uvlong, uvlong, ulong);
uvlong memmapalloc(uvlong, uvlong, uvlong, ulong);
void memmapfree(uvlong, uvlong, ulong);
devproc: fix proccrlmemio bugs dont kill the calling process when demand load fails if fixfault() is called from devproc. this happens when you delete the binary of a running process and try to debug the process accessing uncached pages thru /proc/$pid/mem file. fixes to procctlmemio(): - fix missed unlock as txt2data() can error - make sure the segment isnt freed by taking a reference (under p->seglock) - access the page with segment locked (see comment) - get rid of the segment stealer lock other stuff: - move txt2data() and data2txt() to segment.c - add procpagecount() function - make return type mcounseg() to ulong
2014-07-14 04:02:21 +00:00
ulong mcountseg(Segment*);
kernel: catch address overflow in syssegfree() the "to" address can overflow in syssegfree() causing wrong number of pages to be passed to mfreeseg(). with the current implementation of mfreeseg() however, this doesnt cause any data corruption but was just freeing an unexpected number of pages. this change checks for this condition in syssegfree() and errors out instead. also mfreeseg() was changed to take ulong argument for number of pages instead of int to keep it consistent with other routines that work with page counts.
2015-03-07 17:59:06 +00:00
void mfreeseg(Segment*, uintptr, ulong);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void microdelay(int);
uvlong mk64fract(uvlong, uvlong);
void mkqid(Qid*, vlong, ulong, int);
void mmurelease(Proc*);
void mmuswitch(Proc*);
kernel: export mntattach() from devmnt.c avoiding bogus struct passing and special case in namec() we already export mntauth() and mntversion(), so why not stop being sneaky and just export mntattach() so bindmount() and devshr can just call it directly with proper arguments being checked. we can also avoid handling #M attach specially in namec() by having the devmnt's attach function do error(Enoattach).
2015-07-28 07:52:21 +00:00
Chan* mntattach(Chan*, Chan*, char*, int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
Chan* mntauth(Chan*, char*);
kernel: make fversion()/mntversion() types consistent
2016-03-10 02:02:28 +00:00
int mntversion(Chan*, char*, int, int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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*);
kernel: get rid of auxpage() and preserve cache index bits in Page.va in mount cache the mount cache uses Page.va to store cached range offset and limit, but mips kernel uses cache index bits from Page.va to maintain page coloring. Page.va was not initialized by auxpage(). this change removes auxpage() which was primarily used only by the mount cache and use newpage() with cache file offset page as va so we will get a page of the right color. mount cache keeps the index bits intact by only using the top and buttom PGSHIFT bits of Page.va for the range offset/limit.
2015-03-16 04:46:08 +00:00
int needpages(void*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
Chan* newchan(void);
kernel: implement per file descriptor OCEXEC flag, reject ORCLOSE when opening /fd, /srv and /shr The OCEXEC flag used to be maintained per channel, making it shared between all the file desciptors. This has a unexpected side effects with regard to channel passing drivers such as devdup (/fd), devsrv (/srv) and devshr (/shr). For example, opening a /srv file with OCEXEC makes it impossible to be remounted by exportfs as it internally does a exec() to mount and re-export it. There is no way to reset the flag. This change makes the OCEXEC flag per file descriptor, so a open with the OCEXEC flag only affects the fd group of the calling process, and not the channel itself. On rfork(RFFDG), the per file descriptor flags get copied. On dup(), the per file descriptor flags are reset. The second modification is that /fd, /srv and /shr should reject the ORCLOSE flag, as the files that are returned have already been opend.
2020-12-13 15:04:09 +00:00
int newfd(Chan*, int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
Mhead* newmhead(Chan*);
kernel: pgrpcpy(), simplify Mount structure instead of ordering the source mount list, order the new destination list which has the advantage that we do not need to wlock the source namespace, so copying can be done in parallel and we do not need the copy forward pointer in the Mount structure. the Mhead back pointer in the Mount strcture was unused, removed.
2015-08-09 19:16:10 +00:00
Mount* newmount(Chan*, int, char*);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
Page* newpage(int, Segment **, uintptr);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
Path* newpath(char*);
Pgrp* newpgrp(void);
Rgrp* newrgrp(void);
Proc* newproc(void);
void nexterror(void);
int notify(Ureg*);
uvlong ns2fastticks(uvlong);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
int okaddr(uintptr, ulong, int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
int openmode(ulong);
Block* packblock(Block*);
Block* padblock(Block*, int);
void pageinit(void);
kernel: improve page reclaimation strategy and locking when reclaiming pages from an image, always reclaim all the hash chains equally. that way, we avoid being biased towards the chains at the start of the Image.pghash[] array. images can be in two states: active or inactive. inactive images are the ones which are not used by program while active ones aare. when reclaiming pages, we should try to reclaim pages from inactive images first and only if that set becomes exhausted attempt to release text pages and attempt to reclaim pages from active images. when we run out of Image structures, it makes only sense to reclaim pages from inactive images, as reclaiming pages from active ones will never free any Image structures. change putimage() to require a image already locked and make it unlock the image. this avoids many pointless unlock()/lock() sequences as all callers of putimage() already had the image locked.
2020-04-26 17:54:46 +00:00
ulong pagereclaim(Image*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void panic(char*, ...);
Cmdbuf* parsecmd(char *a, int n);
void pathclose(Path*);
ulong perfticks(void);
void pexit(char*, int);
void pgrpcpy(Pgrp*, Pgrp*);
kernel: fix multiple devproc bugs and pid reuse issues devproc assumes that when we hold the Proc.debug qlock, the process will be prevented from exiting. but there is another race where the process has already exited and the Proc* slot gets reused. to solve this, on process creation we also have to acquire the debug qlock while initializing the fields of the process. this also means newproc() should only initialize fields *not* protected by the debug qlock. always acquire the Proc.debug qlock when changing strings in the proc structure to avoid doublefree on concurrent update. for changing the user string, we add a procsetuser() function that does this for auth.c and devcap. remove pgrpnote() from pgrp.c and replace by static postnotepg() in devproc. avoid the assumption that the Proc* entries returned by proctab() are continuous. fixed devproc permission issues: - make sure only eve can access /proc/trace - none should only be allowed to read its own /proc/n/text - move Proc.kp checks into procopen() pid reuse was not handled correctly, as we where only checking if a pid had a living process, but there still could be processes expecting a particular parentpid or noteid. this is now addressed with reference counted Pid structures which are organized in a hash table. read access to the hash table does not require locks which will be usefull for dtracy later.
2020-02-23 17:00:21 +00:00
ulong pidalloc(Proc*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
#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);
kernel: remove implicit Proc* argument from procctl() procctl() is always called with up and it would not work correctly if passed a different process, so remove the Proc* argument and use up directly.
2014-11-09 07:19:28 +00:00
void procctl(void);
kernel: avoid inconsistent reads in /proc/#/fd and /proc/#/ns to allow bytewise access to /proc/#/fd, the contents of the file where recreated on each call. if fd's had been closed or reassigned between the reads, the offset would be inconsistent and a read could start off in the middle of a line. this happens when you cat /proc/#/fd file of a busy process that mutates its filedescriptor table. to fix this, we now return one line record at a time. if the line fits in the read size, then this means the next read will always start at the beginning of the next line record. we remember the consumed byte count in Chan.mrock and the current record in Chan.nrock. (these fields are free to usefor non-directory files) if a read comes in and the offset is the same as c->mrock, we do not need to regenerate the file and just render the next c->nrock's record. for reads smaller than the line count, we have to regenerate the content up to the offset and the race is still possible, but this should not be the common case. the same algorithm is now used for /proc/#/ns file, allowing a simpler reimplementation and getting rid of Mntwalk state strcture.
2014-12-21 03:46:22 +00:00
int procfdprint(Chan*, int, char*, int);
kernel: make noswap flag exclude processes from killbig() if not eve, reset noswap flag on exec
2014-08-16 22:50:20 +00:00
void procflushseg(Segment*);
zynq: introduce SG_FAULT to prevent access to AXI segment while PL is not ready access to the axi segment hangs the machine when the fpga is not programmed yet. to prevent access, we introduce a new SG_FAULT flag, that when set on the Segment.type or Physseg.attr, causes the fault handler to immidiately return with an error (as if the segment would not be mapped). during programming, we temporarily set the SG_FAULT flag on the axi physseg, flush all processes tlb's that have the segment mapped and when programming is done, we clear the flag again.
2016-03-27 18:57:01 +00:00
void procflushpseg(Physseg*);
pc: replace duplicated and broken mmu flush code in vunmap() comparing m with MACHP() is wrong as m is a constant on 386. add procflushothers(), which flushes all processes except up using common procflushmmu() routine.
2019-12-07 01:19:14 +00:00
void procflushothers(void);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
int procindex(ulong);
void procinit0(void);
kernel: make noswap flag exclude processes from killbig() if not eve, reset noswap flag on exec
2014-08-16 22:50:20 +00:00
ulong procpagecount(Proc*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void procpriority(Proc*, int, int);
kernel: remove Proc* argument from procsetuser() function
2020-12-19 17:07:12 +00:00
void procsetuser(char*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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*);
kernel: convert putmmu() to uintptr for va and pa
2014-01-20 02:17:55 +00:00
void putmmu(uintptr, uintptr, Page*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void putpage(Page*);
void putseg(Segment*);
void putstrn(char*, int);
void putswap(Page*);
ulong pwait(Waitmsg*);
kernel/qio: big cleanup of qio functions remove bl2mem(), it is broken. a fault while copying to memory yields a partially freed block list. it can be simply replaced by readblist() and freeblist(), which we also use for qcopy() now. remove mem2bl(), and handle putting back remainer from a short read internally (splitblock()) avoiding the releasing and re- acquiering of the ilock. always attempt to free blocks outside of the ilock. have qaddlist() return the number of bytes enqueued, which avoids walking the block list twice.
2016-11-07 21:20:10 +00:00
int qaddlist(Queue*, Block*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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);
void randominit(void);
ulong randomread(void*, ulong);
sdram: experimental ramdisk driver this driver makes regions of physical memory accessible as a disk. to use it, ramdiskinit() has to be called before confinit(), so that conf.mem[] banks can be reserved. currently, only pc and pc64 kernel use it, but otherwise the implementation is portable. ramdisks are not zeroed when allocated, so that the contents are preserved across warm reboots. to not waste memory, physical segments do not allocate Page structures or populate the segment pte's anymore. theres also a new SG_CHACHED attribute.
2018-05-27 20:59:19 +00:00
void ramdiskinit(void);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void rdb(void);
kernel/qio: make readblist() offset of type ulong as the rest
2016-11-12 16:41:58 +00:00
long readblist(Block*, uchar*, long, ulong);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
void relocateseg(Segment*, uintptr);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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 schedinit(void);
void (*screenputs)(char*, int);
kernel: add secalloc() and secfree() functions for secret memory allocation The kernel needs to keep cryptographic keys and cipher states confidential. secalloc() allocates memory from the secret pool which is protected from debuggers reading the memory thru devproc. secfree() releases the memory, overriding the data with garbage.
2016-08-27 18:33:03 +00:00
void* secalloc(ulong);
void secfree(void*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
long seconds(void);
devsegment: cleanups - return distinct error message when attempting to create Globalseg with physseg name - copy directory name to up->genbuf so it stays valid after we unlock(&glogalseglock) - cleanup wstat() handling, allow changing uid - make sure global segment size is below SEGMAXSIZE - move isoverlap() check from globalsegattach() into segattach() - remove Proc* argument from globalsegattach(), segattach() and isoverlap() - make Physseg.attr and segattach attr parameter an int for consistency
2016-03-30 20:49:13 +00:00
uintptr segattach(int, char *, uintptr, uintptr);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
void segclock(uintptr);
kernel: add segio() function for reading/writing segments devproc's procctlmemio() did not handle physical segment types correctly, as it assumed it can just kmap() the page in question and write to it. physical segments however need to be mapped uncached but kmap() will always map cached as it assumes normal memory. on some machines with aliasing memory with different cache attributes leads to undefined behaviour! we borrow the code from devsegment and provide a generic segio() function to read and write user segments which handles all the cases without using kmap by just spawning a kproc that attaches the segment that needs to be read from or written to. fault() will setup the right mmu attributes for us. it will also properly flush pages for segments that maintain instruction cache when written. however, tlb's have to be flushed separately. segio() is used for devsegment and devproc now, which also allows for simplification of fixfault() as there is no special error handling case anymore as fixfault() is now called from faulting process *only*. reads from /proc/$pid/mem can now span multiple pages.
2015-04-15 22:45:25 +00:00
long segio(Segio*, Segment*, void*, long, vlong, int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void segpage(Segment*, Page*);
int setcolor(ulong, ulong, ulong, ulong);
void setkernur(Ureg*, Proc*);
int setlabel(Label*);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
void setmalloctag(void*, uintptr);
kernel: fix multiple devproc bugs and pid reuse issues devproc assumes that when we hold the Proc.debug qlock, the process will be prevented from exiting. but there is another race where the process has already exited and the Proc* slot gets reused. to solve this, on process creation we also have to acquire the debug qlock while initializing the fields of the process. this also means newproc() should only initialize fields *not* protected by the debug qlock. always acquire the Proc.debug qlock when changing strings in the proc structure to avoid doublefree on concurrent update. for changing the user string, we add a procsetuser() function that does this for auth.c and devcap. remove pgrpnote() from pgrp.c and replace by static postnotepg() in devproc. avoid the assumption that the Proc* entries returned by proctab() are continuous. fixed devproc permission issues: - make sure only eve can access /proc/trace - none should only be allowed to read its own /proc/n/text - move Proc.kp checks into procopen() pid reuse was not handled correctly, as we where only checking if a pid had a living process, but there still could be processes expecting a particular parentpid or noteid. this is now addressed with reference counted Pid structures which are organized in a hash table. read access to the hash table does not require locks which will be usefull for dtracy later.
2020-02-23 17:00:21 +00:00
ulong setnoteid(Proc*, ulong);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
void setrealloctag(void*, uintptr);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void setregisters(Ureg*, char*, char*, int);
kernel: add support for hardware watchpoints
2017-06-12 19:03:07 +00:00
void setupwatchpts(Proc*, Watchpt*, int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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*);
kbdfs
2011-05-09 08:32:14 +00:00
void srvrenameuser(char*, char*);
devshr: rename hook
2011-07-28 12:22:39 +00:00
void shrrenameuser(char*, char*);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
int swapcount(uintptr);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
int swapfull(void);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
void syscallfmt(ulong syscallno, uintptr pc, va_list list);
void sysretfmt(ulong syscallno, va_list list, uintptr ret, uvlong start, uvlong stop);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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);
kernel: fix twakeup()/timerdel() race condition timerdel() did not make sure that the timer function is not active (on another cpu). just acquiering the Timer lock in the timer function only blocks the caller of timerdel()/timeradd() but not the other way arround (on a multiprocessor). this changes the timer code to track activity of the timer function, having timerdel() wait until the timer has finished executing.
2017-03-28 22:30:53 +00:00
void twakeup(Ureg*, Timer *);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
int uartctl(Uart*, char*);
int uartgetc(void);
void uartkick(void*);
remove non standard COM3 (eia2) serial port from i8250 uart. access to non standard serial port COM3 at i/o port 0x200 causes kernel panic on some machines (Toshiba Sattelite 1415-S115). also, some machines have gameport at 0x200. i readded uartisa to the pcf and pccpuf kernel configurations so one can use plan9.ini to add non standard uarts like: uart2=type=isa port=0x200 irq=5
2013-01-13 09:23:31 +00:00
void uartmouse(char*, int (*)(Queue*, int), int);
void uartsetmouseputc(char*, int (*)(Queue*, int));
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
uintptr userpc(void);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
long userwrite(char*, int);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
void validaddr(uintptr, ulong, int);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void validname(char*, int);
char* validnamedup(char*, int);
void validstat(uchar*, int);
kernel: change vmemchr() length argument to ulong and simplify
2015-08-06 08:15:07 +00:00
void* vmemchr(void*, int, ulong);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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*);
kernel: fix ulong abuse in xalloc
2014-01-21 21:12:25 +00:00
void xhole(uintptr, uintptr);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
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);
kernel: apply uintptr for ulong when a pointer is stored this change is in preparation for amd64. the systab calling convention was also changed to return uintptr (as segattach returns a pointer) and the arguments are now passed as va_list which handles amd64 arguments properly (all arguments are passed in 64bit quantities on the stack, tho the upper part will not be initialized when the element is smaller than 8 bytes). this is partial. xalloc needs to be converted in the future.
2014-01-19 23:47:55 +00:00
Segment* newseg(int, uintptr, ulong);
Segment* seg(Proc*, uintptr, int);
devproc: fix proccrlmemio bugs dont kill the calling process when demand load fails if fixfault() is called from devproc. this happens when you delete the binary of a running process and try to debug the process accessing uncached pages thru /proc/$pid/mem file. fixes to procctlmemio(): - fix missed unlock as txt2data() can error - make sure the segment isnt freed by taking a reference (under p->seglock) - access the page with segment locked (see comment) - get rid of the segment stealer lock other stuff: - move txt2data() and data2txt() to segment.c - add procpagecount() function - make return type mcounseg() to ulong
2014-07-14 04:02:21 +00:00
Segment* txt2data(Segment*);
Import sources from 2011-03-30 iso image
2011-03-30 12:46:40 +00:00
void hnputv(void*, uvlong);
void hnputl(void*, uint);
void hnputs(void*, ushort);
uvlong nhgetv(void*);
uint nhgetl(void*);
ushort nhgets(void*);
ulong µs(void);
long lcycles(void);
#pragma varargck argpos iprint 1
#pragma varargck argpos panic 1
#pragma varargck argpos pprint 1
Reference in a new issue Copy permalink