Linux内核RPC请求过程

2022-03-11 03:19:43

这篇文章讲讲服务器端RPC报文的处理流程。服务器端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.         // 这是一块缓存，服务器从网卡中接收到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_server;  
  13.         u32                     dir;  
  14.   
  15.         /* 
  16.          * Setup response xdr_buf. 
  17.          * Initially it has just one page 
  18.          */  
  19.         rqstp->rq_resused = 1;  
  20.         // 为RPC应答消息分配内存  
  21.         resv->iov_base = page_address(rqstp->rq_respages[0]);  
  22.         resv->iov_len = 0;   
  23.         rqstp->rq_res.pages = rqstp->rq_respages + 1;  
  24.         rqstp->rq_res.len = 0;  
  25.         rqstp->rq_res.page_base = 0;  
  26.         rqstp->rq_res.page_len = 0;  
  27.         rqstp->rq_res.buflen = PAGE_SIZE;  
  28.         rqstp->rq_res.tail[0].iov_base = NULL;  
  29.         rqstp->rq_res.tail[0].iov_len = 0;  
  30.   
  31.         rqstp->rq_xid = svc_getu32(argv);   // 这里开始解析RPC报文了，按照RPC报文格式，这是RPC消息的XID。  
  32.   
  33.         dir  = svc_getnl(argv);   // 这个函数解析出了RPC保本中的第二个字段(Message Type)  
  34.         if (dir != 0) {           // RPC协议规定，RPC应答消息中Message Type字段必须为0.如果不是0就不处理了。  
  35.                 /* direction != CALL */  
  36.                 svc_printk(rqstp, "bad direction %d, dropping request\n", dir);  
  37.                 serv->sv_stats->rpcbadfmt++;  
  38.                 svc_drop(rqstp);   // 丢弃这个RPC报文。  
  39.                 return 0;  
  40.         }  
  41.   
  42.         // 现在可以确定这是一个RPC请求报文了，调用svc_process_common()进行处理，这是RPC请求的主处理函数，并且会填充RPC应答报文。  
  43.         // 返回值1表示处理过程正常，已经正常填充了RPC应答消息，可以发送给客户端了。  
  44.         // 返回值0表示RPC请求报文格式异常，直接丢弃这个报文。  
  45.         /* Returns 1 for send, 0 for drop */  
  46.         if (svc_process_common(rqstp, argv, resv))  
  47.                 return svc_send(rqstp);    // 这是发送RPC应答消息的报文，不会深入分析这个函数了。  
  48.         else {  
  49.                 svc_drop(rqstp);    // 丢弃RPC报文。  
  50.                 return 0;  
  51.         }  
  52. }  

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）检查服务器端是否可以处理这个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.   
  4. /* First words of reply: */  
  5. svc_putnl(resv, 1);             // 组装RPC应答报文中第二个字段Message Type，RPC应答消息中这个字段固定为1.  
  6.   
  7. // 目前通用的RPC版本是2，服务器端只支持RPC版本2。如果不是版本2，则不处理了。  
  8. if (vers != 2)          /* RPC version number */  
  9.         goto err_bad_rpc;  
  10.   
  11. // 组装RPC应答消息的第三个字段 Reply State，这里暂时将这个字段设置为0了，表示正常。  
  12. // 但这只是一个暂时值，如果后面用户验证过程出错了，会修改这个字段。  
  13. // reply_statp就是指向了这个字段的位置，当出错后可以根据reply_statp指针找到这个字段。  
  14. reply_statp = resv->iov_base + resv->iov_len;   // 写到这个位置了  
  15. 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 */  

也很简单，直接从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.   
  7.         *authp = rpc_auth_ok;  
  8.   
  9.         // 前面的函数已经解析出了RPC请求报文中前6个字段，下面该解析第7个字段Credential了。  
  10.         // Credential中第一个字段是Flavor，表示认证方式。  
  11.         flavor = svc_getnl(&rqstp->rq_arg.head[0]);  
  12.   
  13.         dprintk("svc: svc_authenticate (%d)\n", flavor);  
  14.   
  15.         spin_lock(&authtab_lock);  
  16.         // 判断服务器端是否支持这种认证方式  
  17.         // authtab[flavor]是这种认证方式的操作函数集合  
  18.         if (flavor >= RPC_AUTH_MAXFLAVOR || !(aops = authtab[flavor]) ||  
  19.             !try_module_get(aops->owner)) {  
  20.                 spin_unlock(&authtab_lock);  
  21.                 *authp = rpc_autherr_badcred;   // 不支持这种认证方式，这是错误码  
  22.                 return SVC_DENIED;  
  23.         }  
  24.         spin_unlock(&authtab_lock);  
  25.   
  26.         rqstp->rq_authop = aops;    // 认证方式的操作函数集合  
  27.         // 调用具体认证方式中的accept()函数解析RPC报文中的认证信息。  
  28.         // 每种认证方式都有自己的处理函数。  
  29.         return aops->accept(rqstp, authp);   
  30. }  

