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.16-2' of git://git.linux-nfs.org/projects/anna/linux-nfs

Pull NFS client fixes from Anna Schumaker:

- Fix loop in GSS sequence number cache

- Clean up /proc/net/rpc/nfs if nfs_fs_proc_net_init() fails

- Fix a race to wake on NFS_LAYOUT_DRAIN

- Fix handling of NFS level errors in I/O

* tag 'nfs-for-6.16-2' of git://git.linux-nfs.org/projects/anna/linux-nfs:
NFSv4/flexfiles: Fix handling of NFS level errors in I/O
NFSv4/pNFS: Fix a race to wake on NFS_LAYOUT_DRAIN
nfs: Clean up /proc/net/rpc/nfs when nfs_fs_proc_net_init() fails.
sunrpc: fix loop in gss seqno cache

Linus Torvalds ce95858a 66701750

+102 -39
+84 -34
fs/nfs/flexfilelayout/flexfilelayout.c
··· 1105 1105 } 1106 1106 1107 1107 static int ff_layout_async_handle_error_v4(struct rpc_task *task, 1108 + u32 op_status, 1108 1109 struct nfs4_state *state, 1109 1110 struct nfs_client *clp, 1110 1111 struct pnfs_layout_segment *lseg, ··· 1116 1115 struct nfs4_deviceid_node *devid = FF_LAYOUT_DEVID_NODE(lseg, idx); 1117 1116 struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table; 1118 1117 1119 - switch (task->tk_status) { 1120 - case -NFS4ERR_BADSESSION: 1121 - case -NFS4ERR_BADSLOT: 1122 - case -NFS4ERR_BAD_HIGH_SLOT: 1123 - case -NFS4ERR_DEADSESSION: 1124 - case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1125 - case -NFS4ERR_SEQ_FALSE_RETRY: 1126 - case -NFS4ERR_SEQ_MISORDERED: 1118 + switch (op_status) { 1119 + case NFS4_OK: 1120 + case NFS4ERR_NXIO: 1121 + break; 1122 + case NFSERR_PERM: 1123 + if (!task->tk_xprt) 1124 + break; 1125 + xprt_force_disconnect(task->tk_xprt); 1126 + goto out_retry; 1127 + case NFS4ERR_BADSESSION: 1128 + case NFS4ERR_BADSLOT: 1129 + case NFS4ERR_BAD_HIGH_SLOT: 1130 + case NFS4ERR_DEADSESSION: 1131 + case NFS4ERR_CONN_NOT_BOUND_TO_SESSION: 1132 + case NFS4ERR_SEQ_FALSE_RETRY: 1133 + case NFS4ERR_SEQ_MISORDERED: 1127 1134 dprintk("%s ERROR %d, Reset session. Exchangeid " 1128 1135 "flags 0x%x\n", __func__, task->tk_status, 1129 1136 clp->cl_exchange_flags); 1130 1137 nfs4_schedule_session_recovery(clp->cl_session, task->tk_status); 1131 - break; 1132 - case -NFS4ERR_DELAY: 1138 + goto out_retry; 1139 + case NFS4ERR_DELAY: 1133 1140 nfs_inc_stats(lseg->pls_layout->plh_inode, NFSIOS_DELAY); 1134 1141 fallthrough; 1135 - case -NFS4ERR_GRACE: 1142 + case NFS4ERR_GRACE: 1136 1143 rpc_delay(task, FF_LAYOUT_POLL_RETRY_MAX); 1137 - break; 1138 - case -NFS4ERR_RETRY_UNCACHED_REP: 1139 - break; 1144 + goto out_retry; 1145 + case NFS4ERR_RETRY_UNCACHED_REP: 1146 + goto out_retry; 1140 1147 /* Invalidate Layout errors */ 1141 - case -NFS4ERR_PNFS_NO_LAYOUT: 1142 - case -ESTALE: /* mapped NFS4ERR_STALE */ 1143 - case -EBADHANDLE: /* mapped NFS4ERR_BADHANDLE */ 1144 - case -EISDIR: /* mapped NFS4ERR_ISDIR */ 1145 - case -NFS4ERR_FHEXPIRED: 1146 - case -NFS4ERR_WRONG_TYPE: 1148 + case NFS4ERR_PNFS_NO_LAYOUT: 1149 + case NFS4ERR_STALE: 1150 + case NFS4ERR_BADHANDLE: 1151 + case NFS4ERR_ISDIR: 1152 + case NFS4ERR_FHEXPIRED: 1153 + case NFS4ERR_WRONG_TYPE: 1147 1154 dprintk("%s Invalid layout error %d\n", __func__, 1148 1155 task->tk_status); 1149 1156 /* ··· 1164 1155 pnfs_destroy_layout(NFS_I(inode)); 1165 1156 rpc_wake_up(&tbl->slot_tbl_waitq); 1166 1157 goto reset; 1158 + default: 1159 + break; 1160 + } 1161 + 1162 + switch (task->tk_status) { 1167 1163 /* RPC connection errors */ 1168 1164 case -ENETDOWN: 1169 1165 case -ENETUNREACH: ··· 1188 1174 nfs4_delete_deviceid(devid->ld, devid->nfs_client, 1189 1175 &devid->deviceid); 1190 1176 rpc_wake_up(&tbl->slot_tbl_waitq); 1191 - fallthrough; 1177 + break; 1192 1178 default: 1193 - if (ff_layout_avoid_mds_available_ds(lseg)) 1194 - return -NFS4ERR_RESET_TO_PNFS; 1195 - reset: 1196 - dprintk("%s Retry through MDS. Error %d\n", __func__, 1197 - task->tk_status); 1198 - return -NFS4ERR_RESET_TO_MDS; 1179 + break; 1199 1180 } 1181 + 1182 + if (ff_layout_avoid_mds_available_ds(lseg)) 1183 + return -NFS4ERR_RESET_TO_PNFS; 1184 + reset: 1185 + dprintk("%s Retry through MDS. Error %d\n", __func__, 1186 + task->tk_status); 1187 + return -NFS4ERR_RESET_TO_MDS; 1188 + 1189 + out_retry: 1200 1190 task->tk_status = 0; 1201 1191 return -EAGAIN; 1202 1192 } 1203 1193 1204 1194 /* Retry all errors through either pNFS or MDS except for -EJUKEBOX */ 1205 1195 static int ff_layout_async_handle_error_v3(struct rpc_task *task, 1196 + u32 op_status, 1206 1197 struct nfs_client *clp, 1207 1198 struct pnfs_layout_segment *lseg, 1208 1199 u32 idx) 1209 1200 { 1210 1201 struct nfs4_deviceid_node *devid = FF_LAYOUT_DEVID_NODE(lseg, idx); 1202 + 1203 + switch (op_status) { 1204 + case NFS_OK: 1205 + case NFSERR_NXIO: 1206 + break; 1207 + case NFSERR_PERM: 1208 + if (!task->tk_xprt) 1209 + break; 1210 + xprt_force_disconnect(task->tk_xprt); 1211 + goto out_retry; 1212 + case NFSERR_ACCES: 1213 + case NFSERR_BADHANDLE: 1214 + case NFSERR_FBIG: 1215 + case NFSERR_IO: 1216 + case NFSERR_NOSPC: 1217 + case NFSERR_ROFS: 1218 + case NFSERR_STALE: 1219 + goto out_reset_to_pnfs; 1220 + case NFSERR_JUKEBOX: 1221 + nfs_inc_stats(lseg->pls_layout->plh_inode, NFSIOS_DELAY); 1222 + goto out_retry; 1223 + default: 1224 + break; 1225 + } 1211 1226 1212 1227 switch (task->tk_status) { 1213 1228 /* File access problems. Don't mark the device as unavailable */ ··· 1261 1218 nfs4_delete_deviceid(devid->ld, devid->nfs_client, 1262 1219 &devid->deviceid); 1263 1220 } 1221 + out_reset_to_pnfs: 1264 1222 /* FIXME: Need to prevent infinite looping here. */ 1265 1223 return -NFS4ERR_RESET_TO_PNFS; 1266 1224 out_retry: ··· 1272 1228 } 1273 1229 1274 1230 static int ff_layout_async_handle_error(struct rpc_task *task, 1231 + u32 op_status, 1275 1232 struct nfs4_state *state, 1276 1233 struct nfs_client *clp, 1277 1234 struct pnfs_layout_segment *lseg, ··· 1291 1246 1292 1247 switch (vers) { 1293 1248 case 3: 1294 - return ff_layout_async_handle_error_v3(task, clp, lseg, idx); 1295 - case 4: 1296 - return ff_layout_async_handle_error_v4(task, state, clp, 1249 + return ff_layout_async_handle_error_v3(task, op_status, clp, 1297 1250 lseg, idx); 1251 + case 4: 1252 + return ff_layout_async_handle_error_v4(task, op_status, state, 1253 + clp, lseg, idx); 1298 1254 default: 1299 1255 /* should never happen */ 1300 1256 WARN_ON_ONCE(1); ··· 1348 1302 switch (status) { 1349 1303 case NFS4ERR_DELAY: 1350 1304 case NFS4ERR_GRACE: 1305 + case NFS4ERR_PERM: 1351 1306 break; 1352 1307 case NFS4ERR_NXIO: 1353 1308 ff_layout_mark_ds_unreachable(lseg, idx); ··· 1381 1334 trace_ff_layout_read_error(hdr, task->tk_status); 1382 1335 } 1383 1336 1384 - err = ff_layout_async_handle_error(task, hdr->args.context->state, 1337 + err = ff_layout_async_handle_error(task, hdr->res.op_status, 1338 + hdr->args.context->state, 1385 1339 hdr->ds_clp, hdr->lseg, 1386 1340 hdr->pgio_mirror_idx); 1387 1341 ··· 1555 1507 trace_ff_layout_write_error(hdr, task->tk_status); 1556 1508 } 1557 1509 1558 - err = ff_layout_async_handle_error(task, hdr->args.context->state, 1510 + err = ff_layout_async_handle_error(task, hdr->res.op_status, 1511 + hdr->args.context->state, 1559 1512 hdr->ds_clp, hdr->lseg, 1560 1513 hdr->pgio_mirror_idx); 1561 1514 ··· 1605 1556 trace_ff_layout_commit_error(data, task->tk_status); 1606 1557 } 1607 1558 1608 - err = ff_layout_async_handle_error(task, NULL, data->ds_clp, 1609 - data->lseg, data->ds_commit_index); 1559 + err = ff_layout_async_handle_error(task, data->res.op_status, 1560 + NULL, data->ds_clp, data->lseg, 1561 + data->ds_commit_index); 1610 1562 1611 1563 trace_nfs4_pnfs_commit_ds(data, err); 1612 1564 switch (err) {
+14 -3
fs/nfs/inode.c
··· 2589 2589 static int nfs_net_init(struct net *net) 2590 2590 { 2591 2591 struct nfs_net *nn = net_generic(net, nfs_net_id); 2592 + int err; 2592 2593 2593 2594 nfs_clients_init(net); 2594 2595 2595 2596 if (!rpc_proc_register(net, &nn->rpcstats)) { 2596 - nfs_clients_exit(net); 2597 - return -ENOMEM; 2597 + err = -ENOMEM; 2598 + goto err_proc_rpc; 2598 2599 } 2599 2600 2600 - return nfs_fs_proc_net_init(net); 2601 + err = nfs_fs_proc_net_init(net); 2602 + if (err) 2603 + goto err_proc_nfs; 2604 + 2605 + return 0; 2606 + 2607 + err_proc_nfs: 2608 + rpc_proc_unregister(net, "nfs"); 2609 + err_proc_rpc: 2610 + nfs_clients_exit(net); 2611 + return err; 2601 2612 } 2602 2613 2603 2614 static void nfs_net_exit(struct net *net)
+3 -1
fs/nfs/pnfs.c
··· 2059 2059 static void nfs_layoutget_end(struct pnfs_layout_hdr *lo) 2060 2060 { 2061 2061 if (atomic_dec_and_test(&lo->plh_outstanding) && 2062 - test_and_clear_bit(NFS_LAYOUT_DRAIN, &lo->plh_flags)) 2062 + test_and_clear_bit(NFS_LAYOUT_DRAIN, &lo->plh_flags)) { 2063 + smp_mb__after_atomic(); 2063 2064 wake_up_bit(&lo->plh_flags, NFS_LAYOUT_DRAIN); 2065 + } 2064 2066 } 2065 2067 2066 2068 static bool pnfs_is_first_layoutget(struct pnfs_layout_hdr *lo)
+1 -1
net/sunrpc/auth_gss/auth_gss.c
··· 1724 1724 maj_stat = gss_validate_seqno_mic(ctx, task->tk_rqstp->rq_seqnos[0], seq, p, len); 1725 1725 /* RFC 2203 5.3.3.1 - compute the checksum of each sequence number in the cache */ 1726 1726 while (unlikely(maj_stat == GSS_S_BAD_SIG && i < task->tk_rqstp->rq_seqno_count)) 1727 - maj_stat = gss_validate_seqno_mic(ctx, task->tk_rqstp->rq_seqnos[i], seq, p, len); 1727 + maj_stat = gss_validate_seqno_mic(ctx, task->tk_rqstp->rq_seqnos[i++], seq, p, len); 1728 1728 if (maj_stat == GSS_S_CONTEXT_EXPIRED) 1729 1729 clear_bit(RPCAUTH_CRED_UPTODATE, &cred->cr_flags); 1730 1730 if (maj_stat)