Print this page
OS-2444 richmond hardware maps need to support ivy bridge (review fixes)
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/fm/topo/modules/common/fac_prov_mptsas/fac_prov_mptsas.c
+++ new/usr/src/lib/fm/topo/modules/common/fac_prov_mptsas/fac_prov_mptsas.c
1 1 /*
2 2 * This file and its contents are supplied under the terms of the
3 3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 4 * You may only use this file in accordance with the terms of version
5 5 * 1.0 of the CDDL.
6 6 *
7 7 * A full copy of the text of the CDDL should have accompanied this
8 8 * source. A copy of the CDDL is also available via the Internet at
9 9 * http://www.illumos.org/license/CDDL.
10 10 */
11 11
12 12 /*
13 13 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
14 14 */
15 15
16 16 #include <unistd.h>
17 17 #include <stdio.h>
18 18 #include <stdlib.h>
19 19 #include <fcntl.h>
20 20 #include <string.h>
21 21 #include <strings.h>
22 22 #include <limits.h>
23 23 #include <alloca.h>
24 24 #include <errno.h>
25 25 #include <libnvpair.h>
26 26 #include <sys/types.h>
27 27 #include <sys/stat.h>
28 28 #include <sys/param.h>
29 29 #include <sys/fm/protocol.h>
30 30 #include <fm/libtopo.h>
31 31 #include <fm/topo_mod.h>
32 32
33 33 #include "sys/scsi/adapters/mpt_sas/mptsas_ioctl.h"
34 34
35 35 #define TOPO_METH_MPTSAS_LED_MODE_VERSION 0
36 36
37 37 static int fac_prov_mptsas_enum(topo_mod_t *, tnode_t *, const char *,
38 38 topo_instance_t, topo_instance_t, void *, void *);
39 39
40 40 /*
41 41 * mpt_sas facility provider methods
42 42 */
43 43 static int mptsas_led_mode(topo_mod_t *, tnode_t *, topo_version_t,
44 44 nvlist_t *, nvlist_t **);
45 45
46 46 const topo_modops_t mptsas_ops = { fac_prov_mptsas_enum, NULL };
47 47
48 48 const topo_modinfo_t mptsas_info =
49 49 { "mpt_sas facility provider", FM_FMRI_SCHEME_HC, TOPO_VERSION,
50 50 &mptsas_ops };
51 51
52 52 static const topo_method_t mptsas_fac_methods[] = {
53 53 { "mptsas_led_mode", TOPO_PROP_METH_DESC,
54 54 TOPO_METH_MPTSAS_LED_MODE_VERSION,
55 55 TOPO_STABILITY_INTERNAL, mptsas_led_mode },
56 56 { NULL }
57 57 };
58 58
59 59 /*ARGSUSED*/
60 60 int
61 61 _topo_init(topo_mod_t *mod, topo_version_t version)
62 62 {
63 63 if (getenv("TOPOFACMPTSASDEBUG") != NULL)
64 64 topo_mod_setdebug(mod);
65 65
66 66 return (topo_mod_register(mod, &mptsas_info, TOPO_VERSION));
|
↓ open down ↓ |
66 lines elided |
↑ open up ↑ |
67 67 }
68 68
69 69 void
70 70 _topo_fini(topo_mod_t *mod)
71 71 {
72 72 topo_mod_unregister(mod);
73 73 }
74 74
75 75 /*
76 76 * Get or set LED state for a particular target attached to an mpt_sas
77 - * instance at (Enclosure Number, Slot Number).
78 - *
79 - * Returns:
80 - * -2 /devices node (*devctl) does not exist
81 - * -1 All other failures
82 - * 0 Success
77 + * instance at (Enclosure Number, Slot Number). The function returns
78 + * -1 on error and sets errno to ENOENT _only_ if the /devices node
79 + * (*devctl) does not exist.
83 80 */
84 81 static int
85 82 do_led_control(topo_mod_t *mod, char *devctl, uint16_t enclosure,
86 83 uint16_t slot, uint8_t led, uint32_t *ledmode, boolean_t set)
87 84 {
88 85 int fd;
89 86 mptsas_led_control_t lc;
90 87
91 88 bzero(&lc, sizeof (lc));
92 89
93 90 lc.Command = set ? MPTSAS_LEDCTL_FLAG_SET : MPTSAS_LEDCTL_FLAG_GET;
94 91 lc.Enclosure = enclosure;
95 92 lc.Slot = slot;
96 93 lc.Led = led;
97 94 lc.LedStatus = *ledmode;
98 95
99 96 if ((fd = open(devctl, (set ? O_RDWR : O_RDONLY))) == -1) {
100 - int rc = (errno == ENOENT ? -2 : -1);
97 + int en = errno;
101 98 topo_mod_dprintf(mod, "devctl open failed: %s",
102 99 strerror(errno));
103 - return (rc);
100 + errno = en;
101 + return (-1);
104 102 }
105 103
106 104 if (ioctl(fd, MPTIOCTL_LED_CONTROL, &lc) == -1) {
107 105 if (errno == ENOENT) {
108 106 /*
109 107 * If there is not presently a target attached for
110 108 * a particular enclosure/slot pair then the driver
111 109 * does not track LED status for this bay. Assume
112 110 * all LEDs are off.
113 111 */
114 112 lc.LedStatus = 0;
115 113 } else {
114 + int en = errno;
116 115 topo_mod_dprintf(mod, "led control ioctl failed: %s",
117 116 strerror(errno));
118 117 (void) close(fd);
118 + errno = en;
119 119 return (-1);
120 120 }
121 121 }
122 122
123 123 *ledmode = lc.LedStatus ? TOPO_LED_STATE_ON : TOPO_LED_STATE_OFF;
124 124
125 125 (void) close(fd);
126 + errno = 0;
126 127 return (0);
127 128 }
128 129
129 130 static int
130 131 mptsas_led_mode(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
131 132 nvlist_t *in, nvlist_t **nvout)
132 133 {
133 134 int err, ret = 0;
134 135 tnode_t *pnode = topo_node_parent(node);
135 136 uint32_t type, ledmode = 0;
136 137 nvlist_t *pargs, *nvl;
137 138 char *driver = NULL, *devctl = NULL;
138 139 uint32_t enclosure, slot;
139 140 uint8_t mptsas_led;
140 - boolean_t set;
141 + boolean_t set, done;
141 142 char *elem, *lastp;
142 143
143 144 if (vers > TOPO_METH_MPTSAS_LED_MODE_VERSION)
144 145 return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
145 146
146 147 if (topo_prop_get_string(pnode, TOPO_PGROUP_BINDING,
147 148 TOPO_BINDING_DRIVER, &driver, &err) != 0 ||
148 149 strcmp("mpt_sas", driver) != 0) {
149 150 topo_mod_dprintf(mod, "%s: Facility driver was not mpt_sas",
150 151 __func__);
151 152 ret = topo_mod_seterrno(mod, EMOD_NVL_INVAL);
152 153 goto out;
153 154 }
154 155 if (topo_prop_get_uint32(node, TOPO_PGROUP_FACILITY, TOPO_FACILITY_TYPE,
155 156 &type, &err) != 0) {
156 157 topo_mod_dprintf(mod, "%s: Failed to lookup %s property "
157 158 "(%s)", __func__, TOPO_FACILITY_TYPE, topo_strerror(err));
158 159 return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
159 160 }
160 161 switch (type) {
161 162 case (TOPO_LED_TYPE_SERVICE):
162 163 mptsas_led = MPTSAS_LEDCTL_LED_FAIL;
163 164 break;
164 165 case (TOPO_LED_TYPE_LOCATE):
165 166 mptsas_led = MPTSAS_LEDCTL_LED_IDENT;
166 167 break;
167 168 case (TOPO_LED_TYPE_OK2RM):
168 169 mptsas_led = MPTSAS_LEDCTL_LED_OK2RM;
169 170 break;
170 171 default:
171 172 topo_mod_dprintf(mod, "%s: Invalid LED type: 0x%x\n", __func__,
172 173 type);
173 174 return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
174 175 }
175 176 if (topo_prop_get_string(pnode, TOPO_PGROUP_BINDING,
176 177 TOPO_BINDING_DEVCTL, &devctl, &err) != 0 ||
177 178 topo_prop_get_uint32(pnode, TOPO_PGROUP_BINDING,
178 179 TOPO_BINDING_ENCLOSURE, &enclosure, &err) != 0 ||
179 180 topo_prop_get_uint32(pnode, TOPO_PGROUP_BINDING,
180 181 TOPO_BINDING_SLOT, &slot, &err) != 0) {
181 182 topo_mod_dprintf(mod, "%s: Facility was missing mpt_sas binding"
182 183 " properties\n", __func__);
183 184 ret = topo_mod_seterrno(mod, EMOD_NVL_INVAL);
184 185 goto out;
185 186 }
186 187
187 188 if ((nvlist_lookup_nvlist(in, TOPO_PROP_PARGS, &pargs) == 0) &&
188 189 nvlist_exists(pargs, TOPO_PROP_VAL_VAL)) {
189 190 /*
190 191 * Set the LED mode
191 192 */
192 193 set = B_TRUE;
193 194 if ((ret = nvlist_lookup_uint32(pargs, TOPO_PROP_VAL_VAL,
194 195 &ledmode)) != 0) {
195 196 topo_mod_dprintf(mod, "%s: Failed to lookup %s nvpair "
196 197 "(%s)\n", __func__, TOPO_PROP_VAL_VAL,
197 198 strerror(ret));
198 199 ret = topo_mod_seterrno(mod, EMOD_NVL_INVAL);
199 200 goto out;
200 201 }
201 202 topo_mod_dprintf(mod, "%s: Setting LED mode to %s\n", __func__,
202 203 ledmode ? "ON" : "OFF");
203 204 } else {
204 205 /*
205 206 * Get the LED mode
206 207 */
207 208 set = B_FALSE;
208 209 topo_mod_dprintf(mod, "%s: Getting LED mode\n", __func__);
209 210 }
210 211
|
↓ open down ↓ |
60 lines elided |
↑ open up ↑ |
211 212 /*
212 213 * devctl is a (potentially) pipe-separated list of different device
213 214 * paths to try.
214 215 */
215 216 if ((elem = topo_mod_strsplit(mod, devctl, "|", &lastp)) == NULL) {
216 217 topo_mod_dprintf(mod, "%s: could not parse devctl list",
217 218 __func__);
218 219 ret = topo_mod_seterrno(mod, EMOD_UNKNOWN);
219 220 goto out;
220 221 }
222 + done = B_FALSE;
221 223 do {
222 224 topo_mod_dprintf(mod, "%s: trying mpt_sas instance at %s\n",
223 225 __func__, elem);
224 226
225 227 ret = do_led_control(mod, elem, enclosure, slot,
226 228 mptsas_led, &ledmode, set);
227 229
228 - topo_mod_strfree(mod, elem);
229 -
230 230 /*
231 231 * Only try further devctl paths from the list if this one
232 232 * was not found:
233 233 */
234 - if (ret != -2) {
235 - break;
234 + if (ret == 0 || errno != ENOENT) {
235 + done = B_TRUE;
236 236 } else {
237 237 topo_mod_dprintf(mod, "%s: instance not found\n",
238 238 __func__);
239 239 }
240 240
241 - } while ((elem = topo_mod_strsplit(mod, NULL, "|", &lastp)) != NULL);
241 + topo_mod_strfree(mod, elem);
242 +
243 + } while (!done && (elem = topo_mod_strsplit(mod, NULL, "|",
244 + &lastp)) != NULL);
242 245
243 246 if (ret != 0) {
244 247 topo_mod_dprintf(mod, "%s: do_led_control failed", __func__);
245 248 ret = topo_mod_seterrno(mod, EMOD_UNKNOWN);
246 249 goto out;
247 250 }
248 251
249 252 if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
250 253 nvlist_add_string(nvl, TOPO_PROP_VAL_NAME, TOPO_LED_MODE) != 0 ||
251 254 nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_UINT32) != 0 ||
252 255 nvlist_add_uint32(nvl, TOPO_PROP_VAL_VAL, ledmode) != 0) {
253 256 topo_mod_dprintf(mod, "%s: Failed to allocate 'out' nvlist\n",
254 257 __func__);
255 258 nvlist_free(nvl);
256 259 ret = topo_mod_seterrno(mod, EMOD_NOMEM);
257 260 goto out;
258 261 }
259 262 *nvout = nvl;
260 263
261 264 out:
262 265 if (driver != NULL)
263 266 topo_mod_strfree(mod, driver);
264 267 if (devctl != NULL)
265 268 topo_mod_strfree(mod, devctl);
266 269 return (ret);
267 270 }
268 271
269 272 /*ARGSUSED*/
270 273 static int
271 274 fac_prov_mptsas_enum(topo_mod_t *mod, tnode_t *rnode, const char *name,
272 275 topo_instance_t min, topo_instance_t max, void *arg, void *unused)
273 276 {
274 277 if (topo_node_flags(rnode) == TOPO_NODE_FACILITY) {
275 278 if (topo_method_register(mod, rnode, mptsas_fac_methods) != 0) {
276 279 topo_mod_dprintf(mod, "%s: topo_method_register() "
277 280 "failed: %s", __func__, topo_mod_errmsg(mod));
278 281 return (-1);
279 282 }
280 283 return (0);
281 284 }
282 285
283 286 topo_mod_dprintf(mod, "%s: unexpected node flags %x", __func__,
284 287 topo_node_flags(rnode));
285 288 return (-1);
286 289 }
|
↓ open down ↓ |
35 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX