Remove the priority part of the priority|flags argument to tsleep().  Only
flags are passed now.  The priority was a user scheduler thingy that is not
used by the LWKT subsystem.  For process statistics assume sleeps without
P_SINTR set to be disk-waits, and sleeps with it set to be normal sleeps.

This commit should not contain any operational changes.

Nuke huge mbuf macros stage 1/2: Remove massive inline mbuf macros to reduce
L1/L2 cache pollution.  Est. performance improvement of 4-6% and the kernel
is 42KB smaller.

Submitted-by: Bosko Milekic <bmilekic@technokratis.com>

Remove an unnecessary cli that was causing 'trap 12 with interrupts disabled'
warnings from start_init() (harmless, but annoying).

Make the kernel load properly recognize ABS symbols (.SET assembly
instruction) whos value is 0.  It was improperly assuming that symbols with
a 0 value could not be found, and also confusing ABS symbols with COMMON
symbols.

GDB changes required for gdb -k kernel /dev/mem.  Still selected by
process, not thread.  A "thread" command still needs to be added.

The comment was wrong, ptmmap *is* used, put it back in (fix crash
accessing /dev/mem)

Fix minor compile warning.

Fix minor buildworld issues, mainly #include file dependancies and fields
that have moved from struct proc to struct thread.

Add missing required '*' in indirect jmp (fix assembler warning).

oops, fix bug in last commit, and adjust the p_slptime check.

Make the pigs display more meaningful by showing processes which haven't
slept recently even if they aren't using much cpu.  Things like buildworlds
were not showing up at all.  This combined with the graph display makes
pigs far more useful.

Collapse gd_astpending and gd_reqpri together into gd_reqflags.  gd_reqflags
now rollsup requests made pending for doreti.  Cleanup a number of scheduling
primitives and note that we do not need to use locked bus cycles on per-cpu
variables.

Note that the aweful idelayed hack for certain softints (used only by the TTY
subsystem, BTW) gets slightly broken in this commit because idelayed has become
per-cpu and the clock ints aren't yet distributed.

Forward FAST interrupts to the MP lock holder + minor fixes.

partially fix pctcpu and userland rescheduling.  We really have to distribute
hardclock/statclock to all cpus to make it work properly.

account for the time array being in microseconds now, and allow the
interval to be specified as a fraction of a second.

Make the cpu/stat display work properly again.

Fix overflow in delta percentage calculation due to the fact that our 32 bit
cp_time[] counters are now in microseconds.

Cleanup hardclock() and statclock(), making them work properly even though
we do not replicate the clock interrupts across all cpus.

misc cleanup.  Add a case where we don't want an idlethread to HLT (if there
are pending fast ints that need the MP lock).

MP Implmentation 4/4: Final cleanup for this stage.  Deal with a race
that occurs due to not having to hold the MP lock through an lwkt_switch()
where another cpu may pull off a process from the userland scheduler and
schedule its thread before the original cpu has completely switched out it.
Oddly enough latencies were enough that this bug never caused a crash!

Cleanup the scheduling code and in particular the switch assembly code, save
and restore eflags (cli/sti state) when switching heavy weight processes
(this is already done for light weight threads), add some counters, and
optimize fork() to (statistically) stay on the current cpu for a short while
to take advantage of locality of cache reference, which greatly improves
fork/exec times.  Note that synchronous pipe operations between two procseses
already (statistically) stick to the same cpu (which is what we want).

MP Implmentation 3B/4: Remove Xcpuast and Xforward_irq, replacing them
with IPI messaging functions.  Fix user scheduling issues so user processes
are dependably scheduled on available cpus.

MP Implmentation 3A/4: Fix stupid bug introduced in last commit.

MP Implmentation 3A/4: Cleanup MP lock operations to allow the MP lock to
occassionally be out of synch from td_mpcount, so we don't have to
disable interrupts and so we can call try_mplock() from the middle of a
switch function.

MP Implmentation 3/4: MAJOR progress on SMP, full userland MP is now working!
A number of issues relating to MP lock operation have been fixed, primarily
that we have to read %cr2 before get_mplock() since get_mplock() may switch
away.  Idlethreads can now safely HLT without any performance detriment.
The userland scheduler has been almost completely rewritten and is now
using an extremely flexible abstraction with a lot of room to grow.  pgeflag
has been removed from mapdev (without per-page invalidation it isn't safe
to use PG_G even on UP).  Necessary locked bus cycles have been added for
the pmap->pm_active field in swtch.s.  CR3 has been unoptimized for the
moment (see comment in swtch.s).  Since the switch code runs without the
MP lock we have to adjust pm_active PRIOR to loading %cr3.
Additional sanity checks have been added to the code (see PARANOID_INVLTLB
and ONLY_ONE_USER_CPU in the code), plus many more in kern_switch.c.
A passive release mechanism has been implemented to optimize P_CURPROC/lwkt
priority shifting when going from user->kernel and kernel->user.
Note: preemptive interrupts don't care due to the way preemption works so
no additional complexity there.  non-locking atomic functions to protect
only against local interrupts have been added.  astpending now uses
non-locking atomic functions to set and clear bits.  private_tss has been
moved to a per-cpu variable.   The LWKT thread module has been considerably
enhanced and cleaned up, including some fixes to handle MPLOCKED vs td_mpcount
races (so eventually we can do MP locking without a pushfl/cli/popfl combo).
stopevent() needs critical section protection, maybe.

The syncer is not a process any more, deal with it as a thread.

MP Implmentation 2A/4: Post commit cleanup, fix missing token releases that
were messing up td_pri's critical count, and add smart LWKT rescheduling
when a higher priority thread is scheduled (and could not preempt).  This
fixes the priority problems.

MP Implementation 2/4: Implement a poor-man's IPI messaging subsystem,
get both cpus arbitrating the BGL for interrupts, IPIing foreign
cpu LWKT scheduling requests without crashing, and dealing with the cpl.

The APs are in a slightly less degenerate state now, but hardclock and
statclock distribution is broken, only one user process is being scheduled
at a time, and priorities are all messed up.

MP Implementation 1/2: Get the APIC code working again, sweetly integrate the
MP lock into the LWKT scheduler, replace the old simplelock code with
tokens or spin locks as appropriate.  In particular, the vnode interlock
(and most other interlocks) are now tokens.  Also clean up a few curproc/cred
sequences that are no longer needed.

The APs are left in degenerate state with non IPI interrupts disabled as
additional LWKT work must be done before we can really make use of them,
and FAST interrupts are not managed by the MP lock yet.  The main thing
for this stage was to get the system working with an APIC again.

buildworld tested on UP and 2xCPU/MP (Dell 2550)

oops, forgot one.  Remove another curproc/cred dependancy

Remove td_proc dependancy on cred that is no longer used.

fix a bug in the exit td_switch function, curthread was not always being
loaded correctly.

Integrate the interrupt related operations for /dev/random support
directly into kern/kern_intr.c to work around a bad design.  Eventually
the 5.x random code will be backported.

Generic MP rollup work.

add gd_other_cpus

Document hardwired indexes for fields.

Misc interrupts/LWKT 2/2: Fix a reentrancy issue with thread repriortization
when entering and leaving the kernel from userland.

misc quota proc->thread

Split the struct vmmeter cnt structure into a global vmstats structure and
a per-cpu cnt structure.  Adjust the sysctls to accumulate statistics
over all cpus.

(userland syncup)

Split the struct vmmeter cnt structure into a global vmstats structure and
a per-cpu cnt structure.  Adjust the sysctls to accumulate statistics
over all cpus.

properly initialize ncpus for UP

Split the struct vmmeter cnt structure into a global vmstats structure and
a per-cpu cnt structure.  Adjust the sysctls to accumulate statistics
over all cpus.

Add some temporary debugging.

fix unused variable warning

Remove pre-ELF underscore prefix and asnames macro hacks.

Enhance debugging (sync before MP work).

For the moment uio_td may sometimes be NULL -> nfsm_request -> nfs_request ->
nfs_msg(), so allow td to be NULL there too.

Operations on the user scheduler must be inside a critical section (fixes
producable panic).

Sync userland up with the kernel.  This primarily adjusts ps, etc to handle
information stored in the thread structure.

Add threads to the process-retrieval sysctls so they show up in top, ps, etc.
Reorder the boot sequence a little to add a TAILQ for all threads.   Add
a td_refs field to prevent a thread from disappearing on us.

Fix a race in sysctl_out_proc() vs copyout() that could crash the kernel.

Misc interrupts/LWKT 1/2: threaded interrupts 2: Major work on the
user scheduler, separate it completely from the LWKT scheduler and make
user priorities, including idprio, normal, and rtprio, work properly.
This includes fixing the priority inversion problem that 4.x had.
Also complete the work on interrupt preemption.  There were a few things
I wasn't doing correctly including not protecting the initial call
to cpu_heavy_restore when a process is just starting up.  Enhance DDB a
bit (threads don't show up in PS yet).

This is a major milestone.

Misc interrupts/LWKT 1/2: interlock the idle thread.  Put execution of
fast interrupts inside a critical section.  Make the hardclock and statclock
INTR_FAST.  Implement the strict priority queue mechanism for LWKTs.
Implement prioritized preemption for interrupt and softint preemption.
Keep better stats.

Note: this commit hacks up the userland scheduler, in particular the
notion of 'curproc' because threaded interrupts really mess up the userland
scheduler's idea of curproc, which it uses to assume that the process is not
on a run queue even though it is runnable.  The next step will be to
separate out and cleanup the userland scheduler.

Add 64 bit display output support to sysctl plus convenient macros.

Implement interrupt thread preemption + minor cleanup.

threaded interrupts 1: Rewrite the ICU interrupt code, splz, and doreti code.
The APIC code hasn't been done yet.   Consolidate many interrupt thread
related functions into MI code, especially software interrupts.  All normal
interrupts and software interrupts are now threaded, and I'm almost ready
to deal with interrupt-thread-only preemption.  At the moment I run
interrupt threads in a critical section and probably will continue to do
so until I can make them MP safe.

format cleanup for readability.  Tab out back-slashes.

smp/up collapse stage 2 of 2:  cleanup the globaldata structure, cleanup
and separate machine dependant portions of thread, proc, and globaldata,
and reduce the need to include lots of MD header files.

Give ps access to a process's thread structure.

smp/up collapse stage 1 of 2: Make UP use the globaldata structure the same
way SMP does, and start removing all the bad macros and hacks that existed
before.

go back to using gd_cpuid instead of gd_cpu.

Cleanup lwkt threads a bit, change the exit/reap interlock.

proc->thread stage 6: kernel threads now create processless LWKT threads.
A number of obvious curproc cases were removed, tsleep/wakeup was made to
work with threads (wmesg, ident, and timeout features moved to threads).
There are probably a few curproc cases left to fix.

cleanup some odd uses of curproc.  Remove PHOLD/PRELE around physical I/O
(our UPAGES can no longer be swapped out and if they eventually are made
to it will only be when the thread is sleeping on a particular address).

Also move the inblock/oublock accounting in vfs_busy_pages() allowing us
to remove additional curproc references from various filesystem code.  This
also makes inblock/oublock more consistent.

cleanup

simple cleanups (removal of ancient macros)

proc->thread stage 5:  BUF/VFS clearance!  Remove the ucred argument from
vop_close, vop_getattr, vop_fsync, and vop_createvobject.  These VOPs can
be called from multiple contexts so the cred is fairly useless, and UFS
ignorse it anyway.  For filesystems (like NFS) that sometimes need a cred
we use proc0.p_ucred for now.

This removal also removed the need for a 'proc' reference in the related
VFS procedures, which greatly helps our proc->thread conversion.

bp->b_wcred and bp->b_rcred have also been removed, and for the same reason.
It makes no sense to have a particular cred when multiple users can
access a file.  This may create issues with certain types of NFS mounts
but if it does we will solve them in a way that doesn't pollute the
struct buf.

Introduce cratom(), remove crcopy().

proc->thread stage 4: post commit cleanup.  Fix minor issues when recompiling
with GENERIC.

proc->thread stage 4: post commit, introduce sys/file2.h.  As with other header
files I am separating the inline functions out, because interdependancies
are making limited header file inclusion and ordering a joke.

proc->thread stage 4: rework the VFS and DEVICE subsystems to take thread
pointers instead of process pointers as arguments, similar to what FreeBSD-5
did.  Note however that ultimately both APIs are going to be message-passing
which means the current thread context will not be useable for creds and
descriptor access.

proc->thread stage 3.5: Add an IO_CORE flag so coda doesn't have to dig
into the user process structure.

proc->thread stage 3: synchronize ps, top, and libkvm, and add some convenience
fields to eproc in the kernel to help them along.

proc->thread stage3: make time accounting threads based and rework it for
performance.

Cleanup user/sys/interrupt time accounting.  Get rid of the microputime and
equivalent support code in mi_switch() (it was really a bad idea to put that
in the critical path IMHO).  Instead account for time statistically
from the statclock, which produce time accounting that is just as accurate
in the long haul.  Remove the u/s/iticks fields from the proc structure and
put a slightly different version in the thread structure, so time can be
accounted for both threads and processes.

proc->thread stage2: post-commit fixes/cleanup(2)

proc->thread stage2: post-commit fixes/cleanup

proc->thread stage 2: MAJOR revamping of system calls, ucred, jail API,
and some work on the low level device interface (proc arg -> thread arg).
As -current did, I have removed p_cred and incorporated its functions
into p_ucred.  p_prison has also been moved into p_ucred and adjusted
accordingly.  The jail interface tests now uses ucreds rather then processes.

The syscall(p,uap) interface has been changed to just (uap).  This is inclusive
of the emulation code.  It makes little sense to pass a proc pointer around
which confuses the MP readability of the code, because most system call code
will only work with the current process anyway.  Note that eventually
*ALL* syscall emulation code will be moved to a kernel-protected userland
layer because it really makes no sense whatsoever to implement these
emulations in the kernel.

suser() now takes no arguments and only operates with the current process.
The process argument has been removed from suser_xxx() so it now just takes
a ucred and flags.

The sysctl interface was adjusted somewhat.

Optimize lwkt_rwlock.c a bit

proc->thread stage 1: change kproc_*() API to take and return threads.  Note:
we won't be able to turn off the underlying proc until we have a clean thread
path all the way through, which aint now.

minor code optimization.

Finish migrating the cpl into the thread structure.

Add parens for code readability (no functional change)

thread stage 10: (note stage 9 was the kern/lwkt_rwlock commit).  Cleanup
thread and process creation functions.  Check the spl against ipending in
cpu_lwkt_restore (so the idle loop does not lockup the machine).  Remove
the old VM object kstack allocation and freeing code.  Leave newly created
processes in a stopped state to fix wakeup/fork_handler races.  Normalize
the lwkt_init_*() functions.

Add a sysctl debug.untimely_switch which will cause the last crit_exit()
to yield, which causes a task switch to occur in wakeup() and catches a
lot of 4.x-isms that can be found and fixed on UP.

Add kern/lwkt_rwlock.c -- reader/writer locks.  Clean up the process exit &
reaping interlock code to allow context switches to occur.  Clean up and
make operational the lwkt_block/signaling code.

rename td_token to td_xtoken to deal with conflict against sys/thread.h

thread stage 8: add crit_enter(), per-thread cpl handling, fix deferred
interrupt handling for critical sections, add some basic passive token code,
and blocking/signaling code.   Add structural definitions for additional
LWKT mechanisms.

Remove asleep/await.  Add generation number based xsleep/xwakeup.

Note that when exiting the last crit_exit() we run splz() to catch up
on blocked interrupts.  There is also some #if 0'd code that will cause
a thread switch to occur 'at odd times'... primarily wakeup()->
lwkt_schedule()->critical_section->switch.  This will be usefulf or testing
purposes down the line.

The passive token code is mostly disabled at the moment.  It's primary use
will be under SMP and its primary advantage is very low overhead on UP and,
if used properly, should also have good characteristics under SMP.

thread stage 7: Implement basic LWKTs, use a straight round-robin model for
the moment.  Also continue consolidating the globaldata structure so both UP
and SMP use it with more commonality.  Temporarily match user processes up
with scheduled LWKTs on a 1:1 basis.  Eventually user processes will have
LWKTs, but they will not all be scheduled 1:1 with the user process's
runnability.

With this commit work can potentially start to fan out, but I'm not ready
to announce yet.

thread stage 6:  Move thread stack management from the proc structure to
the thread structure, cleanup the pmap_new_*() and pmap_dispose_*()
functions, and disable UPAGES swapping (if we eventually separate the kstack
from the UPAGES we can reenable it).  Also LIFO/4 cache thread structures
which improves fork() performance by 40% (when used in typical fork/exec/exit
or fork/subshell/exit situations).

thread stage 5: Separate the inline functions out of sys/buf.h, creating
sys/buf2.h (A methodology that will continue as time passes).  This solves
inline vs struct ordering problems.

Do a major cleanup of the globaldata access methodology.  Create a
gcc-cacheable 'mycpu' macro & inline to access per-cpu data.  Atomicy is not
required because we will never change cpus out from under a thread, even if
it gets preempted by an interrupt thread, because we want to be able to
implement per-cpu caches that do not require locked bus cycles or special
instructions.

Add missing prototype (fixes warning).

Fix an argument mismatch in a debugging printf

get rid of (incorrect) gcc warning.

remove unused variable.

Oops commit the thread.h file.

thread stage 4: remove curpcb, use td_pcb reference instead.   Move the pcb
to the end of the thread stack, and note that a pcb will always exist because
a thread context will always exist.  Also note that vm86 replaces td_pcb
temporarily and we really need to rip that out and instead make a copy on
the stack, because assumptions are made in regards to the pcb's location.

thread stage 3: create independant thread structure, unembed from proc.

thread stage 2: convert npxproc to npxthread.

thread stage 1: convert curproc to curthread, embed struct thread in proc.

Retarget makesyscalls.sh from FreeBSD to TurtleBSD

Remove UUCP support.  Note: /usr/src/gnu/libexec/uucp and /usr/src/libexec/uucpd
physically removed from repository.

Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids.  Most
ids have been removed from !lint sections and moved into comment sections.