系统调用通常是如何实现的

Question

I am implementing something very similar to simplistic OS but I am struggling to grasp what syscalls actually are:
First of all - in process system which thread does typically * execute the interrupt routine(the syscall kernel function) - one of the kernel threads or the user space thread given temporal privilege and routine address?
How would be syscall mechanism implemented in user space - does either of following match roughly what is going on under hood?
Implementation A:

//equivalent to assembly
//MOV EAX sys_call_no
//INT 0x80
void* interrupt(int service, void* args)
{
   return kernel::int_vector[service](args);
}

Implementation B:

//equivalent to assembly
//MOV EAX sys_call_no
//INT 0x80
void* interrupt(int service, void* args, void* ret)
{
   kernel::intr_queue.push_back_syncd(interrupt_context(){kernel::int_vector[service], args, ret});
   waitForServiceCompleted();
   return ret;
}
//in kernel thread
while(true)
{
  while(!intr_queue.isEmpty())
  {
    auto context = intr_queue.pop();
    context.ret = context.func(context.args);
    notifyDone();
  }
}

C: I don't understand it at all - it works completely differently.
* by typically I mean most common current desktop systems like window 7/8 or latest Ubuntu distribution
note: sorry if this is not the correct SE site to post this question - please comment me to move it

Answer 1

Implementation A is typically how it works. Operating systems primarily use their own threads only for tasks that don't involve directly responding to a specific process request. When a process makes a typical system call, that thread switches to a kernel stack and begins running kernel code in kernel context.