Linux内核RPC请求过程

这篇文章讲讲server端RPC报文的处理流程。server端RPC报文的处理函数是svc_process，这个函数位于net/sunrpc/svc.c中。这个函数须要一个svc_rqst结构的指针作为參数，svc_rqst是与RPC请求相关的一个数据结构，这里包括了接收到的RPC消息，RPC消息的解析结果也放在这个数据结构中，RPC消息的处理结果也放在这个消息中了。这个数据结构的定义在include/linux/sunrpc/svc.h。因为我主要想解说NFS，所以非常多RPC的知识就略过不讲了。

[cpp] view
plaincopyprint?

1. /*
2. * Process the RPC request.
3. */
4. int
5. svc_process(struct svc_rqst *rqstp)
6. {
7. // 这是一块缓存，server从网卡中接收到RPC消息后存放在这里（已经去掉了IP头，TCP或UDP报文头）
8. // argv指向了缓存的起始地址，从这里開始就是RPC报文头了。
9. struct kvec             *argv = &rqstp->rq_arg.head[0];
10. // 这是一块缓存，这块缓存用来存放RPC应答消息，当今还沒有分配内存。
11. struct kvec             *resv = &rqstp->rq_res.head[0];
12. struct svc_serv         *serv = rqstp->rq_服务器;
13. u32                     dir;
14. /*
15. * Setup response xdr_buf.
16. * Initially it has just one page
17. */
18. rqstp->rq_resused = 1;
19. // 为RPC应答消息分配内存
20. resv->iov_base = page_address(rqstp->rq_respages[0]);
21. resv->iov_len = 0;
22. rqstp->rq_res.pages = rqstp->rq_respages + 1;
23. rqstp->rq_res.len = 0;
24. rqstp->rq_res.page_base = 0;
25. rqstp->rq_res.page_len = 0;
26. rqstp->rq_res.buflen = PAGE_SIZE;
27. rqstp->rq_res.tail[0].iov_base = NULL;
28. rqstp->rq_res.tail[0].iov_len = 0;
29. rqstp->rq_xid = svc_getu32(argv);   // 这里開始解析RPC报文了，依照RPC报文格式，这是RPC消息的XID。
30. dir  = svc_getnl(argv);   // 这个函数解析出了RPC保本中的第二个字段(Message Type)
31. if (dir != 0) {           // RPC协议规定，RPC应答消息中Message Type字段必须为0.假设不是0就不处理了。
32. /* direction != CALL */
33. svc_printk(rqstp, "bad direction %d, dropping request\n", dir);
34. serv->sv_stats->rpcbadfmt++;
35. svc_drop(rqstp);   // 丢弃这个RPC报文。
36. return 0;
37. }
38. // 当今能够确定这是一个RPC请求报文了，调用svc_process_common()进行处理，这是RPC请求的主处理函数，而且会填充RPC应答报文。
39. // 返回值1表示处理过程正常，已经正常填充了RPC应答消息，能够发送给client了。
40. // 返回值0表示RPC请求报文格式异常，直接丢弃这个报文。
41. /* Returns 1 for send, 0 for drop */
42. if (svc_process_common(rqstp, argv, resv))
43. return svc_send(rqstp);    // 这是发送RPC应答消息的报文，不会深入分析这个函数了。
44. else {
45. svc_drop(rqstp);    // 丢弃RPC报文。
46. return 0;
47. }
48. }

svc_process_common是基本的处理函数，这个函数的定义例如以下：

static int svc_process_common(struct svc_rqst *rqstp, struct kvec *argv, struct kvec *resv)

參数rqstp 表示一个RPC请求。

參数argv是一块缓存，这块缓存中保存了接收到的RPC请求报文。

參数resv是一块缓存，这块缓存用来保存组装后的RPC应答报文。

这个函数的处理流程就比較复杂了，基本上包括以下五个处理步骤：

（1）组装RPC报文头基本信息

（2）解析RPC服务信息

（3）对用户身份进行验证

（4）检查server端能否够处理这个RPC请求

（5）处理RPC请求

