at_wini: remove unnecessary quirks debug message

kernel: fpu_init: only enable OSXMMEXCPT in CR4 on at least SSE1 machines.

Found and debugged by totalinux at yandex.ru and Evgeniy Ivanov, thanks!

kernel: fpu init to separate function; also move fpu init down

moving the fpu code causes exceptions raised by it to be trapped
neatly instead of causing a triple fault, before the IDT is initialized.

Scan all processes for that might be blocked on a lock

at_wini: more general system to allow devices that behave like ata controllers.

(let silicon image sata controller that is pci class 1, subclass 0x80,
but works as a sata controller, work as such.)

pci: don't do sanity check for missing pci bus, the check can misfire.

tty: try more often to get the config byte.

Avoid sbrk (in favour of malloc) in RS where possible

Fix types in debug register functions

Enable malloc assertions

Add timeout for test 7 to indicate which test (if any) hangs

pagefault() is private

mtree: no more /lib and /lib/i386.

Add missing newline at end of file

Remove debug printfs in breakpoints.c, they should never have been there

Unified crash recovery and live update.

RS CHANGES:
- Crash recovery is now implemented like live update. Two instances are kept
side by side and the dead version is live updated into the new one. The endpoint
doesn't change and the failure is not exposed (by default) to other system
services.
- The new instance can be created reactively (when a crash is detected) or
proactively. In the latter case, RS can be instructed to keep a replica of
the system service to perform a hot swap when the service fails. The flag
SF_USE_REPL is set in that case.
- The new flag SF_USE_REPL is supported for services in the boot image and
dynamically started services through the RS interface (i.e. -p option in the
service utility).
- Fixed a free unallocated memory bug for core system services.

Removed unused prototype

Changed pagefault delivery to VM

this patch changes the way pagefaults are delivered to VM. It adopts
the same model as the out-of-quantum messages sent by kernel to a
scheduler.

- everytime a userspace pagefault occurs, kernel creates a message
  which is sent to VM on behalf of the faulting process

- the process is blocked on delivery to VM in the standard IPC code
  instead of waiting in a spacial in-kernel queue (stack) and is not
  runnable until VM tell kernel that the pagefault is resolved and is
  free to clear the RTS_PAGEFAULT flag.

- VM does not need call kernel and poll the pagefault information
  which saves many (1/2?) calls and kernel calls that return "no more
  data"

- VM notification by kernel does not need to use signals

- each entry in proc table is by 12 bytes smaller (~3k save)

cd boot workaround for bioses that didn't want to boot >4 image sectors.

boot is a normal binary with a.out again. use 'cdbootblock,' a CDBOOT
variant of bootblock, both from bootblock.s, as the first boot image
that then loads boot, exactly like the bootblock loads boot when booting
from harddisk. the sector numbers (2048 byte iso sectors) are patched in
by writeisofs, like installboot does for bootblock. bootblock unchanged.

vfs: start at vmnt[0] to sync mounted filesystems, not vmnt[1].

remove intr_disabled() as interrupts are always disabled in the kernel now.

Fixed printf warning in the filter driver

Set IPC status code only for RECEIVE

Remove a redundant getdomainname() implementation.

intercept puts() in libsys, for gcc

fix make(1) error output

Also remove awk.old from makefile.

Fix some compilation errors with the gcc compiler, fix some recent warnings.

Remove obsolete implementation of awk.

Remove useless symbol declarations from headers, make symbols local where possible, add some explicit initialization to global variables.

More accurate make rule.

Remove U16_t and most other similar types. Rewrite functions to ansi-style
declaration if necessary.

Forgot to add two new files to SVN.

Add some support for wchar_t.

Code cleanup: remove unused #include, variables and code,

fix mfs/isofs signal handling

Add scancode reading capability to TTY

Add scancode reading capability to TTY

Add scancode reading capability to TTY

Add timerisclear() macro.

unbreak _open for gcc-compiled programs

Provide information on lethal signals (stacktrace and signo)

Remove some duplicate declarations in headers.
Explicitly declare some functions as returning void.

vm: util.S not used currently; leave it out.

vm: include no-caching bits in PTF_ALLFLAGS for flags sanity check.

vm: don't force physical addresses to be nonzero.

Remove the types Dev_t, _mnx_Gui, _mnx_Uid, and similar.
Use ANSI-style function declarations where necessary.

