NFS读写块大小分析

最新推荐文章于 2023-01-22 08:21:28 发布

zangjiaoshou

最新推荐文章于 2023-01-22 08:21:28 发布

阅读量604

点赞数

文章标签： linux java 多线程 redis nginx

本文链接：https://blog.csdn.net/zangjiaoshou/article/details/122063801

版权

Linux NFS 客户端在挂载服务器的 NFS 共享时可以使用 rsize 和 wsize 参数指定 NFS 读写的块大小，但实际使用时发现并不完全凑效，下面简单分析一下。

我先在一台 RHEL6 客户端上挂载另一台 RHEL6 服务器上的 NFS 共享：

[root @localhost ~] # mount -t nfs 192.168.1.122:/nfs/share /mnt/nfs

[root @localhost ~] # grep /mnt/nfs /proc/mounts

192.168.1.122: /nfs/share /mnt/nfs nfs rw,relatime,vers=3,rsize=262144,wsize=262144,namlen=255,hard,proto=tcp,timeo=600,retrans=2,sec=sys,mountaddr=192.168.1.122,mountvers=3,mountport=892,mountproto=udp,local_lock=none,addr=192.168.1.122 0 0

从上面可以看到不指定 rsize 和 wsize 参数时，默认的读写块大小都是 256KB（rsize=262144），而且使用的是 TCP 协议（proto=tcp）。

下面使用 UDP 协议挂载 NFS 共享：

[root @localhost ~] # mount -t nfs -o udp 192.168.1.122:/nfs/share /mnt/nfs

[root @localhost ~] # grep /mnt/nfs /proc/mounts

192.168.1.122: /nfs/share /mnt/nfs nfs rw,relatime,vers=3,rsize=32768,wsize=32768,namlen=255,hard,proto=udp,timeo=11,retrans=3,sec=sys,mountaddr=192.168.1.122,mountvers=3,mountport=892,mountproto=udp,local_lock=none,addr=192.168.1.122 0 0

从结果可以看出，使用 UDP 协议时块大小就只有 32KB 了。

准备在客户端这边修改 mount 参数将 NFS TCP 方式的读写块大小增加到 1MB：

[root @localhost ~] # mount -t nfs -o rsize=1048576,wsize=1048576 192.168.1.122:/nfs/share /mnt/nfs

[root@localhost ~] # grep /mnt/nfs /proc/mounts

但从上面的结果来看，实际使用的块大小还是 256KB。

在客户端这边修改 mount 参数将 NFS UDP 方式的读写块大小增加到 256KB：

[root@localhost ~] # mount -t nfs -o udp,rsize=262144,wsize=262144 192.168.1.122:/nfs/share /mnt/nfs

[root@localhost ~] # grep /mnt/nfs /proc/mounts

UDP 模式下读写的块大小也无法修改，客户端似乎已经使用了最大的读写块大小。

没办法，下面来看看 Linux kernel 源代码，找出真正的原因，先在 include/linux/nfs_xdr.h 文件中找到了 NFS I/O 块大小的定义：

include/linux/nfs_xdr.h

/*

* To change the maximum rsize and wsize supported by the NFS client, adjust

* NFS_MAX_FILE_IO_SIZE. 64KB is a typical maximum, but some servers can

* support a megabyte or more. The default is left at 4096 bytes, which is

* reasonable for NFS over UDP.

*/

#define NFS_MAX_FILE_IO_SIZE (1048576U)

#define NFS_DEF_FILE_IO_SIZE (4096U)

#define NFS_MIN_FILE_IO_SIZE (1024U)

这里可以看到 NFS 默认使用 4KB 块大小，客户端实际挂载时会做调整，最小 1KB，最大 1MB。

NFS 客户端在挂载时会与 NFS 服务器协商适合的读写块大小值，我们来看看 fs/nfs/client.c 文件中协商设置 NFS 文件系统信息的代码：

fs/nfs/client.c

static void nfs_server_set_fsinfo( struct nfs_server *server, struct nfs_fsinfo *fsinfo)

{

unsigned long max_rpc_payload;

/* Work out a lot of parameters */

if (server->rsize == 0)

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

if (server->wsize == 0)

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

if (fsinfo->rtmax >= 512 && server->rsize > fsinfo->rtmax)

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

if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)

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

max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);

if (server->rsize > max_rpc_payload)

server->rsize = max_rpc_payload;

if (server->rsize > NFS_MAX_FILE_IO_SIZE)

server->rsize = NFS_MAX_FILE_IO_SIZE;

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

server->backing_dev_info.name = "nfs" ;

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

if (server->wsize > max_rpc_payload)

server->wsize = max_rpc_payload;

if (server->wsize > NFS_MAX_FILE_IO_SIZE)

server->wsize = NFS_MAX_FILE_IO_SIZE;

/*......*/

}

从上面 nfs_server_set_fsinfo 函数的代码可以看到 NFS 客户端实际参考了服务器返回的 rtmax 和 wtmax 值，而这个值可以在挂载 NFS 文件系统时用抓包工具看到（NFS 使用的 RPC 协议）。

下面的图片中显示的就是 NFS 客户端中指定 rsize 和 wsize 参数为 1MB 时 Wireshark 上抓到的 NFS FSINFO 请求的实际数据；

挂载NFS的网络抓包

上面图片里小椭圆圈表示的是 NFS FSINFO 请求，大椭圆圈里就是服务器传过来的 rtmax 和 wtmax 值了，我们可以看到值就是 256KB。这样也就能解释了为什么客户端增大 NFS 读写块大小也不起作用了。

