Whamcloud - gitweb
9c31da46921eecb5ec4da321d6d66608bffd3fe4
[fs/lustre-release.git] / lnet / include / lnet / types.h
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2012, 2014, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  */
36
37 #ifndef __LNET_TYPES_H__
38 #define __LNET_TYPES_H__
39
40 /** \addtogroup lnet
41  * @{ */
42
43 #include <libcfs/types.h>
44
45 /** \addtogroup lnet_addr
46  * @{ */
47
48 #define LNET_VERSION            "0.7.0"
49
50 /** Portal reserved for LNet's own use.
51  * \see lustre/include/lustre/lustre_idl.h for Lustre portal assignments.
52  */
53 #define LNET_RESERVED_PORTAL      0
54
55 /**
56  * Address of an end-point in an LNet network.
57  *
58  * A node can have multiple end-points and hence multiple addresses.
59  * An LNet network can be a simple network (e.g. tcp0) or a network of
60  * LNet networks connected by LNet routers. Therefore an end-point address
61  * has two parts: network ID, and address within a network.
62  *
63  * \see LNET_NIDNET, LNET_NIDADDR, and LNET_MKNID.
64  */
65 typedef __u64 lnet_nid_t;
66 /**
67  * ID of a process in a node. Shortened as PID to distinguish from
68  * lnet_process_id_t, the global process ID.
69  */
70 typedef __u32 lnet_pid_t;
71
72 /** wildcard NID that matches any end-point address */
73 #define LNET_NID_ANY      ((lnet_nid_t) -1)
74 /** wildcard PID that matches any lnet_pid_t */
75 #define LNET_PID_ANY      ((lnet_pid_t) -1)
76
77 #define LNET_PID_RESERVED 0xf0000000 /* reserved bits in PID */
78 #define LNET_PID_USERFLAG 0x80000000 /* set in userspace peers */
79 #define LNET_PID_LUSTRE 12345
80
81 #define LNET_TIME_FOREVER    (-1)
82
83 /* how an LNET NID encodes net:address */
84 /** extract the address part of an lnet_nid_t */
85
86 static inline __u32 LNET_NIDADDR(lnet_nid_t nid)
87 {
88         return nid & 0xffffffff;
89 }
90
91 static inline __u32 LNET_NIDNET(lnet_nid_t nid)
92 {
93         return (nid >> 32) & 0xffffffff;
94 }
95
96 static inline lnet_nid_t LNET_MKNID(__u32 net, __u32 addr)
97 {
98         return (((__u64)net) << 32) | addr;
99 }
100
101 static inline __u32 LNET_NETNUM(__u32 net)
102 {
103         return net & 0xffff;
104 }
105
106 static inline __u32 LNET_NETTYP(__u32 net)
107 {
108         return (net >> 16) & 0xffff;
109 }
110
111 static inline __u32 LNET_MKNET(__u32 type, __u32 num)
112 {
113         return (type << 16) | num;
114 }
115
116 #define WIRE_ATTR       __attribute__((packed))
117
118 /* Packed version of lnet_process_id_t to transfer via network */
119 typedef struct {
120         lnet_nid_t nid;
121         lnet_pid_t pid; /* node id / process id */
122 } WIRE_ATTR lnet_process_id_packed_t;
123
124 /* The wire handle's interface cookie only matches one network interface in
125  * one epoch (i.e. new cookie when the interface restarts or the node
126  * reboots).  The object cookie only matches one object on that interface
127  * during that object's lifetime (i.e. no cookie re-use). */
128 typedef struct {
129         __u64 wh_interface_cookie;
130         __u64 wh_object_cookie;
131 } WIRE_ATTR lnet_handle_wire_t;
132
133 typedef enum {
134         LNET_MSG_ACK = 0,
135         LNET_MSG_PUT,
136         LNET_MSG_GET,
137         LNET_MSG_REPLY,
138         LNET_MSG_HELLO,
139 } lnet_msg_type_t;
140
141 /* The variant fields of the portals message header are aligned on an 8
142  * byte boundary in the message header.  Note that all types used in these
143  * wire structs MUST be fixed size and the smaller types are placed at the
144  * end. */
145 typedef struct lnet_ack {
146         lnet_handle_wire_t      dst_wmd;
147         __u64                   match_bits;
148         __u32                   mlength;
149 } WIRE_ATTR lnet_ack_t;
150
151 typedef struct lnet_put {
152         lnet_handle_wire_t      ack_wmd;
153         __u64                   match_bits;
154         __u64                   hdr_data;
155         __u32                   ptl_index;
156         __u32                   offset;
157 } WIRE_ATTR lnet_put_t;
158
159 typedef struct lnet_get {
160         lnet_handle_wire_t      return_wmd;
161         __u64                   match_bits;
162         __u32                   ptl_index;
163         __u32                   src_offset;
164         __u32                   sink_length;
165 } WIRE_ATTR lnet_get_t;
166
167 typedef struct lnet_reply {
168         lnet_handle_wire_t      dst_wmd;
169 } WIRE_ATTR lnet_reply_t;
170
171 typedef struct lnet_hello {
172         __u64                   incarnation;
173         __u32                   type;
174 } WIRE_ATTR lnet_hello_t;
175
176 typedef struct {
177         lnet_nid_t      dest_nid;
178         lnet_nid_t      src_nid;
179         lnet_pid_t      dest_pid;
180         lnet_pid_t      src_pid;
181         __u32           type;           /* lnet_msg_type_t */
182         __u32           payload_length; /* payload data to follow */
183         /*<------__u64 aligned------->*/
184         union {
185                 lnet_ack_t      ack;
186                 lnet_put_t      put;
187                 lnet_get_t      get;
188                 lnet_reply_t    reply;
189                 lnet_hello_t    hello;
190         } msg;
191 } WIRE_ATTR lnet_hdr_t;
192
193 /* A HELLO message contains a magic number and protocol version
194  * code in the header's dest_nid, the peer's NID in the src_nid, and
195  * LNET_MSG_HELLO in the type field.  All other common fields are zero
196  * (including payload_size; i.e. no payload).
197  * This is for use by byte-stream LNDs (e.g. TCP/IP) to check the peer is
198  * running the same protocol and to find out its NID. These LNDs should
199  * exchange HELLO messages when a connection is first established.  Individual
200  * LNDs can put whatever else they fancy in lnet_hdr_t::msg.
201  */
202 typedef struct {
203         __u32   magic;          /* LNET_PROTO_TCP_MAGIC */
204         __u16   version_major;  /* increment on incompatible change */
205         __u16   version_minor;  /* increment on compatible change */
206 } WIRE_ATTR lnet_magicversion_t;
207
208 /* PROTO MAGIC for LNDs */
209 #define LNET_PROTO_IB_MAGIC             0x0be91b91
210 #define LNET_PROTO_GNI_MAGIC            0xb00fbabe /* ask Kim */
211 #define LNET_PROTO_TCP_MAGIC            0xeebc0ded
212 #define LNET_PROTO_ACCEPTOR_MAGIC       0xacce7100
213 #define LNET_PROTO_PING_MAGIC           0x70696E67 /* 'ping' */
214
215 /* Placeholder for a future "unified" protocol across all LNDs */
216 /* Current LNDs that receive a request with this magic will respond with a
217  *  *  * "stub" reply using their current protocol */
218 #define LNET_PROTO_MAGIC                0x45726963 /* ! */
219
220 #define LNET_PROTO_TCP_VERSION_MAJOR    1
221 #define LNET_PROTO_TCP_VERSION_MINOR    0
222
223 /* Acceptor connection request */
224 typedef struct {
225         __u32   acr_magic;      /* PTL_ACCEPTOR_PROTO_MAGIC */
226         __u32   acr_version;    /* protocol version */
227         __u64   acr_nid;        /* target NID */
228 } WIRE_ATTR lnet_acceptor_connreq_t;
229
230 #define LNET_PROTO_ACCEPTOR_VERSION     1
231
232 typedef struct lnet_counters {
233         __u32   msgs_alloc;
234         __u32   msgs_max;
235         __u32   errors;
236         __u32   send_count;
237         __u32   recv_count;
238         __u32   route_count;
239         __u32   drop_count;
240         __u64   send_length;
241         __u64   recv_length;
242         __u64   route_length;
243         __u64   drop_length;
244 } WIRE_ATTR lnet_counters_t;
245
246 #define LNET_NI_STATUS_UP       0x15aac0de
247 #define LNET_NI_STATUS_DOWN     0xdeadface
248 #define LNET_NI_STATUS_INVALID  0x00000000
249
250 #define LNET_MAX_INTERFACES     16
251
252 /**
253  * Objects maintained by the LNet are accessed through handles. Handle types
254  * have names of the form lnet_handle_xx_t, where xx is one of the two letter
255  * object type codes ('eq' for event queue, 'md' for memory descriptor, and
256  * 'me' for match entry).
257  * Each type of object is given a unique handle type to enhance type checking.
258  * The type lnet_handle_any_t can be used when a generic handle is needed.
259  * Every handle value can be converted into a value of type lnet_handle_any_t
260  * without loss of information.
261  */
262 typedef struct {
263         __u64         cookie;
264 } lnet_handle_any_t;
265
266 typedef lnet_handle_any_t lnet_handle_eq_t;
267 typedef lnet_handle_any_t lnet_handle_md_t;
268 typedef lnet_handle_any_t lnet_handle_me_t;
269
270 #define LNET_WIRE_HANDLE_COOKIE_NONE   (-1)
271
272 /**
273  * Invalidate handle \a h.
274  */
275 static inline void LNetInvalidateHandle(lnet_handle_any_t *h)
276 {
277         h->cookie = LNET_WIRE_HANDLE_COOKIE_NONE;
278 }
279
280 /**
281  * Compare handles \a h1 and \a h2.
282  *
283  * \return 1 if handles are equal, 0 if otherwise.
284  */
285 static inline int LNetHandleIsEqual (lnet_handle_any_t h1, lnet_handle_any_t h2)
286 {
287         return (h1.cookie == h2.cookie);
288 }
289
290 /**
291  * Check whether handle \a h is invalid.
292  *
293  * \return 1 if handle is invalid, 0 if valid.
294  */
295 static inline int LNetHandleIsInvalid(lnet_handle_any_t h)
296 {
297         return (LNET_WIRE_HANDLE_COOKIE_NONE == h.cookie);
298 }
299
300 /**
301  * Global process ID.
302  */
303 typedef struct {
304         /** node id */
305         lnet_nid_t nid;
306         /** process id */
307         lnet_pid_t pid;
308 } lnet_process_id_t;
309 /** @} lnet_addr */
310
311 /** \addtogroup lnet_me
312  * @{ */
313
314 /**
315  * Specifies whether the match entry or memory descriptor should be unlinked
316  * automatically (LNET_UNLINK) or not (LNET_RETAIN).
317  */
318 typedef enum {
319         LNET_RETAIN = 0,
320         LNET_UNLINK
321 } lnet_unlink_t;
322
323 /**
324  * Values of the type lnet_ins_pos_t are used to control where a new match
325  * entry is inserted. The value LNET_INS_BEFORE is used to insert the new
326  * entry before the current entry or before the head of the list. The value
327  * LNET_INS_AFTER is used to insert the new entry after the current entry
328  * or after the last item in the list.
329  */
330 typedef enum {
331         /** insert ME before current position or head of the list */
332         LNET_INS_BEFORE,
333         /** insert ME after current position or tail of the list */
334         LNET_INS_AFTER,
335         /** attach ME at tail of local CPU partition ME list */
336         LNET_INS_LOCAL
337 } lnet_ins_pos_t;
338
339 /** @} lnet_me */
340
341 /** \addtogroup lnet_md
342  * @{ */
343
344 /**
345  * Defines the visible parts of a memory descriptor. Values of this type
346  * are used to initialize memory descriptors.
347  */
348 typedef struct {
349         /**
350          * Specify the memory region associated with the memory descriptor.
351          * If the options field has:
352          * - LNET_MD_KIOV bit set: The start field points to the starting
353          * address of an array of lnet_kiov_t and the length field specifies
354          * the number of entries in the array. The length can't be bigger
355          * than LNET_MAX_IOV. The lnet_kiov_t is used to describe page-based
356          * fragments that are not necessarily mapped in virtal memory.
357          * - LNET_MD_IOVEC bit set: The start field points to the starting
358          * address of an array of struct iovec and the length field specifies
359          * the number of entries in the array. The length can't be bigger
360          * than LNET_MAX_IOV. The struct iovec is used to describe fragments
361          * that have virtual addresses.
362          * - Otherwise: The memory region is contiguous. The start field
363          * specifies the starting address for the memory region and the
364          * length field specifies its length.
365          *
366          * When the memory region is fragmented, all fragments but the first
367          * one must start on page boundary, and all but the last must end on
368          * page boundary.
369          */
370         void            *start;
371         unsigned int     length;
372         /**
373          * Specifies the maximum number of operations that can be performed
374          * on the memory descriptor. An operation is any action that could
375          * possibly generate an event. In the usual case, the threshold value
376          * is decremented for each operation on the MD. When the threshold
377          * drops to zero, the MD becomes inactive and does not respond to
378          * operations. A threshold value of LNET_MD_THRESH_INF indicates that
379          * there is no bound on the number of operations that may be applied
380          * to a MD.
381          */
382         int              threshold;
383         /**
384          * Specifies the largest incoming request that the memory descriptor
385          * should respond to. When the unused portion of a MD (length -
386          * local offset) falls below this value, the MD becomes inactive and
387          * does not respond to further operations. This value is only used
388          * if the LNET_MD_MAX_SIZE option is set.
389          */
390         int              max_size;
391         /**
392          * Specifies the behavior of the memory descriptor. A bitwise OR
393          * of the following values can be used:
394          * - LNET_MD_OP_PUT: The LNet PUT operation is allowed on this MD.
395          * - LNET_MD_OP_GET: The LNet GET operation is allowed on this MD.
396          * - LNET_MD_MANAGE_REMOTE: The offset used in accessing the memory
397          *   region is provided by the incoming request. By default, the
398          *   offset is maintained locally. When maintained locally, the
399          *   offset is incremented by the length of the request so that
400          *   the next operation (PUT or GET) will access the next part of
401          *   the memory region. Note that only one offset variable exists
402          *   per memory descriptor. If both PUT and GET operations are
403          *   performed on a memory descriptor, the offset is updated each time.
404          * - LNET_MD_TRUNCATE: The length provided in the incoming request can
405          *   be reduced to match the memory available in the region (determined
406          *   by subtracting the offset from the length of the memory region).
407          *   By default, if the length in the incoming operation is greater
408          *   than the amount of memory available, the operation is rejected.
409          * - LNET_MD_ACK_DISABLE: An acknowledgment should not be sent for
410          *   incoming PUT operations, even if requested. By default,
411          *   acknowledgments are sent for PUT operations that request an
412          *   acknowledgment. Acknowledgments are never sent for GET operations.
413          *   The data sent in the REPLY serves as an implicit acknowledgment.
414          * - LNET_MD_KIOV: The start and length fields specify an array of
415          *   lnet_kiov_t.
416          * - LNET_MD_IOVEC: The start and length fields specify an array of
417          *   struct iovec.
418          * - LNET_MD_MAX_SIZE: The max_size field is valid.
419          *
420          * Note:
421          * - LNET_MD_KIOV or LNET_MD_IOVEC allows for a scatter/gather
422          *   capability for memory descriptors. They can't be both set.
423          * - When LNET_MD_MAX_SIZE is set, the total length of the memory
424          *   region (i.e. sum of all fragment lengths) must not be less than
425          *   \a max_size.
426          */
427         unsigned int     options;
428         /**
429          * A user-specified value that is associated with the memory
430          * descriptor. The value does not need to be a pointer, but must fit
431          * in the space used by a pointer. This value is recorded in events
432          * associated with operations on this MD.
433          */
434         void            *user_ptr;
435         /**
436          * A handle for the event queue used to log the operations performed on
437          * the memory region. If this argument is a NULL handle (i.e. nullified
438          * by LNetInvalidateHandle()), operations performed on this memory
439          * descriptor are not logged.
440          */
441         lnet_handle_eq_t eq_handle;
442 } lnet_md_t;
443
444 /* Max Transfer Unit (minimum supported everywhere).
445  * CAVEAT EMPTOR, with multinet (i.e. routers forwarding between networks)
446  * these limits are system wide and not interface-local. */
447 #define LNET_MTU_BITS   20
448 #define LNET_MTU        (1 << LNET_MTU_BITS)
449
450 /** limit on the number of fragments in discontiguous MDs */
451 #define LNET_MAX_IOV    256
452
453 /**
454  * Options for the MD structure. See lnet_md_t::options.
455  */
456 #define LNET_MD_OP_PUT               (1 << 0)
457 /** See lnet_md_t::options. */
458 #define LNET_MD_OP_GET               (1 << 1)
459 /** See lnet_md_t::options. */
460 #define LNET_MD_MANAGE_REMOTE        (1 << 2)
461 /* unused                            (1 << 3) */
462 /** See lnet_md_t::options. */
463 #define LNET_MD_TRUNCATE             (1 << 4)
464 /** See lnet_md_t::options. */
465 #define LNET_MD_ACK_DISABLE          (1 << 5)
466 /** See lnet_md_t::options. */
467 #define LNET_MD_IOVEC                (1 << 6)
468 /** See lnet_md_t::options. */
469 #define LNET_MD_MAX_SIZE             (1 << 7)
470 /** See lnet_md_t::options. */
471 #define LNET_MD_KIOV                 (1 << 8)
472
473 /* For compatibility with Cray Portals */
474 #define LNET_MD_PHYS                         0
475
476 /** Infinite threshold on MD operations. See lnet_md_t::threshold */
477 #define LNET_MD_THRESH_INF       (-1)
478
479 /* NB lustre portals uses struct iovec internally! */
480 typedef struct iovec lnet_md_iovec_t;
481
482 /**
483  * A page-based fragment of a MD.
484  */
485 typedef struct {
486         /** Pointer to the page where the fragment resides */
487         struct page      *kiov_page;
488         /** Length in bytes of the fragment */
489         unsigned int     kiov_len;
490         /**
491          * Starting offset of the fragment within the page. Note that the
492          * end of the fragment must not pass the end of the page; i.e.,
493          * kiov_len + kiov_offset <= PAGE_CACHE_SIZE.
494          */
495         unsigned int     kiov_offset;
496 } lnet_kiov_t;
497 /** @} lnet_md */
498
499 /** \addtogroup lnet_eq
500  * @{ */
501
502 /**
503  * Six types of events can be logged in an event queue.
504  */
505 typedef enum {
506         /** An incoming GET operation has completed on the MD. */
507         LNET_EVENT_GET          = 1,
508         /**
509          * An incoming PUT operation has completed on the MD. The
510          * underlying layers will not alter the memory (on behalf of this
511          * operation) once this event has been logged.
512          */
513         LNET_EVENT_PUT,
514         /**
515          * A REPLY operation has completed. This event is logged after the
516          * data (if any) from the REPLY has been written into the MD.
517          */
518         LNET_EVENT_REPLY,
519         /** An acknowledgment has been received. */
520         LNET_EVENT_ACK,
521         /**
522          * An outgoing send (PUT or GET) operation has completed. This event
523          * is logged after the entire buffer has been sent and it is safe for
524          * the caller to reuse the buffer.
525          *
526          * Note:
527          * - The LNET_EVENT_SEND doesn't guarantee message delivery. It can
528          *   happen even when the message has not yet been put out on wire.
529          * - It's unsafe to assume that in an outgoing GET operation
530          *   the LNET_EVENT_SEND event would happen before the
531          *   LNET_EVENT_REPLY event. The same holds for LNET_EVENT_SEND and
532          *   LNET_EVENT_ACK events in an outgoing PUT operation.
533          */
534         LNET_EVENT_SEND,
535         /**
536          * A MD has been unlinked. Note that LNetMDUnlink() does not
537          * necessarily trigger an LNET_EVENT_UNLINK event.
538          * \see LNetMDUnlink
539          */
540         LNET_EVENT_UNLINK,
541 } lnet_event_kind_t;
542
543 #define LNET_SEQ_BASETYPE       long
544 typedef unsigned LNET_SEQ_BASETYPE lnet_seq_t;
545 #define LNET_SEQ_GT(a,b)        (((signed LNET_SEQ_BASETYPE)((a) - (b))) > 0)
546
547 /**
548  * Information about an event on a MD.
549  */
550 typedef struct {
551         /** The identifier (nid, pid) of the target. */
552         lnet_process_id_t   target;
553         /** The identifier (nid, pid) of the initiator. */
554         lnet_process_id_t   initiator;
555         /**
556          * The NID of the immediate sender. If the request has been forwarded
557          * by routers, this is the NID of the last hop; otherwise it's the
558          * same as the initiator.
559          */
560         lnet_nid_t          sender;
561         /** Indicates the type of the event. */
562         lnet_event_kind_t   type;
563         /** The portal table index specified in the request */
564         unsigned int        pt_index;
565         /** A copy of the match bits specified in the request. */
566         __u64               match_bits;
567         /** The length (in bytes) specified in the request. */
568         unsigned int        rlength;
569         /**
570          * The length (in bytes) of the data that was manipulated by the
571          * operation. For truncated operations, the manipulated length will be
572          * the number of bytes specified by the MD (possibly with an offset,
573          * see lnet_md_t). For all other operations, the manipulated length
574          * will be the length of the requested operation, i.e. rlength.
575          */
576         unsigned int        mlength;
577         /**
578          * The handle to the MD associated with the event. The handle may be
579          * invalid if the MD has been unlinked.
580          */
581         lnet_handle_md_t    md_handle;
582         /**
583          * A snapshot of the state of the MD immediately after the event has
584          * been processed. In particular, the threshold field in md will
585          * reflect the value of the threshold after the operation occurred.
586          */
587         lnet_md_t           md;
588         /**
589          * 64 bits of out-of-band user data. Only valid for LNET_EVENT_PUT.
590          * \see LNetPut
591          */
592         __u64               hdr_data;
593         /**
594          * Indicates the completion status of the operation. It's 0 for
595          * successful operations, otherwise it's an error code.
596          */
597         int                 status;
598         /**
599          * Indicates whether the MD has been unlinked. Note that:
600          * - An event with unlinked set is the last event on the MD.
601          * - This field is also set for an explicit LNET_EVENT_UNLINK event.
602          * \see LNetMDUnlink
603          */
604         int                 unlinked;
605         /**
606          * The displacement (in bytes) into the memory region that the
607          * operation used. The offset can be determined by the operation for
608          * a remote managed MD or by the local MD.
609          * \see lnet_md_t::options
610          */
611         unsigned int        offset;
612         /**
613          * The sequence number for this event. Sequence numbers are unique
614          * to each event.
615          */
616         volatile lnet_seq_t sequence;
617 } lnet_event_t;
618
619 /**
620  * Event queue handler function type.
621  *
622  * The EQ handler runs for each event that is deposited into the EQ. The
623  * handler is supplied with a pointer to the event that triggered the
624  * handler invocation.
625  *
626  * The handler must not block, must be reentrant, and must not call any LNet
627  * API functions. It should return as quickly as possible.
628  */
629 typedef void (*lnet_eq_handler_t)(lnet_event_t *event);
630 #define LNET_EQ_HANDLER_NONE NULL
631 /** @} lnet_eq */
632
633 /** \addtogroup lnet_data
634  * @{ */
635
636 /**
637  * Specify whether an acknowledgment should be sent by target when the PUT
638  * operation completes (i.e., when the data has been written to a MD of the
639  * target process).
640  *
641  * \see lnet_md_t::options for the discussion on LNET_MD_ACK_DISABLE by which
642  * acknowledgments can be disabled for a MD.
643  */
644 typedef enum {
645         /** Request an acknowledgment */
646         LNET_ACK_REQ,
647         /** Request that no acknowledgment should be generated. */
648         LNET_NOACK_REQ
649 } lnet_ack_req_t;
650 /** @} lnet_data */
651
652 /** @} lnet */
653 #endif