以下具体解说各个步骤

（1）组装RPC报文头基本信息

svc_process()中解析了RPC请求报文头的前两个字段(XID和Message Type)，这里解析解析请求报文中的第3个字段，组装了应答报文中的前三个字段。处理程序例如以下：

[cpp] view
plaincopyprint?

1. svc_putu32(resv, rqstp->rq_xid);        // 组装RPC应答报文中的第一个字段XID
2. vers = svc_getnl(argv);         // 解析RPC请求报文中的第三个字段 RPC Version
3. /* First words of reply: */
4. svc_putnl(resv, 1);             // 组装RPC应答报文中第二个字段Message Type，RPC应答消息中这个字段固定为1.
5. // 眼下通用的RPC版本号是2，server端仅仅支持RPC版本号2。假设不是版本号2，则不处理了。
6. if (vers != 2)          /* RPC version number */
7. goto err_bad_rpc;
8. // 组装RPC应答消息的第三个字段 Reply State，这里临时将这个字段设置为0了，表示正常。
9. // 但这不过一个临时值，假设后面用户验证过程出错了，会改动这个字段。
10. // reply_statp就是指向了这个字段的位置，当出错后能够依据reply_statp指针找到这个字段。
11. reply_statp = resv->iov_base + resv->iov_len;   // 写到这个位置了
12. svc_putnl(resv, 0);             /* ACCEPT */

（2）解析RPC服务信息

[cpp] view
plaincopyprint?

1. // 解析RPC请求消息中第4个字段Program，这个字段是RPC服务程序(如NFS服务)的编号
2. rqstp->rq_prog = prog = svc_getnl(argv);        /* program number */
3. // 解析RPC请求消息中第5个字段Version，这个字段是RPC服务程序的版本
4. rqstp->rq_vers = vers = svc_getnl(argv);        /* version number */
5. // 解析RPC请求消息中第6个字段Procedure，这个字段是RPC服务例程的编号
6. rqstp->rq_proc = proc = svc_getnl(argv);        /* procedure number */

也非常easy，直接从RPC请求消息中提取数据就能够了。

（3）对用户身份进行验证

[cpp] view
plaincopyprint?

1. auth_res = svc_authenticate(rqstp, &auth_stat);
2. /* Also give the program a chance to reject this call: */
3. if (auth_res == SVC_OK && progp) {
4. auth_stat = rpc_autherr_badcred;
5. auth_res = progp->pg_authenticate(rqstp);
6. }

这里包括了两个函数svc_authenticate和progp->pg_authenticate。svc_authenticate的作用是解析RPC请求报文中的认证信息， progp->pg_authenticate的作用是依据解析出的信息对用户身份进行验证。这两个函数都和採用的认证方式有关，我们这里仅仅简介，下一篇文章中将以UNIX认证为例具体解说解析和认证过程。

解析RPC消息中用户信息的函数是svc_authenticate()。rqstp是输入參数，表示一个RPC请求；auth_stat是输出參数，表示解析结果。这个函数的代码例如以下：

[cpp] view
plaincopyprint?

1. int
2. svc_authenticate(struct svc_rqst *rqstp, __be32 *authp)
3. {
4. rpc_authflavor_t        flavor;
5. struct auth_ops         *aops;
6. *authp = rpc_auth_ok;
7. // 前面的函数已经解析出了RPC请求报文中前6个字段，以下该解析第7个字段Credential了。
8. // Credential中第一个字段是Flavor，表示认证方式。
9. flavor = svc_getnl(&rqstp->rq_arg.head[0]);
10. dprintk("svc: svc_authenticate (%d)\n", flavor);
11. spin_lock(&authtab_lock);
12. // 推断server端是否支持这样的认证方式
13. // authtab[flavor]是这样的认证方式的操作函数集合
14. if (flavor >= RPC_AUTH_MAXFLAVOR || !(aops = authtab[flavor]) ||
15. !try_module_get(aops->owner)) {
16. spin_unlock(&authtab_lock);
17. *authp = rpc_autherr_badcred;   // 不支持这样的认证方式，这是错误码
18. return SVC_DENIED;
19. }
20. spin_unlock(&authtab_lock);
21. rqstp->rq_authop = aops;    // 认证方式的操作函数集合
22. // 调用详细认证方式中的accept()函数解析RPC报文中的认证信息。
23. // 每种认证方式都有自己的处理函数。
24. return aops->accept(rqstp, authp);
25. }

