NFS客户端、服务器协商读写粒度（rsize、wsize）流程 【转】

   rsize和wsize决定了网络文件系统（NFS）一次网络交互所能够读写的数据块的大小，rsize和wsize的大小对网络文件系统（NFS）的性能有重要影响。rsize和wsize的大小是在用户配置的基础上客户端和服务器端共同协商的结果。

       本文面向NFS的开发者和维护者，主要介绍rsize和wsize在客户端和服务器之间协商的流程，同时介绍rsize和wsize的设置的方法。文章以V3的实现为主线，顺便提及V4，代码基于Linux-pnfs-2.6.32。

（1）      用户挂载

用户在挂载NFS文件系统的时候，可以用挂载选项指定rsize和wsize的大小，如下：

mount -t nfs -o vers=3,xxxx,rsize=????,wsize=????

Linux mount 命令将由系统调用下发到内核的vfs层，由vfs_kern_mount执行挂载操作。Vfs_kern_mount将调用具体文件系统的get_sb方法创建并初始化super block。对于NFS文件系统来说，这个方法便是Nfs_get_sb/Nfs4_get_sb，这两个函数定义在nfs模块代码的super.c文件当中。

（2）      Nfs_get_sb/nfs4_get_sb

这里主要介绍nfs_get_sb，nfs4_get_sb可以以此为参照。Nfs_get_sb的部分函数代码如下：

2142 static int nfs_get_sb(structfile_system_type *fs_type,

2143         int flags, const char *dev_name, void*raw_data, struct vfsmount *mnt)

2144 {//其中raw_data包含了用户挂载时的挂载参数

2145         struct nfs_server *server = NULL;

2146         struct super_block *s;

2147         struct nfs_parsed_mount_data *data;//内核挂载参数

2148         struct nfs_fh *mntfh;

2149         struct dentry *mntroot;

2150         int (*compare_super)(structsuper_block *, void *) = nfs_compare_super;

2151         struct nfs_sb_mountdata sb_mntdata = {

2152                 .mntflags = flags,

2153         };

2154         int error = -ENOMEM;

2155

2156         data = nfs_alloc_parsed_mount_data(3);//分配并且初始化内核挂载参数，此时data中的rsize和wsize分别被初始化为NFS_MAX_FILE_IO_SIZE（4U * 1048576U = 4MB）；

2157         mntfh = kzalloc(sizeof(*mntfh),GFP_KERNEL);

2158         if (data == NULL || mntfh == NULL)

2159                 goto out_free_fh;

2160

2161        security_init_mnt_opts(&data->lsm_opts);

2162

2163         /* Validate the mount data */

2164         error = nfs_validate_mount_data(raw_data,data, mntfh, dev_name);//利用raw_data和dev_name设置内核挂载参数，这时data当中rsize和wsize被设置为用户挂载时指定的大小。

2165         if (error < 0)

2166                 goto out;

2167

2168 #ifdef CONFIG_NFS_V4

2169         if (data->version == 4) {

2170                 error = nfs4_try_mount(flags,dev_name, data, mnt);

2171                kfree(data->client_address);

2172                 goto out;

2173         }

2174 #endif  /* CONFIG_NFS_V4 */

2175

2176         /* Get a volume representation */

2177         server = nfs_create_server(data,mntfh);//创建server,server中保存了和服务器交互的参数，在这个函数中客户端将和服务器协商rsize和wsize的大小。

2178         if (IS_ERR(server)) {

2179                 error = PTR_ERR(server);

2180                 goto out;

2181    }

}

（3）      客户端协商过程

在nfs_create_server/nfs4_create_server中，首先会调用nfs_init_server对server进行初始化，其中会利用用户设置的data中的rsize和wsize对server中的rsize和wsize进行赋值；然后会调用nfs_probe_fsinfo过程，nfs_probe_fsinfo过程会通过远程过程调用获取服务器所允许的读写粒度的相关信息，最终决定系统所允许的rsize和wsize的大小。nfs_probe_fsinfo函数的部分代码如下：

