The Design and Implementation of the Anykernel and Rump Kernels

105
3.5.1 Passive Serialization Techniques
Passive serialization [42] is essentially a variation of a reader-writer lock where the
read side of the lock is cheap and the write side of the lock is expensive, i.e. the
lock is optimized for readers. It is called passive serialization because readers do
not take an atomic platform level lock. The lack of a read-side lock is made up
for by deferred garbage collection, where an old copy is released only after it has
reached a quiescent state, i.e. there are no readers accessing the old copy. In an
operating system kernel the quiescent state is usually established by making the old
copy unreachable and waiting until all CPUs in the system have run code.
An example of passive serialization used for example in the Linux kernel is the readcopy
update (RCU) facility [68]. However, the algorithm is patented and can be
freely implemented only in GPL or LGPL licensed code. Both licenses are seen as
too restrictive for the NetBSD kernel and are not allowed by the project. Therefore,
RCU itself cannot be implemented in NetBSD. Another example of passive serialization
is the rmlock (read-mostly lock) facility offered by FreeBSD. It is essentially
a reader/writer locking facility with a lockless fastpath for readers. The write locks
are expensive and require cross calling other CPUs and running code on them.
Despite the lack of a locking primitive which is implemented using passive synchronization,
passive synchronization is still used in the NetBSD kernel. One example
which was present in NetBSD 5.99.48 is the dynamic loading and unloading of system
calls in sys/kern/kern_syscall.c. These operations require atomic locking
so as to make sure no system call is loaded more than once, and also to make
sure a system call is not unloaded while it is still in use. Having to take a regular
lock every time a system call is executed would be wasteful, given that unloading
of system calls during runtime takes place relatively seldom, if ever. Instead, the
implementation uses a passive synchronization algorithm where a lock is used only
for operations which are not performance-critical. We describe the elements of the