Handled review bugs/comments

AI scan (Pass 1):

• bnxt_ktls_init() enabled kTLS whenever the firmware's kTLS capability was set, without checking that MPC actually has a usable TCE ring (kTLS and MPC are gated on independent firmware capabilities, and bnxt_set_dflt_mpc_rings() can legitimately land on zero TCE rings even when the capability bit is set). The first TLS session would then hit bnxt_select_mpc_ring()'s % mpc_ring_count[TCE] with that count at 0. Require BNXT_MPC_CRYPTO_CAPABLE(softc) and a non-zero TCE ring count before enabling kTLS.
• bnxt_ktls_submit_mbuf() returned 0 (success) on the "no segments after len adjustment" path after already freeing the mbuf, unlike every other error path in the function. Its caller, bnxt_ktls_tx_replay(), treats 0 as "replay posted" and its own caller then skips rolling back the presync command already written to the ring, leaving it with no replay packet behind it. Return ENOSPC instead.
• bnxt_ktls_tx_replay() rewound m_data on r_mb->m_next, assuming that is always the TLS record mbuf. It isn't necessarily: the record is located elsewhere via bnxt_get_tls_record() walking the whole chain for the first M_EXTPG mbuf, and m_pullup() in bnxt_get_tcp_seq() can reshape the chain first. Use bnxt_get_tls_record() here too instead of assuming m_next.
• bnxt_free_ktls_rexmit_mbuf() dereferenced txr->replay_pkt[i] with no NULL check, even though bnxt_alloc_ktls_rexmit_mbuf() leaves replay_pkt NULL on its own allocation failure and callers only guard on if (ktls), not on a successful alloc for that specific ring; it also never NULLed replay_pkt after freeing it, so a second call (or the dangling pointer surviving past this call) would double free. Add both.
• bnxt_alloc_ktls_info() ignored bus_dma_tag_create() failure and left softc->ktls_info fully wired up with a NULL dma_tag anyway; bnxt_ktls_init()/bnxt_alloc_ktls_rexmit_mbuf() would then use it. Back out ktls_info entirely on that failure instead.
• bnxt_tls_snd_tag_alloc()'s failure path scrubbed nothing before returning kctx_tx to the zone, unlike the normal free path (bnxt_tls_tag_zfree()), even though bnxt_ktls_dev_add() may have already memcpy'd the AES-GCM session key into kctx_tx->crypto_info by the time some of those failures are hit (e.g. the unsupported snd_tag-type case). Scrub crypto_info there too.
• bnxt_pre_alloc_tx_crypto_keys() accumulated the *requested* batch_sz into its reported/looping key count, but bnxt_hwrm_key_ctx_alloc() can allocate fewer than requested (it clamps to max_key_ctxs_alloc, and overwrites the count entirely in partition_mode) - the true count is tracked separately in ktls->tck.total_alloc via bnxt_key_ctx_store(). Use that instead, both for the "did we get anything at all" check and the final reported total.
• bnxt_ktls_init() leaks the firmware key contexts bnxt_pre_alloc_tx_crypto_keys() already allocated if a later step (mpc_zone/taskqueue/zone creation) fails; each of those failure paths only cleaned up its own local resource. Call bnxt_clear_ktls() on those paths to at least drop the driver's own tracking of them. Note: this driver has no HWRM_FUNC_KEY_CTX_FREE call anywhere to release them on the firmware side (only the auto-generated struct definitions exist in hsi_struct_def.h) - that gap is pre-existing and is not fixed here.

Issues found during internal testing:

• Under a test creating 50K HW kTLS sessions and randomly killing/ restarting connections, dmesg showed intermittent "kTLS crypto add failed"/"kTLS crypto delete failed" with rc=16 (EBUSY), and not all 50K connections were created on every run.
• bnxt_xmit_crypto_cmd() sent EBUSY straight up to the caller the moment bnxt_start_xmit_mpc() found the MPC TX ring momentarily full, with no retry. Under heavy concurrent session churn (many crypto add/delete commands submitted back-to-back across a small set of MPC TCE rings) the ring can fill for a few microseconds before completions drain it; treating that as a hard failure aborted the corresponding kTLS session setup/teardown outright, explaining the missing connections. Retry with a short DELAY instead: this check runs strictly before anything is posted to the ring, so the condition is unambiguously transient. Bounded at 200 retries * 10us, counted in the new mpc_ring_busy error counter.
• Separately, bnxt_ktls_dev_del() only called bnxt_free_one_kctx() when bnxt_crypto_del() succeeded, silently leaking the KID forever on any failure (this predates the retry above, but the retry makes the remaining failures rarer, not impossible). Every failure return from bnxt_xmit_crypto_cmd() (ENOMEM on the mpc_zone ctx alloc, or EBUSY from the ring-space check) happens before anything reaches the ring, so a failed delete never has an in-flight, outcome- unknown command - it's always safe to free the KID regardless of rc. Under sustained churn this leak measurably shrank the available KID pool over a test run, compounding the "not all sessions created" symptom as fewer KIDs remained for new sessions.

AI scan (Pass 2):

