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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 
30 #include "cfga_usb.h"
31 
32 
33 #define	MAX_FORMAT	80	/* for info table */
34 
35 cfga_usb_ret_t		usb_rcm_offline(const char *, char **, char *,
36 			    cfga_flags_t);
37 cfga_usb_ret_t		usb_rcm_online(const char *, char **, char *,
38 			    cfga_flags_t);
39 cfga_usb_ret_t		usb_rcm_remove(const char *, char **, char *,
40 			    cfga_flags_t);
41 static cfga_usb_ret_t 	usb_rcm_info_table(rcm_info_t *, char **);
42 static cfga_usb_ret_t 	usb_rcm_init(const char *, cfga_flags_t, char **,
43 			    uint_t *);
44 
45 
46 static rcm_handle_t *rcm_handle = NULL;
47 static mutex_t rcm_handle_lock = DEFAULTMUTEX;
48 
49 
50 /*
51  * usb_rcm_offline:
52  *	Offline USB resource consumers.
53  */
54 cfga_usb_ret_t
usb_rcm_offline(const char * rsrc,char ** errstring,char * rsrc_fixed,cfga_flags_t flags)55 usb_rcm_offline(const char *rsrc, char **errstring, char *rsrc_fixed,
56     cfga_flags_t flags)
57 {
58 	int		rret;
59 	uint_t		rflags = 0;
60 	rcm_info_t	*rinfo = NULL;
61 	cfga_usb_ret_t	ret = CFGA_USB_OK;
62 
63 	DPRINTF("usb_rcm_offline:\n");
64 
65 	if ((ret = usb_rcm_init(rsrc, flags, errstring, &rflags)) !=
66 	    CFGA_USB_OK) {
67 
68 		return (ret);
69 	}
70 
71 	DPRINTF("usb_rcm_offline: rsrc_fixed: %s\n", rsrc_fixed);
72 
73 	if ((rret = rcm_request_offline(rcm_handle, rsrc_fixed, rflags, &rinfo))
74 	    != RCM_SUCCESS) {
75 		DPRINTF("usb_rcm_offline: rcm_request_offline failed\n");
76 
77 		if (rinfo) {
78 			(void) usb_rcm_info_table(rinfo, errstring);
79 			rcm_free_info(rinfo);
80 			rinfo = NULL;
81 		}
82 
83 		DPRINTF("usb_rcm_offline: table = %s\n", *errstring);
84 
85 		if (rret == RCM_FAILURE) {
86 			(void) usb_rcm_online(rsrc, errstring,
87 			    rsrc_fixed, flags);
88 		}
89 		ret = CFGA_USB_RCM_OFFLINE;
90 	}
91 
92 	return (ret);
93 }
94 
95 
96 /*
97  * usb_rcm_online:
98  *	Online USB resource consumers that were previously offlined.
99  */
100 cfga_usb_ret_t
usb_rcm_online(const char * rsrc,char ** errstring,char * rsrc_fixed,cfga_flags_t flags)101 usb_rcm_online(const char *rsrc, char **errstring, char *rsrc_fixed,
102     cfga_flags_t flags)
103 {
104 	rcm_info_t	*rinfo = NULL;
105 	cfga_usb_ret_t	ret = CFGA_USB_OK;
106 
107 	DPRINTF("usb_rcm_online:\n");
108 
109 	if ((ret = usb_rcm_init(rsrc, flags, errstring, NULL)) != CFGA_USB_OK) {
110 
111 		return (ret);
112 	}
113 
114 	if (rcm_notify_online(rcm_handle, rsrc_fixed, 0, &rinfo) !=
115 	    RCM_SUCCESS && (rinfo != NULL)) {
116 		DPRINTF("usb_rcm_online: rcm_notify_online failed\n");
117 
118 		(void) usb_rcm_info_table(rinfo, errstring);
119 		rcm_free_info(rinfo);
120 		rinfo = NULL;
121 		ret = CFGA_USB_RCM_ONLINE;
122 	}
123 
124 	return (ret);
125 }
126 
127 
128 /*
129  * usb_rcm_remove:
130  *	Remove USB resource consumers after their kernel removal.
131  */
132 cfga_usb_ret_t
usb_rcm_remove(const char * rsrc,char ** errstring,char * rsrc_fixed,cfga_flags_t flags)133 usb_rcm_remove(const char *rsrc, char **errstring, char *rsrc_fixed,
134     cfga_flags_t flags)
135 {
136 	rcm_info_t	*rinfo = NULL;
137 	cfga_usb_ret_t	ret = CFGA_USB_OK;
138 
139 	DPRINTF("usb_rcm_remove:\n");
140 
141 	if ((ret = usb_rcm_init(rsrc, flags, errstring, NULL)) != CFGA_USB_OK) {
142 
143 		return (ret);
144 	}
145 
146 	if (rcm_notify_remove(rcm_handle, rsrc_fixed, 0, &rinfo) !=
147 	    RCM_SUCCESS && (rinfo != NULL)) {
148 		DPRINTF("usb_rcm_remove: rcm_notify_remove failed\n");
149 
150 		(void) usb_rcm_info_table(rinfo, errstring);
151 		rcm_free_info(rinfo);
152 		rinfo = NULL;
153 		ret = CFGA_USB_RCM_ONLINE;
154 	}
155 
156 	return (ret);
157 }
158 
159 
160 /*
161  * usb_rcm_init:
162  *	Contains common initialization code for entering a usb_rcm_xx() routine.
163  */
164 /* ARGSUSED */
165 static cfga_usb_ret_t
usb_rcm_init(const char * rsrc,cfga_flags_t flags,char ** errstring,uint_t * rflags)166 usb_rcm_init(const char *rsrc, cfga_flags_t flags, char **errstring,
167     uint_t *rflags)
168 {
169 	DPRINTF("usb_rcm_init:\n");
170 
171 	/* Validate the rsrc argument */
172 	if (rsrc == NULL) {
173 		DPRINTF("usb_rcm_init: rsrc is NULL\n");
174 		return (CFGA_USB_INTERNAL_ERROR);
175 	}
176 
177 	/* Translate the cfgadm flags to RCM flags */
178 	if (rflags && (flags & CFGA_FLAG_FORCE)) {
179 		*rflags |= RCM_FORCE;
180 	}
181 
182 	/* Get a handle for the RCM operations */
183 	(void) mutex_lock(&rcm_handle_lock);
184 	if (rcm_handle == NULL) {
185 		if (rcm_alloc_handle(NULL, RCM_NOPID, NULL, &rcm_handle) !=
186 		    RCM_SUCCESS) {
187 			DPRINTF("usb_rcm_init: alloc_handle failed\n");
188 			(void) mutex_unlock(&rcm_handle_lock);
189 
190 			return (CFGA_USB_RCM_HANDLE);
191 		}
192 	}
193 	(void) mutex_unlock(&rcm_handle_lock);
194 
195 	return (CFGA_USB_OK);
196 }
197 
198 
199 /*
200  * usb_rcm_info_table:
201  *	Takes an opaque rcm_info_t pointer and a character pointer,
202  *	and appends the rcm_info_t data in the form of a table to the
203  *	given character pointer.
204  */
205 static cfga_usb_ret_t
usb_rcm_info_table(rcm_info_t * rinfo,char ** table)206 usb_rcm_info_table(rcm_info_t *rinfo, char **table)
207 {
208 	int i;
209 	size_t w;
210 	size_t width = 0;
211 	size_t w_rsrc = 0;
212 	size_t w_info = 0;
213 	size_t table_size = 0;
214 	uint_t tuples = 0;
215 	rcm_info_tuple_t *tuple = NULL;
216 	char *rsrc;
217 	char *info;
218 	char *newtable;
219 	static char format[MAX_FORMAT];
220 	const char *infostr;
221 
222 	DPRINTF("usb_rcm_info_table:\n");
223 
224 	/* Protect against invalid arguments */
225 	if (rinfo == NULL || table == NULL) {
226 		return (CFGA_USB_INTERNAL_ERROR);
227 	}
228 
229 	/* Set localized table header strings */
230 	rsrc = dgettext(TEXT_DOMAIN, "Resource");
231 	info = dgettext(TEXT_DOMAIN, "Information");
232 
233 	/* A first pass, to size up the RCM information */
234 	while (tuple = rcm_info_next(rinfo, tuple)) {
235 		if ((infostr = rcm_info_info(tuple)) != NULL) {
236 			tuples++;
237 			if ((w = strlen(rcm_info_rsrc(tuple))) > w_rsrc)
238 				w_rsrc = w;
239 			if ((w = strlen(infostr)) > w_info)
240 				w_info = w;
241 		}
242 	}
243 
244 	/* If nothing was sized up above, stop early */
245 	if (tuples == 0) {
246 		DPRINTF("usb_rcm_info_table: no tuples\n");
247 
248 		return (CFGA_USB_OK);
249 	}
250 
251 	/* Adjust column widths for column headings */
252 	if ((w = strlen(rsrc)) > w_rsrc) {
253 		w_rsrc = w;
254 	} else if ((w_rsrc - w) % 2) {
255 		w_rsrc++;
256 	}
257 
258 	if ((w = strlen(info)) > w_info) {
259 		w_info = w;
260 	} else if ((w_info - w) % 2) {
261 		w_info++;
262 	}
263 
264 	/*
265 	 * Compute the total line width of each line,
266 	 * accounting for intercolumn spacing.
267 	 */
268 	width = w_info + w_rsrc + 4;
269 
270 	/* Allocate space for the table */
271 	table_size = (2 + tuples) * (width + 1) + 2;
272 	if (*table == NULL) {
273 		/* zero fill for the strcat() call below */
274 		*table = calloc(table_size, sizeof (char));
275 		if (*table == NULL) {
276 			DPRINTF("usb_rcm_info_table: no table\n");
277 
278 			return (CFGA_USB_ALLOC_FAIL);
279 		}
280 	} else {
281 		newtable = realloc(*table, strlen(*table) + table_size);
282 		if (newtable == NULL) {
283 			DPRINTF("usb_rcm_info_table: no new table\n");
284 
285 			return (CFGA_USB_ALLOC_FAIL);
286 		} else {
287 			*table = newtable;
288 		}
289 	}
290 
291 	/* Place a table header into the string */
292 
293 	/* The resource header */
294 	(void) strcat(*table, "\n");
295 	w = strlen(rsrc);
296 
297 	for (i = 0; i < ((w_rsrc - w) / 2); i++) {
298 		(void) strcat(*table, " ");
299 	}
300 	(void) strcat(*table, rsrc);
301 
302 	for (i = 0; i < ((w_rsrc - w) / 2); i++) {
303 		(void) strcat(*table, " ");
304 	}
305 
306 	/* The information header */
307 	(void) strcat(*table, "  ");
308 	w = strlen(info);
309 	for (i = 0; i < ((w_info - w) / 2); i++) {
310 		(void) strcat(*table, " ");
311 	}
312 	(void) strcat(*table, info);
313 
314 	for (i = 0; i < ((w_info - w) / 2); i++) {
315 		(void) strcat(*table, " ");
316 	}
317 
318 	(void) strcat(*table, "\n");
319 
320 	/* Underline the headers */
321 	for (i = 0; i < w_rsrc; i++) {
322 		(void) strcat(*table, "-");
323 	}
324 
325 	(void) strcat(*table, "  ");
326 	for (i = 0; i < w_info; i++) {
327 		(void) strcat(*table, "-");
328 	}
329 
330 	(void) strcat(*table, "\n");
331 
332 	/* Construct the format string */
333 	(void) snprintf(format, MAX_FORMAT, "%%-%ds  %%-%ds",
334 	    (int)w_rsrc, (int)w_info);
335 
336 	/* Add the tuples to the table string */
337 	tuple = NULL;
338 	while ((tuple = rcm_info_next(rinfo, tuple)) != NULL) {
339 		if ((infostr = rcm_info_info(tuple)) != NULL) {
340 			(void) sprintf(&((*table)[strlen(*table)]),
341 			    format, rcm_info_rsrc(tuple), infostr);
342 			(void) strcat(*table, "\n");
343 		}
344 	}
345 
346 	return (CFGA_USB_OK);
347 }
348