这个函数的主要作用是解析RPC请求消息中的Credential字段和Verifier字段，然后填充RPC应答消息中的Verifier字段。这个函数仅仅解析了Credential中的第一个字段，这个字段表示认证类型，然后就调用对应认证方式中的函数进行处理了。眼下Linux中支持下列认证方式

[cpp] view
plaincopyprint?

1. enum rpc_auth_flavors {
2. RPC_AUTH_NULL  = 0,
3. RPC_AUTH_UNIX  = 1,
4. RPC_AUTH_SHORT = 2,
5. RPC_AUTH_DES   = 3,
6. RPC_AUTH_KRB   = 4,
7. RPC_AUTH_GSS   = 6,
8. RPC_AUTH_MAXFLAVOR = 8,
9. /* pseudoflavors: */
10. RPC_AUTH_GSS_KRB5  = 390003,
11. RPC_AUTH_GSS_KRB5I = 390004,
12. RPC_AUTH_GSS_KRB5P = 390005,
13. RPC_AUTH_GSS_LKEY  = 390006,
14. RPC_AUTH_GSS_LKEYI = 390007,
15. RPC_AUTH_GSS_LKEYP = 390008,
16. RPC_AUTH_GSS_SPKM  = 390009,
17. RPC_AUTH_GSS_SPKMI = 390010,
18. RPC_AUTH_GSS_SPKMP = 390011,
19. };

RPC_AUTH_MAXFLAVOR表示认证方式种类，以下的认证方式所有属于RPC_AUTH_GSS认证的子类。每种认证方式都须要实现以下的函数

[cpp] view
plaincopyprint?

1. struct auth_ops {
2. char *  name;
3. struct module *owner;
4. int     flavour;
5. int     (*accept)(struct svc_rqst *rq, __be32 *authp);
6. int     (*release)(struct svc_rqst *rq);
7. void    (*domain_release)(struct auth_domain *);
8. int     (*set_客户端)(struct svc_rqst *rq);
9. };

下篇文章中我们会具体介绍UNIX认证的操作过程，这里就不深入解说了。

（4）检查server端能否够处理这个RPC请求

[cpp] view
plaincopyprint?

1. progp = serv->sv_program;       // 取出这个端口中注冊的RPC服务处理程序
2. // 每一个端口上能够注冊多种RPC服务，这些RPC服务的处理程序构成了一个链表，
3. // 遍历链表中的每一种处理程序，检查是否支持接收到的RPC请求。
4. for (progp = serv->sv_program; progp; progp = progp->pg_next)
5. if (prog == progp->pg_prog)     // 比較程序编号，假设编号相等就表示找到处理程序了。
6. break;
7. // progp就是找到的处理程序。假设遍历到链表结尾也沒有找到编号相等的处理程序，
8. // 则表示server不能处理这个请求。这样的情况下，因为已经遍历到链表结尾，progp就是NULL。
9. if (progp == NULL)      // 假设沒有处理例程，退出。
10. goto err_bad_prog;
11. // 对照完RPC程序编号后还须要对照程序版本，假设版本不相等也不能处理。
12. if (vers >= progp->pg_nvers ||
13. !(versp = progp->pg_vers[vers]))
14. goto err_bad_vers;
15. // versp是RPC处理程序中的一个版本号，每一个版本号的处理程序中包括多个处理例程，
16. // procp依据例程编号找到了处理例程，须要检查server端是否实现了这个处理例程。
17. // procp->pc_func就是这个处理例程的处理函数了，假设server端沒有实现这个例程，
18. // 也直接退出。
19. procp = versp->vs_proc + proc;      // 取出处理例程
20. if (proc >= versp->vs_nproc || !procp->pc_func)
21. goto err_bad_proc;
22. rqstp->rq_procinfo = procp;     // 设置处理程序
23. /* Syntactic check complete */
24. serv->sv_stats->rpccnt++;
25. /* Build the reply header. */
26. statp = resv->iov_base +resv->iov_len;
27. // 这是RPC应答消息的第5个字段Accept State，先初始化为RPC_SUCCESS。
28. // 假设这个RPC的处理过程出错了，会改动这个字段的值，改动为对应的错误码。
29. svc_putnl(resv, RPC_SUCCESS);       // 认证通过

