We do not use the accessed and dirty bits in
page table entries so we can just always set them.
this avoids that the cpu needs to atomically write
back to the page table when setting these bits.
According to 'Digital Camera connectivity solutions using the picture
transfer protocol' [1] Section 2.3: "the PTP is specified using the
transaction model. A transaction is composed of a request operation,
followed by an optional data transfer and a response. Each
transaction has an identifier (TransactionID) that is session unique
and comprise of a 32 bit unsigned number. The transaction IDs are a
sequence of numbers starting with 0x00000000 (for the SessionOpen
transaction) and increasing with every following operation."
[1] https://people.ece.cornell.edu/land/courses/ece4760/FinalProjects/f2012/jmv87/site/files/PTP%20Protocol.pdf
Before the note handler would be set on all procs
which would cause all threads to try and kill
all other threads on exit. This also adds some
procsetname() calls which makes it easier to see
exactly what is going on in something like pstree(1).
Add vncv option '-a' to autoscale remote frame buffer to
local screen window size; useful when remote frame buffer
is larger than the local screen.
If the remote frame buffer is larger than the local screen,
and autoscaling is disabled, only the upper left corner is
accessible.
Before, it was possible to add routes before
the interface existed.
The routes would look for their interface lazily
as the route was looked up, but this leads to
all kinds of hard to explain behaviour when
a interface goes away and the routes start
wandering to a different interface on their
own which they will stick to when a new
interface comes up that would match the route
better.
Instead, we have routes always associated
to their desination interface and remove
the routes when the interface gets unbound.
It is no longer possible to add routes for
interfaces that do not exist.
This is easier to reason about behaviour as
well as allows us to get rid of canrlock(ifc)
in findipifc().
All routes inside the routing tree are now
by definition up-to-date (as long as we
hold the routelock).
Callers of v4lookup()/v6lookup() still should
check if the ifcid of the interface still
matches the route once they have acquired
the interface lock.
Now, *maxmem and *ncpu are not required to be provided.
They will be detected automatically from the QEMU device
tree. Further, >4GB memory configurations are also supported.
The maximum number of CPUs is 16 for now, and the maximum
supported memory is 16GB
I get every hour a delay of the echo replies for as
long as 20 seconds causing reconnects.
It does recover however and sends all the replies
eventually.
In 6? and 8? JMP works a bit uniquely,
when passed a function name it always encodes
as a JMP* instead of a JMP. This means
JMP myfunc(SB)
always assume that myfunc is a function pointer, not
a function itself. The new JMPF instead has the same
semantics as CALL and matches B and JMP in other
assemblers. This allows for a small optimization in
our 386 and amd64 entrypoint by avoiding a jump between
_main and _callmain.
At startup, look for audio devices like /dev/audio*
and open the first one that shows up.
We allow to later changing the audio device using
the new "new" control message to /dev/audio.
Only devices named /dev/audio*, #u/audio* and #A/audio*
are allowd so far to prevent accidents.
Move the "double-ready" check into queueproc() function,
doing it while holding the runq lock, meaning
all transitions to Ready state are serialized.
We do not just check for double-ready but for any
"illegal" transisions:
ready() on Dead, Moribund, New, Ready, Running and Waitrelease
is not allowed.
ready() on Queueing*, Wakeme, Broken, Stopped and Rendez
is only valid when done from another process.
For rescheduling, we have to go to Scheding state
before calling ready(). (rebalance(), schedinit()...)
The EDF scheduler had this bug where it could ready() multiple
times as it was staying in Waitrelease state after releasing
the edflock. Now it transitions thru Scheding avoiding
the issue.
Some callers of unlock change the process state
(such as qlock()) which means they are committed
to calling sched() anyway, so no ned to call it
internally.
Move waserror()/poperror() out of the loop,
so we can also catch errors from canacquire().
This is theoretically possible if memory has
been paged out and we get I/O errors when
trying to page it back in.
For ready() to check invalid state transitions,
we want to ensure that ready() is never called
on a dead proc (or one that is currently dying),
however when we create a new process,
its initial state was "Dead" until is is ready()d.
Instead, introduce the state "New", which is
set when the proc is removed from the freelist
by newproc(), making New -> Ready -> Running
state transition valid.
Also make sure we never leave notes to deadly
processes or ones that are in "Broken" state.
When we get a clock interrupt, we should not
call sched() when the process is not in "Running" state
as it is already committed to call sched() itself.
(An example is qlock(), just after the unlock() call).
As this is basically the same check as done in
preempted(), unify both and add a "clockintr"
argument to preempted().
Then most trap handlers just become:
preempted(irq());
Also, we do not want to call preempted() for traps,
as the trap handler has just setup some machine
state to resolve the trap. We can wait for the
clock interrupt if we really need the preempt.
On pnp(), just allocate descriptors and bring the controller
in a halted state.
Start the controller and dma in attach().
This prevents MAME from locking up when there is ethernet
traffic during bootup.
