Print this page
8634 epoll fails to wake on certain edge-triggered conditions
8635 epoll should not emit POLLNVAL
8636 recursive epoll should emit EPOLLRDNORM
Reviewed by: Jerry Jelinek <jerry.jelinek@joyent.com>
Reviewed by: Robert Mustacchi <rm@joyent.com>
Reviewed by: Toomas Soome <tsoome@me.com>
Reviewed by: Igor Kozhukhov <igor@dilos.org>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/intel/io/ipmi/ipmi_main.c
+++ new/usr/src/uts/intel/io/ipmi/ipmi_main.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 - * Copyright (c) 2013, Joyent, Inc. All rights reserved.
23 + * Copyright 2017 Joyent, Inc.
24 24 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
25 25 */
26 26
27 27 /*
28 28 * The ipmi driver is an openipmi compatible IPMI driver based on the FreeBSD
29 29 * driver.
30 30 *
31 31 * The current implementation has several limitations:
32 32 * 1) It only does discovery through the SMBIOS. The FreeBSD driver has
33 33 * several additional ways to discover the IPMI device (acpi, bus checking,
34 34 * etc.). This support could be ported if necessary.
35 35 * 2) The driver currently only supports the IPMI KCS_MODE mode (reported
36 36 * through the SMBIOS as SMBIOS SMB_IPMI_T_KCS). Support for the other modes
37 37 * (BT_MODE, SMIC_MODE, SSIF_MODE) could be ported if necessary.
38 38 * 3) The driver does not currently set up an IPMI watchdog. This also could
39 39 * be ported if necessary.
40 40 */
41 41
42 42 #include <sys/devops.h>
43 43 #include <sys/conf.h>
44 44 #include <sys/modctl.h>
45 45 #include <sys/types.h>
46 46 #include <sys/file.h>
47 47 #include <sys/errno.h>
48 48 #include <sys/open.h>
49 49 #include <sys/cred.h>
50 50 #include <sys/uio.h>
51 51 #include <sys/stat.h>
52 52 #include <sys/cmn_err.h>
53 53 #include <sys/ddi.h>
54 54 #include <sys/sunddi.h>
55 55 #include <sys/smbios.h>
56 56 #include <sys/smbios_impl.h>
57 57 #include <sys/policy.h>
58 58 #include <sys/ipmi.h>
59 59 #include "ipmivars.h"
60 60
61 61 static dev_info_t *ipmi_dip;
62 62 static boolean_t ipmi_attached = B_FALSE;
63 63 static boolean_t ipmi_found = B_FALSE;
64 64 static struct ipmi_softc softc;
65 65 static struct ipmi_softc *sc = &softc;
66 66 static list_t dev_list;
67 67 static id_space_t *minor_ids;
68 68 static kmutex_t dev_list_lock;
69 69
70 70 #define PTRIN(p) ((void *)(uintptr_t)(p))
71 71 #define PTROUT(p) ((uintptr_t)(p))
72 72
73 73 /*
74 74 * Use the SMBIOS info to determine if the system has an IPMI.
75 75 */
76 76 static int
77 77 get_smbios_ipmi_info(void)
78 78 {
79 79 smbios_ipmi_t ipmi;
80 80
81 81 if (ksmbios == NULL || smbios_info_ipmi(ksmbios, &ipmi) == SMB_ERR)
82 82 return (DDI_FAILURE);
83 83
84 84 cmn_err(CE_CONT, "!SMBIOS type 0x%x, addr 0x%llx", ipmi.smbip_type,
85 85 (long long unsigned int)(ipmi.smbip_addr));
86 86
87 87 /*
88 88 * Some systems have a bios that will report an IPMI device even when
89 89 * it is not installed. In this case we see 0x0 as the base address.
90 90 * If we see this address, assume the device is not really present.
91 91 */
92 92 if (ipmi.smbip_addr == NULL) {
93 93 cmn_err(CE_WARN, "!SMBIOS: Invalid base address");
94 94 return (DDI_FAILURE);
95 95 }
96 96
97 97 sc->ipmi_io_type = ipmi.smbip_type;
98 98 switch (ipmi.smbip_type) {
99 99 case SMB_IPMI_T_KCS:
100 100 case SMB_IPMI_T_SMIC:
101 101 sc->ipmi_io_address = ipmi.smbip_addr;
102 102 sc->ipmi_io_mode = (ipmi.smbip_flags & SMB_IPMI_F_IOADDR) ?
103 103 1 : 0;
104 104 sc->ipmi_io_spacing = ipmi.smbip_regspacing;
105 105 break;
106 106 case SMB_IPMI_T_SSIF:
107 107 if ((ipmi.smbip_addr & 0xffffffffffffff00) != 0) {
108 108 cmn_err(CE_WARN, "!SMBIOS: Invalid SSIF SMBus address, "
109 109 "using BMC I2C slave address instead");
110 110 sc->ipmi_io_address = ipmi.smbip_i2c;
111 111 } else {
112 112 sc->ipmi_io_address = ipmi.smbip_addr;
113 113 }
114 114 break;
115 115 default:
116 116 return (DDI_FAILURE);
117 117 }
118 118
119 119 if (ipmi.smbip_intr > 15) {
120 120 cmn_err(CE_WARN, "!SMBIOS: Non-ISA IRQ %d for IPMI",
121 121 ipmi.smbip_intr);
122 122 return (DDI_FAILURE);
123 123 }
124 124
125 125 sc->ipmi_io_irq = ipmi.smbip_intr;
126 126 return (DDI_SUCCESS);
127 127 }
128 128
129 129 static ipmi_device_t *
130 130 lookup_ipmidev_by_dev(dev_t dev)
131 131 {
132 132 ipmi_device_t *p;
133 133
134 134 mutex_enter(&dev_list_lock);
135 135 for (p = list_head(&dev_list); p; p = list_next(&dev_list, p)) {
136 136 if (dev == p->ipmi_dev) {
137 137 mutex_exit(&dev_list_lock);
138 138 return (p);
139 139 }
140 140 }
141 141 mutex_exit(&dev_list_lock);
142 142 return (NULL);
143 143 }
144 144
145 145 /*
146 146 * Each open returns a new pseudo device.
147 147 */
148 148 /*ARGSUSED*/
149 149 static int
150 150 ipmi_open(dev_t *devp, int flag, int otyp, cred_t *cred)
151 151 {
152 152 minor_t minor;
153 153 ipmi_device_t *dev;
154 154
155 155 if (ipmi_attached == B_FALSE)
156 156 return (ENXIO);
157 157
158 158 if (ipmi_found == B_FALSE)
159 159 return (ENODEV);
160 160
161 161 /* exclusive opens are not supported */
162 162 if (flag & FEXCL)
163 163 return (ENOTSUP);
164 164
165 165 if ((minor = (minor_t)id_alloc_nosleep(minor_ids)) == 0)
166 166 return (ENODEV);
167 167
168 168 /* Initialize the per file descriptor data. */
169 169 dev = kmem_zalloc(sizeof (ipmi_device_t), KM_SLEEP);
170 170
171 171 dev->ipmi_pollhead = kmem_zalloc(sizeof (pollhead_t), KM_SLEEP);
172 172
173 173 TAILQ_INIT(&dev->ipmi_completed_requests);
174 174 dev->ipmi_address = IPMI_BMC_SLAVE_ADDR;
175 175 dev->ipmi_lun = IPMI_BMC_SMS_LUN;
176 176 *devp = makedevice(getmajor(*devp), minor);
177 177 dev->ipmi_dev = *devp;
178 178 cv_init(&dev->ipmi_cv, NULL, CV_DEFAULT, NULL);
179 179
180 180 mutex_enter(&dev_list_lock);
181 181 list_insert_head(&dev_list, dev);
182 182 mutex_exit(&dev_list_lock);
183 183
184 184 return (0);
185 185 }
186 186
187 187 /*ARGSUSED*/
188 188 static int
189 189 ipmi_close(dev_t dev, int flag, int otyp, cred_t *cred)
190 190 {
191 191 ipmi_device_t *dp;
192 192 struct ipmi_request *req, *next;
193 193
194 194 if ((dp = lookup_ipmidev_by_dev(dev)) == NULL)
195 195 return (ENODEV);
196 196
197 197 IPMI_LOCK(sc);
198 198 /* remove any pending requests */
199 199 req = TAILQ_FIRST(&sc->ipmi_pending_requests);
200 200 while (req != NULL) {
201 201 next = TAILQ_NEXT(req, ir_link);
202 202
203 203 if (req->ir_owner == dp) {
204 204 TAILQ_REMOVE(&sc->ipmi_pending_requests, req, ir_link);
205 205 ipmi_free_request(req);
206 206 }
207 207 req = next;
208 208 }
209 209
210 210 dp->ipmi_status |= IPMI_CLOSING;
211 211 while (dp->ipmi_status & IPMI_BUSY)
212 212 cv_wait(&dp->ipmi_cv, &sc->ipmi_lock);
213 213 IPMI_UNLOCK(sc);
214 214
215 215 /* remove any requests in queue of stuff completed */
216 216 while ((req = TAILQ_FIRST(&dp->ipmi_completed_requests)) != NULL) {
217 217 TAILQ_REMOVE(&dp->ipmi_completed_requests, req, ir_link);
218 218 ipmi_free_request(req);
219 219 }
220 220
221 221 mutex_enter(&dev_list_lock);
222 222 list_remove(&dev_list, dp);
223 223 mutex_exit(&dev_list_lock);
224 224 id_free(minor_ids, getminor(dev));
225 225 cv_destroy(&dp->ipmi_cv);
226 226 kmem_free(dp->ipmi_pollhead, sizeof (pollhead_t));
227 227 kmem_free(dp, sizeof (ipmi_device_t));
228 228
229 229 return (0);
230 230 }
231 231
232 232 /*ARGSUSED*/
233 233 static int
234 234 ipmi_ioctl(dev_t dv, int cmd, intptr_t data, int flags, cred_t *cr, int *rvalp)
235 235 {
236 236 struct ipmi_device *dev;
237 237 struct ipmi_request *kreq;
238 238 struct ipmi_req req;
239 239 struct ipmi_recv recv;
240 240 struct ipmi_recv32 recv32;
241 241 struct ipmi_addr addr;
242 242 int error, len;
243 243 model_t model;
244 244 int orig_cmd = 0;
245 245 uchar_t t_lun;
246 246
247 247 if (secpolicy_sys_config(cr, B_FALSE) != 0)
248 248 return (EPERM);
249 249
250 250 if ((dev = lookup_ipmidev_by_dev(dv)) == NULL)
251 251 return (ENODEV);
252 252
253 253 model = get_udatamodel();
254 254 if (model == DATAMODEL_NATIVE) {
255 255 switch (cmd) {
256 256 case IPMICTL_SEND_COMMAND:
257 257 if (copyin((void *)data, &req, sizeof (req)))
258 258 return (EFAULT);
259 259 break;
260 260 case IPMICTL_RECEIVE_MSG_TRUNC:
261 261 case IPMICTL_RECEIVE_MSG:
262 262 if (copyin((void *)data, &recv, sizeof (recv)))
263 263 return (EFAULT);
264 264 break;
265 265 }
266 266 } else {
267 267 /* Convert 32-bit structures to native. */
268 268 struct ipmi_req32 req32;
269 269
270 270 switch (cmd) {
271 271 case IPMICTL_SEND_COMMAND_32:
272 272 if (copyin((void *)data, &req32, sizeof (req32)))
273 273 return (EFAULT);
274 274
275 275 req.addr = PTRIN(req32.addr);
276 276 req.addr_len = req32.addr_len;
277 277 req.msgid = req32.msgid;
278 278 req.msg.netfn = req32.msg.netfn;
279 279 req.msg.cmd = req32.msg.cmd;
280 280 req.msg.data_len = req32.msg.data_len;
281 281 req.msg.data = PTRIN(req32.msg.data);
282 282
283 283 cmd = IPMICTL_SEND_COMMAND;
284 284 break;
285 285
286 286 case IPMICTL_RECEIVE_MSG_TRUNC_32:
287 287 case IPMICTL_RECEIVE_MSG_32:
288 288 if (copyin((void *)data, &recv32, sizeof (recv32)))
289 289 return (EFAULT);
290 290
291 291 recv.addr = PTRIN(recv32.addr);
292 292 recv.addr_len = recv32.addr_len;
293 293 recv.msg.data_len = recv32.msg.data_len;
294 294 recv.msg.data = PTRIN(recv32.msg.data);
295 295
296 296 orig_cmd = cmd;
297 297 cmd = (cmd == IPMICTL_RECEIVE_MSG_TRUNC_32) ?
298 298 IPMICTL_RECEIVE_MSG_TRUNC : IPMICTL_RECEIVE_MSG;
299 299 break;
300 300 }
301 301 }
302 302
303 303 switch (cmd) {
304 304 case IPMICTL_SEND_COMMAND:
305 305 /* Check that we didn't get a ridiculous length */
306 306 if (req.msg.data_len > IPMI_MAX_RX)
307 307 return (EINVAL);
308 308
309 309 kreq = ipmi_alloc_request(dev, req.msgid,
310 310 IPMI_ADDR(req.msg.netfn, 0), req.msg.cmd,
311 311 req.msg.data_len, IPMI_MAX_RX);
312 312 /* This struct is the same for 32/64 */
313 313 if (req.msg.data_len > 0 &&
314 314 copyin(req.msg.data, kreq->ir_request, req.msg.data_len)) {
315 315 ipmi_free_request(kreq);
316 316 return (EFAULT);
317 317 }
318 318 IPMI_LOCK(sc);
319 319 dev->ipmi_requests++;
320 320 error = sc->ipmi_enqueue_request(sc, kreq);
321 321 IPMI_UNLOCK(sc);
322 322 if (error)
323 323 return (error);
324 324 break;
325 325
326 326 case IPMICTL_RECEIVE_MSG_TRUNC:
327 327 case IPMICTL_RECEIVE_MSG:
328 328 /* This struct is the same for 32/64 */
329 329 if (copyin(recv.addr, &addr, sizeof (addr)))
330 330 return (EFAULT);
331 331
332 332 IPMI_LOCK(sc);
333 333 kreq = TAILQ_FIRST(&dev->ipmi_completed_requests);
334 334 if (kreq == NULL) {
335 335 IPMI_UNLOCK(sc);
336 336 return (EAGAIN);
337 337 }
338 338 addr.channel = IPMI_BMC_CHANNEL;
339 339 recv.recv_type = IPMI_RESPONSE_RECV_TYPE;
340 340 recv.msgid = kreq->ir_msgid;
341 341 recv.msg.netfn = IPMI_REPLY_ADDR(kreq->ir_addr) >> 2;
342 342 recv.msg.cmd = kreq->ir_command;
343 343 error = kreq->ir_error;
344 344 if (error) {
345 345 TAILQ_REMOVE(&dev->ipmi_completed_requests, kreq,
346 346 ir_link);
347 347 dev->ipmi_requests--;
348 348 IPMI_UNLOCK(sc);
349 349 ipmi_free_request(kreq);
350 350 return (error);
351 351 }
352 352 len = kreq->ir_replylen + 1;
353 353 if (recv.msg.data_len < len && cmd == IPMICTL_RECEIVE_MSG) {
354 354 IPMI_UNLOCK(sc);
355 355 return (EMSGSIZE);
356 356 }
357 357 TAILQ_REMOVE(&dev->ipmi_completed_requests, kreq, ir_link);
358 358 dev->ipmi_requests--;
359 359 IPMI_UNLOCK(sc);
360 360 len = min(recv.msg.data_len, len);
361 361 recv.msg.data_len = (unsigned short)len;
362 362
363 363 if (orig_cmd == IPMICTL_RECEIVE_MSG_TRUNC_32 ||
364 364 orig_cmd == IPMICTL_RECEIVE_MSG_32) {
365 365 /* Update changed fields in 32-bit structure. */
366 366 recv32.recv_type = recv.recv_type;
367 367 recv32.msgid = (int32_t)recv.msgid;
368 368 recv32.msg.netfn = recv.msg.netfn;
369 369 recv32.msg.cmd = recv.msg.cmd;
370 370 recv32.msg.data_len = recv.msg.data_len;
371 371
372 372 error = copyout(&recv32, (void *)data, sizeof (recv32));
373 373 } else {
374 374 error = copyout(&recv, (void *)data, sizeof (recv));
375 375 }
376 376
377 377 /* This struct is the same for 32/64 */
378 378 if (error == 0)
379 379 error = copyout(&addr, recv.addr, sizeof (addr));
380 380 if (error == 0)
381 381 error = copyout(&kreq->ir_compcode, recv.msg.data, 1);
382 382 if (error == 0)
383 383 error = copyout(kreq->ir_reply, recv.msg.data + 1,
384 384 len - 1);
385 385 ipmi_free_request(kreq);
386 386
387 387 if (error)
388 388 return (EFAULT);
389 389
390 390 break;
391 391
392 392 case IPMICTL_SET_MY_ADDRESS_CMD:
393 393 IPMI_LOCK(sc);
394 394 if (copyin((void *)data, &dev->ipmi_address,
395 395 sizeof (dev->ipmi_address))) {
396 396 IPMI_UNLOCK(sc);
397 397 return (EFAULT);
398 398 }
399 399 IPMI_UNLOCK(sc);
400 400 break;
401 401
402 402 case IPMICTL_GET_MY_ADDRESS_CMD:
403 403 IPMI_LOCK(sc);
404 404 if (copyout(&dev->ipmi_address, (void *)data,
405 405 sizeof (dev->ipmi_address))) {
406 406 IPMI_UNLOCK(sc);
407 407 return (EFAULT);
408 408 }
409 409 IPMI_UNLOCK(sc);
410 410 break;
411 411
412 412 case IPMICTL_SET_MY_LUN_CMD:
413 413 IPMI_LOCK(sc);
414 414 if (copyin((void *)data, &t_lun, sizeof (t_lun))) {
415 415 IPMI_UNLOCK(sc);
416 416 return (EFAULT);
417 417 }
418 418 dev->ipmi_lun = t_lun & 0x3;
419 419 IPMI_UNLOCK(sc);
420 420 break;
421 421
422 422 case IPMICTL_GET_MY_LUN_CMD:
423 423 IPMI_LOCK(sc);
424 424 if (copyout(&dev->ipmi_lun, (void *)data,
425 425 sizeof (dev->ipmi_lun))) {
426 426 IPMI_UNLOCK(sc);
427 427 return (EFAULT);
428 428 }
429 429 IPMI_UNLOCK(sc);
430 430 break;
431 431
432 432 case IPMICTL_SET_GETS_EVENTS_CMD:
433 433 break;
434 434
435 435 case IPMICTL_REGISTER_FOR_CMD:
436 436 case IPMICTL_UNREGISTER_FOR_CMD:
437 437 return (EINVAL);
438 438
439 439 default:
440 440 return (EINVAL);
441 441 }
442 442
443 443 return (0);
444 444 }
445 445
446 446 static int
447 447 ipmi_poll(dev_t dv, short events, int anyyet, short *reventsp,
448 448 pollhead_t **phpp)
449 449 {
450 450 struct ipmi_device *dev;
451 451 short revent = 0;
452 452
|
↓ open down ↓ |
419 lines elided |
↑ open up ↑ |
453 453 if ((dev = lookup_ipmidev_by_dev(dv)) == NULL)
454 454 return (ENODEV);
455 455
456 456 if (events & (POLLIN | POLLRDNORM)) {
457 457 if (!TAILQ_EMPTY(&dev->ipmi_completed_requests))
458 458 revent |= events & (POLLIN | POLLRDNORM);
459 459 if (dev->ipmi_requests == 0)
460 460 revent |= POLLERR;
461 461 }
462 462
463 - if (revent == 0) {
464 - /* nothing has occurred */
465 - if (!anyyet)
466 - *phpp = dev->ipmi_pollhead;
463 + if ((revent == 0 && !anyyet) || (events & POLLET)) {
464 + *phpp = dev->ipmi_pollhead;
467 465 }
468 466
469 467 *reventsp = revent;
470 468 return (0);
471 469 }
472 470
473 471 /*ARGSUSED*/
474 472 static int
475 473 ipmi_info(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
476 474 {
477 475 switch (cmd) {
478 476 case DDI_INFO_DEVT2DEVINFO:
479 477 *resultp = ipmi_dip;
480 478 return (DDI_SUCCESS);
481 479 case DDI_INFO_DEVT2INSTANCE:
482 480 *resultp = NULL;
483 481 return (DDI_SUCCESS);
484 482 }
485 483 return (DDI_FAILURE);
486 484 }
487 485
488 486 static void
489 487 ipmi_cleanup(dev_info_t *dip)
490 488 {
491 489 /* poke the taskq so that it can terminate */
492 490 IPMI_LOCK(sc);
493 491 sc->ipmi_detaching = 1;
494 492 cv_signal(&sc->ipmi_request_added);
495 493 IPMI_UNLOCK(sc);
496 494
497 495 ipmi_shutdown(sc);
498 496 ddi_remove_minor_node(dip, NULL);
499 497 ipmi_dip = NULL;
500 498
501 499 mutex_destroy(&dev_list_lock);
502 500 list_destroy(&dev_list);
503 501 id_space_destroy(minor_ids);
504 502
505 503 sc->ipmi_detaching = 0;
506 504 }
507 505
508 506 static int
509 507 ipmi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
510 508 {
511 509 if (cmd != DDI_ATTACH)
512 510 return (DDI_FAILURE);
513 511
514 512 /* this driver only supports one device instance */
515 513 if (ddi_get_instance(dip) != 0) {
516 514 cmn_err(CE_WARN,
517 515 "!not attaching to non-zero device instance %d",
518 516 ddi_get_instance(dip));
519 517 return (DDI_FAILURE);
520 518 }
521 519
522 520 if (get_smbios_ipmi_info() == DDI_FAILURE)
523 521 return (DDI_FAILURE);
524 522
525 523 /*
526 524 * Support for the other types (SMIC, SSIF) should be added here.
527 525 */
528 526 switch (sc->ipmi_io_type) {
529 527 case SMB_IPMI_T_KCS:
530 528 if (ipmi_kcs_attach(sc) != 0)
531 529 return (DDI_FAILURE);
532 530 break;
533 531 default:
534 532 return (DDI_FAILURE);
535 533 }
536 534 ipmi_found = B_TRUE;
537 535
538 536 if (ddi_create_minor_node(dip, "ipmi", S_IFCHR, 0, DDI_PSEUDO,
539 537 0) == DDI_FAILURE) {
540 538 cmn_err(CE_WARN, "!attach could not create minor node");
541 539 ddi_remove_minor_node(dip, NULL);
542 540 return (DDI_FAILURE);
543 541 }
544 542
545 543 ipmi_dip = dip;
546 544
547 545 list_create(&dev_list, sizeof (ipmi_device_t),
548 546 offsetof(ipmi_device_t, ipmi_node));
549 547 mutex_init(&dev_list_lock, NULL, MUTEX_DRIVER, NULL);
550 548
551 549 /* Create ID space for open devs. ID 0 is reserved. */
552 550 minor_ids = id_space_create("ipmi_id_space", 1, 128);
553 551
554 552 if (ipmi_startup(sc) != B_TRUE) {
555 553 ipmi_cleanup(dip);
556 554 return (DDI_FAILURE);
557 555 }
558 556
559 557 ipmi_attached = B_TRUE;
560 558
561 559 return (DDI_SUCCESS);
562 560 }
563 561
564 562 static int
565 563 ipmi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
566 564 {
567 565 if (cmd != DDI_DETACH)
568 566 return (DDI_FAILURE);
569 567
570 568 if (ipmi_found == B_FALSE)
571 569 return (DDI_SUCCESS);
572 570
573 571 mutex_enter(&dev_list_lock);
574 572 if (!list_is_empty(&dev_list)) {
575 573 mutex_exit(&dev_list_lock);
576 574 return (DDI_FAILURE);
577 575 }
578 576 mutex_exit(&dev_list_lock);
579 577
580 578 ipmi_cleanup(dip);
581 579
582 580 ipmi_attached = B_FALSE;
583 581 return (DDI_SUCCESS);
584 582 }
585 583
586 584 static struct cb_ops ipmi_cb_ops = {
587 585 ipmi_open,
588 586 ipmi_close,
589 587 nodev, /* strategy */
590 588 nodev, /* print */
591 589 nodev, /* dump */
592 590 nodev, /* read */
593 591 nodev, /* write */
594 592 ipmi_ioctl,
595 593 nodev, /* devmap */
596 594 nodev, /* mmap */
597 595 nodev, /* segmap */
598 596 ipmi_poll,
599 597 ddi_prop_op,
600 598 NULL, /* streamtab */
601 599 D_NEW | D_MP, /* flags */
602 600 CB_REV,
603 601 nodev, /* awread */
604 602 nodev /* awrite */
605 603 };
606 604
607 605 static struct dev_ops ipmi_ops = {
608 606 DEVO_REV,
609 607 0, /* reference count */
610 608 ipmi_info,
611 609 nulldev, /* identify */
612 610 nulldev, /* probe */
613 611 ipmi_attach,
614 612 ipmi_detach,
615 613 nodev, /* reset */
616 614 &ipmi_cb_ops,
617 615 NULL, /* bus ops */
618 616 NULL, /* power */
619 617 ddi_quiesce_not_needed,
620 618 };
621 619
622 620 static struct modldrv md = {
623 621 &mod_driverops, "ipmi driver", &ipmi_ops
624 622 };
625 623
626 624 static struct modlinkage ml = {
627 625 MODREV_1, &md, NULL
628 626 };
629 627
630 628 int
631 629 _init(void)
632 630 {
633 631 return (mod_install(&ml));
634 632 }
635 633
636 634 int
637 635 _fini(void)
638 636 {
639 637 return (mod_remove(&ml));
640 638 }
641 639
642 640 int
643 641 _info(struct modinfo *mip)
644 642 {
645 643 return (mod_info(&ml, mip));
646 644 }
|
↓ open down ↓ |
170 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX