CVS log for src/sys/sys/lock.h

Up to [cvs.NetBSD.org] / src / sys / sys

Request diff between arbitrary revisions

Keyword substitution: kv
Default branch: MAIN

sys/lock.h: remove stray semicolon from SPINLOCK_BACKOFF macro

sys/sys: remove CONSTCOND comment from do-while-0 loop

Lint doesn't need this comment anymore, as there is nothing surprising
or unusual about this idiom.

sys/lock.h: Need <sys/systm.h> for nullop.

But only do that we're not using SPINLOCK_BACKOFF_HOOK from
<machine/lock.h>.

Sync w/ HEAD.

Nothing here came from UCB, it's all NetBSD.

Include missing opt_lockdebug.h.

Kill off kernel_lock_plug_leak(), and go back to dropping kernel_lock in
exit1(), since there seems little hope of finding the leaking code any
time soon.  Can still be caught with LOCKDEBUG.

Sync with head.

Add a kernel_lock_plug_leak() that drops any holds and tries to identify
the baddy.

Sync with HEAD

Sync with HEAD

Remove unused macro.

Sync with HEAD.

sync with head.

sync with head

Remove vlockmgr().  Generic vnode lock operations now use a rwlock located
in the vnode.  All LK_* flags move from sys/lock.h to sys/vnode.h.  Calls
to vlockmgr() in file systems get replaced with VOP_LOCK() or VOP_UNLOCK().

Welcome to 5.99.34.

Discussed on tech-kern.

Clean up vnode lock operations:

 - VOP_LOCK(vp, flags): Limit the set of allowed flags to LK_EXCLUSIVE,
   LK_SHARED and LK_NOWAIT.  LK_INTERLOCK is no longer allowed as it
   makes no sense here.

- VOP_ISLOCKED(vp): Remove the for some time unused return value
  LK_EXCLOTHER.  Mark this operation as "diagnostic only".
  Making a lock decision based on this operation is no longer allowed.

Discussed on tech-kern.

Remove the concept of recursive vnode locks by eliminating
vn_setrecurse(), vn_restorerecurse() and LK_CANRECURSE.
Welcome to 5.99.31

Discussed on tech-kern.

Sync with HEAD.

sync with head.

sync with head.

Remove clause 3 and 4 from TNF licenses

sync with HEAD

Sync with HEAD.

sync with head.

Goodbye lockmgr().

sync with head

Sync with HEAD

- Fix a memory order problem with non-interlocked mutex release.
- Give kernel_lock its own cache line.

transferlockers() is gone. ok ad

sync with HEAD

Sync with HEAD

Overzealous; pull in machine/lock.h again.

Start detangling lock.h from intr.h. This is likely to cause short term
breakage, but the mess of dependencies has been regularly breaking the
build recently anyhow.

Sync with HEAD

Merge vmlocking2 to head.

Allocate but do not use a lockdebug record for 'struct lock' so that it's
easier to find leaks.

- Don't drain the vnode lock in vclean(); reference counting and XLOCK
  should be enough.
- LK_SETRECURSE is gone.

Sync with HEAD.

Pullup to HEAD

Sync with HEAD.

Sync with head.

sync with head

Nothing uses shared -> exclusive upgrades any more, so remove the code.
This is good since they are effectively the same as ...

	lockmgr(&lock, LK_RELEASE);
	lockmgr(&lock, LK_EXCLUSIVE);

.. and therefore don't behave as expected.

Pull the vmlocking changes into a new branch.

sync with HEAD

sync with head.

Sync with HEAD.

Follow the merge of pmap.c on i386 and amd64 and move
pmap_init_tmp_pgtbl into arch/x86/x86/pmap.c. Modify the ACPI wakeup
code to restore CR4 before jumping back into kernel space as the large
page option might cover that.

sync with head.

<sys/lock.h> wants uintptr_t, so include <sys/stdint.h>.
cf <slrnfgtjo3.rj4.mason@g.primenet.com.au>, et al.

Merge from vmlocking:

- G/C spinlockmgr() and simple_lock debugging.
- Always include the kernel_lock functions, for LKMs.
- Slightly improved subr_lockdebug code.
- Keep sizeof(struct lock) the same if LOCKDEBUG.

'volatile' isn't needed here.

- Always include the kernel_lock functions, for LKMs.
- Fix uniprocessor builds.
- Tidy up a bit.

crackmgr(): don't keep track of line numbers/file names for LOCKDEBUG.
Instead, just stash a couple of text addresses into struct lock. Keep
these in struct lock even if compiled without LOCKDEBUG, so that the
size of struct lock is not changed by it.

Kill transferlockers() now that it's unused.

sync with head.

Sync w/ NetBSD-4-RC_1

Pull up following revision(s) (requested by pooka in ticket #1816):
	sys/sys/lock.h: revision 1.72
	sys/kern/kern_lock.c: revision 1.118
	sys/kern/vfs_subr.c: revision 1.295
Define a new lockmgr flag LK_RESURRECT which can be used in
conjunction with LK_DRAIN.  This has the same effect as LK_DRAIN
except it atomically does NOT mark the lock as drained.  This
guarantees that when we got the lock, we were the last one currently
waiting for the lock.
Use LK_DRAIN|LK_RESURRECT in vclean() to make sure there are no
waiters for the lock.  This should fix behaviour theoretized to be
caused by vfs_subr.c 1.289 which caused vclean() to run into
completion and free the vnode before all lock-waiters had been
processed.  Should therefore fix the "simple_lock: unitialized lock"
problems seen recently.
thanks to Juergen Hannken-Illjes for some analysis of the problem
and Erik Bertelsen for testing

Sync with HEAD.

Sync with HEAD.

Pull up following revision(s) (requested by pooka in ticket #11349):
	sys/sys/lock.h: revision 1.72
	sys/kern/kern_lock.c: revision 1.118 via patch
	sys/kern/vfs_subr.c: revision 1.295
Define a new lockmgr flag LK_RESURRECT which can be used in
conjunction with LK_DRAIN.  This has the same effect as LK_DRAIN
except it atomically does NOT mark the lock as drained.  This
guarantees that when we got the lock, we were the last one currently
waiting for the lock.
Use LK_DRAIN|LK_RESURRECT in vclean() to make sure there are no
waiters for the lock.  This should fix behaviour theoretized to be
caused by vfs_subr.c 1.289 which caused vclean() to run into
completion and free the vnode before all lock-waiters had been
processed.  Should therefore fix the "simple_lock: unitialized lock"
problems seen recently.
thanks to Juergen Hannken-Illjes for some analysis of the problem
and Erik Bertelsen for testing

Pull up following revision(s) (requested by pooka in ticket #808):
	sys/sys/lock.h: revision 1.72
	sys/kern/kern_lock.c: revision 1.118
	sys/kern/vfs_subr.c: revision 1.295
Define a new lockmgr flag LK_RESURRECT which can be used in
conjunction with LK_DRAIN.  This has the same effect as LK_DRAIN
except it atomically does NOT mark the lock as drained.  This
guarantees that when we got the lock, we were the last one currently
waiting for the lock.
Use LK_DRAIN|LK_RESURRECT in vclean() to make sure there are no
waiters for the lock.  This should fix behaviour theoretized to be
caused by vfs_subr.c 1.289 which caused vclean() to run into
completion and free the vnode before all lock-waiters had been
processed.  Should therefore fix the "simple_lock: unitialized lock"
problems seen recently.
thanks to Juergen Hannken-Illjes for some analysis of the problem
and Erik Bertelsen for testing

Define a new lockmgr flag LK_RESURRECT which can be used in
conjunction with LK_DRAIN.  This has the same effect as LK_DRAIN
except it atomically does NOT mark the lock as drained.  This
guarantees that when we got the lock, we were the last one currently
waiting for the lock.

Use LK_DRAIN|LK_RESURRECT in vclean() to make sure there are no
waiters for the lock.  This should fix behaviour theoretized to be
caused by vfs_subr.c 1.289 which caused vclean() to run into
completion and free the vnode before all lock-waiters had been
processed.  Should therefore fix the "simple_lock: unitialized lock"
problems seen recently.

thanks to Juergen Hannken-Illjes for some analysis of the problem
and Erik Bertelsen for testing

file lock.h was added on branch matt-mips64 on 2007-07-29 12:40:38 +0000

Define a new lockmgr flag LK_RESURRECT which can be used in
conjunction with LK_DRAIN.  This has the same effect as LK_DRAIN
except it atomically does NOT mark the lock as drained.  This
guarantees that when we got the lock, we were the last one currently
waiting for the lock.

Use LK_DRAIN|LK_RESURRECT in vclean() to make sure there are no
waiters for the lock.  This should fix behaviour theoretized to be
caused by vfs_subr.c 1.289 which caused vclean() to run into
completion and free the vnode before all lock-waiters had been
processed.  Should therefore fix the "simple_lock: unitialized lock"
problems seen recently.

thanks to Juergen Hannken-Illjes for some analysis of the problem
and Erik Bertelsen for testing

Add lockdestroy() which tears down lk_interlock.

Sync with head.

merge yamt-idlelwp branch.  asked by core@.  some ports still needs work.

from doc/BRANCHES:

	idle lwp, and some changes depending on it.

	1. separate context switching and thread scheduling.
	   (cf. gmcgarry_ctxsw)
	2. implement idle lwp.
	3. clean up related MD/MI interfaces.
	4. make scheduler(s) modular.

Pull up a change from the yamt-idlelwp branch: adjust the constants for
spinlock backoff.

Adjust the constants for spinlock backoff downwards, on the assumption that
SPINLOCK_BACKOFF_HOOK costs >=20 cycles. To be revisited.

Backport lock.h split into the simplelock.h and other #include changes
from HEAD. This fixes the problems with circular includes.

Pull in the initial set of changes for the vmlocking branch.

Sync with head.

Put the simplelock stuff into its own header file to simplify dependencies.

- sync with head.
- move sched_changepri back to kern_synch.c as it doesn't know PPQ anymore.

typedef pri_t and use it instead of int and u_char.

sync with head.

add bitmask_snprintf string.

Merge newlock2 to head.

- Increase spinout timeout.
- Spin testing kernel_lock to reduce bus traffic.

sync with head.

Checkpoint work in progress.

Checkpoint work in progress.

Export kernel_mutex.

sync with head.

sync with head

- Declare lock_owner_onproc(). Traverses the CPU list and checks if
  ci->ci_curlwp == arg.
- Define SPINLOCK_SPIN_HOOK to /* nothing */ if it's not defined
  already.
- Define SPINLOCK_BACKOFF() macro.

sync with head.

fix incomplete initializers in the LOCKDEBUG case

sync with head.

Sync with head.

sync with head.

sync with head.

Merge 2006-03-28 NetBSD-current into the "peter-altq" branch.

Add simple_lock_assert_locked/simple_lock_assert_unlocked to provide additional
useful information when panic'ing because the assertion fails.
Use these to define the SCHED_ASSERT_LOCKED/SCHED_ASSERT_UNLOCKED macros.

sync with head.

Spell LK_CANRECURSE correctly in the comment.

changes for making DIAGNOSTIC not change the kernel ABI:
 - for structure fields that are conditionally present,
   make those fields always present.
 - for functions which are conditionally inline, make them never inline.
 - remove some other functions which are conditionally defined but
   don't actually do anything anymore.
 - make a lock-debugging function conditional on only LOCKDEBUG.

as discussed on tech-kern some time back.

Remove leading __ from __(const|inline|signed|volatile) -- it is obsolete.

merge ktrace-lwp.

Sync with HEAD. Here we go again...

Add an internal _TAILQ macro that allows us to be explicit about volatile
qualifiers and use it in the lock case. This will help us clean the XXX
volatile cast-aways in kern_lock.c

sync with -current

sync with head.  xen and whitespace.  xen part is not finished.

Sync with HEAD.

Hi Perry!

nuke trailing whitespace

Sync with HEAD.

don't reference kernel_lock directly.

Sync with HEAD

fix comment - LK_NOWAIT, not LK_WAIT

Fix the sync with head I botched.

Sync with HEAD.

Sync with HEAD

Pull up revision 1.55 (requested by kleink in ticket #580):
  Tidy up the namespace: lint -> __lint__.

Tidy up the namespace: lint -> __lint__.

Add ffs internal snapshots. Written by Marshall Kirk McKusick for FreeBSD.

- Not enabled by default. Needs kernel option FFS_SNAPSHOT.
- Change parameters of ffs_blkfree.
- Let the copy-on-write functions return an error so spec_strategy
    may fail if the copy-on-write fails.
- Change genfs_*lock*() to use vp->v_vnlock instead of &vp->v_lock.
- Add flag B_METAONLY to VOP_BALLOC to return indirect block buffer.
- Add a function ffs_checkfreefile needed for snapshot creation.
- Add special handling of snapshot files:
    Snapshots may not be opened for writing and the attributes are read-only.
    Use the mtime as the time this snapshot was taken.
    Deny mtime updates for snapshot files.
- Add function transferlockers to transfer any waiting processes from
  one lock to another.
- Add vfsop VFS_SNAPSHOT to take a snapshot and make it accessible through
  a vnode.
- Add snapshot support to ls, fsck_ffs and dump.

Welcome to 2.0F.

Approved by: Jason R. Thorpe <thorpej@netbsd.org>

introduce LK_EXCLOTHER for lockstatus().
from FreeBSD, but a little differently.  instead of letting lockstatus()
take an additional thread argument, always use curlwp/curcpu.

there's no need to initialize simplelock on uniprocessor.

turn ACQUIRE macro into a function by introducing new internal
flags, LK_SHARE_NONZERO and LK_WAIT_NONZERO.  from FreeBSD.

Move UCB-licensed code from 4-clause to 3-clause licence.

Patches provided by Joel Baker in PR 22364, verified by myself.

prototype must not carry variable name

Add a LOCK_INITIALIZER() macro to statically initialize a struct lock.

Merge the nathanw_sa branch.

catch up with -current on kqueue branch

Catch up to -current.

Catch up with -current.

Move kernel_lock manipulation info functions so that they will
show up in a profile.

Split the "simplelock" stuff out of lock.h into simplelock.h.  The
new __cpu_simple_lock_t basic atomic primitive is still useful, even
with the new mutex implementation.

In mutex.h, use simplelock.h rather than lock.h.

Make lockmgr() lwp-aware:
- Locks are counted against LWPs, not procs.
- When we record the lockholder in the lock structure, we need to
  also record the lwpid.
- When we are checking who holds the lock, also consider lwpid.

Fixes a "locking against myself" panic reported by Allen Briggs that
could be easily triggered by redirecting the output of an LWP-using
program to a file.

Catch up to -current.

Add a simple_lock_only_held() LOCKDEBUG routine, which allows code
to assert that exactly zero or one (and a specific one) locks are
held.

From Bill Sommerfeld.

use _KERNEL_OPT

replace {simple_,}lock{_data,}_t with struct {simple,}lock {,*}.

remove some lint

Sync with HEAD.

adjust the spinlock macros in the non-MULTIPROCESSOR, non-LOCKDEBUG case
so that gcc will think that static spinlock are used.
this allows us to remove the ugly conditionalization of
static spinlock declarations.

Add a LOCKDEBUG check for a r/w spinlock spinning out of control.
Partially from Bill Sommerfeld.

Update thorpej_scsipi to -current as of a month ago

Back out mistaken commits.

Extend kinfo_proc2 with CPU id

Since the spinlock count is per-cpu, we don't need atomic operations
to update it, so don't bother with <machine/atomic.h>

Flush kernel_lock_release_all() and kernel_lock_acquire_count() (which
didn't do spinlock accounting correctly), and replace them with
spinlock_release_all() and spinlock_acquire_count().

Lock debugging fix: Make sure a simplelock's lock_holder gets
initialized properly, and consistently tracks the owning CPU's
cpuid.  Add some diagnostic assertions to enforce this.

Some more lock debugging support:
- LOCK_ASSERT(), which expands to KASSERT() if LOCKDEBUG.
- new simple_lock_held(), which tests if the calling CPU holds
  the specified simple lock.

From Bill Sommerfeld, modified slightly by me.

Pullup from trunk:
Add a DIAGNOSTIC or LOCKDEBUG check for held spin locks.

Pullup from trunk:
It doesn't make sense to charge simple locks to proc's, because
simple locks are held by CPUs.  Remove p_simple_locks (which was
unused anyway, really), and add a LOCKDEBUG check for held simple
locks in mi_switch().  Grow p_locks to an int to take up the space
previously used by p_simple_locks so that the proc structure doens't
change size.

Add a DIAGNOSTIC or LOCKDEBUG check for held spin locks.

It doesn't make sense to charge simple locks to proc's, because
simple locks are held by CPUs.  Remove p_simple_locks (which was
unused anyway, really), and add a LOCKDEBUG check for held simple
locks in mi_switch().  Grow p_locks to an int to take up the space
previously used by p_simple_locks so that the proc structure doens't
change size.

ANSI'ify.

Sync w/ netbsd-1-5-base.

Revert rev. 1.30.

Make "src/regress/sys/kern/extent" build again.

Correct SIMPLELOCK_INITIALIZER for the LOCKDEBUG case.

Protect kernel function prototypes with _KERNEL.

Let each platform typedef the new __cpu_simple_lock_t, which should
be the most efficient type used for the atomic operations in the
simplelock structure, and should also be __volatile.

Require that each each MACHINE/MACHINE_ARCH supply a lock.h.  This file
contains the values __SIMPLELOCK_LOCKED and __SIMPLELOCK_UNLOCKED, which
replace the old SIMPLELOCK_LOCKED and SIMPLELOCK_UNLOCKED.  These files
are also required to supply inline functions __cpu_simple_lock(),
__cpu_simple_lock_try(), and __cpu_simple_unlock() if locking is to be
supported on that platform (i.e. if MULTIPROCESSOR is defined in the
_KERNEL case).  Change these functions to take an int * (&alp->lock_data)
rather than the struct simplelock * itself.

These changes make it possible for userland to use the locking primitives
by including <machine/lock.h>.

Pull up to last week's -current.

Sync with -current

delete unused __attribute__((__aligned__)) on locks

Arrange struct simplelock more efficiently. (Megabytes of these can be
allocated dynamically.)

Use cpuid_t and cpu_number().

add simple_lock_assert() prototype lost in last resync.

Update from trunk.

Fix a thinko in draining of spin locks: bump waitcount in the spin case,
too.  Remove some needless code duplication by adding a "drain" argument
to the ACQUIRE() macro (compiler can [and does] optimize the constant
conditional).

Make a slight rearrangement in how <machine/lock.h> is included.

Improve the LOCKDEBUG code:
- Now compatible with MULTIPROCESSOR (requires other changes not yet
  committed, but which will be later today).
- In addition to tracking simple locks, track exclusive spin locks.
- Count spin locks like we do sleep locks (in the cpu_info for this
  CPU).
- Lock debug lists are now TAILQs, so as to make the locking order
  more obvious when dumping the list.

Also, some suggestions from Bill Sommerfeld:
- SIMPLELOCK_LOCKED and SIMPLELOCK_UNLOCKED constants, which may be
  defined in <machine/lock.h> (default to 1 and 0, respectively).  This
  makes it easier to support architectures which use test-and-clear
  rather than test-and-set.
- Add __attribute__((__aligned__)) to the `lock_data' member of the
  simplelock structure.  This makes it easier to support architectures
  which can only perform atomic operations on very-well-aligned memory
  locations.  NOTE: This changes the size of struct simplelock, and
  will cause a version bump.

Add a spin lock mode to the lock manager.  Provides a read/write
spin lock facility.  Some code and ideas from Ross Harvey.

merge everything from chs-ubc branch.

Pull up 1.17 -> 1.18.

Add a SIMPLELOCK_INITIALIZER macro, to statically initialize a simplelock,
so that simple_lock_init() is not necessary.

Prevent deadlock cited in PR4629 from crashing the system.  (copyout
and system call now just return EFAULT).  A complete fix will
presumably have to wait for UBC and/or for vnode locking protocols to
be revamped to allow use of shared locks.

completely remove Mach VM support.  all that is left is the all the
header files as UVM still uses (most of) these.

Define LK_SETRECURSE.

define SLOCK_{,UN}LOCKED for LOCKDEBUG.

initial snapshot.  lots left to do.

LOCKDEBUG enhancements for non-MP:
keep a list of locked locks.
use this to print where the lock was locked
when we either go to sleep with a lock held
or try to free a locked lock.

- Add a CPU identifier to the simplelock if LOCKDEBUG.
- Arrange for <machine/lock.h> to provide LOCKDEBUG functionality if
  LOCKDEBUG && MULTIPROCESSOR.

revert the uniproc lines to the old noop defines. changes broke compiling
on !MULTIPROC && !LOCKDEBUG compiles.

Key off MULTIPROCESSOR, not NCPUS > 1.  Pull in <machine/lock.h> if
MULTIPROCESSOR is defined, and rely on it to define the simple lock
operations.

defopt LOCKDEBUG

Merge with Lite2 + local changes

- add defopt's for UVM, UVMHIST and PMAP_NEW.
- remove unnecessary UVMHIST_DECL's.

add/cleanup multiple inclusion protection.

snazzier LOCKDEBUG code.

initial import of the new virtual memory system, UVM, into -current.

UVM was written by chuck cranor <chuck@maria.wustl.edu>, with some
minor portions derived from the old Mach code.  i provided some help
getting swap and paging working, and other bug fixes/ideas.  chuck
silvers <chuq@chuq.com> also provided some other fixes.

this is the rest of the MI portion changes.

this will be KNF'd shortly.  :-)

Update marc-pcmcia branch from trunk.

Make wmesg arguments to various functions const.

There appear to be spinlock bugs in the VM code. They are not a problem
now, as we're always one on CPU (they will be later, though). With DEBUG,
they cause a lot of output, so DEBUG -> LOCKDEBUG for now.

Add lock count fields to proc structure. Always define NCPU to 1 for now
in lock.h

Import Lite2 locking code

Initial revision