On uniprocessor systems, no synchronization is required between threads in the kernel unless a thread sleeps during a critical section. This is because the kernel is non-preemptible and no other thread can run until the current thread sleeps or exits the kernel. On multiprocessor systems, the kernel is still non-preemptible, but it is reentrant (multiple threads can be executing in the code at the same time) because other threads can be running in the kernel on other processors.
In preemptible kernels, any time that a "higher priority" (better goodness) thread is made runnable, the current thread is preempted (loses control of the CPU) and the higher priority thread is dispatched.
The trend in operating system design has been to make operating systems preemptible to give more predictable latency for event handling and interactive behavior.
Pageable kernels allow kernel references to page fault and make page data addressible in a manner similar to that supported for applications.
The trend in operating systems has been to make operating systems pageable to handle data structures that may not need to reside in physical memory (due to infrequent use) in a simple way (merely touching them rather than explicitly copying them into memory when needed).
An MP-safe operating system can be run on multiprocessor hardware, but may not exhibit performance that scales well with the addition of processors. Usually, there is a limit to the number of processors that will sifnificantly improve a particular workload.
An MP-efficient operating system has endeavored to achieve close to linear scalability for some set of workloads with some number of processors. This means that each additional processor improves the performance by a nearly constant amount (up to some number of processors.