1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright (c) 2002-2003, Network Appliance, Inc. All rights reserved.
23 */
24
25/*
26 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
27 * Use is subject to license terms.
28 */
29
30/*
31 *
32 * MODULE: dat_strerror.c
33 *
34 * PURPOSE: Convert DAT_RETURN values to humman readable string
35 *
36 * $Id: dat_strerror.c,v 1.2 2003/08/06 14:40:29 jlentini Exp $
37 */
38
39#include <dat/udat.h>
40
41
42/*
43 *
44 * Internal Function Declarations
45 *
46 */
47
48DAT_RETURN
49dat_strerror_major(
50    IN  DAT_RETURN 		value,
51    OUT const char 		**message);
52
53DAT_RETURN
54dat_strerror_minor(
55    IN  DAT_RETURN 		value,
56    OUT const char 		**message);
57
58
59/*
60 *
61 * Internal Function Definitions
62 *
63 */
64
65DAT_RETURN
66dat_strerror_major(
67    IN  DAT_RETURN 		value,
68    OUT const char 		**message)
69{
70	switch (DAT_GET_TYPE(value)) {
71	case DAT_SUCCESS:
72	{
73		*message = "DAT_SUCCESS";
74		return (DAT_SUCCESS);
75	}
76	case DAT_ABORT:
77	{
78		*message = "DAT_ABORT";
79		return (DAT_SUCCESS);
80	}
81	case DAT_CONN_QUAL_IN_USE:
82	{
83		*message = "DAT_CONN_QUAL_IN_USE";
84		return (DAT_SUCCESS);
85	}
86	case DAT_INSUFFICIENT_RESOURCES:
87	{
88		*message = "DAT_INSUFFICIENT_RESOURCES";
89		return (DAT_SUCCESS);
90	}
91	case DAT_INTERNAL_ERROR:
92	{
93		*message = "DAT_INTERNAL_ERROR";
94		return (DAT_SUCCESS);
95	}
96	case DAT_INVALID_HANDLE:
97	{
98		*message = "DAT_INVALID_HANDLE";
99		return (DAT_SUCCESS);
100	}
101	case DAT_INVALID_PARAMETER:
102	{
103		*message = "DAT_INVALID_PARAMETER";
104		return (DAT_SUCCESS);
105	}
106	case DAT_INVALID_STATE:
107	{
108		*message = "DAT_INVALID_STATE";
109		return (DAT_SUCCESS);
110	}
111	case DAT_LENGTH_ERROR:
112	{
113		*message = "DAT_LENGTH_ERROR";
114		return (DAT_SUCCESS);
115	}
116	case DAT_MODEL_NOT_SUPPORTED:
117	{
118		*message = "DAT_MODEL_NOT_SUPPORTED";
119		return (DAT_SUCCESS);
120	}
121	case DAT_NAME_NOT_FOUND:
122	{
123		*message = "DAT_NAME_NOT_FOUND";
124		return (DAT_SUCCESS);
125	}
126	case DAT_PRIVILEGES_VIOLATION:
127	{
128		*message = "DAT_PRIVILEGES_VIOLATION";
129		return (DAT_SUCCESS);
130	}
131	case DAT_PROTECTION_VIOLATION:
132	{
133		*message = "DAT_PROTECTION_VIOLATION";
134		return (DAT_SUCCESS);
135	}
136	case DAT_QUEUE_EMPTY:
137	{
138		*message = "DAT_QUEUE_EMPTY";
139		return (DAT_SUCCESS);
140	}
141	case DAT_QUEUE_FULL:
142	{
143		*message = "DAT_QUEUE_FULL";
144		return (DAT_SUCCESS);
145	}
146	case DAT_TIMEOUT_EXPIRED:
147	{
148		*message = "DAT_TIMEOUT_EXPIRED";
149		return (DAT_SUCCESS);
150	}
151	case DAT_PROVIDER_ALREADY_REGISTERED:
152	{
153		*message = "DAT_PROVIDER_ALREADY_REGISTERED";
154		return (DAT_SUCCESS);
155	}
156	case DAT_PROVIDER_IN_USE:
157	{
158		*message = "DAT_PROVIDER_IN_USE";
159		return (DAT_SUCCESS);
160	}
161	case DAT_INVALID_ADDRESS:
162	{
163		*message = "DAT_INVALID_ADDRESS";
164		return (DAT_SUCCESS);
165	}
166	case DAT_INTERRUPTED_CALL:
167	{
168		*message = "DAT_INTERRUPTED_CALL";
169		return (DAT_SUCCESS);
170	}
171	case DAT_NOT_IMPLEMENTED:
172	{
173		*message = "DAT_NOT_IMPLEMENTED";
174		return (DAT_SUCCESS);
175	}
176	default:
177	{
178		return (DAT_INVALID_PARAMETER);
179	}
180	}
181}
182
183
184DAT_RETURN
185dat_strerror_minor(
186    IN  DAT_RETURN 		value,
187    OUT const char 		**message)
188{
189	switch (DAT_GET_SUBTYPE(value)) {
190	case DAT_NO_SUBTYPE:
191	{
192		*message = "";
193		return (DAT_SUCCESS);
194	}
195	case DAT_SUB_INTERRUPTED:
196	{
197		*message = "DAT_SUB_INTERRUPTED";
198		return (DAT_SUCCESS);
199	}
200	case DAT_RESOURCE_MEMORY:
201	{
202		*message = "DAT_RESOURCE_MEMORY";
203		return (DAT_SUCCESS);
204	}
205	case DAT_RESOURCE_DEVICE:
206	{
207		*message = "DAT_RESOURCE_DEVICE";
208		return (DAT_SUCCESS);
209	}
210	case DAT_RESOURCE_TEP:
211	{
212		*message = "DAT_RESOURCE_TEP";
213		return (DAT_SUCCESS);
214	}
215	case DAT_RESOURCE_TEVD:
216	{
217		*message = "DAT_RESOURCE_TEVD";
218		return (DAT_SUCCESS);
219	}
220	case DAT_RESOURCE_PROTECTION_DOMAIN:
221	{
222		*message = "DAT_RESOURCE_PROTECTION_DOMAIN";
223		return (DAT_SUCCESS);
224	}
225	case DAT_RESOURCE_MEMORY_REGION:
226	{
227		*message = "DAT_RESOURCE_MEMORY_REGION";
228		return (DAT_SUCCESS);
229	}
230	case DAT_RESOURCE_ERROR_HANDLER:
231	{
232		*message = "DAT_RESOURCE_ERROR_HANDLER";
233		return (DAT_SUCCESS);
234	}
235	case DAT_RESOURCE_CREDITS:
236	{
237		*message = "DAT_RESOURCE_CREDITS";
238		return (DAT_SUCCESS);
239	}
240	case DAT_INVALID_HANDLE_IA:
241	{
242		*message = "DAT_INVALID_HANDLE_IA";
243		return (DAT_SUCCESS);
244	}
245	case DAT_INVALID_HANDLE_EP:
246	{
247		*message = "DAT_INVALID_HANDLE_EP";
248		return (DAT_SUCCESS);
249	}
250	case DAT_INVALID_HANDLE_LMR:
251	{
252		*message = "DAT_INVALID_HANDLE_LMR";
253		return (DAT_SUCCESS);
254	}
255	case  DAT_INVALID_HANDLE_RMR:
256	{
257		*message = "DAT_INVALID_HANDLE_RMR";
258		return (DAT_SUCCESS);
259	}
260	case DAT_INVALID_HANDLE_PZ:
261	{
262		*message = "DAT_INVALID_HANDLE_PZ";
263		return (DAT_SUCCESS);
264	}
265	case DAT_INVALID_HANDLE_PSP:
266	{
267		*message = "DAT_INVALID_HANDLE_PSP";
268		return (DAT_SUCCESS);
269	}
270	case DAT_INVALID_HANDLE_RSP:
271	{
272		*message = "DAT_INVALID_HANDLE_RSP";
273		return (DAT_SUCCESS);
274	}
275	case DAT_INVALID_HANDLE_CR:
276	{
277		*message = "DAT_INVALID_HANDLE_CR";
278		return (DAT_SUCCESS);
279	}
280	case DAT_INVALID_HANDLE_CNO:
281	{
282		*message = "DAT_INVALID_HANDLE_CNO";
283		return (DAT_SUCCESS);
284	}
285	case DAT_INVALID_HANDLE_EVD_CR:
286	{
287		*message = "DAT_INVALID_HANDLE_EVD_CR";
288		return (DAT_SUCCESS);
289	}
290	case DAT_INVALID_HANDLE_EVD_REQUEST:
291	{
292		*message = "DAT_INVALID_HANDLE_EVD_REQUEST";
293		return (DAT_SUCCESS);
294	}
295	case DAT_INVALID_HANDLE_EVD_RECV:
296	{
297		*message = "DAT_INVALID_HANDLE_EVD_RECV";
298		return (DAT_SUCCESS);
299	}
300	case DAT_INVALID_HANDLE_EVD_CONN:
301	{
302		*message = "DAT_INVALID_HANDLE_EVD_CONN";
303		return (DAT_SUCCESS);
304	}
305	case DAT_INVALID_HANDLE_EVD_ASYNC:
306	{
307		*message = "DAT_INVALID_HANDLE_EVD_ASYNC";
308		return (DAT_SUCCESS);
309	}
310	case DAT_INVALID_ARG1:
311	{
312		*message = "DAT_INVALID_ARG1";
313		return (DAT_SUCCESS);
314	}
315	case DAT_INVALID_ARG2:
316	{
317		*message = "DAT_INVALID_ARG2";
318		return (DAT_SUCCESS);
319	}
320	case DAT_INVALID_ARG3:
321	{
322		*message = "DAT_INVALID_ARG3";
323		return (DAT_SUCCESS);
324	}
325	case DAT_INVALID_ARG4:
326	{
327		*message = "DAT_INVALID_ARG4";
328		return (DAT_SUCCESS);
329	}
330	case DAT_INVALID_ARG5:
331	{
332		*message = "DAT_INVALID_ARG5";
333		return (DAT_SUCCESS);
334	}
335	case DAT_INVALID_ARG6:
336	{
337		*message = "DAT_INVALID_ARG6";
338		return (DAT_SUCCESS);
339	}
340	case DAT_INVALID_ARG7:
341	{
342		*message = "DAT_INVALID_ARG7";
343		return (DAT_SUCCESS);
344	}
345	case DAT_INVALID_ARG8:
346	{
347		*message = "DAT_INVALID_ARG8";
348		return (DAT_SUCCESS);
349	}
350	case DAT_INVALID_ARG9:
351	{
352		*message = "DAT_INVALID_ARG9";
353		return (DAT_SUCCESS);
354	}
355	case DAT_INVALID_ARG10:
356	{
357		*message = "DAT_INVALID_ARG10";
358		return (DAT_SUCCESS);
359	}
360	case DAT_INVALID_STATE_EP_UNCONNECTED:
361	{
362		*message = "DAT_INVALID_STATE_EP_UNCONNECTED";
363		return (DAT_SUCCESS);
364	}
365	case DAT_INVALID_STATE_EP_ACTCONNPENDING:
366	{
367		*message = "DAT_INVALID_STATE_EP_ACTCONNPENDING";
368		return (DAT_SUCCESS);
369	}
370	case DAT_INVALID_STATE_EP_PASSCONNPENDING:
371	{
372		*message = "DAT_INVALID_STATE_EP_PASSCONNPENDING";
373		return (DAT_SUCCESS);
374	}
375	case DAT_INVALID_STATE_EP_TENTCONNPENDING:
376	{
377		*message = "DAT_INVALID_STATE_EP_TENTCONNPENDING";
378		return (DAT_SUCCESS);
379	}
380	case DAT_INVALID_STATE_EP_CONNECTED:
381	{
382		*message = "DAT_INVALID_STATE_EP_CONNECTED";
383		return (DAT_SUCCESS);
384	}
385	case DAT_INVALID_STATE_EP_DISCONNECTED:
386	{
387		*message = "DAT_INVALID_STATE_EP_DISCONNECTED";
388		return (DAT_SUCCESS);
389	}
390	case DAT_INVALID_STATE_EP_RESERVED:
391	{
392		*message = "DAT_INVALID_STATE_EP_RESERVED";
393		return (DAT_SUCCESS);
394	}
395	case DAT_INVALID_STATE_EP_COMPLPENDING:
396	{
397		*message = "DAT_INVALID_STATE_EP_COMPLPENDING";
398		return (DAT_SUCCESS);
399	}
400	case DAT_INVALID_STATE_EP_DISCPENDING:
401	{
402		*message = "DAT_INVALID_STATE_EP_DISCPENDING";
403		return (DAT_SUCCESS);
404	}
405	case DAT_INVALID_STATE_EP_PROVIDERCONTROL:
406	{
407		*message = "DAT_INVALID_STATE_EP_PROVIDERCONTROL";
408		return (DAT_SUCCESS);
409	}
410	case DAT_INVALID_STATE_EP_NOTREADY:
411	{
412		*message = "DAT_INVALID_STATE_EP_NOTREADY";
413		return (DAT_SUCCESS);
414	}
415	case DAT_INVALID_STATE_CNO_IN_USE:
416	{
417		*message = "DAT_INVALID_STATE_CNO_IN_USE";
418		return (DAT_SUCCESS);
419	}
420	case DAT_INVALID_STATE_CNO_DEAD:
421	{
422		*message = "DAT_INVALID_STATE_CNO_DEAD";
423		return (DAT_SUCCESS);
424	}
425	case DAT_INVALID_STATE_EVD_OPEN:
426	{
427		*message = "DAT_INVALID_STATE_EVD_OPEN";
428		return (DAT_SUCCESS);
429	}
430	case DAT_INVALID_STATE_EVD_ENABLED:
431	{
432		*message = "DAT_INVALID_STATE_EVD_ENABLED";
433		return (DAT_SUCCESS);
434	}
435	case DAT_INVALID_STATE_EVD_DISABLED:
436	{
437		*message = "DAT_INVALID_STATE_EVD_DISABLED";
438		return (DAT_SUCCESS);
439	}
440	case DAT_INVALID_STATE_EVD_WAITABLE:
441	{
442		*message = "DAT_INVALID_STATE_EVD_WAITABLE";
443		return (DAT_SUCCESS);
444	}
445	case DAT_INVALID_STATE_EVD_UNWAITABLE:
446	{
447		*message = "DAT_INVALID_STATE_EVD_UNWAITABLE";
448		return (DAT_SUCCESS);
449	}
450	case DAT_INVALID_STATE_EVD_IN_USE:
451	{
452		*message = "DAT_INVALID_STATE_EVD_IN_USE";
453		return (DAT_SUCCESS);
454	}
455	case DAT_INVALID_STATE_EVD_CONFIG_NOTIFY:
456	{
457		*message = "DAT_INVALID_STATE_EVD_CONFIG_NOTIFY";
458		return (DAT_SUCCESS);
459	}
460	case DAT_INVALID_STATE_EVD_CONFIG_SOLICITED:
461	{
462		*message = "DAT_INVALID_STATE_EVD_CONFIG_SOLICITED";
463		return (DAT_SUCCESS);
464	}
465	case DAT_INVALID_STATE_EVD_CONFIG_THRESHOLD:
466	{
467		*message = "DAT_INVALID_STATE_EVD_CONFIG_THRESHOLD";
468		return (DAT_SUCCESS);
469	}
470	case DAT_INVALID_STATE_EVD_WAITER:
471	{
472		*message = "DAT_INVALID_STATE_EVD_WAITER";
473		return (DAT_SUCCESS);
474	}
475	case DAT_INVALID_STATE_EVD_ASYNC:
476	{
477		*message = "DAT_INVALID_STATE_EVD_ASYNC";
478		return (DAT_SUCCESS);
479	}
480	case DAT_INVALID_STATE_IA_IN_USE:
481	{
482		*message = "DAT_INVALID_STATE_IA_IN_USE";
483		return (DAT_SUCCESS);
484	}
485	case DAT_INVALID_STATE_LMR_IN_USE:
486	{
487		*message = "DAT_INVALID_STATE_LMR_IN_USE";
488		return (DAT_SUCCESS);
489	}
490	case DAT_INVALID_STATE_LMR_FREE:
491	{
492		*message = "DAT_INVALID_STATE_LMR_FREE";
493		return (DAT_SUCCESS);
494	}
495	case DAT_INVALID_STATE_PZ_IN_USE:
496	{
497		*message = "DAT_INVALID_STATE_PZ_IN_USE";
498		return (DAT_SUCCESS);
499	}
500	case DAT_INVALID_STATE_PZ_FREE:
501	{
502		*message = "DAT_INVALID_STATE_PZ_FREE";
503		return (DAT_SUCCESS);
504	}
505	case DAT_PRIVILEGES_READ:
506	{
507		*message = "DAT_PRIVILEGES_READ";
508		return (DAT_SUCCESS);
509	}
510	case DAT_PRIVILEGES_WRITE:
511	{
512		*message = "DAT_PRIVILEGES_WRITE";
513		return (DAT_SUCCESS);
514	}
515	case DAT_PRIVILEGES_RDMA_READ:
516	{
517		*message = "DAT_PRIVILEGES_RDMA_READ";
518		return (DAT_SUCCESS);
519	}
520	case DAT_PRIVILEGES_RDMA_WRITE:
521	{
522		*message = "DAT_PRIVILEGES_RDMA_WRITE";
523		return (DAT_SUCCESS);
524	}
525	case DAT_PROTECTION_READ:
526	{
527		*message = "DAT_PROTECTION_READ";
528		return (DAT_SUCCESS);
529	}
530	case DAT_PROTECTION_WRITE:
531	{
532		*message = "DAT_PROTECTION_WRITE";
533		return (DAT_SUCCESS);
534	}
535	case DAT_PROTECTION_RDMA_READ:
536	{
537		*message = "DAT_PROTECTION_RDMA_READ";
538		return (DAT_SUCCESS);
539	}
540	case DAT_PROTECTION_RDMA_WRITE:
541	{
542		*message = "DAT_PROTECTION_RDMA_WRITE";
543		return (DAT_SUCCESS);
544	}
545	case DAT_INVALID_ADDRESS_UNSUPPORTED:
546	{
547		*message = "DAT_INVALID_ADDRESS_UNSUPPORTED";
548		return (DAT_SUCCESS);
549	}
550	case DAT_INVALID_ADDRESS_UNREACHABLE:
551	{
552		*message = "DAT_INVALID_ADDRESS_UNREACHABLE";
553		return (DAT_SUCCESS);
554	}
555	case DAT_INVALID_ADDRESS_MALFORMED:
556	{
557		*message = "DAT_INVALID_ADDRESS_MALFORMED";
558		return (DAT_SUCCESS);
559	}
560	case DAT_INVALID_RO_COOKIE:
561		*message = "DAT_INVALID_RO_COOKIE";
562		return (DAT_SUCCESS);
563	default:
564	{
565		return (DAT_INVALID_PARAMETER);
566	}
567	}
568}
569
570
571/*
572 *
573 * External Function Definitions
574 *
575 */
576
577DAT_RETURN
578dat_strerror(
579	IN  DAT_RETURN 		value,
580	OUT const char 		**major_message,
581	OUT const char		**minor_message)
582{
583	/*
584	 * The DAT specification contains a note to implementers
585	 * suggesting that the consumer's DAT_RETURN value be used
586	 * as an index into a table of text strings. However,
587	 * the DAT_RETURN values are not consecutive. Therefore this
588	 * implementation does not follow the suggested implementation.
589	 */
590
591	if (DAT_SUCCESS != dat_strerror_major(value, major_message)) {
592		return (DAT_INVALID_PARAMETER);
593	} else if (DAT_SUCCESS != dat_strerror_minor(value, minor_message)) {
594		return (DAT_INVALID_PARAMETER);
595	} else {
596		return (DAT_SUCCESS);
597	}
598}
599