PM remembers what it should schedule

- while PM implements fork also for RS it needs to remember what to
  schedule and what not. PM_SCHEDULED flag serves this purpose.

- PM only schedules processes that are descendaints of init, i.e. normal
  user processes

- after a process is forked PM schedules for the first time only
  processes that have PM_SCHEDULED set. The others are handled iether
  by kernel or some other scheduler

vm: remove assert, map in of phys addr 0 is legit sometimes.

Fix date in UPDATING

vm: use assert() instead of vm_assert(); remove vm_assert().

let vm use physically fragmented memory for allocations.

map_copy_ph_block is replaced by map_clone_ph_block, which can
replace a single physical block by multiple physical blocks.

also,
 . merge map_mem.c with region.c, as they manipulate the same
   data structures
 . NOTRUNNABLE removed as sanity check
 . use direct functions for ALLOC_MEM and FREE_MEM again
 . add some checks to shared memory mapping code
 . fix for data structure integrity when using shared memory
 . fix sanity checks

ipc server: don't print as many errors, to make ipc test less noisy.

Fixed escape warning.

Quantum in fork

- This patch removes the time slice split between parent and child in
  fork.

- The time slice of the parent remains unchanged and the child does
  not have any.

- If the process has a scheduler, the scheduler must assign the
  quantum and priority of the new process and let it run.

- If the child does not inherit a scheduler, it is scheduled by the
  dummy default kernel policy. (servers, drivers, etc.)

- In theory, the scheduler can change the quantum even of the parent
  process and implement any policy for splitting the quantum as
  neither the parent nor the child are runnable.  Sending the
  out-of_quantum message on behalf of the processes may look like the
  right solution, however, the scheduler would probably handle the
  message before the whole fork protocol is finished. This way the
  scheduler has absolute control when the process should become
  runnable.

Restructure and simplyfycation of the scheduling code in PM a little bit.

- It introduces schedule_process() which makes a kernel call to set
  the scheduling parameters of a process. It is used in the next patch.

This tiny cleanup makes the naming a variables in createpde() more clear.

A simpler test whether to use kernel's default scheduling

- this is a small addition to the userspace scheduling.
  proc_kernel_scheduler() tests whether to use the default scheduling
  policy in kernel. It is true if the process' scheduler is NULL _or_
  self. Currently none of the tests was complete.

do_schedule() cleanup

- it is not neccessary to test whether the scheduler is a system
  process as the process already head permissions to make this call.

- it is better to test whether the scheduler has permission to make
  changes to this process before testing whether the values are valid.

Driver mapping refactory.

VFS CHANGES:
- dmap table no longer statically initialized in VFS
- Dropped FSSIGNON svrctl call no longer used by INET

INET CHANGES:
- INET announces its presence to VFS just like any other driver

RS CHANGES:
- The boot image dev table contains all the data to initialize VFS' dmap table
- RS interface supports asynchronous up and update operations now
- RS interface extended to support driver style and flags

port of netbsd's tr

netbsd's original tr/extern.h as tr.h

original netbsd's tr(1)

no minix tr

Fixed gcc -Wall warnings.

isblank() implementation.

Driver refactory for live update and crash recovery.

SYSLIB CHANGES:
- DS calls to publish / retrieve labels consider endpoints instead of u32_t.

VFS CHANGES:
- mapdriver() only adds an entry in the dmap table in VFS.
- dev_up() is only executed upon reception of a driver up event.

INET CHANGES:
- INET no longer searches for existing drivers instances at startup.
- A newtwork driver is (re)initialized upon reception of a driver up event.
- Networking startup is now race-free by design. No need to waste 5 seconds
at startup any more.

DRIVER CHANGES:
- Every driver publishes driver up events when starting for the first time or
in case of restart when recovery actions must be taken in the upper layers.
- Driver up events are published by drivers through DS.
- For regular drivers, VFS is normally the only subscriber, but not necessarily.
For instance, when the filter driver is in use, it must subscribe to driver
up events to initiate recovery.
- For network drivers, inet is the only subscriber for now.
- Every VFS driver is statically linked with libdriver, every network driver
is statically linked with libnetdriver.