• bnxt_ktls_mpc_cmp() unconditionally dereferenced and mutated ctx->kctx_tx (state, mpc_retry, start/end timing) on every completion, with nothing preventing that tag from having already been returned to the UMA zone (and possibly reallocated to a new session) by the time the completion arrived - both bnxt_tls_snd_tag_alloc()'s failure path (which freed the tag immediately after bnxt_ktls_dev_del() posted an async delete) and the normal bnxt_tls_snd_tag_free()/bnxt_tls_work() path (whose taskqueue defer does not actually wait for any in-flight MPC completion) could race a real completion against reuse of that memory. Add an mpc_inflight refcount to bnxt_ktls_offload_ctx_tx, taken in bnxt_xmit_crypto_cmd() before a command is posted and dropped in bnxt_ktls_mpc_cmp() once its completion is processed; the tag is now only actually freed (via bnxt_tls_tag_zfree()) once the count reaches zero, from whichever of the three sites - the alloc-failure path, bnxt_tls_work(), or the completion handler itself - observes that last.
• bnxt_ktls_submit_mbuf()'s segment-counting loop dropped the final DMA segment outright when it was longer than the remaining replay length, instead of including it with a clamped length; the resulting replay packet was silently shorter than the TLS record it was supposed to reproduce. Clamp segs[i].ds_len in place instead of breaking before counting it.
• bnxt_pre_alloc_tx_crypto_keys() decremented alloc_keys by the requested batch_sz even when bnxt_hwrm_key_ctx_alloc() granted fewer contexts than requested (rc == 0 doesn't mean the full batch was allocated - see max_key_ctxs_alloc clamping and partition mode, already noted above). Decrement by what tck.total_alloc actually grew by instead, and stop with a logged message if a call makes no progress at all.
• bnxt_ktls_dev_del()'s device-not-open retry loop busy-waited via DELAY(1000 * 100) for up to 2 seconds total across BNXT_RETRY_MAX attempts; it runs from bnxt_tls_snd_tag_free() in ordinary thread context with no locks held, so use pause() instead.
• bnxt_detach() waited on uma_zone_get_cur(ktls->zone) reaching zero with no bound, unlike the pending-counter wait right after it; a kTLS session that the stack never tears down (stuck connection, application bug) would hang detach/unload forever. Bound it to 30 seconds, matching the existing pending wait, and log if the bound is hit.
• bnxt_attach_post() freed ktls_info on bnxt_alloc_ktls_rexmit_mbuf() failure but not the counters bnxt_alloc_ktls_counters() had already allocated for it, leaking every counter_u64_t for the life of the attach. Free counters first (bnxt_free_ktls_info() NULLs softc->ktls_info, which would make a later bnxt_free_ktls_counters() call a no-op).
• ktls_counters[]'s "seq_fwd_tx_replay_pkts" sysctl entry used BNXT_KTLS_TX_SEQ_FWD (aliasing seq_fwd_tx_pkts) instead of BNXT_KTLS_TX_SEQ_FWD_REPLAY, hiding the latter counter entirely.
• bnxt_create_ktls_sysctls()'s error-counter loop indexed err_counters[i] by loop position instead of err_counters->id like the normal-counter loop just above it; harmless while the table happens to be enum-ordered, but fragile to reordering.
• bnxt_key_ctx_store()'s tck/rck macros were unscoped object-like #defines expanding to a raw array-subscript expression, risking silently mangling any unrelated local/member named tck or rck anywhere bnxt_ktls.h is included. Replaced with BNXT_TCK()/ BNXT_RCK() function-like macros.
• SET_TX_OPAQUE_KTLS's do { ... } while(0) had a trailing semicolon in the macro definition itself, producing a stray empty statement at every call site. Removed.
• Dropped a duplicate #include <sys/malloc.h>, and reordered bnxt_free_ktls_rexmit_mbuf()'s void inline to the conventional inline void.
• Documented in place, without changing behavior, three items where the reviewer's suggested direction risked being worse than the current code: (1) bnxt_key_ctx_store()'s per-key bnxt_kid_info allocation in the non-contiguous case is real memory/scan-overhead amplification versus the contiguous case, but bounded by kctx->max_ctx and not a leak - fixing it needs a second storage mode in struct bnxt_kid_info touching both bnxt_alloc_one_kctx()/bnxt_free_one_kctx(); (2) bnxt_ktls_submit_mbuf()'s TSO segment size for multi-segment replay packets under 9000 bytes is a DMA-cluster-size artifact rather than a real MSS, but the principled fix (the original mbuf's pi->ipi_tso_segsz) can legitimately be 0 for a small, never-TSO'd original packet that still defragmented into multiple segments here; and (3) the bnxt_xmit_crypto_cmd() ring-busy retry's DELAY() is bounded to 2ms with tx_lock already released, unlike bnxt_ktls_dev_del()'s hundred-millisecond retry loop above, so it doesn't need a sleepable primitive.
• Added a comment on bnxt_ktls_tx_ooo()'s offset = (uintptr_t)m->m_data clarifying that m_data is not a pointer here: for M_EXTPG TLS record mbufs the stack repurposes it as a byte offset into the logical record (tcp_output.c's tcp_m_copym(), cxgbe's kTLS driver via mtod(m_tls, vm_offset_t)) - flagged by review as a suspected bug, verified correct against both call sites.

Fix several use-after-free/leak/crash paths found by review: set
kctx_tx->ktls before any early return can free it, tear down the
ktls_stats/mpc_cmp_time_stats sysctls before the memory they point
into, reset partition_mode and add a reset generation so a firmware
reset can't leave a stale KID in use or a NULL partition bitmap
dereferenced, defer KID reuse until the delete MPC completion actually
confirms it instead of racing a new ADD against it, wait unbounded
(not 30s) for live send tags before detach destroys their zone, and
preserve the connection's real TSO MSS for replay packets instead of
a fixed 9000 or a DMA-fragment-size guess. Also trim several inline
comments down to the essential fact.

Fix further issues from an another review pass: retry a busy
sysctl_ctx_free() instead of freeing kTLS state out from under live
sysctl nodes, close a use-after-free between bnxt_tls_work() and the
MPC completion handler, drop a dead if_snd_tag_alloc_params local, fix
an mpc_cmp_time sysctl indexed by loop position instead of counter id,
and a few widths/dead-code/comment cleanups.