大家好：我最近在学习网路协议栈代码
 
我在网上看到了 如下：  想问一下进程上下文是什么意思？由tcp_recvmsg调用，到底是怎么样调用的  ？？？ 谢谢
static void tcp_prequeue_process(struct sock *sk)
 {
      struct sk_buff *skb;
      struct tcp_sock *tp = tcp_sk(sk);
      NET_INC_STATS_USER(LINUX_MIB_TCPPREQUEUED);
      /* RX process wants to run with disabled BHs, though it is not
       * necessary */
      local_bh_disable();
      while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)
          sk->sk_backlog_rcv(sk, skb);
      local_bh_enable();
      /* Clear memory counter. */
      tp->ucopy.memory = 0;
 }
可见tcp_prequeue_process中最后也调用了tcp_v4_do_rcv，不过是在进程上下文，由tcp_recvmsg调用，而不是软中断上下文。

 tcp_recvmsg()：
 ｛
      .......
if (!sysctl_tcp_low_latency && tp->ucopy.task == user_recv) {
              /* Install new reader */
              if (!user_recv && !(flags & (MSG_TRUNC | MSG_PEEK))) {
                  user_recv = current;
                  tp->ucopy.task = user_recv;
                  tp->ucopy.iov = msg->msg_iov;
              }
              tp->ucopy.len = len;
              BUG_TRAP(tp->copied_seq == tp->rcv_nxt ||
                   (flags & (MSG_PEEK | MSG_TRUNC)));
              /* Ugly... If prequeue is not empty, we have to
               * process it before releasing socket, otherwise
               * order will be broken at second iteration.
               * More elegant solution is required!!!
               *
               * Look: we have the following (pseudo)queues:
               *
               * 1. packets in flight
               * 2. backlog
               * 3. prequeue
               * 4. receive_queue
               *
               * Each queue can be processed only if the next ones
               * are empty. At this point we have empty receive_queue.
               * But prequeue _can_ be not empty after 2nd iteration,
               * when we jumped to start of loop because backlog
               * processing added something to receive_queue.
               * We cannot release_sock(), because backlog contains
               * packets arrived _after_ prequeued ones.
               *
               * Shortly, algorithm is clear --- to process all
               * the queues in order. We could make it more directly,
               * requeueing packets from backlog to prequeue, if
               * is not empty. It is more elegant, but eats cycles,
               * unfortunately.
               */
              if (!skb_queue_empty(&tp->ucopy.prequeue))
                  goto do_prequeue;
              /* __ Set realtime policy in scheduler __ */
          }
      ........
 do_prequeue:
                  tcp_prequeue_process(sk);
 ...
 }

钩子函数？