DRIVER LIBRARIES CHANGES:
- Libdriver is extended to provide generic receive() and ds_publish() interfaces
for VFS drivers.
- driver_receive() is a wrapper for sef_receive() also used in driver_task()
to discard spurious messages that were meant to be delivered to a previous
version of the driver.
- driver_receive_mq() is the same as driver_receive() but integrates support
for queued messages.
- driver_announce() publishes a driver up event for VFS drivers and marks
the driver as initialized and expecting a DEV_OPEN message.
- Libnetdriver is introduced to provide similar receive() and ds_publish()
interfaces for network drivers (netdriver_announce() and netdriver_receive()).
- Network drivers all support live update with no state transfer now.

KERNEL CHANGES:
- Added kernel call statectl for state management. Used by driver_announce() to
unblock eventual callers sendrecing to the driver.

ipc test improvements

 . rename testshm.sh to test.sh so all test scripts are called test.sh
 . delete msg* tests as msg* functionality isn't implemented
 . add ipc/test.sh that runs all test.sh scripts in the subdirs

more stack for boot

Rename all uses of U8_t to u8_t and remove U8_t, remove unused I8_t,
Remove all uses of U16_t and U32_t in pci-related code.
If necessary to avoid problems, change functions to ansi-style declaration.

Fixed a panic message

- exceptions cannot occur in kernel tasks as we don't have kernel
  tasks anymore

Removed unused variables, added const where possible.

A fixed prototype in dec21140A.c

do_nice.c

- this file is not used and should have been remove in r6557

Small fixes

- do_sync_ipc() is private

- fixed typo in a comment

do_ipc() rearrangements

this patch does not add or change any functionality of do_ipc(), it
only makes things a little cleaner (hopefully).

Until now do_ipc() was responsible for handling all ipc calls. The
catch is that SENDA is fairly different which results in some ugly
code like this typecasting and variables naming which does not make
much sense for SENDA and makes the code hard to read.

result = mini_senda(caller_ptr, (asynmsg_t *)m_ptr, (size_t)src_dst_e);

As it is called directly from assembly, the new do_ipc() takes as
input values of 3 registers in reg_t variables (it used to be 4,
however, bit_map wasn't used so I removed it), does the checks common
to all ipc calls and call the appropriate handler either for
do_sync_ipc() (all except SENDA) or mini_senda() (for SENDA) while
typecasting the reg_t values correctly. As a result, handling SENDA
differences in do_sync_ipc() is no more needed. Also the code that
uses msg_size variable is improved a little bit.

arch_do_syscall() is simplified too.

RTS_SYS_LOCK and do_runctl()

- No need for RTS_SYS_LOCK as there are no tasks anymore.

do_vtimer()

- removed comment which is not true anymore as we don't have any
  tasks. No need to take any special measures.

Convert kernel over to bsdmake

Fixed some incorrect uses of printf-like functions.

Fix printfs with too few or too many parms, remove unused vars, fix incorrect flag tests, other code cleanup.

Lots of const correctness, other cleanup.

introduce the fsckopts sysenv, options passed to fsck by /etc/rc.

setting 'fsckopts=-a' makes it much easier to work on a minix machine
remotely and reboot after a crash.

only print 'PCI: ignoring bad value ...' once per boot.

Move kernel signal SIGKNDELAY to system signal SIGSNDELAY and fix broken ptrace.

Move allocation of temporary inodes for cloned character special devices from
MFS to PFS.

More use of endpoint_t. Other code cleanup.

Fixed missing __UNCONST macro definition in previous patch.

cdecl calling convention requires to push arguments on the stack in a
reverse order to easily support variadic arguments. Thus, instead of
using the proper stdarg.h macros (that nowadays are
compiler-dependent), it may be tempting to directly take the address of
the last argument and considering it as the start of an array. This is
a shortcut that avoid looping to get all the arguments as the CPU
already pushed them on the stack before the call to the function.

Unfortunately, such an assumption is strictly compiler-dependent and
compilers are free to move the last argument on the stack, as a local
variable, and return the address of the location where the argument was
stored, if asked for. This will break things as the rest of the array's
argument are stored elsewhere (typically, a couple of words above the
location where the argument was stored).

This patch fixes the issue by allowing ACK to take the shortcut and
enabling gcc/llvm-gcc to follow the right way.

Fixed brackets in bitmap macros

don't print SYSTEM stacktrace on exceptions as it's not scheduled any more.

NOREC_ENTER and NOREC_RETURN checks removed

- the reasons for these checks no longer exist

- these check are problematic on SMP

fix null deref; vmnt->mounted_on is NULL legitimately for root.

changed check+panic to assert().

added assert().

A reliable way for userspace to check if a msg is from kernel

- IPC_FLG_MSG_FROM_KERNEL status flag is returned to userspace if the
  receive was satisfied by s message which was sent by the kernel on
  behalf of a process. This perfectly reliale information.

- MF_SENDING_FROM_KERNEL flag added to processes to be able to set
  IPC_FLG_MSG_FROM_KERNEL when finishing receive if the receiver
  wasn't ready to receive immediately.

- PM is changed to use this information to confirm that the scheduling
  messages are indeed from the kernel and not faked by a process.

  PM uses sef_receive_status()

- get_work() is removed from PM to make the changes simpler

Slightly faster IPC

- there are cycles wasted in the IPC call due to a fairly compliacted
  way of copying messages from userland to kernel. Sometimes this
  complicated way (generic though) is used even for copying within the
  kernel address space, sometimes it is used for copying in case _no_
  copying is necessary. The goal of this patch is to improve this a
  little bit.

- the places where a copy is from user to kernel use the
  copy_msg_from_user() kernel-kernel copies are turned into
  assignments and BuildNotifyMessage uses the delivery buffers to
  avoid copying.

- copy_msg_from_user() was introduced when removing the system task
  and is about 2/3 faster then using the current mechanism
  (phys_copy). It also avoids the PHYS_COPY_CATCH macro. Assignment is
  also faster and no copy is the fastest ;-) so perhaps there will be
  some hardly noticable performance gain besides the clean up.

