Whamcloud - gitweb
fa71506107eeea8b2fefb4c3079162d390369072
[fs/lustre-release.git] / lnet / ulnds / ptllnd / ptllnd.h
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * Copyright (C) 2005 Cluster File Systems, Inc. All rights reserved.
5  *   Author: Eric Barton <eeb@bartonsoftware.com>
6  *
7  *   This file is part of the Lustre file system, http://www.lustre.org
8  *   Lustre is a trademark of Cluster File Systems, Inc.
9  *
10  *   This file is confidential source code owned by Cluster File Systems.
11  *   No viewing, modification, compilation, redistribution, or any other
12  *   form of use is permitted except through a signed license agreement.
13  *
14  *   If you have not signed such an agreement, then you have no rights to
15  *   this file.  Please destroy it immediately and contact CFS.
16  *
17  */
18
19
20 #define DEBUG_SUBSYSTEM S_LND
21
22 #include <lnet/lib-lnet.h>
23 #include <lnet/ptllnd_wire.h>
24
25 #include <portals/p30.h>
26 #include <lnet/ptllnd.h>           /* Depends on portals/p30.h */
27 #include <stdarg.h>
28
29 #define PTLLND_DEBUG_TIMING 0
30
31 #define PTLLND_MSGS_PER_BUFFER     64
32 #define PTLLND_MSGS_SPARE          256
33 #define PTLLND_PEER_HASH_SIZE      101
34 #define PTLLND_EQ_SIZE             1024
35 #if PTLLND_DEBUG_TIMING
36 # define PTLLND_TX_HISTORY         1024
37 #else
38 # define PTLLND_TX_HISTORY         0
39 #endif
40 #define PTLLND_WARN_LONG_WAIT      5 /* seconds */
41 #define PTLLND_ABORT_ON_NAK        1 /* abort app on (e.g.) protocol version mismatch */
42 #define PTLLND_DUMP_ON_NAK         0 /* dump debug? */
43
44
45 /* Hack to record history 
46  * This should really be done by CDEBUG(D_NETTRACE...  */
47
48 typedef struct {
49         struct list_head          he_list;
50         struct timeval            he_time;
51         const char               *he_fn;
52         const char               *he_file;
53         int                       he_seq;
54         int                       he_line;
55         char                      he_msg[80];
56 } ptllnd_he_t;
57
58 void ptllnd_dump_history();
59 void ptllnd_history(const char *fn, const char *file, const int line,
60                     const char *fmt, ...);
61 #define PTLLND_HISTORY(fmt, a...) \
62         ptllnd_history(__FUNCTION__, __FILE__, __LINE__, fmt, ## a)
63
64         
65 #define PTLLND_MD_OPTIONS        (PTL_MD_LUSTRE_COMPLETION_SEMANTICS |\
66                                   PTL_MD_EVENT_START_DISABLE)
67 typedef struct
68 {
69         int                        plni_portal;
70         ptl_pid_t                  plni_ptllnd_pid; /* Portals PID of peers I may connect to */
71         int                        plni_peer_credits;
72         int                        plni_max_msg_size;
73         int                        plni_buffer_size;
74         int                        plni_msgs_spare;
75         int                        plni_peer_hash_size;
76         int                        plni_eq_size;
77         int                        plni_checksum;
78         int                        plni_max_tx_history;
79         int                        plni_abort_on_nak;
80         int                        plni_dump_on_nak;
81
82         __u64                      plni_stamp;
83         struct list_head           plni_active_txs;
84         struct list_head           plni_zombie_txs;
85         int                        plni_ntxs;
86         int                        plni_nrxs;
87
88         ptl_handle_ni_t            plni_nih;
89         ptl_handle_eq_t            plni_eqh;
90         ptl_process_id_t           plni_portals_id;   /* Portals ID of interface */
91
92         struct list_head          *plni_peer_hash;
93         int                        plni_npeers;
94
95         struct list_head           plni_tx_history;
96         int                        plni_ntx_history;
97
98         struct list_head           plni_buffers;
99         int                        plni_nbuffers;
100         int                        plni_nposted_buffers;
101         int                        plni_nmsgs;
102 } ptllnd_ni_t;
103
104 #define PTLLND_CREDIT_HIGHWATER(plni) ((plni)->plni_peer_credits - 1)
105
106 typedef struct
107 {
108         struct list_head           plp_list;
109         lnet_ni_t                 *plp_ni;
110         lnet_process_id_t          plp_id;
111         ptl_process_id_t           plp_ptlid;
112         int                        plp_credits; /* # msg buffers reserved for me at peer */
113
114         /* credits for msg buffers I've posted for this peer...
115          * outstanding - free buffers I've still to inform my peer about
116          * sent        - free buffers I've told my peer about
117          * lazy        - additional buffers (over and above plni_peer_credits)
118          *               posted to prevent peer blocking on sending a non-RDMA
119          *               messages to me when LNET isn't eagerly responsive to
120          *               the network (i.e. liblustre doesn't have control). 
121          * extra_lazy  - lazy credits not required any more. */
122         int                        plp_outstanding_credits;
123         int                        plp_sent_credits;
124         int                        plp_lazy_credits;
125         int                        plp_extra_lazy_credits;
126
127         int                        plp_max_msg_size;
128         int                        plp_refcount;
129         int                        plp_recvd_hello:1;
130         int                        plp_closing:1;
131         __u64                      plp_match;
132         __u64                      plp_stamp;
133         struct list_head           plp_txq;
134         struct list_head           plp_activeq;
135 } ptllnd_peer_t;
136
137 typedef struct
138 {
139         struct list_head           plb_list;
140         lnet_ni_t                 *plb_ni;
141         int                        plb_posted;
142         ptl_handle_md_t            plb_md;
143         char                      *plb_buffer;
144 } ptllnd_buffer_t;
145
146 typedef struct
147 {
148         ptllnd_peer_t             *rx_peer;
149         kptl_msg_t                *rx_msg;
150         int                        rx_nob;
151 } ptllnd_rx_t;
152
153 typedef struct
154 {
155         struct list_head           tx_list;
156         int                        tx_type;
157         int                        tx_status;
158         ptllnd_peer_t             *tx_peer;
159         lnet_msg_t                *tx_lnetmsg;
160         lnet_msg_t                *tx_lnetreplymsg;
161         unsigned int               tx_niov;
162         ptl_md_iovec_t            *tx_iov;
163         ptl_handle_md_t            tx_bulkmdh;
164         ptl_handle_md_t            tx_reqmdh;
165 #if PTLLND_DEBUG_TIMING
166         struct timeval             tx_bulk_posted;
167         struct timeval             tx_bulk_done;
168         struct timeval             tx_req_posted;
169         struct timeval             tx_req_done;
170 #endif
171         int                        tx_completing; /* someone already completing */
172         int                        tx_msgsize;  /* # bytes in tx_msg */
173         kptl_msg_t                 tx_msg;      /* message to send */
174 } ptllnd_tx_t;
175
176 #define PTLLND_RDMA_WRITE           0x100       /* pseudo message type */
177 #define PTLLND_RDMA_READ            0x101       /* (no msg actually sent) */
178
179 /* Hack to extract object type from event's user_ptr relies on (and checks)
180  * that structs are somewhat aligned. */
181 #define PTLLND_EVENTARG_TYPE_TX     0x1
182 #define PTLLND_EVENTARG_TYPE_BUF    0x2
183 #define PTLLND_EVENTARG_TYPE_MASK   0x3
184
185 static inline void *
186 ptllnd_obj2eventarg (void *obj, int type)
187 {
188         unsigned long ptr = (unsigned long)obj;
189
190         LASSERT ((ptr & PTLLND_EVENTARG_TYPE_MASK) == 0);
191         LASSERT ((type & ~PTLLND_EVENTARG_TYPE_MASK) == 0);
192
193         return (void *)(ptr | type);
194 }
195
196 static inline int
197 ptllnd_eventarg2type (void *arg)
198 {
199         unsigned long ptr = (unsigned long)arg;
200
201         return (ptr & PTLLND_EVENTARG_TYPE_MASK);
202 }
203
204 static inline void *
205 ptllnd_eventarg2obj (void *arg)
206 {
207         unsigned long ptr = (unsigned long)arg;
208
209         return (void *)(ptr & ~PTLLND_EVENTARG_TYPE_MASK);
210 }
211
212 #if PTLLND_DEBUG_TIMING
213 # define PTLLND_DBGT_INIT(tv)  memset(&(tv), 0, sizeof(tv))
214 # define PTLLND_DBGT_STAMP(tv) gettimeofday(&(tv), NULL)
215 # define DBGT_FMT              "%ld.%06ld"
216 # define DBGT_ARGS(tv)         , (long)((tv).tv_sec), (long)((tv).tv_usec)
217 #else
218 # define PTLLND_DBGT_INIT(tv)
219 # define PTLLND_DBGT_STAMP(tv)
220 # define DBGT_FMT              "-"
221 # define DBGT_ARGS(tv)
222 #endif
223
224 int ptllnd_parse_int_tunable(int *value, char *name, int dflt);
225 void ptllnd_cull_tx_history(ptllnd_ni_t *plni);
226 int ptllnd_startup(lnet_ni_t *ni);
227 void ptllnd_shutdown(lnet_ni_t *ni);
228 int ptllnd_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg);
229 int ptllnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *msg);
230 int ptllnd_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg,
231                 int delayed, unsigned int niov,
232                 struct iovec *iov, lnet_kiov_t *kiov,
233                 unsigned int offset, unsigned int mlen, unsigned int rlen);
234 int ptllnd_eager_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg,
235                       void **new_privatep);
236
237 ptllnd_tx_t *ptllnd_new_tx(ptllnd_peer_t *peer, int type, int payload_nob);
238 void ptllnd_notify(lnet_ni_t *ni, lnet_nid_t nid, int alive);
239 int  ptllnd_setasync(lnet_ni_t *ni, lnet_process_id_t id, int n);
240 void ptllnd_wait(lnet_ni_t *ni, int milliseconds);
241 void ptllnd_check_sends(ptllnd_peer_t *peer);
242 void ptllnd_debug_peer(lnet_ni_t *ni, lnet_process_id_t id);
243 void ptllnd_destroy_peer(ptllnd_peer_t *peer);
244 void ptllnd_close_peer(ptllnd_peer_t *peer, int error);
245 int ptllnd_post_buffer(ptllnd_buffer_t *buf);
246 int ptllnd_size_buffers (lnet_ni_t *ni, int delta);
247 const char *ptllnd_evtype2str(int type);
248 const char *ptllnd_msgtype2str(int type);
249 const char *ptllnd_errtype2str(int type);
250 char *ptllnd_ptlid2str(ptl_process_id_t id);
251
252 static inline void
253 ptllnd_peer_addref (ptllnd_peer_t *peer)
254 {
255         LASSERT (peer->plp_refcount > 0);
256         peer->plp_refcount++;
257 }
258
259 static inline void
260 ptllnd_peer_decref (ptllnd_peer_t *peer)
261 {
262         LASSERT (peer->plp_refcount > 0);
263         peer->plp_refcount--;
264         if (peer->plp_refcount == 0)
265                 ptllnd_destroy_peer(peer);
266 }
267
268 static inline void
269 ptllnd_post_tx(ptllnd_tx_t *tx)
270 {
271         ptllnd_peer_t *peer = tx->tx_peer;
272         LASSERT(tx->tx_peer != NULL);
273         list_add_tail(&tx->tx_list, &peer->plp_txq);
274         ptllnd_check_sends(peer);
275 }
276
277 static inline lnet_nid_t
278 ptllnd_ptl2lnetnid(lnet_ni_t *ni, ptl_nid_t portals_nid)
279 {
280         return LNET_MKNID(LNET_NIDNET(ni->ni_nid), portals_nid);
281 }
282
283 static inline ptl_nid_t
284 ptllnd_lnet2ptlnid(lnet_nid_t lnet_nid)
285 {
286         return LNET_NIDADDR(lnet_nid);
287 }
288
289 /*
290  * A note about lprintf():
291  *  Normally printf() is redirected to stdout of the console
292  *  from which yod launched the catamount application.  However
293  *  there is a lot of initilziation code that runs before this
294  *  redirection is hooked up, and printf() seems to go to the bit bucket
295  *
296  *  To get any kind of debug output and init time lprintf() can
297  *  be used to output to the console from which bookqk was used to
298  *  boot the catamount node.  This works for debugging some simple
299  *  cases.
300  */
301
302