When SMP was first introduced to Linux back in 2.0 kernel days, it was done with the "big kernel lock". The Big Kernel Lock was used so that when one processor tried to enter the kernel it had to acquire this lock, and if another processor was already in the kernel it would block and wait for it to finish.

In the 2.2 series of kernels, this "Big Kernel Lock" was slowly removed from parts of the kernel. This allowed more than one processor to be executing kernel code simultaniously, but only for some operations, others hadn't been updated yet for one reason or another, so they acquired the Big Kernel Lock.

Now, in 2.4, the Big Kernel Lock has gone away, everything is protected by its own little locks. This means the kernel is "reentrant". Now, the Preemptive Kernel Patch works by allowing a process to preempt the suspension of another process already in the kernel on the same CPU. This gives much better response, since if you have a high priority task that's blocked waiting on some data, and a low priority process running, as soon as the data is available to the high priority task it can resume running immediately, whereas before preemption it would have to wait until the low priority task left the kernel.

Surprisingly enough, in most situations this actually improves performance! The reason is that processes that have been blocked get an opportunity to run as soon as possible doing a bit of work and then usually blocking quickly afterwards allowing the machine to return to its previous job.

Breaking the "big kernel lock" into many little locks is not nearly as simple as is might seem, because the slightest mistake in the logic results in a DeadLock.

If you are looking for information on how to get KernelPreemption working under Linux kernels:

If you run a 2.6 kernel, then you just need to enable the preemptive kernel option.

If you run a 2.4 kernel, you'll need to patch it. Look at to find a patch for your kernel. Note that if there isn't a patch for your kernel yet, you'll have to wait. Sorry.