该解释的内容都写在凝视中了，这里说明一下Linux中保存RPC处理程序的数据结构。首先是RPC例程的数据结构。

[cpp] view
plaincopyprint?

1. struct svc_procedure {
2. // 这是RPC请求的处理函数
3. svc_procfunc            pc_func;        /* process the request */
4. // 这是RPC请求的解码函数，RPC报文的内容是pc_func的參数，
5. // 这个函数负责解析这些内容
6. kxdrproc_t              pc_decode;      /* XDR decode args */
7. // 这是RPC请求的编码函数，server端须要将pc_func的处理结果封装到
8. // RPC应答报文中，这就是封装函数
9. kxdrproc_t              pc_encode;      /* XDR encode result */
10. // 这是释放内存的一个函数，由于pc_func可能须要分配额外的内存
11. kxdrproc_t              pc_release;     /* XDR free result */
12. // 这是RPC请求报文中数据的长度
13. unsigned int            pc_argsize;     /* argument struct size */
14. // 这是RPC应答报文中数据的长度
15. unsigned int            pc_ressize;     /* result struct size */
16. // 这是这个例程的调用次数，就是一个统计量
17. unsigned int            pc_count;       /* call count */
18. // 这是缓存类型，NFS中某些请求能够缓存处理结果。当再次接收到同样的请求后，
19. // 就不处理了，直接将缓存中的数据返回给client就能够了。
20. unsigned int            pc_cachetype;   /* cache info (NFS) */
21. // 这是调整RPC应答消息缓存的一个数据量
22. unsigned int            pc_xdrressize;  /* maximum size of XDR reply */
23. };

以下是RPC版本号的数据结构，一个版本号中包括多个例程。

[cpp] view
plaincopyprint?

1. struct svc_version {
2. // 版本号编号
3. u32                     vs_vers;        /* version number */
4. // 这个版本号中RPC例程的数量
5. u32                     vs_nproc;       /* number of procedures */
6. // 这里包括了各个RPC例程的处理函数，这里不是一个例程，
7. // 这个版本号中全部例程的处理函数都在这里，各个例程按顺序排列。
8. struct svc_procedure *  vs_proc;        /* per-procedure info */
9. // 这也是从组装应答消息相关的缓存的一个长度
10. u32                     vs_xdrsize;     /* xdrsize needed for this version */
11. // 假设这个值为1，就说明尽管定义了这个版本号的处理例程，可是不正确外提供服务
12. unsigned int            vs_hidden : 1;  /* Don't register with 端口mapper.
13. * Only used for nfsacl so far. */
14. /* Override dispatch function (e.g. when caching replies).
15. * A return value of 0 means drop the request.
16. * vs_dispatch == NULL means use default dispatcher.
17. */
18. // 这是RPC请求的处理函数，简单来说就是依次调用svc_procedure中的pc_decode、pc_func、pc_encode函数.
19. // NFS中这个函数是nfsd_dispatch().
20. int                     (*vs_dispatch)(struct svc_rqst *, __be32 *);
21. };

最后是RPC服务程序的数据结构，每一个RPC服务程序包括多个版本号。

[cpp] view
plaincopyprint?