我们后台登陆到 NFS 服务器上，可以从 /proc/fs/nfsd/max_block_size 文件中看到当前 NFS 服务器的最大块大小，然后尝试修改它：

~ # cat /proc/fs/nfsd/max_block_size

262144

~ # echo 524288 > /proc/fs/nfsd/max_block_size

~ # cat /proc/fs/nfsd/max_block_size

262144

可以看到当前 NFS 服务器的最大读写块大小确实是 256KB，但是我们想修改它的值的时候，却似乎又修改不了。这样只能再看看修改 max_block_size 的 kernel 源代码了，对应的代码在 nfsd/nfsctl.c 文件中：

nfsd/nfsctl.c

static ssize_t write_maxblksize( struct file *file, char *buf, size_t size)

{

char *mesg = buf;

if (size > 0) {

int bsize;

int rv = get_int(&mesg, &bsize);

if (rv)

return rv;

/* force bsize into allowed range and

* required alignment.

*/

if (bsize < 1024)

bsize = 1024;

if (bsize > NFSSVC_MAXBLKSIZE)

bsize = NFSSVC_MAXBLKSIZE;

bsize &= ~(1024-1);

mutex_lock(&nfsd_mutex);

if (nfsd_serv && nfsd_serv->sv_nrthreads) {

mutex_unlock(&nfsd_mutex);

return -EBUSY;

}

nfsd_max_blksize = bsize;

mutex_unlock(&nfsd_mutex);

}

return scnprintf(buf, SIMPLE_TRANSACTION_LIMIT, "%d\n" ,

nfsd_max_blksize);

}

write_maxblksize 函数中判断了传入的参数，如果写入的值超过 NFSSVC_MAXBLKSIZE 值则固定为 NFSSVC_MAXBLKSIZE 值，那我们来看看 NFSSVC_MAXBLKSIZE 的定义：

linux/nfsd/const.h

/*

* Maximum blocksizes supported by daemon under various circumstances.

*/

#define NFSSVC_MAXBLKSIZE RPCSVC_MAXPAYLOAD

/* NFSv2 is limited by the protocol specification, see RFC 1094 */

#define NFSSVC_MAXBLKSIZE_V2 (8*1024)

linux/nfsd/const.h 中 NFSSVC_MAXBLKSIZE 定义为了 RPCSVC_MAXPAYLOAD 的值，那看看 linux/sunrpc/svc.h 中 RPCSVC_MAXPAYLOAD 的实际值：

linux/sunrpc/svc.h

/*

* Maximum payload size supported by a kernel RPC server.

* This is use to determine the max number of pages nfsd is

* willing to return in a single READ operation.

*

* These happen to all be powers of 2, which is not strictly

* necessary but helps enforce the real limitation, which is

* that they should be multiples of PAGE_CACHE_SIZE.

*

* For UDP transports, a block plus NFS,RPC, and UDP headers

* has to fit into the IP datagram limit of 64K. The largest

* feasible number for all known page sizes is probably 48K,

* but we choose 32K here. This is the same as the historical

* Linux limit; someone who cares more about NFS/UDP performance

* can test a larger number.

*

* For TCP transports we have more freedom. A size of 1MB is

* chosen to match the client limit. Other OSes are known to

* have larger limits, but those numbers are probably beyond

* the point of diminishing returns.

*/

#define RPCSVC_MAXPAYLOAD (1*1024*1024u)

#define RPCSVC_MAXPAYLOAD_TCP RPCSVC_MAXPAYLOAD

#define RPCSVC_MAXPAYLOAD_UDP (32*1024u)

从 linux/sunrpc/svc.h 中可以看到 NFS 读写块大小必须为 2 的幂，这样也大概知道读写块大小限制的原因了：

对于 UDP 来说，由于一个 UDP 包最大才 64KB，因此使用 UDP 协议的 NFS 读写块大小最大不超过 48KB，而 kernel 中则直接限制为 32KB 了；而使用 TCP 协议的 NFS 由于没有这个限制允许更大的读写块大小，但 Linux kernel 还是将其限制为 1MB 了。

至于 max_block_size 值不能直接修改的现象也找到原因了，在 nfsd/nfsctl.c 文件中高亮显示的第 18 行代码里判断了 NFS 服务器是否在启动运行，如果在运行则不允许修改。

下面就好办了，先卸载 NFS 共享的挂载，停止服务器的 NFS 服务，修改 max_block_size 值，然后重新启动 NFS 服务，

~ # service nfs stop

Shutting down NFS mountd: [ OK ]

Shutting down NFS daemon: [ OK ]

Shutting down NFS services: [ OK ]

~ # echo 1048576 > /proc/fs/nfsd/max_block_size

~ # cat /proc/fs/nfsd/max_block_size

1048576

~ # service nfs start

可以看到现在 NFS 的最大块大小可以修改了，接着在客户端中指定读写块大小并重新挂载 NFS 共享，这个时候客户端也能正确使用更大的块大小了：

[root@localhost fs] # mount -t nfs -o rsize=1048576,wsize=1048576 192.168.1.122:/nfs/share /mnt/nfs

[root@localhost fs] # grep /mnt/nfs /proc/mounts

192.168.1.122: /nfs/share /mnt/nfs nfs rw,relatime,vers=3,rsize=1048576,wsize=1048576,namlen=255,hard,proto=tcp,timeo=600,retrans=2,sec=sys,mountaddr=192.168.1.122,mountvers=3,mountport=892,mountproto=udp,local_lock=none,addr=192.168.1.122 0 0

如果要深究一下 NFS 服务器初始的最大块大小只有 256KB 的原因，可以看看 kernel 中 nfsd/nfssvc.c 文件中的代码：

nfsd/nfssvc.c