927 static int nfs_probe_fsinfo(struct nfs_server*server, struct nfs_fh *mntfh, struct nfs_fattr *fatt     r)

 928 {

 929         struct nfs_fsinfo fsinfo;

 930         struct nfs_client *clp = server->nfs_client;

 931         int error;

 932

 933         dprintk("-->nfs_probe_fsinfo() ");

 934

 935         if(clp->rpc_ops->set_capabilities != NULL) {

 936                 error =clp->rpc_ops->set_capabilities(server, mntfh);

 937                 if (error < 0)

 938                         goto out_error;

 939         }

 940

 941         fsinfo.fattr = fattr;

 942         nfs_fattr_init(fattr);

 943         error =clp->rpc_ops->fsinfo(server, mntfh, &fsinfo);//通过远程过程调用获取服务器导出文件系统信息，其中包括所允许的读写粒度的相关信息。

 944         if (error < 0)

 945                 goto out_error;

 946

 947         nfs_server_set_fsinfo(server,&fsinfo);//协商决定最终的rsize和wsize

}

       其中nfs_server_set_fsinfo函数的部分代码如下：

869 staticvoid nfs_server_set_fsinfo(struct nfs_server *server, struct nfs_fsinfo*fsinfo)

 870 {

 871        unsigned long max_rpc_payload;

 872

 873        /* Work out a lot of parameters */

 874        if (server->rsize == 0)//如果用户没有对rsize进行设置

 875                 server->rsize =nfs_block_size(fsinfo->rtpref, NULL);//rtpref->（perfer.优先）读操作的传输粒度

 876        if (server->wsize == 0) 如果用户没有对wsize进行设置

 877                 server->wsize =nfs_block_size(fsinfo->wtpref, NULL);//wtpref->（perfer.优先）写操作的传输粒度

 878

 879        if (fsinfo->rtmax >= 512 && server->rsize >fsinfo->rtmax)//rtmax->最大读操作的传输粒度

 880                 server->rsize =nfs_block_size(fsinfo->rtmax, NULL);

 881        if (fsinfo->wtmax >= 512 && server->wsize >fsinfo->wtmax) //wtmax->最大读操作的传输粒度

 882                server->wsize =nfs_block_size(fsinfo->wtmax, NULL);

 883

 884        max_rpc_payload = nfs_block_size(rpc_max_payload(server->client),NULL); //Rpc_max_payload 对于传输协议tcp和udp来说不一样。1、对于tcp来说rpc_max_payload就是一个分片大小，#define RPC_MAX_FRAGMENT_SIZE ((1U << 31) -1)；2、对于udp来说rpc_max_payload是一个IP包减去IP、UDP、RPC头之后的大小，(1U <<16) - (MAX_HEADER << 3)。

 885        if (server->rsize > max_rpc_payload)

 886                 server->rsize =max_rpc_payload;

 887        if (server->rsize > NFS_MAX_FILE_IO_SIZE)// NFS_MAX_FILE_IO_SIZE（4U * 1048576U = 4MB）

 888                 server->rsize =NFS_MAX_FILE_IO_SIZE;

 889        server->rpages = (server->rsize + PAGE_CACHE_SIZE - 1) >>PAGE_CACHE_SHIFT;

 890

 891        server->backing_dev_info.name = "nfs";

 892        server->backing_dev_info.ra_pages = server->rpages *NFS_MAX_READAHEAD;

 893

 894        if (server->wsize > max_rpc_payload)

 895                 server->wsize =max_rpc_payload;

 896        if (server->wsize > NFS_MAX_FILE_IO_SIZE)

 897                 server->wsize =NFS_MAX_FILE_IO_SIZE;

}

（4）      服务器传递的参数

这里不过多阐述远程过程调用的问题，仅关注对于远程过程调用fsinfo，服务器给客户端传输了什么参数。首先看v3服务器端的处理函数nfsd3_proc_fsinfo。

