tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'nfs-for-6.9-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs

Pull NFS client updates from Trond Myklebust:
"Highlights include:

Bugfixes:
- Fix for an Oops in the NFSv4.2 listxattr handler
- Correct an incorrect buffer size in listxattr
- Fix for an Oops in the pNFS flexfiles layout
- Fix a refcount leak in NFS O_DIRECT writes
- Fix missing locking in NFS O_DIRECT
- Avoid an infinite loop in pnfs_update_layout
- Fix an overflow in the RPC waitqueue queue length counter
- Ensure that pNFS I/O is also protected by TLS when xprtsec is
specified by the mount options
- Fix a leaked folio lock in the netfs read code
- Fix a potential deadlock in fscache
- Allow setting the fscache uniquifier in NFSv4
- Fix an off by one in root_nfs_cat()
- Fix another off by one in rpc_sockaddr2uaddr()
- nfs4_do_open() can incorrectly trigger state recovery
- Various fixes for connection shutdown

Features and cleanups:
- Ensure that containers only see their own RPC and NFS stats
- Enable nconnect for RDMA
- Remove dead code from nfs_writepage_locked()
- Various tracepoint additions to track EXCHANGE_ID, GETDEVICEINFO,
and mount options"

* tag 'nfs-for-6.9-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (29 commits)
nfs: fix panic when nfs4_ff_layout_prepare_ds() fails
NFS: trace the uniquifier of fscache
NFS: Read unlock folio on nfs_page_create_from_folio() error
NFS: remove unused variable nfs_rpcstat
nfs: fix UAF in direct writes
nfs: properly protect nfs_direct_req fields
NFS: enable nconnect for RDMA
NFSv4: nfs4_do_open() is incorrectly triggering state recovery
NFS: avoid infinite loop in pnfs_update_layout.
NFS: remove sync_mode test from nfs_writepage_locked()
NFSv4.1/pnfs: fix NFS with TLS in pnfs
NFS: Fix an off by one in root_nfs_cat()
nfs: make the rpc_stat per net namespace
nfs: expose /proc/net/sunrpc/nfs in net namespaces
sunrpc: add a struct rpc_stats arg to rpc_create_args
nfs: remove unused NFS_CALL macro
NFSv4.1: add tracepoint to trunked nfs4_exchange_id calls
NFS: Fix nfs_netfs_issue_read() xarray locking for writeback interrupt
SUNRPC: increase size of rpc_wait_queue.qlen from unsigned short to unsigned int
nfs: fix regression in handling of fsc= option in NFSv4
...

Linus Torvalds c1f10ac8 90a498f2

