Debian Codegraph @

dat/include/dat2/udat.h

raw
1 /*
2 * Copyright (c) 2002-2006, Network Appliance, Inc. All rights reserved.
3 *
4 * This Software is licensed under all of the following licenses:
5 *
6 * 1) under the terms of the "Common Public License 1.0" a copy of which is
7 * in the file LICENSE.txt in the root directory. The license is also
8 * available from the Open Source Initiative, see
9 * http://www.opensource.org/licenses/cpl.php.
10 *
11 * 2) under the terms of the "The BSD License" a copy of which is in the file
12 * LICENSE2.txt in the root directory. The license is also available from
13 * the Open Source Initiative, see
14 * http://www.opensource.org/licenses/bsd-license.php.
15 *
16 * 3) under the terms of the "GNU General Public License (GPL) Version 2" a
17 * copy of which is in the file LICENSE3.txt in the root directory. The
18 * license is also available from the Open Source Initiative, see
19 * http://www.opensource.org/licenses/gpl-license.php.
20 *
21 * Licensee has the right to choose one of the above licenses.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions are
25 * met:
26 *
27 * Redistributions of source code must retain both the above copyright
28 * notice and one of the license notices.
29 *
30 * Redistributions in binary form must reproduce both the above copyright
31 * notice, one of the license notices in the documentation
32 * and/or other materials provided with the distribution.
33 *
34 * Neither the name of Network Appliance, Inc. nor the names of other DAT
35 * Collaborative contributors may be used to endorse or promote
36 * products derived from this software without specific prior written
37 * permission.
38 */
39
40 /****************************************************************
41 *
42 * HEADER: udat.h
43 *
44 * PURPOSE: defines the user DAT API
45 *
46 * Description: Header file for "uDAPL: User Direct Access Programming
47 * Library, Version: 2.0"
48 *
49 * Mapping rules:
50 * All global symbols are prepended with DAT_ or dat_
51 * All DAT objects have an 'api' tag which, such as 'ep' or 'lmr'
52 * The method table is in the provider definition structure.
53 *
54 ***************************************************************/
55
56 #ifndef _UDAT_H_
57 #define _UDAT_H_
58
59 #include <dat2/udat_config.h>
60 #include <dat2/dat_platform_specific.h>
61
62 #ifdef __cplusplus
63 extern "C"
64 {
65 #endif
66
67 typedef enum dat_mem_type
68 {
69 /* Shared between udat and kdat */
70 DAT_MEM_TYPE_VIRTUAL = 0x00,
71 DAT_MEM_TYPE_LMR = 0x01,
72 /* udat specific */
73 DAT_MEM_TYPE_SHARED_VIRTUAL = 0x02
74 } DAT_MEM_TYPE;
75
76 /* dat handle types */
77 typedef enum dat_handle_type
78 {
79 DAT_HANDLE_TYPE_CR,
80 DAT_HANDLE_TYPE_EP,
81 DAT_HANDLE_TYPE_EVD,
82 DAT_HANDLE_TYPE_IA,
83 DAT_HANDLE_TYPE_LMR,
84 DAT_HANDLE_TYPE_PSP,
85 DAT_HANDLE_TYPE_PZ,
86 DAT_HANDLE_TYPE_RMR,
87 DAT_HANDLE_TYPE_RSP,
88 DAT_HANDLE_TYPE_CNO,
89 DAT_HANDLE_TYPE_SRQ,
90 DAT_HANDLE_TYPE_CSP
91 #ifdef DAT_EXTENSIONS
92 ,DAT_HANDLE_TYPE_EXTENSION_BASE
93 #endif
94 } DAT_HANDLE_TYPE;
95
96 /* EVD state consists of three orthogonal substates. One for
97 * enabled/disabled,one for waitable/unwaitable, and one for
98 * configuration. Within each substate the values are mutually
99 * exclusive.
100 */
101 typedef enum dat_evd_state
102 {
103 DAT_EVD_STATE_ENABLED = 0x01,
104 DAT_EVD_STATE_DISABLED = 0x02,
105 DAT_EVD_STATE_WAITABLE = 0x04,
106 DAT_EVD_STATE_UNWAITABLE = 0x08,
107 DAT_EVD_STATE_CONFIG_NOTIFY = 0x10,
108 DAT_EVD_STATE_CONFIG_SOLICITED = 0x20,
109 DAT_EVD_STATE_CONFIG_THRESHOLD = 0x30
110 } DAT_EVD_STATE;
111
112 typedef enum dat_evd_param_mask
113 {
114 DAT_EVD_FIELD_IA_HANDLE = 0x01,
115 DAT_EVD_FIELD_EVD_QLEN = 0x02,
116 DAT_EVD_FIELD_EVD_STATE = 0x04,
117 DAT_EVD_FIELD_CNO = 0x08,
118 DAT_EVD_FIELD_EVD_FLAGS = 0x10,
119 DAT_EVD_FIELD_ALL = 0x1F
120 } DAT_EVD_PARAM_MASK;
121
122 typedef DAT_UINT64 DAT_PROVIDER_ATTR_MASK;
123
124 enum dat_lmr_param_mask
125 {
126 DAT_LMR_FIELD_IA_HANDLE = 0x001,
127 DAT_LMR_FIELD_MEM_TYPE = 0x002,
128 DAT_LMR_FIELD_REGION_DESC = 0x004,
129 DAT_LMR_FIELD_LENGTH = 0x008,
130 DAT_LMR_FIELD_PZ_HANDLE = 0x010,
131 DAT_LMR_FIELD_MEM_PRIV = 0x020,
132 DAT_LMR_FIELD_VA_TYPE = 0x040,
133 DAT_LMR_FIELD_LMR_CONTEXT = 0x080,
134 DAT_LMR_FIELD_RMR_CONTEXT = 0x100,
135 DAT_LMR_FIELD_REGISTERED_SIZE = 0x200,
136 DAT_LMR_FIELD_REGISTERED_ADDRESS = 0x400,
137
138 DAT_LMR_FIELD_ALL = 0x7FF
139 };
140
141 #include <dat2/dat.h>
142
143 typedef DAT_HANDLE DAT_CNO_HANDLE;
144
145 struct dat_evd_param
146 {
147 DAT_IA_HANDLE ia_handle;
148 DAT_COUNT evd_qlen;
149 DAT_EVD_STATE evd_state;
150 DAT_CNO_HANDLE cno_handle;
151 DAT_EVD_FLAGS evd_flags;
152 };
153
154 #define DAT_LMR_COOKIE_SIZE 40 /* size of DAT_LMR_COOKIE in bytes */
155 typedef char (* DAT_LMR_COOKIE)[DAT_LMR_COOKIE_SIZE];
156
157 /* Format for OS wait proxy agent function */
158
159 typedef void (DAT_API *DAT_AGENT_FUNC)
160 (
161 DAT_PVOID, /* instance data */
162 DAT_EVD_HANDLE /* Event Dispatcher*/
163 );
164
165 /* Definition */
166
167 typedef struct dat_os_wait_proxy_agent
168 {
169 DAT_PVOID instance_data;
170 DAT_AGENT_FUNC proxy_agent_func;
171 } DAT_OS_WAIT_PROXY_AGENT;
172
173 /* Define NULL Proxy agent */
174
175 #define DAT_OS_WAIT_PROXY_AGENT_NULL \
176 (DAT_OS_WAIT_PROXY_AGENT) { \
177 (DAT_PVOID) NULL, \
178 (DAT_AGENT_FUNC) NULL}
179
180 /* Flags */
181
182 /* The value specified by the uDAPL Consumer for dat_ia_open to indicate
183 * that no async EVD should be created for the opening instance of an IA.
184 * The same IA has been open before that has the only async EVD to
185 * handle async errors for all open instances of the IA.
186 */
187
188 #define DAT_EVD_ASYNC_EXISTS (DAT_EVD_HANDLE) 0x1
189
190 /*
191 * The value returned by the dat_ia_query for the case when there is no
192 * async EVD for the IA instance. The Consumer specified the value of
193 * DAT_EVD_ASYNC_EXISTS for the async_evd_handle for dat_ia_open.
194 */
195
196 #define DAT_EVD_OUT_OF_SCOPE (DAT_EVD_HANDLE) 0x2
197
198 /*
199 * Memory types
200 *
201 * Specifying memory type for LMR create. A Consumer must use a single
202 * value when registering memory. The union of any of these
203 * flags is used in the Provider parameters to indicate what memory
204 * type Provider supports for LMR memory creation.
205 */
206
207 /* For udapl only */
208
209 typedef struct dat_shared_memory
210 {
211 DAT_PVOID virtual_address;
212 DAT_LMR_COOKIE shared_memory_id;
213 } DAT_SHARED_MEMORY;
214
215 typedef union dat_region_description
216 {
217 DAT_PVOID for_va;
218 DAT_LMR_HANDLE for_lmr_handle;
219 DAT_SHARED_MEMORY for_shared_memory; /* For udapl only */
220 } DAT_REGION_DESCRIPTION;
221
222 /* LMR Arguments */
223
224 struct dat_lmr_param
225 {
226 DAT_IA_HANDLE ia_handle;
227 DAT_MEM_TYPE mem_type;
228 DAT_REGION_DESCRIPTION region_desc;
229 DAT_VLEN length;
230 DAT_PZ_HANDLE pz_handle;
231 DAT_MEM_PRIV_FLAGS mem_priv;
232 DAT_VA_TYPE va_type;
233 DAT_LMR_CONTEXT lmr_context;
234 DAT_RMR_CONTEXT rmr_context;
235 DAT_VLEN registered_size;
236 DAT_VADDR registered_address;
237 };
238
239 typedef enum dat_proxy_type
240 {
241 DAT_PROXY_TYPE_NONE = 0x0,
242 DAT_PROXY_TYPE_AGENT = 0x1,
243 DAT_PROXY_TYPE_FD = 0x2
244 } DAT_PROXY_TYPE;
245
246 typedef struct dat_cno_param
247 {
248 DAT_IA_HANDLE ia_handle;
249 DAT_PROXY_TYPE proxy_type;
250 union {
251 DAT_OS_WAIT_PROXY_AGENT agent;
252 DAT_FD fd;
253 DAT_PVOID none;
254 } proxy;
255 } DAT_CNO_PARAM;
256
257 typedef enum dat_cno_param_mask
258 {
259 DAT_CNO_FIELD_IA_HANDLE = 0x1,
260 DAT_CNO_FIELD_PROXY_TYPE = 0x2,
261 DAT_CNO_FIELD_PROXY = 0x3,
262 DAT_CNO_FIELD_ALL = 0x4
263 } DAT_CNO_PARAM_MASK;
264
265 struct dat_ia_attr
266 {
267 char adapter_name[DAT_NAME_MAX_LENGTH];
268 char vendor_name[DAT_NAME_MAX_LENGTH];
269 DAT_UINT32 hardware_version_major;
270 DAT_UINT32 hardware_version_minor;
271 DAT_UINT32 firmware_version_major;
272 DAT_UINT32 firmware_version_minor;
273 DAT_IA_ADDRESS_PTR ia_address_ptr;
274 DAT_COUNT max_eps;
275 DAT_COUNT max_dto_per_ep;
276 DAT_COUNT max_rdma_read_per_ep_in;
277 DAT_COUNT max_rdma_read_per_ep_out;
278 DAT_COUNT max_evds;
279 DAT_COUNT max_evd_qlen;
280 DAT_COUNT max_iov_segments_per_dto;
281 DAT_COUNT max_lmrs;
282 DAT_SEG_LENGTH max_lmr_block_size;
283 DAT_VADDR max_lmr_virtual_address;
284 DAT_COUNT max_pzs;
285 DAT_SEG_LENGTH max_message_size;
286 DAT_SEG_LENGTH max_rdma_size;
287 DAT_COUNT max_rmrs;
288 DAT_VADDR max_rmr_target_address;
289 DAT_COUNT max_srqs;
290 DAT_COUNT max_ep_per_srq;
291 DAT_COUNT max_recv_per_srq;
292 DAT_COUNT max_iov_segments_per_rdma_read;
293 DAT_COUNT max_iov_segments_per_rdma_write;
294 DAT_COUNT max_rdma_read_in;
295 DAT_COUNT max_rdma_read_out;
296 DAT_BOOLEAN max_rdma_read_per_ep_in_guaranteed;
297 DAT_BOOLEAN max_rdma_read_per_ep_out_guaranteed;
298 DAT_BOOLEAN zb_supported;
299 DAT_EXTENSION extension_supported;
300 DAT_COUNT extension_version;
301 DAT_COUNT num_transport_attr;
302 DAT_NAMED_ATTR *transport_attr;
303 DAT_COUNT num_vendor_attr;
304 DAT_NAMED_ATTR *vendor_attr;
305 };
306
307
308 #define DAT_IA_FIELD_IA_EXTENSION UINT64_C(0x100000000)
309 #define DAT_IA_FIELD_IA_EXTENSION_VERSION UINT64_C(0x200000000)
310
311 #define DAT_IA_FIELD_IA_NUM_TRANSPORT_ATTR UINT64_C(0x400000000)
312 #define DAT_IA_FIELD_IA_TRANSPORT_ATTR UINT64_C(0x800000000)
313 #define DAT_IA_FIELD_IA_NUM_VENDOR_ATTR UINT64_C(0x1000000000)
314 #define DAT_IA_FIELD_IA_VENDOR_ATTR UINT64_C(0x2000000000)
315 #define DAT_IA_FIELD_ALL UINT64_C(0x3FFFFFFFFF)
316
317 /* General Provider attributes. udat specific. */
318
319 typedef enum dat_pz_support
320 {
321 DAT_PZ_UNIQUE,
322 DAT_PZ_SHAREABLE
323 } DAT_PZ_SUPPORT;
324
325 #include <dat2/udat_vendor_specific.h>
326
327 /* Provider should support merging of all event stream types. Provider
328 * attribute specify support for merging different event stream types.
329 * It is a 2D binary matrix where each row and column represents an event
330 * stream type. Each binary entry is 1 if the event streams of its raw
331 * and column can fed the same EVD, and 0 otherwise. The order of event
332 * streams in row and column is the same as in the definition of
333 * DAT_EVD_FLAGS: index 0 - Software Event, 1- Connection Request,
334 * 2 - DTO Completion, 3 - Connection event, 4 - RMR Bind Completion,
335 * 5 - Asynchronous event. By definition each diagonal entry is 1.
336 * Consumer allocates an array for it and passes it IN as a pointer
337 * for the array that Provider fills. Provider must fill the array
338 * that Consumer passes.
339 */
340
341 struct dat_provider_attr
342 {
343 char provider_name[DAT_NAME_MAX_LENGTH];
344 DAT_UINT32 provider_version_major;
345 DAT_UINT32 provider_version_minor;
346 DAT_UINT32 dapl_version_major;
347 DAT_UINT32 dapl_version_minor;
348 DAT_MEM_TYPE lmr_mem_types_supported;
349 DAT_IOV_OWNERSHIP iov_ownership_on_return;
350 DAT_QOS dat_qos_supported;
351 DAT_COMPLETION_FLAGS completion_flags_supported;
352 DAT_BOOLEAN is_thread_safe;
353 DAT_COUNT max_private_data_size;
354 DAT_BOOLEAN supports_multipath;
355 DAT_EP_CREATOR_FOR_PSP ep_creator;
356 DAT_PZ_SUPPORT pz_support;
357 DAT_UINT32 optimal_buffer_alignment;
358 const DAT_BOOLEAN evd_stream_merging_supported[6][6];
359 DAT_BOOLEAN srq_supported;
360 DAT_COUNT srq_watermarks_supported;
361 DAT_BOOLEAN srq_ep_pz_difference_supported;
362 DAT_COUNT srq_info_supported;
363 DAT_COUNT ep_recv_info_supported;
364 DAT_BOOLEAN lmr_sync_req;
365 DAT_BOOLEAN dto_async_return_guaranteed;
366 DAT_BOOLEAN rdma_write_for_rdma_read_req;
367 DAT_BOOLEAN rdma_read_lmr_rmr_context_exposure;
368 DAT_RMR_SCOPE rmr_scope_supported;
369 DAT_BOOLEAN is_signal_safe;
370 DAT_BOOLEAN ha_supported;
371 DAT_HA_LB ha_loadbalancing;
372 DAT_COUNT num_provider_specific_attr;
373 DAT_NAMED_ATTR * provider_specific_attr;
374 };
375
376 #define DAT_PROVIDER_FIELD_PROVIDER_NAME UINT64_C(0x00000001)
377 #define DAT_PROVIDER_FIELD_PROVIDER_VERSION_MAJOR UINT64_C(0x00000002)
378 #define DAT_PROVIDER_FIELD_PROVIDER_VERSION_MINOR UINT64_C(0x00000004)
379 #define DAT_PROVIDER_FIELD_DAPL_VERSION_MAJOR UINT64_C(0x00000008)
380 #define DAT_PROVIDER_FIELD_DAPL_VERSION_MINOR UINT64_C(0x00000010)
381 #define DAT_PROVIDER_FIELD_LMR_MEM_TYPE_SUPPORTED UINT64_C(0x00000020)
382 #define DAT_PROVIDER_FIELD_IOV_OWNERSHIP UINT64_C(0x00000040)
383 #define DAT_PROVIDER_FIELD_DAT_QOS_SUPPORTED UINT64_C(0x00000080)
384 #define DAT_PROVIDER_FIELD_COMPLETION_FLAGS_SUPPORTED UINT64_C(0x00000100)
385 #define DAT_PROVIDER_FIELD_IS_THREAD_SAFE UINT64_C(0x00000200)
386 #define DAT_PROVIDER_FIELD_MAX_PRIVATE_DATA_SIZE UINT64_C(0x00000400)
387 #define DAT_PROVIDER_FIELD_SUPPORTS_MULTIPATH UINT64_C(0x00000800)
388 #define DAT_PROVIDER_FIELD_EP_CREATOR UINT64_C(0x00001000)
389 #define DAT_PROVIDER_FIELD_PZ_SUPPORT UINT64_C(0x00002000)
390 #define DAT_PROVIDER_FIELD_OPTIMAL_BUFFER_ALIGNMENT UINT64_C(0x00004000)
391 #define DAT_PROVIDER_FIELD_EVD_STREAM_MERGING_SUPPORTED UINT64_C(0x00008000)
392 #define DAT_PROVIDER_FIELD_SRQ_SUPPORTED UINT64_C(0x00010000)
393 #define DAT_PROVIDER_FIELD_SRQ_WATERMARKS_SUPPORTED UINT64_C(0x00020000)
394 #define DAT_PROVIDER_FIELD_SRQ_EP_PZ_DIFFERENCE_SUPPORTED UINT64_C(0x00040000)
395 #define DAT_PROVIDER_FIELD_SRQ_INFO_SUPPORTED UINT64_C(0x00080000)
396 #define DAT_PROVIDER_FIELD_EP_RECV_INFO_SUPPORTED UINT64_C(0x00100000)
397 #define DAT_PROVIDER_FIELD_LMR_SYNC_REQ UINT64_C(0x00200000)
398 #define DAT_PROVIDER_FIELD_DTO_ASYNC_RETURN_GUARANTEED UINT64_C(0x00400000)
399 #define DAT_PROVIDER_FIELD_RDMA_WRITE_FOR_RDMA_READ_REQ UINT64_C(0x00800000)
400 #define DAT_PROVIDER_FIELD_RDMA_READ_LMR_RMR_CONTEXT_EXPOSURE UINT64_C(0x01000000)
401 #define DAT_PROVIDER_FIELD_RMR_SCOPE_SUPPORTED UINT64_C(0x02000000)
402 #define DAT_PROVIDER_FIELD_IS_SIGNAL_SAFE UINT64_C(0x04000000)
403 #define DAT_PROVIDER_FIELD_HA_SUPPORTED UINT64_C(0x08000000)
404 #define DAT_PROVIDER_FIELD_HA_LB UINT64_C(0x10000000)
405 #define DAT_PROVIDER_FIELD_NUM_PROVIDER_SPECIFIC_ATTR UINT64_C(0x20000000)
406 #define DAT_PROVIDER_FIELD_PROVIDER_SPECIFIC_ATTR UINT64_C(0x40000000)
407
408 #define DAT_PROVIDER_FIELD_ALL UINT64_C(0x7FFFFFFF)
409 #define DAT_PROVIDER_FIELD_NONE UINT64_C(0x0)
410
411 /**************************************************************/
412
413 /*
414 * User DAT function call definitions,
415 */
416
417 extern DAT_RETURN DAT_API dat_lmr_create (
418 IN DAT_IA_HANDLE, /* ia_handle */
419 IN DAT_MEM_TYPE, /* mem_type */
420 IN DAT_REGION_DESCRIPTION, /* region_description */
421 IN DAT_VLEN, /* length */
422 IN DAT_PZ_HANDLE, /* pz_handle */
423 IN DAT_MEM_PRIV_FLAGS, /* privileges */
424 IN DAT_VA_TYPE, /* va_type */
425 OUT DAT_LMR_HANDLE *, /* lmr_handle */
426 OUT DAT_LMR_CONTEXT *, /* lmr_context */
427 OUT DAT_RMR_CONTEXT *, /* rmr_context */
428 OUT DAT_VLEN *, /* registered_length */
429 OUT DAT_VADDR * ); /* registered_address */
430
431 extern DAT_RETURN DAT_API dat_lmr_query (
432 IN DAT_LMR_HANDLE, /* lmr_handle */
433 IN DAT_LMR_PARAM_MASK, /* lmr_param_mask */
434 OUT DAT_LMR_PARAM * ); /* lmr_param */
435
436 /* Event Functions */
437
438 extern DAT_RETURN DAT_API dat_evd_create (
439 IN DAT_IA_HANDLE, /* ia_handle */
440 IN DAT_COUNT, /* evd_min_qlen */
441 IN DAT_CNO_HANDLE, /* cno_handle */
442 IN DAT_EVD_FLAGS, /* evd_flags */
443 OUT DAT_EVD_HANDLE * ); /* evd_handle */
444
445 extern DAT_RETURN DAT_API dat_evd_modify_cno (
446 IN DAT_EVD_HANDLE, /* evd_handle */
447 IN DAT_CNO_HANDLE); /* cno_handle */
448
449 extern DAT_RETURN DAT_API dat_cno_create (
450 IN DAT_IA_HANDLE, /* ia_handle */
451 IN DAT_OS_WAIT_PROXY_AGENT,/* agent */
452 OUT DAT_CNO_HANDLE *); /* cno_handle */
453
454 extern DAT_RETURN DAT_API dat_cno_modify_agent (
455 IN DAT_CNO_HANDLE, /* cno_handle */
456 IN DAT_OS_WAIT_PROXY_AGENT);/* agent */
457
458 extern DAT_RETURN DAT_API dat_cno_query (
459 IN DAT_CNO_HANDLE, /* cno_handle */
460 IN DAT_CNO_PARAM_MASK, /* cno_param_mask */
461 OUT DAT_CNO_PARAM * ); /* cno_param */
462
463 extern DAT_RETURN DAT_API dat_cno_free (
464 IN DAT_CNO_HANDLE); /* cno_handle */
465
466 extern DAT_RETURN DAT_API dat_cno_wait (
467 IN DAT_CNO_HANDLE, /* cno_handle */
468 IN DAT_TIMEOUT, /* timeout */
469 OUT DAT_EVD_HANDLE *); /* evd_handle */
470
471 extern DAT_RETURN DAT_API dat_evd_enable (
472 IN DAT_EVD_HANDLE); /* evd_handle */
473
474 extern DAT_RETURN DAT_API dat_evd_wait (
475 IN DAT_EVD_HANDLE, /* evd_handle */
476 IN DAT_TIMEOUT, /* timeout */
477 IN DAT_COUNT, /* threshold */
478 OUT DAT_EVENT *, /* event */
479 OUT DAT_COUNT * ); /* n_more_events */
480
481 extern DAT_RETURN DAT_API dat_evd_disable (
482 IN DAT_EVD_HANDLE); /* evd_handle */
483
484 extern DAT_RETURN DAT_API dat_evd_set_unwaitable (
485 IN DAT_EVD_HANDLE); /* evd_handle */
486
487 extern DAT_RETURN DAT_API dat_evd_clear_unwaitable (
488 IN DAT_EVD_HANDLE); /* evd_handle */
489
490 extern DAT_RETURN DAT_API dat_cno_fd_create (
491 IN DAT_IA_HANDLE, /* ia_handle */
492 OUT DAT_FD *, /* file descriptor */
493 OUT DAT_CNO_HANDLE * ); /* cno_handle */
494
495 extern DAT_RETURN DAT_API dat_cno_trigger (
496 IN DAT_CNO_HANDLE, /* cno_handle */
497 OUT DAT_EVD_HANDLE * ); /* evd_handle */
498
499 #ifdef __cplusplus
500 }
501 #endif
502
503 #endif /* _UDAT_H_ */