这个函数的主要作用是解析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_client)(struct svc_rqst *rq);  
  9. };  

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

（4）检查服务器端是否可以处理这个RPC请求

[cpp] view plaincopyprint?
  1. progp = serv->sv_program;       // 取出这个端口中注册的RPC服务处理程序  
  2.   
  3. // 每个端口上可以注册多种RPC服务，这些RPC服务的处理程序构成了一个链表，  
  4. // 遍历链表中的每一种处理程序，检查是否支持接收到的RPC请求。  
  5. for (progp = serv->sv_program; progp; progp = progp->pg_next)  
  6.         if (prog == progp->pg_prog)     // 比较程序编号，如果编号相等就表示找到处理程序了。  
  7.                 break;    
  8.   
  9. // progp就是找到的处理程序。如果遍历到链表结尾也没有找到编号相等的处理程序，  
  10. // 则表示服务器不能处理这个请求。这种情况下，由于已经遍历到链表结尾，progp就是NULL。  
  11. if (progp == NULL)      // 如果没有处理例程，退出。  
  12.         goto err_bad_prog;  
  13.   
  14. // 对比完RPC程序编号后还需要对比程序版本号，如果版本号不相等也不能处理。  
  15. if (vers >= progp->pg_nvers ||  
  16.   !(versp = progp->pg_vers[vers]))  
  17.         goto err_bad_vers;  
  18.   
  19. // versp是RPC处理程序中的一个版本，每个版本的处理程序中包含多个处理例程，  
  20. // procp根据例程编号找到了处理例程，需要检查服务器端是否实现了这个处理例程。  
  21. // procp->pc_func就是这个处理例程的处理函数了，如果服务器端没有实现这个例程，  
  22. // 也直接退出。  
  23. procp = versp->vs_proc + proc;      // 取出处理例程  
  24. if (proc >= versp->vs_nproc || !procp->pc_func)  
  25.         goto err_bad_proc;  
  26. rqstp->rq_procinfo = procp;     // 设置处理程序  
  27.   
  28. /* Syntactic check complete */  
  29. serv->sv_stats->rpccnt++;  
  30.   
  31. /* Build the reply header. */  
  32. statp = resv->iov_base +resv->iov_len;  
  33. // 这是RPC应答消息的第5个字段Accept State，先初始化为RPC_SUCCESS。  
  34. // 如果这个RPC的处理过程出错了，会修改这个字段的值，修改为相应的错误码。  
  35. 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请求的编码函数，服务器端需要将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.         // 就不处理了，直接将缓存中的数据返回给客户端就可以了。  
  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.   
  12.         // 如果这个值为1，就说明虽然定义了这个版本的处理例程，但是不对外提供服务  
  13.         unsigned int            vs_hidden : 1;  /* Don‘t register with portmapper. 
  14.                                                  * Only used for nfsacl so far. */  
  15.   
  16.         /* Override dispatch function (e.g. when caching replies). 
  17.          * A return value of 0 means drop the request. 
  18.          * vs_dispatch == NULL means use default dispatcher. 
  19.          */  
  20.         // 这是RPC请求的处理函数，简单来说就是依次调用svc_procedure中的pc_decode、pc_func、pc_encode函数.  
  21.         // NFS中这个函数是nfsd_dispatch().  
  22.         int                     (*vs_dispatch)(struct svc_rqst *, __be32 *);  
  23. };  

最后是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.         // 处理请求  
  10.         *statp = procp->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);  
  11.   
  12.         /* Encode reply */  
  13.         if (rqstp->rq_dropme) {  
  14.                 if (procp->pc_release)  
  15.                         procp->pc_release(rqstp, NULL, rqstp->rq_resp);  
  16.                 goto dropit;   
  17.         }         
  18.         // 编码处理结果，将处理结果封装到RPC应答消息中  
  19.         if (*statp == rpc_success &&  
  20.             (xdr = procp->pc_encode) &&  
  21.             !xdr(rqstp, resv->iov_base+resv->iov_len, rqstp->rq_resp)) {  
  22.                 dprintk("svc: failed to encode reply\n");  
  23.                 /* serv->sv_stats->rpcsystemerr++; */  
  24.                 *statp = rpc_system_err;  
  25.         }         
  26. } else {  
  27.         dprintk("svc: calling dispatcher\n");  
  28.         if (!versp->vs_dispatch(rqstp, statp)) {    // 这个函数负责处理请求  
  29.                 /* Release reply info */   
  30.                 if (procp->pc_release)  
  31.                         procp->pc_release(rqstp, NULL, rqstp->rq_resp);  
  32.                 goto dropit;   
  33.         }         
  34. }  

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

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

Linux内核RPC请求过程,布布扣,bubuko.com

Linux内核RPC请求过程

上一篇：转:sock_ev——linux平台socket事件框架(基于字节流的测试程序) .


下一篇：Photoshop绘制山水和翠竹的教程