#include <uapi/linux/lnet/lnet-dlc.h>
#include <uapi/linux/lnet/lnetctl.h>
+#include <uapi/linux/lnet/nidstr.h>
/* Max payload size */
#define LNET_MAX_PAYLOAD LNET_MTU
-#define LNET_MAX_IOV (LNET_MAX_PAYLOAD >> PAGE_SHIFT)
+/** limit on the number of fragments in discontiguous MDs */
+#define LNET_MAX_IOV 256
/*
* This is the maximum health value.
LNET_MSG_STATUS_REMOTE_ERROR,
LNET_MSG_STATUS_REMOTE_DROPPED,
LNET_MSG_STATUS_REMOTE_TIMEOUT,
- LNET_MSG_STATUS_NETWORK_TIMEOUT
+ LNET_MSG_STATUS_NETWORK_TIMEOUT,
+ LNET_MSG_STATUS_END,
+};
+
+struct lnet_rsp_tracker {
+ /* chain on the waiting list */
+ struct list_head rspt_on_list;
+ /* cpt to lock */
+ int rspt_cpt;
+ /* nid of next hop */
+ lnet_nid_t rspt_next_hop_nid;
+ /* deadline of the REPLY/ACK */
+ ktime_t rspt_deadline;
+ /* parent MD */
+ struct lnet_handle_md rspt_mdh;
};
struct lnet_msg {
enum lnet_msg_hstatus msg_health_status;
/* This is a recovery message */
bool msg_recovery;
+ /* the number of times a transmission has been retried */
+ int msg_retry_count;
/* flag to indicate that we do not want to resend this message */
bool msg_no_resend;
unsigned int msg_wanted;
unsigned int msg_offset;
unsigned int msg_niov;
- struct kvec *msg_iov;
- lnet_kiov_t *msg_kiov;
+ struct bio_vec *msg_kiov;
struct lnet_event msg_ev;
struct lnet_hdr msg_hdr;
#define lh_entry(ptr, type, member) \
((type *)((char *)(ptr)-(char *)(&((type *)0)->member)))
-struct lnet_eq {
- struct list_head eq_list;
- struct lnet_libhandle eq_lh;
- unsigned long eq_enq_seq;
- unsigned long eq_deq_seq;
- unsigned int eq_size;
- lnet_eq_handler_t eq_callback;
- struct lnet_event *eq_events;
- int **eq_refs; /* percpt refcount for EQ */
-};
-
struct lnet_me {
struct list_head me_list;
- struct lnet_libhandle me_lh;
+ int me_cpt;
struct lnet_process_id me_match_id;
unsigned int me_portal;
unsigned int me_pos; /* hash offset in mt_hash */
};
struct lnet_libmd {
- struct list_head md_list;
- struct lnet_libhandle md_lh;
- struct lnet_me *md_me;
- char *md_start;
- unsigned int md_offset;
- unsigned int md_length;
- unsigned int md_max_size;
- int md_threshold;
- int md_refcount;
- unsigned int md_options;
- unsigned int md_flags;
- unsigned int md_niov; /* # frags at end of struct */
- void *md_user_ptr;
- struct lnet_eq *md_eq;
- struct lnet_handle_md md_bulk_handle;
- union {
- struct kvec iov[LNET_MAX_IOV];
- lnet_kiov_t kiov[LNET_MAX_IOV];
- } md_iov;
+ struct list_head md_list;
+ struct lnet_libhandle md_lh;
+ struct lnet_me *md_me;
+ char *md_start;
+ unsigned int md_offset;
+ unsigned int md_length;
+ unsigned int md_max_size;
+ int md_threshold;
+ int md_refcount;
+ unsigned int md_options;
+ unsigned int md_flags;
+ unsigned int md_niov; /* # frags at end of struct */
+ void *md_user_ptr;
+ struct lnet_rsp_tracker *md_rspt_ptr;
+ lnet_handler_t md_handler;
+ struct lnet_handle_md md_bulk_handle;
+ struct bio_vec md_kiov[LNET_MAX_IOV];
};
-#define LNET_MD_FLAG_ZOMBIE (1 << 0)
-#define LNET_MD_FLAG_AUTO_UNLINK (1 << 1)
-#define LNET_MD_FLAG_ABORTED (1 << 2)
+#define LNET_MD_FLAG_ZOMBIE BIT(0)
+#define LNET_MD_FLAG_AUTO_UNLINK BIT(1)
+#define LNET_MD_FLAG_ABORTED BIT(2)
struct lnet_test_peer {
/* info about peers we are trying to fail */
struct socket;
struct lnet_lnd {
- /* fields managed by portals */
- struct list_head lnd_list; /* stash in the LND table */
- int lnd_refcount; /* # active instances */
-
/* fields initialized by the LND */
__u32 lnd_type;
int (*lnd_ctl)(struct lnet_ni *ni, unsigned int cmd, void *arg);
/* In data movement APIs below, payload buffers are described as a set
- * of 'niov' fragments which are...
- * EITHER
- * in virtual memory (struct kvec *iov != NULL)
- * OR
- * in pages (kernel only: plt_kiov_t *kiov != NULL).
+ * of 'niov' fragments which are in pages.
* The LND may NOT overwrite these fragment descriptors.
* An 'offset' and may specify a byte offset within the set of
* fragments to start from
* credit if the LND does flow control. */
int (*lnd_recv)(struct lnet_ni *ni, void *private, struct lnet_msg *msg,
int delayed, unsigned int niov,
- struct kvec *iov, lnet_kiov_t *kiov,
+ struct bio_vec *kiov,
unsigned int offset, unsigned int mlen, unsigned int rlen);
/* lnet_parse() has had to delay processing of this message
int (*lnd_eager_recv)(struct lnet_ni *ni, void *private,
struct lnet_msg *msg, void **new_privatep);
- /* notification of peer health */
- void (*lnd_notify)(struct lnet_ni *ni, lnet_nid_t peer, int alive);
-
- /* query of peer aliveness */
- void (*lnd_query)(struct lnet_ni *ni, lnet_nid_t peer, time64_t *when);
+ /* notification of peer down */
+ void (*lnd_notify_peer_down)(lnet_nid_t peer);
/* accept a new connection */
int (*lnd_accept)(struct lnet_ni *ni, struct socket *sock);
LNET_NET_STATE_DELETING
};
-#define LNET_NI_STATE_INIT (1 << 0)
-#define LNET_NI_STATE_ACTIVE (1 << 1)
-#define LNET_NI_STATE_FAILED (1 << 2)
-#define LNET_NI_STATE_RECOVERY_PENDING (1 << 3)
-#define LNET_NI_STATE_DELETING (1 << 4)
+enum lnet_ni_state {
+ /* initial state when NI is created */
+ LNET_NI_STATE_INIT = 0,
+ /* set when NI is brought up */
+ LNET_NI_STATE_ACTIVE,
+ /* set when NI is being shutdown */
+ LNET_NI_STATE_DELETING,
+};
+
+#define LNET_NI_RECOVERY_PENDING BIT(0)
+#define LNET_NI_RECOVERY_FAILED BIT(1)
enum lnet_stats_type {
LNET_STATS_TYPE_SEND = 0,
struct lnet_comm_count el_drop_stats;
};
+struct lnet_health_local_stats {
+ atomic_t hlt_local_interrupt;
+ atomic_t hlt_local_dropped;
+ atomic_t hlt_local_aborted;
+ atomic_t hlt_local_no_route;
+ atomic_t hlt_local_timeout;
+ atomic_t hlt_local_error;
+};
+
+struct lnet_health_remote_stats {
+ atomic_t hlt_remote_dropped;
+ atomic_t hlt_remote_timeout;
+ atomic_t hlt_remote_error;
+ atomic_t hlt_network_timeout;
+};
+
struct lnet_net {
/* chain on the ln_nets */
struct list_head net_list;
bool net_tunables_set;
/* procedural interface */
- struct lnet_lnd *net_lnd;
+ const struct lnet_lnd *net_lnd;
/* list of NIs on this net */
struct list_head net_ni_list;
/* dying LND instances */
struct list_head net_ni_zombie;
- /* network state */
- enum lnet_net_state net_state;
+ /* when I was last alive */
+ time64_t net_last_alive;
+
+ /* protects access to net_last_alive */
+ spinlock_t net_lock;
};
struct lnet_ni {
/* chain on the lnet_net structure */
struct list_head ni_netlist;
- /* chain on net_ni_cpt */
- struct list_head ni_cptlist;
-
/* chain on the recovery queue */
struct list_head ni_recovery;
/* percpt reference count */
int **ni_refs;
- /* when I was last alive */
- time64_t ni_last_alive;
-
/* pointer to parent network */
struct lnet_net *ni_net;
/* my health status */
struct lnet_ni_status *ni_status;
- /* NI FSM */
- __u32 ni_state;
+ /* NI FSM. Protected by lnet_ni_lock() */
+ enum lnet_ni_state ni_state;
+
+ /* Recovery state. Protected by lnet_ni_lock() */
+ __u32 ni_recovery_state;
/* per NI LND tunables */
struct lnet_lnd_tunables ni_lnd_tunables;
/* NI statistics */
struct lnet_element_stats ni_stats;
+ struct lnet_health_local_stats ni_hstats;
/* physical device CPT */
int ni_dev_cpt;
atomic_t ni_healthv;
/*
+ * Set to 1 by the LND when it receives an event telling it the device
+ * has gone into a fatal state. Set to 0 when the LND receives an
+ * even telling it the device is back online.
+ */
+ atomic_t ni_fatal_error_on;
+
+ /*
* equivalent interfaces to use
* This is an array because socklnd bonding can still be configured
*/
struct lnet_ping_buffer {
int pb_nnis;
atomic_t pb_refcnt;
+ bool pb_needs_post;
struct lnet_ping_info pb_info;
};
#define LNET_PING_INFO_TO_BUFFER(PINFO) \
container_of((PINFO), struct lnet_ping_buffer, pb_info)
-/* router checker data, per router */
-struct lnet_rc_data {
- /* chain on the_lnet.ln_zombie_rcd or ln_deathrow_rcd */
- struct list_head rcd_list;
- struct lnet_handle_md rcd_mdh; /* ping buffer MD */
- struct lnet_peer_ni *rcd_gateway; /* reference to gateway */
- struct lnet_ping_buffer *rcd_pingbuffer;/* ping buffer */
- int rcd_nnis; /* desired size of buffer */
-};
-
struct lnet_peer_ni {
/* chain on lpn_peer_nis */
struct list_head lpni_peer_nis;
/* chain on remote peer list */
struct list_head lpni_on_remote_peer_ni_list;
+ /* chain on recovery queue */
+ struct list_head lpni_recovery;
/* chain on peer hash */
struct list_head lpni_hashlist;
/* messages blocking for tx credits */
struct list_head lpni_txq;
- /* messages blocking for router credits */
- struct list_head lpni_rtrq;
- /* chain on router list */
- struct list_head lpni_rtr_list;
/* pointer to peer net I'm part of */
struct lnet_peer_net *lpni_peer_net;
/* statistics kept on each peer NI */
struct lnet_element_stats lpni_stats;
- /* spin lock protecting credits and lpni_txq / lpni_rtrq */
+ struct lnet_health_remote_stats lpni_hstats;
+ /* spin lock protecting credits and lpni_txq */
spinlock_t lpni_lock;
/* # tx credits available */
int lpni_txcredits;
/* low water mark */
int lpni_mintxcredits;
+ /*
+ * Each peer_ni in a gateway maintains its own credits. This
+ * allows more traffic to gateways that have multiple interfaces.
+ */
/* # router credits */
int lpni_rtrcredits;
/* low water mark */
int lpni_minrtrcredits;
/* bytes queued for sending */
long lpni_txqnob;
- /* alive/dead? */
- bool lpni_alive;
- /* notification outstanding? */
- bool lpni_notify;
- /* outstanding notification for LND? */
- bool lpni_notifylnd;
- /* some thread is handling notification */
- bool lpni_notifying;
- /* SEND event outstanding from ping */
- bool lpni_ping_notsent;
- /* # times router went dead<->alive. Protected with lpni_lock */
- int lpni_alive_count;
- /* time of last aliveness news */
- time64_t lpni_timestamp;
- /* time of last ping attempt */
- time64_t lpni_ping_timestamp;
- /* != 0 if ping reply expected */
- time64_t lpni_ping_deadline;
- /* when I was last alive */
- time64_t lpni_last_alive;
- /* when lpni_ni was queried last time */
- time64_t lpni_last_query;
/* network peer is on */
struct lnet_net *lpni_net;
/* peer's NID */
lnet_nid_t lpni_nid;
/* # refs */
atomic_t lpni_refcount;
+ /* health value for the peer */
+ atomic_t lpni_healthv;
+ /* recovery ping mdh */
+ struct lnet_handle_md lpni_recovery_ping_mdh;
/* CPT this peer attached on */
int lpni_cpt;
/* state flags -- protected by lpni_lock */
unsigned lpni_state;
- /* # refs from lnet_route_t::lr_gateway */
- int lpni_rtr_refcount;
+ /* status of the peer NI as reported by the peer */
+ __u32 lpni_ns_status;
/* sequence number used to round robin over peer nis within a net */
__u32 lpni_seq;
/* sequence number used to round robin over gateways */
__u32 lpni_gw_seq;
- /* health flag */
- bool lpni_healthy;
/* returned RC ping features. Protected with lpni_lock */
unsigned int lpni_ping_feats;
- /* routes on this peer */
- struct list_head lpni_routes;
+ /* time last message was received from the peer */
+ time64_t lpni_last_alive;
/* preferred local nids: if only one, use lpni_pref.nid */
union lpni_pref {
lnet_nid_t nid;
} lpni_pref;
/* number of preferred NIDs in lnpi_pref_nids */
__u32 lpni_pref_nnids;
- /* router checker state */
- struct lnet_rc_data *lpni_rcd;
};
/* Preferred path added due to traffic on non-MR peer_ni */
-#define LNET_PEER_NI_NON_MR_PREF (1 << 0)
+#define LNET_PEER_NI_NON_MR_PREF BIT(0)
+/* peer is being recovered. */
+#define LNET_PEER_NI_RECOVERY_PENDING BIT(1)
+/* recovery ping failed */
+#define LNET_PEER_NI_RECOVERY_FAILED BIT(2)
+/* peer is being deleted */
+#define LNET_PEER_NI_DELETING BIT(3)
struct lnet_peer {
/* chain on pt_peer_list */
/* list of messages pending discovery*/
struct list_head lp_dc_pendq;
+ /* chain on router list */
+ struct list_head lp_rtr_list;
+
/* primary NID of the peer */
lnet_nid_t lp_primary_nid;
+ /* source NID to use during discovery */
+ lnet_nid_t lp_disc_src_nid;
+
+ /* net to perform discovery on */
+ __u32 lp_disc_net_id;
+
/* CPT of peer_table */
int lp_cpt;
/* number of NIDs on this peer */
int lp_nnis;
+ /* # refs from lnet_route::lr_gateway */
+ int lp_rtr_refcount;
+
+ /*
+ * peer specific health sensitivity value to decrement peer nis in
+ * this peer with if set to something other than 0
+ */
+ __u32 lp_health_sensitivity;
+
+ /* messages blocking for router credits */
+ struct list_head lp_rtrq;
+
+ /* routes on this peer */
+ struct list_head lp_routes;
+
/* reference count */
atomic_t lp_refcount;
- /* lock protecting peer state flags */
+ /* lock protecting peer state flags and lpni_rtrq */
spinlock_t lp_lock;
/* peer state flags */
/* tasks waiting on discovery of this peer */
wait_queue_head_t lp_dc_waitq;
+
+ /* cached peer aliveness */
+ bool lp_alive;
};
/*
*
* A peer is marked NO_DISCOVERY if the LNET_PING_FEAT_DISCOVERY bit was
* NOT set when the peer was pinged by discovery.
+ *
+ * A peer is marked ROUTER if it indicates so in the feature bit.
*/
-#define LNET_PEER_MULTI_RAIL (1 << 0) /* Multi-rail aware */
-#define LNET_PEER_NO_DISCOVERY (1 << 1) /* Peer disabled discovery */
+#define LNET_PEER_MULTI_RAIL BIT(0) /* Multi-rail aware */
+#define LNET_PEER_NO_DISCOVERY BIT(1) /* Peer disabled discovery */
+#define LNET_PEER_ROUTER_ENABLED BIT(2) /* router feature enabled */
+
/*
* A peer is marked CONFIGURED if it was configured by DLC.
*
* A peer that was created as the result of inbound traffic will not
* be marked at all.
*/
-#define LNET_PEER_CONFIGURED (1 << 2) /* Configured via DLC */
-#define LNET_PEER_DISCOVERED (1 << 3) /* Peer was discovered */
-#define LNET_PEER_REDISCOVER (1 << 4) /* Discovery was disabled */
+#define LNET_PEER_CONFIGURED BIT(3) /* Configured via DLC */
+#define LNET_PEER_DISCOVERED BIT(4) /* Peer was discovered */
+#define LNET_PEER_REDISCOVER BIT(5) /* Discovery was disabled */
/*
* A peer is marked DISCOVERING when discovery is in progress.
* The other flags below correspond to stages of discovery.
*/
-#define LNET_PEER_DISCOVERING (1 << 5) /* Discovering */
-#define LNET_PEER_DATA_PRESENT (1 << 6) /* Remote peer data present */
-#define LNET_PEER_NIDS_UPTODATE (1 << 7) /* Remote peer info uptodate */
-#define LNET_PEER_PING_SENT (1 << 8) /* Waiting for REPLY to Ping */
-#define LNET_PEER_PUSH_SENT (1 << 9) /* Waiting for ACK of Push */
-#define LNET_PEER_PING_FAILED (1 << 10) /* Ping send failure */
-#define LNET_PEER_PUSH_FAILED (1 << 11) /* Push send failure */
+#define LNET_PEER_DISCOVERING BIT(6) /* Discovering */
+#define LNET_PEER_DATA_PRESENT BIT(7) /* Remote peer data present */
+#define LNET_PEER_NIDS_UPTODATE BIT(8) /* Remote peer info uptodate */
+#define LNET_PEER_PING_SENT BIT(9) /* Waiting for REPLY to Ping */
+#define LNET_PEER_PUSH_SENT BIT(10) /* Waiting for ACK of Push */
+#define LNET_PEER_PING_FAILED BIT(11) /* Ping send failure */
+#define LNET_PEER_PUSH_FAILED BIT(12) /* Push send failure */
/*
* A ping can be forced as a way to fix up state, or as a manual
* intervention by an admin.
* A push can be forced in circumstances that would normally not
* allow for one to happen.
*/
-#define LNET_PEER_FORCE_PING (1 << 12) /* Forced Ping */
-#define LNET_PEER_FORCE_PUSH (1 << 13) /* Forced Push */
+#define LNET_PEER_FORCE_PING BIT(13) /* Forced Ping */
+#define LNET_PEER_FORCE_PUSH BIT(14) /* Forced Push */
+
+/* force delete even if router */
+#define LNET_PEER_RTR_NI_FORCE_DEL BIT(15)
+
+/* gw undergoing alive discovery */
+#define LNET_PEER_RTR_DISCOVERY BIT(16)
+/* gw has undergone discovery (does not indicate success or failure) */
+#define LNET_PEER_RTR_DISCOVERED BIT(17)
+
+/* peer is marked for deletion */
+#define LNET_PEER_MARK_DELETION BIT(18)
struct lnet_peer_net {
/* chain on lp_peer_nets */
/* Net ID */
__u32 lpn_net_id;
+ /* peer net health */
+ int lpn_healthv;
+
+ /* time of last router net check attempt */
+ time64_t lpn_rtrcheck_timestamp;
+
+ /* selection sequence number */
+ __u32 lpn_seq;
+
/* reference count */
atomic_t lpn_refcount;
};
*
* protected by lnet_net_lock/EX for update
* pt_version
- * pt_number
* pt_hash[...]
* pt_peer_list
* pt_peers
*/
struct lnet_peer_table {
int pt_version; /* /proc validity stamp */
- int pt_number; /* # peers_ni extant */
struct list_head *pt_hash; /* NID->peer hash */
struct list_head pt_peer_list; /* peers */
int pt_peers; /* # peers */
struct lnet_route {
struct list_head lr_list; /* chain on net */
struct list_head lr_gwlist; /* chain on gateway */
- struct lnet_peer_ni *lr_gateway; /* router node */
+ struct lnet_peer *lr_gateway; /* router node */
+ lnet_nid_t lr_nid; /* NID used to add route */
__u32 lr_net; /* remote network number */
+ __u32 lr_lnet; /* local network number */
int lr_seq; /* sequence for round-robin */
- unsigned int lr_downis; /* number of down NIs */
__u32 lr_hops; /* how far I am */
unsigned int lr_priority; /* route priority */
+ bool lr_alive; /* cached route aliveness */
+ bool lr_single_hop; /* this route is single-hop */
};
#define LNET_REMOTE_NETS_HASH_DEFAULT (1U << 7)
struct lnet_rtrbuf {
struct list_head rb_list; /* chain on rbp_bufs */
struct lnet_rtrbufpool *rb_pool; /* owning pool */
- lnet_kiov_t rb_kiov[0]; /* the buffer space */
+ struct bio_vec rb_kiov[0]; /* the buffer space */
};
#define LNET_PEER_HASHSIZE 503 /* prime! */
enum lnet_match_flags {
/* Didn't match anything */
- LNET_MATCHMD_NONE = (1 << 0),
+ LNET_MATCHMD_NONE = BIT(0),
/* Matched OK */
- LNET_MATCHMD_OK = (1 << 1),
+ LNET_MATCHMD_OK = BIT(1),
/* Must be discarded */
- LNET_MATCHMD_DROP = (1 << 2),
+ LNET_MATCHMD_DROP = BIT(2),
/* match and buffer is exhausted */
- LNET_MATCHMD_EXHAUSTED = (1 << 3),
+ LNET_MATCHMD_EXHAUSTED = BIT(3),
/* match or drop */
LNET_MATCHMD_FINISH = (LNET_MATCHMD_OK | LNET_MATCHMD_DROP),
};
/* Options for struct lnet_portal::ptl_options */
-#define LNET_PTL_LAZY (1 << 0)
-#define LNET_PTL_MATCH_UNIQUE (1 << 1) /* unique match, for RDMA */
-#define LNET_PTL_MATCH_WILDCARD (1 << 2) /* wildcard match, request portal */
+#define LNET_PTL_LAZY BIT(0)
+#define LNET_PTL_MATCH_UNIQUE BIT(1) /* unique match, for RDMA */
+#define LNET_PTL_MATCH_WILDCARD BIT(2) /* wildcard match, request portal */
/* parameter for matching operations (GET, PUT) */
struct lnet_match_info {
int msc_nfinalizers;
/* msgs waiting to complete finalizing */
struct list_head msc_finalizing;
+ /* msgs waiting to be resent */
+ struct list_head msc_resending;
struct list_head msc_active; /* active message list */
/* threads doing finalization */
void **msc_finalizers;
+ /* threads doing resends */
+ void **msc_resenders;
};
/* Peer Discovery states */
int ln_nportals;
/* the vector of portals */
struct lnet_portal **ln_portals;
- /* percpt ME containers */
- struct lnet_res_container **ln_me_containers;
/* percpt MD container */
struct lnet_res_container **ln_md_containers;
/* Event Queue container */
struct lnet_res_container ln_eq_container;
- wait_queue_head_t ln_eq_waitq;
spinlock_t ln_eq_wait_lock;
unsigned int ln_remote_nets_hbits;
* ln_api_mutex.
*/
struct lnet_handle_md ln_ping_target_md;
- struct lnet_handle_eq ln_ping_target_eq;
+ lnet_handler_t ln_ping_target_handler;
struct lnet_ping_buffer *ln_ping_target;
atomic_t ln_ping_target_seqno;
* buffer may linger a while after it has been unlinked, in
* which case the event handler cleans up.
*/
- struct lnet_handle_eq ln_push_target_eq;
+ lnet_handler_t ln_push_target_handler;
struct lnet_handle_md ln_push_target_md;
struct lnet_ping_buffer *ln_push_target;
int ln_push_target_nnis;
/* discovery event queue handle */
- struct lnet_handle_eq ln_dc_eqh;
+ lnet_handler_t ln_dc_handler;
/* discovery requests */
struct list_head ln_dc_request;
/* discovery working list */
/* monitor thread startup/shutdown state */
int ln_mt_state;
- /* router checker's event queue */
- struct lnet_handle_eq ln_rc_eqh;
- /* rcd still pending on net */
- struct list_head ln_rcd_deathrow;
- /* rcd ready for free */
- struct list_head ln_rcd_zombie;
/* serialise startup/shutdown */
struct semaphore ln_mt_signal;
/* uniquely identifies this ni in this epoch */
__u64 ln_interface_cookie;
/* registered LNDs */
- struct list_head ln_lnds;
+ const struct lnet_lnd *ln_lnds[NUM_LNDS];
/* test protocol compatibility flags */
- int ln_testprotocompat;
+ unsigned long ln_testprotocompat;
/* 0 - load the NIs from the mod params
* 1 - do not load the NIs from the mod params
bool ln_nis_from_mod_params;
/*
- * waitq for the monitor thread. The monitor thread takes care of
+ * completion for the monitor thread. The monitor thread takes care of
* checking routes, timedout messages and resending messages.
*/
- wait_queue_head_t ln_mt_waitq;
+ struct completion ln_mt_wait_complete;
/* per-cpt resend queues */
struct list_head **ln_mt_resendqs;
/* local NIs to recover */
struct list_head ln_mt_localNIRecovq;
- /* recovery eq handler */
- struct lnet_handle_eq ln_mt_eqh;
+ /* local NIs to recover */
+ struct list_head ln_mt_peerNIRecovq;
+ /*
+ * An array of queues for GET/PUT waiting for REPLY/ACK respectively.
+ * There are CPT number of queues. Since response trackers will be
+ * added on the fast path we can't afford to grab the exclusive
+ * net lock to protect these queues. The CPT will be calculated
+ * based on the mdh cookie.
+ */
+ struct list_head **ln_mt_rstq;
+ /*
+ * A response tracker becomes a zombie when the associated MD is queued
+ * for unlink before the response tracker is detached from the MD. An
+ * entry on a zombie list can be freed when either the remaining
+ * operations on the MD complete or when LNet has shut down.
+ */
+ struct list_head **ln_mt_zombie_rstqs;
+ /* recovery handler */
+ lnet_handler_t ln_mt_handler;
+ /*
+ * Completed when the discovery and monitor threads can enter their
+ * work loops
+ */
+ struct completion ln_started;
};
#endif
git://git.whamcloud.com / fs / lustre-release.git / blobdiff