1. struct svc_program {
2. // 指向了下一套处理程序，能够将多套处理程序注冊在同一个端口上
3. struct svc_program *    pg_next;        /* other programs (same xprt) */
4. // RPC程序编号
5. u32                     pg_prog;        /* program number */
6. // 这是最低版本号
7. unsigned int            pg_lovers;      /* lowest version */
8. // 这是最高版本号
9. unsigned int            pg_hivers;      /* lowest version */
10. // 服务程序中版本号的数量
11. unsigned int            pg_nvers;       /* number of versions */
12. // 这是各个版本号处理程序的指针
13. struct svc_version **   pg_vers;        /* version array */
14. // RPC服务名称
15. char *                  pg_name;        /* service name */
16. // 属于某个类别，同类别的RPC服务共享同样的认证方式
17. char *                  pg_class;       /* class name: services sharing authentication */
18. // 这里包括了一些统计信息
19. struct svc_stat *       pg_stats;       /* rpc statistics */
20. // 这是RPC处理程序中验证用户信息的函数.
21. int                     (*pg_authenticate)(struct svc_rqst *);
22. };

对于NFS服务来说，NFS服务相应的数据结构是svc_program。NFS眼下包括3个不同的版本号(NFSV2、NFSV3、NFSV4)，每一个版本号相应一个svc_version结构。每一个版本号中包括多个处理例程，每一个处理例程相应一个svc_procedure结构。

另一点须要注意，svc_program中包括一个函数pg_authenticate，须要注意这个函数和前面提到的认证方式中accept的差别。accept的作用是解析RPC报文中的认证信息，不过解析数据，可是不正确用户进行认证。pg_authenticate才是真正的认证函数。

（5）处理RPC请求

[cpp] view
plaincopyprint?

1. /* Call the function that processes the request. */
2. if (!versp->vs_dispatch) {
3. /* Decode arguments */
4. xdr = procp->pc_decode;         // 这是RPC请求的解码函数
5. // 開始解码了，解析RPC报文中的数据
6. if (xdr && !xdr(rqstp, argv->iov_base, rqstp->rq_argp))
7. goto err_garbage;
8. // 处理请求
9. *statp = procp->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
10. /* Encode reply */
11. if (rqstp->rq_dropme) {
12. if (procp->pc_release)
13. procp->pc_release(rqstp, NULL, rqstp->rq_resp);
14. goto dropit;
15. }
16. // 编码处理结果，将处理结果封装到RPC应答消息中
17. if (*statp == rpc_success &&
18. (xdr = procp->pc_encode) &&
19. !xdr(rqstp, resv->iov_base+resv->iov_len, rqstp->rq_resp)) {
20. dprintk("svc: failed to encode reply\n");
21. /* serv->sv_stats->rpcsystemerr++; */
22. *statp = rpc_system_err;
23. }
24. } else {
25. dprintk("svc: calling dispatcher\n");
26. if (!versp->vs_dispatch(rqstp, statp)) {    // 这个函数负责处理请求
27. /* Release reply info */
28. if (procp->pc_release)
29. procp->pc_release(rqstp, NULL, rqstp->rq_resp);
30. goto dropit;
31. }
32. }

经过步骤1--步骤4的处理，我们已经解析了RPC请求报头的数据，找到了RPC请求的处理函数，最后一步就是開始处理这个请求了。处理一个RPC请求的函数是svc_version结构中的vs_dispatch函数。假设RPC程序未定义这个函数，就依照标准的流程进行处理。在标准的流程中，首先调用svc_procedure结构中的pc_decode函数，这个函数的内容是解析RPC报文的净荷，对于NFS服务来说，这个函数的作用就是解析RPC报文中的NFS数据，这些数据就是处理函数的參数。真正的处理函数是svc_procedure结构中的pc_func函数，每一个例程都须要定义自己的处理函数。处理完毕后，须要将处理结果封装在RPC应答报文中返回给client。比方对于READ操作，我们须要将读取的数据封装在RPC报文中返回，这个封装过程是由svc_procedure结构中的pc_encode函数实现的。

NFS服务定义了自己的vs_dispatch函数，NFSV2、NFSV3、NFSV4使用了同一个vs_dispatch函数，这个函数的定义是nfsd_dispatch，这个函数定义在fs/nfsd/nfssvc.c中，处理流程基本上和上面讲的流程同样，就不解说了。