+258 -71
+4 -5
fs/nfs/client.c
··· 73 73 .number = NFS_PROGRAM, 74 74 .nrvers = ARRAY_SIZE(nfs_version), 75 75 .version = nfs_version, 76 - .stats = &nfs_rpcstat, 77 76 .pipe_dir_name = NFS_PIPE_DIRNAME, 78 - }; 79 - 80 - struct rpc_stat nfs_rpcstat = { 81 - .program = &nfs_program 82 77 }; 83 78 84 79 static struct nfs_subversion *find_nfs_version(unsigned int version) ··· 497 502 const struct nfs_client_initdata *cl_init, 498 503 rpc_authflavor_t flavor) 499 504 { 505 + struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id); 500 506 struct rpc_clnt *clnt = NULL; 501 507 struct rpc_create_args args = { 502 508 .net = clp->cl_net, ··· 509 513 .servername = clp->cl_hostname, 510 514 .nodename = cl_init->nodename, 511 515 .program = &nfs_program, 516 + .stats = &nn->rpcstats, 512 517 .version = clp->rpc_ops->version, 513 518 .authflavor = flavor, 514 519 .cred = cl_init->cred, ··· 1179 1182 #endif 1180 1183 spin_lock_init(&nn->nfs_client_lock); 1181 1184 nn->boot_time = ktime_get_real(); 1185 + memset(&nn->rpcstats, 0, sizeof(nn->rpcstats)); 1186 + nn->rpcstats.program = &nfs_program; 1182 1187 1183 1188 nfs_netns_sysfs_setup(nn, net); 1184 1189 }
-4
fs/nfs/delegation.c
··· 181 181 struct nfs_open_context *ctx; 182 182 struct nfs4_state_owner *sp; 183 183 struct nfs4_state *state; 184 - unsigned int seq; 185 184 int err; 186 185 187 186 again: ··· 201 202 sp = state->owner; 202 203 /* Block nfs4_proc_unlck */ 203 204 mutex_lock(&sp->so_delegreturn_mutex); 204 - seq = raw_seqcount_begin(&sp->so_reclaim_seqcount); 205 205 err = nfs4_open_delegation_recall(ctx, state, stateid); 206 206 if (!err) 207 207 err = nfs_delegation_claim_locks(state, stateid); 208 - if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) 209 - err = -EAGAIN; 210 208 mutex_unlock(&sp->so_delegreturn_mutex); 211 209 put_nfs_open_context(ctx); 212 210 if (err != 0)
+15 -3
fs/nfs/direct.c
··· 606 606 607 607 trace_nfs_direct_commit_complete(dreq); 608 608 609 + spin_lock(&dreq->lock); 609 610 if (status < 0) { 610 611 /* Errors in commit are fatal */ 611 612 dreq->error = status; ··· 614 613 } else { 615 614 status = dreq->error; 616 615 } 616 + spin_unlock(&dreq->lock); 617 617 618 618 nfs_init_cinfo_from_dreq(&cinfo, dreq); 619 619 ··· 627 625 spin_unlock(&dreq->lock); 628 626 nfs_release_request(req); 629 627 } else if (!nfs_write_match_verf(verf, req)) { 630 - dreq->flags = NFS_ODIRECT_RESCHED_WRITES; 628 + spin_lock(&dreq->lock); 629 + if (dreq->flags == 0) 630 + dreq->flags = NFS_ODIRECT_RESCHED_WRITES; 631 + spin_unlock(&dreq->lock); 631 632 /* 632 633 * Despite the reboot, the write was successful, 633 634 * so reset wb_nio. ··· 672 667 LIST_HEAD(mds_list); 673 668 674 669 nfs_init_cinfo_from_dreq(&cinfo, dreq); 670 + nfs_commit_begin(cinfo.mds); 675 671 nfs_scan_commit(dreq->inode, &mds_list, &cinfo); 676 672 res = nfs_generic_commit_list(dreq->inode, &mds_list, 0, &cinfo); 677 - if (res < 0) /* res == -ENOMEM */ 678 - nfs_direct_write_reschedule(dreq); 673 + if (res < 0) { /* res == -ENOMEM */ 674 + spin_lock(&dreq->lock); 675 + if (dreq->flags == 0) 676 + dreq->flags = NFS_ODIRECT_RESCHED_WRITES; 677 + spin_unlock(&dreq->lock); 678 + } 679 + if (nfs_commit_end(cinfo.mds)) 680 + nfs_direct_write_complete(dreq); 679 681 } 680 682 681 683 static void nfs_direct_write_clear_reqs(struct nfs_direct_req *dreq)
+2
fs/nfs/filelayout/filelayoutdev.c
··· 35 35 #include "../internal.h" 36 36 #include "../nfs4session.h" 37 37 #include "filelayout.h" 38 + #include "../nfs4trace.h" 38 39 39 40 #define NFSDBG_FACILITY NFSDBG_PNFS_LD 40 41 ··· 173 172 dsaddr->ds_list[i] = nfs4_pnfs_ds_add(&dsaddrs, gfp_flags); 174 173 if (!dsaddr->ds_list[i]) 175 174 goto out_err_drain_dsaddrs; 175 + trace_fl_getdevinfo(server, &pdev->dev_id, dsaddr->ds_list[i]->ds_remotestr); 176 176 177 177 /* If DS was already in cache, free ds addrs */ 178 178 while (!list_empty(&dsaddrs)) {
+1 -1
fs/nfs/flexfilelayout/flexfilelayout.c
··· 2016 2016 for (idx = 0; idx < flseg->mirror_array_cnt; idx++) { 2017 2017 mirror = flseg->mirror_array[idx]; 2018 2018 mirror_ds = mirror->mirror_ds; 2019 - if (!mirror_ds) 2019 + if (IS_ERR_OR_NULL(mirror_ds)) 2020 2020 continue; 2021 2021 ds = mirror->mirror_ds->ds; 2022 2022 if (!ds)
+1
fs/nfs/fs_context.c
··· 652 652 ctx->fscache_uniq = NULL; 653 653 break; 654 654 case Opt_fscache: 655 + trace_nfs_mount_assign(param->key, param->string); 655 656 ctx->options |= NFS_OPTION_FSCACHE; 656 657 kfree(ctx->fscache_uniq); 657 658 ctx->fscache_uniq = param->string;
+2 -7
fs/nfs/fscache.c
··· 301 301 struct inode *inode = sreq->rreq->inode; 302 302 struct nfs_open_context *ctx = sreq->rreq->netfs_priv; 303 303 struct page *page; 304 + unsigned long idx; 304 305 int err; 305 306 pgoff_t start = (sreq->start + sreq->transferred) >> PAGE_SHIFT; 306 307 pgoff_t last = ((sreq->start + sreq->len - 307 308 sreq->transferred - 1) >> PAGE_SHIFT); 308 - XA_STATE(xas, &sreq->rreq->mapping->i_pages, start); 309 309 310 310 nfs_pageio_init_read(&pgio, inode, false, 311 311 &nfs_async_read_completion_ops); ··· 316 316 317 317 pgio.pg_netfs = netfs; /* used in completion */ 318 318 319 - xas_lock(&xas); 320 - xas_for_each(&xas, page, last) { 319 + xa_for_each_range(&sreq->rreq->mapping->i_pages, idx, page, start, last) { 321 320 /* nfs_read_add_folio() may schedule() due to pNFS layout and other RPCs */ 322 - xas_pause(&xas); 323 - xas_unlock(&xas); 324 321 err = nfs_read_add_folio(&pgio, ctx, page_folio(page)); 325 322 if (err < 0) { 326 323 netfs->error = err; 327 324 goto out; 328 325 } 329 - xas_lock(&xas); 330 326 } 331 - xas_unlock(&xas); 332 327 out: 333 328 nfs_pageio_complete_read(&pgio); 334 329 nfs_netfs_put(netfs);
+4 -4
fs/nfs/inode.c
··· 2426 2426 2427 2427 static int nfs_net_init(struct net *net) 2428 2428 { 2429 + struct nfs_net *nn = net_generic(net, nfs_net_id); 2430 + 2429 2431 nfs_clients_init(net); 2432 + rpc_proc_register(net, &nn->rpcstats); 2430 2433 return nfs_fs_proc_net_init(net); 2431 2434 } 2432 2435 2433 2436 static void nfs_net_exit(struct net *net) 2434 2437 { 2438 + rpc_proc_unregister(net, "nfs"); 2435 2439 nfs_fs_proc_net_exit(net); 2436 2440 nfs_clients_exit(net); 2437 2441 } ··· 2490 2486 if (err) 2491 2487 goto out1; 2492 2488 2493 - rpc_proc_register(&init_net, &nfs_rpcstat); 2494 - 2495 2489 err = register_nfs_fs(); 2496 2490 if (err) 2497 2491 goto out0; 2498 2492 2499 2493 return 0; 2500 2494 out0: 2501 - rpc_proc_unregister(&init_net, "nfs"); 2502 2495 nfs_destroy_directcache(); 2503 2496 out1: 2504 2497 nfs_destroy_writepagecache(); ··· 2525 2524 nfs_destroy_inodecache(); 2526 2525 nfs_destroy_nfspagecache(); 2527 2526 unregister_pernet_subsys(&nfs_net_ops); 2528 - rpc_proc_unregister(&init_net, "nfs"); 2529 2527 unregister_nfs_fs(); 2530 2528 nfs_fs_proc_exit(); 2531 2529 nfsiod_stop();
-2
fs/nfs/internal.h
··· 449 449 int nfs_get_tree_common(struct fs_context *); 450 450 void nfs_kill_super(struct super_block *); 451 451 452 - extern struct rpc_stat nfs_rpcstat; 453 - 454 452 extern int __init register_nfs_fs(void); 455 453 extern void __exit unregister_nfs_fs(void); 456 454 extern bool nfs_sb_active(struct super_block *sb);
+2
fs/nfs/netns.h
··· 9 9 #include <linux/nfs4.h> 10 10 #include <net/net_namespace.h> 11 11 #include <net/netns/generic.h> 12 + #include <linux/sunrpc/stats.h> 12 13 13 14 struct bl_dev_msg { 14 15 int32_t status; ··· 35 34 struct nfs_netns_client *nfs_client; 36 35 spinlock_t nfs_client_lock; 37 36 ktime_t boot_time; 37 + struct rpc_stat rpcstats; 38 38 #ifdef CONFIG_PROC_FS 39 39 struct proc_dir_entry *proc_nfsfs; 40 40 #endif
+1
fs/nfs/nfs3client.c
··· 111 111 cl_init.hostname = buf; 112 112 113 113 switch (ds_proto) { 114 + case XPRT_TRANSPORT_RDMA: 114 115 case XPRT_TRANSPORT_TCP: 115 116 case XPRT_TRANSPORT_TCP_TLS: 116 117 if (mds_clp->cl_nconnect > 1)
+5 -2
fs/nfs/nfs42.h
··· 55 55 * They would be 7 bytes long in the eventual buffer ("user.x\0"), and 56 56 * 8 bytes long XDR-encoded. 57 57 * 58 - * Include the trailing eof word as well. 58 + * Include the trailing eof word as well and make the result a multiple 59 + * of 4 bytes. 59 60 */ 60 61 static inline u32 nfs42_listxattr_xdrsize(u32 buflen) 61 62 { 62 - return ((buflen / (XATTR_USER_PREFIX_LEN + 2)) * 8) + 4; 63 + u32 size = 8 * buflen / (XATTR_USER_PREFIX_LEN + 2) + 4; 64 + 65 + return (size + 3) & ~3; 63 66 } 64 67 #endif /* CONFIG_NFS_V4_2 */ 65 68 #endif /* __LINUX_FS_NFS_NFS4_2_H */
-1
fs/nfs/nfs4_fs.h
··· 120 120 unsigned long so_flags; 121 121 struct list_head so_states; 122 122 struct nfs_seqid_counter so_seqid; 123 - seqcount_spinlock_t so_reclaim_seqcount; 124 123 struct mutex so_delegreturn_mutex; 125 124 }; 126 125
+2
fs/nfs/nfs4client.c
··· 924 924 else 925 925 cl_init.max_connect = max_connect; 926 926 switch (proto) { 927 + case XPRT_TRANSPORT_RDMA: 927 928 case XPRT_TRANSPORT_TCP: 928 929 case XPRT_TRANSPORT_TCP_TLS: 929 930 cl_init.nconnect = nconnect; ··· 1001 1000 cl_init.hostname = buf; 1002 1001 1003 1002 switch (ds_proto) { 1003 + case XPRT_TRANSPORT_RDMA: 1004 1004 case XPRT_TRANSPORT_TCP: 1005 1005 case XPRT_TRANSPORT_TCP_TLS: 1006 1006 if (mds_clp->cl_nconnect > 1) {
+15 -14
fs/nfs/nfs4proc.c
··· 3069 3069 fmode_t acc_mode = _nfs4_ctx_to_accessmode(ctx); 3070 3070 struct inode *dir = d_inode(opendata->dir); 3071 3071 unsigned long dir_verifier; 3072 - unsigned int seq; 3073 3072 int ret; 3074 3073 3075 - seq = raw_seqcount_begin(&sp->so_reclaim_seqcount); 3076 3074 dir_verifier = nfs_save_change_attribute(dir); 3077 3075 3078 3076 ret = _nfs4_proc_open(opendata, ctx); ··· 3123 3125 if (ret != 0) 3124 3126 goto out; 3125 3127 3126 - if (d_inode(dentry) == state->inode) { 3128 + if (d_inode(dentry) == state->inode) 3127 3129 nfs_inode_attach_open_context(ctx); 3128 - if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) 3129 - nfs4_schedule_stateid_recovery(server, state); 3130 - } 3131 3130 3132 3131 out: 3133 3132 if (!opendata->cancelled) { ··· 8968 8973 return; 8969 8974 8970 8975 status = task->tk_status; 8971 - if (status == 0) 8976 + if (status == 0) { 8972 8977 status = nfs4_detect_session_trunking(adata->clp, 8973 8978 task->tk_msg.rpc_resp, xprt); 8974 - 8979 + trace_nfs4_trunked_exchange_id(adata->clp, 8980 + xprt->address_strings[RPC_DISPLAY_ADDR], status); 8981 + } 8975 8982 if (status == 0) 8976 8983 rpc_clnt_xprt_switch_add_xprt(clnt, xprt); 8977 8984 else if (status != -NFS4ERR_DELAY && rpc_clnt_xprt_switch_has_addr(clnt, ··· 10615 10618 static ssize_t nfs4_listxattr(struct dentry *dentry, char *list, size_t size) 10616 10619 { 10617 10620 ssize_t error, error2, error3; 10621 + size_t left = size; 10618 10622 10619 - error = generic_listxattr(dentry, list, size); 10623 + error = generic_listxattr(dentry, list, left); 10620 10624 if (error < 0) 10621 10625 return error; 10622 10626 if (list) { 10623 10627 list += error; 10624 - size -= error; 10628 + left -= error; 10625 10629 } 10626 10630 10627 - error2 = nfs4_listxattr_nfs4_label(d_inode(dentry), list, size); 10631 + error2 = nfs4_listxattr_nfs4_label(d_inode(dentry), list, left); 10628 10632 if (error2 < 0) 10629 10633 return error2; 10630 10634 10631 10635 if (list) { 10632 10636 list += error2; 10633 - size -= error2; 10637 + left -= error2; 10634 10638 } 10635 10639 10636 - error3 = nfs4_listxattr_nfs4_user(d_inode(dentry), list, size); 10640 + error3 = nfs4_listxattr_nfs4_user(d_inode(dentry), list, left); 10637 10641 if (error3 < 0) 10638 10642 return error3; 10639 10643 10640 - return error + error2 + error3; 10644 + error += error2 + error3; 10645 + if (size && error > size) 10646 + return -ERANGE; 10647 + return error; 10641 10648 } 10642 10649 10643 10650 static void nfs4_enable_swap(struct inode *inode)
+7 -5
fs/nfs/nfs4state.c
··· 513 513 nfs4_init_seqid_counter(&sp->so_seqid); 514 514 atomic_set(&sp->so_count, 1); 515 515 INIT_LIST_HEAD(&sp->so_lru); 516 - seqcount_spinlock_init(&sp->so_reclaim_seqcount, &sp->so_lock); 517 516 mutex_init(&sp->so_delegreturn_mutex); 518 517 return sp; 519 518 } ··· 1666 1667 * server that doesn't support a grace period. 1667 1668 */ 1668 1669 spin_lock(&sp->so_lock); 1669 - raw_write_seqcount_begin(&sp->so_reclaim_seqcount); 1670 1670 restart: 1671 1671 list_for_each_entry(state, &sp->so_states, open_states) { 1672 1672 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags)) ··· 1733 1735 spin_lock(&sp->so_lock); 1734 1736 goto restart; 1735 1737 } 1736 - raw_write_seqcount_end(&sp->so_reclaim_seqcount); 1737 1738 spin_unlock(&sp->so_lock); 1738 1739 #ifdef CONFIG_NFS_V4_2 1739 1740 if (found_ssc_copy_state) ··· 1742 1745 out_err: 1743 1746 nfs4_put_open_state(state); 1744 1747 spin_lock(&sp->so_lock); 1745 - raw_write_seqcount_end(&sp->so_reclaim_seqcount); 1746 1748 spin_unlock(&sp->so_lock); 1747 1749 return status; 1748 1750 } ··· 1924 1928 struct nfs_server *server; 1925 1929 struct rb_node *pos; 1926 1930 LIST_HEAD(freeme); 1927 - int status = 0; 1928 1931 int lost_locks = 0; 1932 + int status; 1929 1933 1934 + status = nfs4_begin_drain_session(clp); 1935 + if (status < 0) 1936 + return status; 1930 1937 restart: 1931 1938 rcu_read_lock(); 1932 1939 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) { ··· 2693 2694 /* Detect expired delegations... */ 2694 2695 if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) { 2695 2696 section = "detect expired delegations"; 2697 + status = nfs4_begin_drain_session(clp); 2698 + if (status < 0) 2699 + goto out_error; 2696 2700 nfs_reap_expired_delegations(clp); 2697 2701 continue; 2698 2702 }
+24
fs/nfs/nfs4super.c
··· 145 145 const char *export_path) 146 146 { 147 147 struct nfs_fs_context *root_ctx; 148 + struct nfs_fs_context *ctx; 148 149 struct fs_context *root_fc; 149 150 struct vfsmount *root_mnt; 150 151 struct dentry *dentry; ··· 154 153 155 154 struct fs_parameter param = { 156 155 .key = "source", 156 + .type = fs_value_is_string, 157 + .dirfd = -1, 158 + }; 159 + 160 + struct fs_parameter param_fsc = { 161 + .key = "fsc", 157 162 .type = fs_value_is_string, 158 163 .dirfd = -1, 159 164 }; ··· 175 168 kfree(root_fc->source); 176 169 root_fc->source = NULL; 177 170 171 + ctx = nfs_fc2context(fc); 178 172 root_ctx = nfs_fc2context(root_fc); 179 173 root_ctx->internal = true; 180 174 root_ctx->server = server; 175 + 176 + if (ctx->fscache_uniq) { 177 + len = strlen(ctx->fscache_uniq); 178 + param_fsc.size = len; 179 + param_fsc.string = kmemdup_nul(ctx->fscache_uniq, len, GFP_KERNEL); 180 + if (param_fsc.string == NULL) { 181 + put_fs_context(root_fc); 182 + return -ENOMEM; 183 + } 184 + ret = vfs_parse_fs_param(root_fc, &param_fsc); 185 + kfree(param_fsc.string); 186 + if (ret < 0) { 187 + put_fs_context(root_fc); 188 + return ret; 189 + } 190 + } 181 191 /* We leave export_path unset as it's not used to find the root. */ 182 192 183 193 len = strlen(hostname) + 5;
+2
fs/nfs/nfs4trace.c
··· 28 28 EXPORT_TRACEPOINT_SYMBOL_GPL(ff_layout_read_error); 29 29 EXPORT_TRACEPOINT_SYMBOL_GPL(ff_layout_write_error); 30 30 EXPORT_TRACEPOINT_SYMBOL_GPL(ff_layout_commit_error); 31 + 32 + EXPORT_TRACEPOINT_SYMBOL_GPL(fl_getdevinfo); 31 33 #endif
+58
fs/nfs/nfs4trace.h
··· 77 77 DEFINE_NFS4_CLIENTID_EVENT(nfs4_sequence); 78 78 DEFINE_NFS4_CLIENTID_EVENT(nfs4_reclaim_complete); 79 79 80 + TRACE_EVENT(nfs4_trunked_exchange_id, 81 + TP_PROTO( 82 + const struct nfs_client *clp, 83 + const char *addr, 84 + int error 85 + ), 86 + 87 + TP_ARGS(clp, addr, error), 88 + 89 + TP_STRUCT__entry( 90 + __string(main_addr, clp->cl_hostname) 91 + __string(trunk_addr, addr) 92 + __field(unsigned long, error) 93 + ), 94 + 95 + TP_fast_assign( 96 + __entry->error = error < 0 ? -error : 0; 97 + __assign_str(main_addr, clp->cl_hostname); 98 + __assign_str(trunk_addr, addr); 99 + ), 100 + 101 + TP_printk( 102 + "error=%ld (%s) main_addr=%s trunk_addr=%s", 103 + -__entry->error, 104 + show_nfs4_status(__entry->error), 105 + __get_str(main_addr), 106 + __get_str(trunk_addr) 107 + ) 108 + ); 109 + 80 110 TRACE_EVENT(nfs4_sequence_done, 81 111 TP_PROTO( 82 112 const struct nfs4_session *session, ··· 2020 1990 TP_ARGS(server, deviceid, status)) 2021 1991 DEFINE_PNFS_DEVICEID_STATUS(nfs4_getdeviceinfo); 2022 1992 DEFINE_PNFS_DEVICEID_STATUS(nfs4_find_deviceid); 1993 + 1994 + TRACE_EVENT(fl_getdevinfo, 1995 + TP_PROTO( 1996 + const struct nfs_server *server, 1997 + const struct nfs4_deviceid *deviceid, 1998 + char *ds_remotestr 1999 + ), 2000 + TP_ARGS(server, deviceid, ds_remotestr), 2001 + 2002 + TP_STRUCT__entry( 2003 + __string(mds_addr, server->nfs_client->cl_hostname) 2004 + __array(unsigned char, deviceid, NFS4_DEVICEID4_SIZE) 2005 + __string(ds_ips, ds_remotestr) 2006 + ), 2007 + 2008 + TP_fast_assign( 2009 + __assign_str(mds_addr, server->nfs_client->cl_hostname); 2010 + __assign_str(ds_ips, ds_remotestr); 2011 + memcpy(__entry->deviceid, deviceid->data, 2012 + NFS4_DEVICEID4_SIZE); 2013 + ), 2014 + TP_printk( 2015 + "deviceid=%s, mds_addr=%s, ds_ips=%s", 2016 + __print_hex(__entry->deviceid, NFS4_DEVICEID4_SIZE), 2017 + __get_str(mds_addr), 2018 + __get_str(ds_ips) 2019 + ) 2020 + ); 2023 2021 2024 2022 DECLARE_EVENT_CLASS(nfs4_flexfiles_io_event, 2025 2023 TP_PROTO(
+2 -2
fs/nfs/nfsroot.c
··· 175 175 size_t len = strlen(dest); 176 176 177 177 if (len && dest[len - 1] != ',') 178 - if (strlcat(dest, ",", destlen) > destlen) 178 + if (strlcat(dest, ",", destlen) >= destlen) 179 179 return -1; 180 180 181 - if (strlcat(dest, src, destlen) > destlen) 181 + if (strlcat(dest, src, destlen) >= destlen) 182 182 return -1; 183 183 return 0; 184 184 }
+8
fs/nfs/pnfs.c
··· 1999 1999 } 2000 2000 2001 2001 lookup_again: 2002 + if (!nfs4_valid_open_stateid(ctx->state)) { 2003 + trace_pnfs_update_layout(ino, pos, count, 2004 + iomode, lo, lseg, 2005 + PNFS_UPDATE_LAYOUT_INVALID_OPEN); 2006 + lseg = ERR_PTR(-EIO); 2007 + goto out; 2008 + } 2009 + 2002 2010 lseg = ERR_PTR(nfs4_client_recover_expired_lease(clp)); 2003 2011 if (IS_ERR(lseg)) 2004 2012 goto out;
+43 -1
fs/nfs/pnfs_nfs.c
··· 919 919 dprintk("--> %s DS %s\n", __func__, ds->ds_remotestr); 920 920 921 921 list_for_each_entry(da, &ds->ds_addrs, da_node) { 922 + char servername[48]; 923 + 922 924 dprintk("%s: DS %s: trying address %s\n", 923 925 __func__, ds->ds_remotestr, da->da_remotestr); 924 926 ··· 931 929 .dstaddr = (struct sockaddr *)&da->da_addr, 932 930 .addrlen = da->da_addrlen, 933 931 .servername = clp->cl_hostname, 932 + .xprtsec = clp->cl_xprtsec, 934 933 }; 935 934 struct nfs4_add_xprt_data xprtdata = { 936 935 .clp = clp, ··· 941 938 .data = &xprtdata, 942 939 }; 943 940 944 - if (da->da_transport != clp->cl_proto) 941 + if (da->da_transport != clp->cl_proto && 942 + clp->cl_proto != XPRT_TRANSPORT_TCP_TLS) 945 943 continue; 944 + if (da->da_transport == XPRT_TRANSPORT_TCP && 945 + mds_srv->nfs_client->cl_proto == 946 + XPRT_TRANSPORT_TCP_TLS) { 947 + struct sockaddr *addr = 948 + (struct sockaddr *)&da->da_addr; 949 + struct sockaddr_in *sin = 950 + (struct sockaddr_in *)&da->da_addr; 951 + struct sockaddr_in6 *sin6 = 952 + (struct sockaddr_in6 *)&da->da_addr; 953 + 954 + /* for NFS with TLS we need to supply a correct 955 + * servername of the trunked transport, not the 956 + * servername of the main transport stored in 957 + * clp->cl_hostname. And set the protocol to 958 + * indicate to use TLS 959 + */ 960 + servername[0] = '\0'; 961 + switch(addr->sa_family) { 962 + case AF_INET: 963 + snprintf(servername, sizeof(servername), 964 + "%pI4", &sin->sin_addr.s_addr); 965 + break; 966 + case AF_INET6: 967 + snprintf(servername, sizeof(servername), 968 + "%pI6", &sin6->sin6_addr); 969 + break; 970 + default: 971 + /* do not consider this address */ 972 + continue; 973 + } 974 + xprt_args.ident = XPRT_TRANSPORT_TCP_TLS; 975 + xprt_args.servername = servername; 976 + } 946 977 if (da->da_addr.ss_family != clp->cl_addr.ss_family) 947 978 continue; 979 + 948 980 /** 949 981 * Test this address for session trunking and 950 982 * add as an alias ··· 991 953 if (xprtdata.cred) 992 954 put_cred(xprtdata.cred); 993 955 } else { 956 + if (da->da_transport == XPRT_TRANSPORT_TCP && 957 + mds_srv->nfs_client->cl_proto == 958 + XPRT_TRANSPORT_TCP_TLS) 959 + da->da_transport = XPRT_TRANSPORT_TCP_TLS; 994 960 clp = nfs4_set_ds_client(mds_srv, 995 961 &da->da_addr, 996 962 da->da_addrlen,
+2
fs/nfs/read.c
··· 305 305 new = nfs_page_create_from_folio(ctx, folio, 0, aligned_len); 306 306 if (IS_ERR(new)) { 307 307 error = PTR_ERR(new); 308 + if (nfs_netfs_folio_unlock(folio)) 309 + folio_unlock(folio); 308 310 goto out; 309 311 } 310 312
+9 -1
fs/nfs/super.c
··· 516 516 else 517 517 nfs_show_nfsv4_options(m, nfss, showdefaults); 518 518 519 - if (nfss->options & NFS_OPTION_FSCACHE) 519 + if (nfss->options & NFS_OPTION_FSCACHE) { 520 + #ifdef CONFIG_NFS_FSCACHE 521 + if (nfss->fscache_uniq) 522 + seq_printf(m, ",fsc=%s", nfss->fscache_uniq); 523 + else 524 + seq_puts(m, ",fsc"); 525 + #else 520 526 seq_puts(m, ",fsc"); 527 + #endif 528 + } 521 529 522 530 if (nfss->options & NFS_OPTION_MIGRATION) 523 531 seq_puts(m, ",migration");
+1 -5
fs/nfs/write.c
··· 667 667 struct inode *inode = folio_file_mapping(folio)->host; 668 668 int err; 669 669 670 - if (wbc->sync_mode == WB_SYNC_NONE && 671 - NFS_SERVER(inode)->write_congested) 672 - return AOP_WRITEPAGE_ACTIVATE; 673 - 674 670 nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE); 675 671 nfs_pageio_init_write(&pgio, inode, 0, false, 676 672 &nfs_async_write_completion_ops); ··· 1646 1650 !atomic_read(&cinfo->rpcs_out)); 1647 1651 } 1648 1652 1649 - static void nfs_commit_begin(struct nfs_mds_commit_info *cinfo) 1653 + void nfs_commit_begin(struct nfs_mds_commit_info *cinfo) 1650 1654 { 1651 1655 atomic_inc(&cinfo->rpcs_out); 1652 1656 }
+1
include/linux/nfs_fs.h
··· 611 611 extern int nfs_commit_inode(struct inode *, int); 612 612 extern struct nfs_commit_data *nfs_commitdata_alloc(void); 613 613 extern void nfs_commit_free(struct nfs_commit_data *data); 614 + void nfs_commit_begin(struct nfs_mds_commit_info *cinfo); 614 615 bool nfs_commit_end(struct nfs_mds_commit_info *cinfo); 615 616 616 617 static inline bool nfs_have_writebacks(const struct inode *inode)
-7
include/linux/nfs_xdr.h
··· 1821 1821 }; 1822 1822 1823 1823 /* 1824 - * NFS_CALL(getattr, inode, (fattr)); 1825 - * into 1826 - * NFS_PROTO(inode)->getattr(fattr); 1827 - */ 1828 - #define NFS_CALL(op, inode, args) NFS_PROTO(inode)->op args 1829 - 1830 - /* 1831 1824 * Function vectors etc. for the NFS client 1832 1825 */ 1833 1826 extern const struct nfs_rpc_ops nfs_v2_clientops;
+1
include/linux/sunrpc/clnt.h
··· 139 139 const char *servername; 140 140 const char *nodename; 141 141 const struct rpc_program *program; 142 + struct rpc_stat *stats; 142 143 u32 prognumber; /* overrides program->number */ 143 144 u32 version; 144 145 rpc_authflavor_t authflavor;
+1 -1
include/linux/sunrpc/sched.h
··· 197 197 unsigned char maxpriority; /* maximum priority (0 if queue is not a priority queue) */ 198 198 unsigned char priority; /* current priority */ 199 199 unsigned char nr; /* # tasks remaining for cookie */ 200 - unsigned short qlen; /* total # tasks waiting in queue */ 200 + unsigned int qlen; /* total # tasks waiting in queue */ 201 201 struct rpc_timer timer_list; 202 202 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG) || IS_ENABLED(CONFIG_TRACEPOINTS) 203 203 const char * name;
+1
include/linux/sunrpc/xprt.h
··· 152 152 int (*prepare_request)(struct rpc_rqst *req, 153 153 struct xdr_buf *buf); 154 154 int (*send_request)(struct rpc_rqst *req); 155 + void (*abort_send_request)(struct rpc_rqst *req); 155 156 void (*wait_for_reply_request)(struct rpc_task *task); 156 157 void (*timer)(struct rpc_xprt *xprt, struct rpc_task *task); 157 158 void (*release_request)(struct rpc_task *task);
+6 -2
include/trace/events/sunrpc.h
··· 639 639 __field(unsigned long, backlog) 640 640 __field(unsigned long, rtt) 641 641 __field(unsigned long, execute) 642 + __field(u32, xprt_id) 642 643 ), 643 644 644 645 TP_fast_assign( ··· 652 651 __entry->backlog = ktime_to_us(backlog); 653 652 __entry->rtt = ktime_to_us(rtt); 654 653 __entry->execute = ktime_to_us(execute); 654 + __entry->xprt_id = task->tk_xprt->id; 655 655 ), 656 656 657 657 TP_printk(SUNRPC_TRACE_TASK_SPECIFIER 658 - " xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu", 658 + " xid=0x%08x %sv%d %s backlog=%lu rtt=%lu execute=%lu" 659 + " xprt_id=%d", 659 660 __entry->task_id, __entry->client_id, __entry->xid, 660 661 __get_str(progname), __entry->version, __get_str(procname), 661 - __entry->backlog, __entry->rtt, __entry->execute) 662 + __entry->backlog, __entry->rtt, __entry->execute, 663 + __entry->xprt_id) 662 664 ); 663 665 664 666 TRACE_EVENT(rpc_xdr_overflow,
+1
include/trace/misc/nfs.h
··· 239 239 { EHOSTDOWN, "EHOSTDOWN" }, \ 240 240 { EPIPE, "EPIPE" }, \ 241 241 { EPFNOSUPPORT, "EPFNOSUPPORT" }, \ 242 + { EINVAL, "EINVAL" }, \ 242 243 { EPROTONOSUPPORT, "EPROTONOSUPPORT" }, \ 243 244 { NFS4ERR_ACCESS, "ACCESS" }, \ 244 245 { NFS4ERR_ATTRNOTSUPP, "ATTRNOTSUPP" }, \
+2 -2
net/sunrpc/addr.c
··· 284 284 } 285 285 286 286 if (snprintf(portbuf, sizeof(portbuf), 287 - ".%u.%u", port >> 8, port & 0xff) > (int)sizeof(portbuf)) 287 + ".%u.%u", port >> 8, port & 0xff) >= (int)sizeof(portbuf)) 288 288 return NULL; 289 289 290 - if (strlcat(addrbuf, portbuf, sizeof(addrbuf)) > sizeof(addrbuf)) 290 + if (strlcat(addrbuf, portbuf, sizeof(addrbuf)) >= sizeof(addrbuf)) 291 291 return NULL; 292 292 293 293 return kstrdup(addrbuf, gfp_flags);
+4 -1
net/sunrpc/clnt.c
··· 405 405 clnt->cl_maxproc = version->nrprocs; 406 406 clnt->cl_prog = args->prognumber ? : program->number; 407 407 clnt->cl_vers = version->number; 408 - clnt->cl_stats = program->stats; 408 + clnt->cl_stats = args->stats ? : program->stats; 409 409 clnt->cl_metrics = rpc_alloc_iostats(clnt); 410 410 rpc_init_pipe_dir_head(&clnt->cl_pipedir_objects); 411 411 err = -ENOMEM; ··· 691 691 .version = clnt->cl_vers, 692 692 .authflavor = clnt->cl_auth->au_flavor, 693 693 .cred = clnt->cl_cred, 694 + .stats = clnt->cl_stats, 694 695 }; 695 696 return __rpc_clone_client(&args, clnt); 696 697 } ··· 714 713 .version = clnt->cl_vers, 715 714 .authflavor = flavor, 716 715 .cred = clnt->cl_cred, 716 + .stats = clnt->cl_stats, 717 717 }; 718 718 return __rpc_clone_client(&args, clnt); 719 719 } ··· 1070 1068 .version = vers, 1071 1069 .authflavor = old->cl_auth->au_flavor, 1072 1070 .cred = old->cl_cred, 1071 + .stats = old->cl_stats, 1073 1072 }; 1074 1073 struct rpc_clnt *clnt; 1075 1074 int err;
+9
net/sunrpc/xprt.c
··· 1398 1398 if (!test_and_clear_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) 1399 1399 return; 1400 1400 if (!list_empty(&req->rq_xmit)) { 1401 + struct rpc_xprt *xprt = req->rq_xprt; 1402 + 1403 + if (list_is_first(&req->rq_xmit, &xprt->xmit_queue) && 1404 + xprt->ops->abort_send_request) 1405 + xprt->ops->abort_send_request(req); 1406 + 1401 1407 list_del(&req->rq_xmit); 1402 1408 if (!list_empty(&req->rq_xmit2)) { 1403 1409 struct rpc_rqst *next = list_first_entry(&req->rq_xmit2, ··· 1546 1540 unsigned int connect_cookie; 1547 1541 int is_retrans = RPC_WAS_SENT(task); 1548 1542 int status; 1543 + 1544 + if (test_bit(XPRT_CLOSE_WAIT, &xprt->state)) 1545 + return -ENOTCONN; 1549 1546 1550 1547 if (!req->rq_bytes_sent) { 1551 1548 if (xprt_request_data_received(task)) {
+22 -1
net/sunrpc/xprtsock.c
··· 62 62 #include "sunrpc.h" 63 63 64 64 static void xs_close(struct rpc_xprt *xprt); 65 + static void xs_reset_srcport(struct sock_xprt *transport); 65 66 static void xs_set_srcport(struct sock_xprt *transport, struct socket *sock); 66 67 static void xs_tcp_set_socket_timeouts(struct rpc_xprt *xprt, 67 68 struct socket *sock); ··· 884 883 return xdr_alloc_bvec(buf, rpc_task_gfp_mask()); 885 884 } 886 885 886 + static void xs_stream_abort_send_request(struct rpc_rqst *req) 887 + { 888 + struct rpc_xprt *xprt = req->rq_xprt; 889 + struct sock_xprt *transport = 890 + container_of(xprt, struct sock_xprt, xprt); 891 + 892 + if (transport->xmit.offset != 0 && 893 + !test_bit(XPRT_CLOSE_WAIT, &xprt->state)) 894 + xprt_force_disconnect(xprt); 895 + } 896 + 887 897 /* 888 898 * Determine if the previous message in the stream was aborted before it 889 899 * could complete transmission. ··· 1577 1565 break; 1578 1566 case TCP_CLOSE: 1579 1567 if (test_and_clear_bit(XPRT_SOCK_CONNECTING, 1580 - &transport->sock_state)) 1568 + &transport->sock_state)) { 1569 + xs_reset_srcport(transport); 1581 1570 xprt_clear_connecting(xprt); 1571 + } 1582 1572 clear_bit(XPRT_CLOSING, &xprt->state); 1583 1573 /* Trigger the socket release */ 1584 1574 xs_run_error_worker(transport, XPRT_SOCK_WAKE_DISCONNECT); ··· 1734 1720 1735 1721 rpc_set_port(xs_addr(xprt), port); 1736 1722 xs_update_peer_port(xprt); 1723 + } 1724 + 1725 + static void xs_reset_srcport(struct sock_xprt *transport) 1726 + { 1727 + transport->srcport = 0; 1737 1728 } 1738 1729 1739 1730 static void xs_set_srcport(struct sock_xprt *transport, struct socket *sock) ··· 3031 3012 .buf_free = rpc_free, 3032 3013 .prepare_request = xs_stream_prepare_request, 3033 3014 .send_request = xs_local_send_request, 3015 + .abort_send_request = xs_stream_abort_send_request, 3034 3016 .wait_for_reply_request = xprt_wait_for_reply_request_def, 3035 3017 .close = xs_close, 3036 3018 .destroy = xs_destroy, ··· 3079 3059 .buf_free = rpc_free, 3080 3060 .prepare_request = xs_stream_prepare_request, 3081 3061 .send_request = xs_tcp_send_request, 3062 + .abort_send_request = xs_stream_abort_send_request, 3082 3063 .wait_for_reply_request = xprt_wait_for_reply_request_def, 3083 3064 .close = xs_tcp_shutdown, 3084 3065 .destroy = xs_destroy,