I do not expect chown, fchownat and lchown to be much used in
UNIX softwares that we care to port.
We stub the functions in libposix so that we can refer them from
standard C libaries (such as newlib).
We will implement them (parsing /cfg/users to determinate uid and gid)
when it will be actually needed from a software ported to Jehanne.
There are a few issues with Plan 9's `access`:
- it has side effects: to test the actual access (that the file
servers can allow or deny according to complex custom rules)
it opens and then closes the file, allocating (and disposing) the fd
- it does not work on directories, since
- they cannot be opened for writing, despite the fact that to
create a file in a directory you must be granted write access on
that directory
- they cannot be opened for execution, despite the fact that to
access a file in a directory you must be granted execution access
on that directory
Despite the fact that `access` (even on UNIX) is a violation of the
"tell, don't ask" principle (the access could be forbidden just after
its successful return, making subsequent `open` fail anyway), this
fact smells of a little design error in the file interface.
So, right now we choose to let the libposix's `access` lie on directories:
it will always return 0 on AWRITE and AEXEC for them, accepting that
a successive create/mkdir may fail.
However, a cleaner file API and protocol should allow a simpler `access`
to be implemented for directories too.
The img_get macro used to subtract 1 to the argument provided before
computing the porinter to the image. I can't remember why it did so.
However the expression was wrong.
Coverity found the issue:
Operands don't affect result (CONSTANT_EXPRESSION_RESULT)
CID: 155616, 155606, 155598, 155597, 155596, 155587,
155580, 155578, 155577, 155576, 155568, 155566
Simply removing the subtraction seems the obvious fix.
This large commit address several issues
- removed 386 directory: Jehanne is 64bit only
- simplified kernel options management
- rewritten boot process
- ported memory related stuff from 9front's 9/pc64
- removed devacpi
- removed old code
- deep refactor of awake syscall
- removed MCACHE support for mount
- fix libc's setjmp/longjmp
This commit introduce a special rendezvous point at (void*)~0 that
cannot be reached by any process, since it's not added to the
rendezvous group.
This turns the rendezvous syscall to a cheap way to block until
either a note or a wakeup from awake(2) occurs.
This new feature is used in libc's sleep: the test qa/kern/fork_chain
has shown that using a stack address as rendezvous point is not safe enougth
for sleep, since two different process forked from the same function can
call sleep with the same base pointer. This lead the wakeup variable in
jehanne_sleep to have the same address on both process.
TODO add a test that show this behaviour in the old code.
To enable -O2 compilation we have to disable some optimizations:
- strict-aliasing (TODO: introduce required unions to enable this)
- aggressive-loop-optimizations
- array-bounds
Affected builds are
- sys/src/cmd/dossrv/build.json
- sys/src/cmd/ip/build.json
- sys/src/lib/authsrv/build.json
- sys/src/lib/memdraw/build.json
This way sleep() knows that it should not interrupt the process
to serve awake().
Also rename Proc.insyscall to Proc.inkernel since that's the meaning
of the flag, which is only read to serve awake()'s mechanics and
to accounttime(). Indeed faultAmd64 was setting insyscall to 1.
The "write on closed pipe" note should be posted only
if the write occurred on a closed pipe.
Before this fix, on any interrupt caused the note to be sent,
despite the pipe being open and fully working.
Awake can now interrupt several blocking syscalls (even
during note handling).
Among others, it can interrupt await, pread and pwrite.
It cannot interrupt several others for different reasons:
- awake cannot be interrupted by awake;
- syscalls like remove and create can be used for kernel comunication
and it would be hard to know if the effect occurred in the
receiving fs if they were interrupted;
- other syscalls do not need awake since they just provide access
to kernel infos (eg seek or fd2path)
NOTE: awakes registered before a note cannot occur during the note
handling and will be deferred till the next call to noted.
Giacomo Tesio