545 nfsd3_proc_fsinfo(struct svc_rqst *rqstp, struct nfsd_fhandle    *argp,

546                                           struct nfsd3_fsinfores *resp)

547 {

548         __be32 nfserr;

549         u32    max_blocksize = svc_max_payload(rqstp);

550

551         dprintk("nfsd: FSINFO(3)   %s ",

552                                SVCFH_fmt(&argp->fh));

553

554         resp->f_rtmax  = max_blocksize;

555         resp->f_rtpref = max_blocksize;

556         resp->f_rtmult = PAGE_SIZE;

557         resp->f_wtmax  = max_blocksize;

558         resp->f_wtpref = max_blocksize;

559         resp->f_wtmult = PAGE_SIZE;

560         resp->f_dtpref = PAGE_SIZE;

    }

V4的代码中fsinfo通过getattr实现，通过服务器端的编码函数nfsd4_encode_fattr来看一下服务器给客户端传回了什么参数。

2146 __be32

2147 nfsd4_encode_fattr(struct svc_fh*fhp, struct svc_export *exp,

2148                 struct dentry *dentry, __be32*buffer, int *countp, u32 *bmval,

2149                 struct svc_rqst *rqstp, intignore_crossmnt)

{

2516         if (bmval0 & FATTR4_WORD0_MAXREAD){

2517                 if ((buflen -= 8) < 0)

2518                         goto out_resource;

2519                 WRITE64((u64)svc_max_payload(rqstp));//客户端解码出来的数值，将决定了客户端rtpref和rtmax的值，详细参见解码函数

2520         }

2521         if (bmval0 &FATTR4_WORD0_MAXWRITE) {

2522                 if ((buflen -= 8) < 0)

2523                         goto out_resource;

2524                 WRITE64((u64)svc_max_payload(rqstp)); //客户端解码出来的数值，将决定了客户端rtpref和rtmax的值，详细参见解码函数

   

    }

 既然参见了解码函数，那么把客户端解码函数相关部分代码也贴一贴吧。

    Decode_fsinfo{

 

4366         fsinfo->rtmult = fsinfo->wtmult= 512;  /* ??? */

4367

4368         if ((status = decode_attr_lease_time(xdr,bitmap, &fsinfo->lease_time)) != 0)

4369                 goto xdr_error;

4370         if ((status =decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)

4371                 goto xdr_error;

4372        if ((status =decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)

4373                 goto xdr_error;

4374         fsinfo->rtpref = fsinfo->dtpref =fsinfo->rtmax;

4375         if ((status =decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)

4376                 goto xdr_error;

4377         fsinfo->wtpref = fsinfo->wtmax;

   

    }

综上可以看出服务器端rtperf、rtmax、wtperf、wtmax，都是由函数svc_max_payload决定的，函数代码如下：

1299 u32 svc_max_payload(const structsvc_rqst *rqstp)

1300 {// xcl_max_payload 和sv_max_payload的较小者决定了函数的返回值，其中sv_max_payload是rpc服务所允许的最大传输粒度，也就是nfsd服务所允许的最大粒度。

1301         u32 max =rqstp->rq_xprt->xpt_class->xcl_max_payload;

1302

1303         if(rqstp->rq_server->sv_max_payload < max)

1304                 max =rqstp->rq_server->sv_max_payload;

1305         return max;

1306 }     

1307EXPORT_SYMBOL_GPL(svc_max_payload);

其中xcl_max_payload在tcp和udp当中的定义如下。

1212 static struct svc_xprt_classsvc_tcp_class = {

1213         .xcl_name = "tcp",

1214         .xcl_owner = THIS_MODULE,

1215         .xcl_ops = &svc_tcp_ops,

1216         .xcl_max_payload =RPCSVC_MAXPAYLOAD_TCP,//(1 *1024 *1024U) =1M

1217 };

 

685 static struct svc_xprt_classsvc_udp_class = {

 686        .xcl_name = "udp",

 687        .xcl_owner = THIS_MODULE,

 688        .xcl_ops = &svc_udp_ops,

 689        .xcl_max_payload = RPCSVC_MAXPAYLOAD_UDP,// (32*1024u) =32k

 690 };

（5）  Nfsd服务所允许的最大传输粒度

       Nfsd模块加载之后，用户就可以通过proc虚拟文件系统接口对nfsd服务所允许的最大传输粒度进行设置了，命令为echo xxxx > /proc/fs/nfsd/max_block_size ,这个虚拟接口在nfsd模块中影响到服务启动时的一个参数nfsd_max_blksize，这个参数最终会影响到Nfsd服务所允许的最大传输粒度。

       Nfsd服务启动函数的相关部分代码如下：

Nfsd_create_serv {

 

321         if (nfsd_max_blksize == 0) {//如果用户没有通过proc接口设置这个参数

322                 /* choose a suitable default*/

323                 struct sysinfo i;

324                 si_meminfo(&i);

325                 /* Aim for 1/4096 of memoryper thread

326                  * This gives 1MB on 4Gigmachines

327                  * But only uses 32K on 128Mmachines.

328                  * Bottom out at 8K on 32M andsmaller.

329                  * Of course, this is only adefault.

330                  */

331                 nfsd_max_blksize =NFSSVC_MAXBLKSIZE;// (1*1024*1024u) =1M

332                 i.totalram <<=PAGE_SHIFT - 12;//i.totalram是系统总共的内存大小，所以如果用户不加以设置，服务器系统的内存的大小也会影响到rsize/wsize

333                 while (nfsd_max_blksize >i.totalram &&

334                        nfsd_max_blksize >=8*1024*2)//最小是8k哦

335                         nfsd_max_blksize /= 2;

336         }

337

338         nfsd_serv =svc_create_pooled(&nfsd_program, nfsd_max_blksize,

339                                      nfsd_last_thread, nfsd, THIS_MODULE); //nfsd_max_blksize作为参数传给了服务创建函数

 

    }

 

435 struct svc_serv *

 436 svc_create_pooled(struct svc_program*prog, unsigned int bufsize,

 437                  void (*shutdown)(structsvc_serv *serv),

 438                   svc_thread_fn func, structmodule *mod)

 439 {//nfsd_max_blksize 被传递给了bufsize

 440        struct svc_serv *serv;

 441        unsigned int npools = svc_pool_map_get();

 442

 443        serv = __svc_create(prog, bufsize,npools, shutdown);

 444

 445        if (serv != NULL) {

 446                 serv->sv_function = func;

 447                 serv->sv_module = mod;

 448        }

 449

 450        return serv;

 451 }

 

360 static struct svc_serv *

 361 __svc_create(struct svc_program *prog,unsigned int bufsize, int npools,

 362              void (*shutdown)(struct svc_serv*serv))

 363 {

 364        struct svc_serv *serv;

 365        unsigned int vers;

 366        unsigned int xdrsize;

 367        unsigned int i;

 368

 369        if (!(serv = kzalloc(sizeof(*serv), GFP_KERNEL)))

 370                 return NULL;

 371        serv->sv_name      =prog->pg_name;

 372        serv->sv_program   = prog;

 373        serv->sv_nrthreads = 1;

 374        serv->sv_stats     =prog->pg_stats;

 375        if (bufsize > RPCSVC_MAXPAYLOAD)

 376                 bufsize = RPCSVC_MAXPAYLOAD;

 377        serv->sv_max_payload =bufsize? bufsize : 4096;

 378        serv->sv_max_mesg  = roundup(serv->sv_max_payload +PAGE_SIZE, PAGE_SIZE);

 379        serv->sv_shutdown  = shutdown;

 380        xdrsize = 0;

}

 

流程介绍结束，最后总结一下，rsize/wsize是由用户、系统网络状况、内存共同决定的，是不是呢？