Userspace scheduling

- cotributed by Bjorn Swift

- In this first phase, scheduling is moved from the kernel to the PM
  server. The next steps are to a) moving scheduling to its own server
  and b) include useful information in the "out of quantum" message,
  so that the scheduler can make use of this information.

- The kernel process table now keeps record of who is responsible for
  scheduling each process (p_scheduler). When this pointer is NULL,
  the process will be scheduled by the kernel. If such a process runs
  out of quantum, the kernel will simply renew its quantum an requeue
  it.

- When PM loads, it will take over scheduling of all running
  processes, except system processes, using sys_schedctl().
  Essentially, this only results in taking over init. As children
  inherit a scheduler from their parent, user space programs forked by
  init will inherit PM (for now) as their scheduler.

 - Once a process has been assigned a scheduler, and runs out of
   quantum, its RTS_NO_QUANTUM flag will be set and the process
   dequeued. The kernel will send a message to the scheduler, on the
   process' behalf, informing the scheduler that it has run out of
   quantum. The scheduler can take what ever action it pleases, based
   on its policy, and then reschedule the process using the
   sys_schedule() system call.

- Balance queues does not work as before. While the old in-kernel
  function used to renew the quantum of processes in the highest
  priority run queue, the user-space implementation only acts on
  processes that have been bumped down to a lower priority queue.
  This approach reacts slower to changes than the old one, but saves
  us sending a sys_schedule message for each process every time we
  balance the queues. Currently, when processes are moved up a
  priority queue, their quantum is also renewed, but this can be
  fiddled with.

- do_nice has been removed from kernel. PM answers to get- and
  setpriority calls, updates it's own nice variable as well as the
  max_run_queue. This will be refactored once scheduling is moved to a
  separate server. We will probably have PM update it's local nice
  value and then send a message to whoever is scheduling the process.

- changes to fix an issue in do_fork() where processes could run out
  of quantum but bypassing the code path that handles it correctly.
  The future plan is to remove the policy from do_fork() and implement
  it in userspace too.

Removed NIL_SYS_PROC and NIL_PROC

- NIL_PROC replaced by simple NULLs

Lots of const correctness.

Preserve the order of IPC messages between two parties.

Currently a sequence of messages between a sender A and a receiver B of the
form: A.asynsend(M1, B); A.send(M2, B) may result in the receiver receiving
M1 first and then M2 or viceversa. This patch makes sure that the original
order M1, M2 is always preserved.

Note that the order of a hypotetical sequence A.asynsend(M1, B);
A.asynsend(M2, B) is already guaranteed by the implementation of
asynsend by design. Other senda-based wrappers can define their own
semantics.

Comment in proc.h

- This comment is not correct as the pproc_addr array does not exist.