In order to answer this question I first need to clarify a bit of terminology.
Virtual memory addresses are divided into user space and kernel space. On some architectures the two are both part of a single linear address space on other architectures the two are independent address spaces.
The CPU at any given time is operating in either user mode or kernel mode. In kernel mode it will have more privileges and it can for example read and write both user space and kernel space. Some CPUs have more privilege levels. AMD64 compatible CPUs for example have four privilege levels which the operating system can make use of though Linux only uses two.
When the CPU is running in user mode it can manipulate pointers pointing to kernel space, but if it tries to access the content pointed to by those pointers it will cause an exception. While running in user mode the CPU can only read, write, and execute bytes in user space and it may be subject to additional restrictions (for example memory mappings could be configured to not allow write and execute for the same range).
From user mode you can only get into kernel mode through exceptions or interrupts which causes execution to start from an address in kernel space previously configured by the kernel. Thus there is no direct way to get code in user space executing in kernel mode.
However it is possible for kernel code to jump to addresses in user space, it's just not a good idea to do so. If you are running with privileges to load kernel modules (which usually means running as root), then you could construct a module in user space memory then load it into the kernel and have it jump back to code in user space. But whatever you are trying to do, there is a better way to achieve it than this.
In Linux there is a concept known as kernel threads. Kernel threads differ from user threads in that they don't have user space. Those threads are always in kernel mode. For performance reasons the context switching can leave the current user space around when switching to a kernel thread thus if a kernel thread try to access user space (which would be a bug) it will access the user space of the most recent user thread to run.
In Linux a process is a group of one or more threads which share certain resources such as using the same user space between them. Linux is very flexible in allowing threads to choose which resources to share and which not to share.