xref: /illumos-gate/usr/src/lib/libpri/common/pri.c (revision e82e447a)
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 2007 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <stdio.h>
29 #include <sys/param.h>
30 #include <fcntl.h>
31 #include <poll.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include <errno.h>
35 
36 #include "sys/ds_pri.h"
37 #include "pri.h"
38 
39 static int pri_fd = -1;
40 
41 
42 
43 /*
44  * Library init function
45  * Returns: Success (0), Failure (-1)
46  */
47 int
pri_init(void)48 pri_init(void)
49 {
50 	int fd;
51 
52 	if (pri_fd != -1)
53 		return (-1);
54 
55 	fd = open(DS_PRI_DRIVER, O_RDONLY);
56 	if (fd < 0)
57 		return (-1);
58 
59 	pri_fd = fd;
60 
61 	return (0);
62 }
63 
64 /*
65  * Library fini function
66  * Returns: N/A
67  */
68 void
pri_fini(void)69 pri_fini(void)
70 {
71 	if (pri_fd < 0)
72 		return;
73 
74 	(void) close(pri_fd);
75 	pri_fd = -1;
76 }
77 
78 /*
79  * PRI retrieval function.
80  * Description:
81  *	- Library routine to retrieve the Physical Resource Inventory (PRI)
82  *	- Utilized by sun4v platforms which support Logical Domains
83  *	- Interacts with the ds_pri pseudo driver to retrieve the
84  *	  PRI. ds_pri driver in turn gets the PRI from the
85  *	  Domain Services kernel module. Domain Services gets the
86  *	  PRI from the Service Processor via LDC (Logical Domain
87  *	  Channel).
88  *	- Consumers of this api include FMA, Zeus, and picld
89  *	- MT-Safe, Stateless
90  *
91  * Imports:
92  *	- ds_pri driver interfaces
93  *
94  * Arguments:
95  *	- wait: specifies whether caller wants to wait for a new PRI,
96  *		PRI_GET is no-wait, PRI_WAITGET is wait-forever
97  *	- token: opaque PRI token, accepted from and/or returned to caller,
98  *		see write-only or read-write semantics below
99  *	- buf: PRI buffer received from ds_pri driver, returned to caller
100  *	- allocp: caller provided pointer to memory allocator function
101  *	- freep: caller provided pointer to memory free function
102  *
103  * Calling Semantics:
104  *	- PRI_GET call ignores the token passed in, and returns
105  *	  immediately with current PRI and its token (if any)
106  *	- PRI_WAITGET call returns only upon the receipt of a new PRI
107  *	  whose token differs from the token passed in by the caller;
108  *	  the passed in token should come from a previous pri_get()
109  *	  call with return value >= 0; the new PRI buffer and its token
110  *	  are returned to the caller
111  *	- If wait time must be bounded, the caller can spawn a thread
112  *	  which makes a PRI_WAITGET call; caller can choose to kill the
113  *	  spawned thread after a finite time
114  *
115  * Usage Semantics:
116  *	- Caller can use the returned PRI buffer as an argument to
117  *	  to md_init_intern() to process it into a machine
118  *	  descriptor (md_t) format
119  *	- Caller can choose to supply the same allocator and free
120  *	  functions to the md_init_intern() call
121  *	- Once the caller is done using these data structures,
122  *	  the following actions need to be performed by the caller:
123  *		- md_fini(mdp) if called md_init_intern()
124  *		- freep(bufp, size)
125  *
126  * Returns:
127  *	>0 if PRI is returned successfully (size of PRI buffer)
128  *	0 if no PRI is available
129  *	-1 if there is an error (errno contains the error code
130  *	provided)
131  *
132  */
133 ssize_t
pri_get(uint8_t wait,uint64_t * token,uint64_t ** buf,void * (* allocp)(size_t),void (* freep)(void *,size_t))134 pri_get(uint8_t wait, uint64_t *token, uint64_t **buf,
135 		void *(*allocp)(size_t), void (*freep)(void *, size_t))
136 {
137 	uint64_t		*bufp;		/* buf holding PRI */
138 	size_t			size;		/* sizeof PRI */
139 	struct dspri_info	pri_info;	/* info about PRI */
140 	struct dspri_info	pri_info2;	/* for PRI delta check */
141 
142 	if (pri_fd < 0) {
143 		errno = EBADF;
144 		return (-1);
145 	}
146 
147 	if (wait == PRI_WAITGET) {
148 		/* wait until have new PRI with different token */
149 		if (ioctl(pri_fd, DSPRI_WAIT, token) < 0) {
150 			return (-1);
151 		}
152 	}
153 
154 	do {
155 		/* get info on current PRI */
156 		if (ioctl(pri_fd, DSPRI_GETINFO, &pri_info) < 0) {
157 			return (-1);
158 		}
159 
160 		size = (size_t)pri_info.size;
161 
162 		/* check to see if no PRI available yet */
163 		if (size == 0) {
164 			*token = pri_info.token;
165 			return (0);
166 		}
167 
168 		/* allocate a buffer and read the PRI into it */
169 		if ((bufp = (uint64_t *)allocp(size)) == NULL) {
170 			if (errno == 0)
171 				errno = ENOMEM;
172 			return (-1);
173 		}
174 		if (read(pri_fd, bufp, size) < 0) {
175 			freep(bufp, size);
176 			return (-1);
177 		}
178 
179 		/*
180 		 * Check whether PRI token changed between the time
181 		 * we did the DSPRI_GETINFO ioctl() and the actual
182 		 * read() from the ds_pri driver. The token delta check
183 		 * tries to catch the above race condition; be sure
184 		 * to not leak memory on retries.
185 		 */
186 		if (ioctl(pri_fd, DSPRI_GETINFO, &pri_info2) < 0) {
187 			freep(bufp, size);
188 			return (-1);
189 		}
190 		if (pri_info2.token != pri_info.token)
191 			freep(bufp, size);
192 
193 	} while (pri_info2.token != pri_info.token);
194 
195 	/* return the PRI, its token, and its size to the caller */
196 	*buf = bufp;
197 	*token = pri_info.token;
198 	return ((ssize_t)size);
199 }
200