Since user threads are mapped to kernel threads, why don't we create all threads as kernel threads that is a process with zero user thread. Doesn't mapping of user thread to kernel thread create overhead?
That is what is typically done. Most modern platforms don't really have user threads any more. You will find two technologies that are similar to user threads, coroutines and strands/fibers. But they're not pre-emptive. So real user threading has pretty much died out in favor of kernel threads.
(To avoid confusion, by "kernel threads", we mean threads that are scheduled by the kernel, not threads that execute in kernel space. By "user threads", we mean threads that are not individually scheduled by the kernel but where a user space scheduler decides which user space thread to run.)
Why don't we create all threads as kernel thread
What you are suggesting is called the one to one model in literature and it’s mostly used. For example JVM (Solaris) originally used many to one model, it created only one kernel thread for many user threads. But then it switched to the one to one model because of performance issues.
Doesn't mapping of user thread to kernel thread create overhead?
It does. But that overhead is in the user space that is because user thread creation and management is done by some library such as JVM And it does not require much evolvement of kernel (read less system calls). But when we create one kernel thread for each user thread the overhead shifts to the kernel space, because now kernel must create additional data structures for each kernel thread (read clone system call in Linux). Also more kernel threads mean more load on the schedular (depending on the scheduling policy).