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 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 28 /* 29 * srn Provide apm-like interfaces to Xorg 30 */ 31 32 #include <sys/types.h> 33 #include <sys/errno.h> 34 #include <sys/modctl.h> 35 #include <sys/conf.h> /* driver flags and functions */ 36 #include <sys/open.h> /* OTYP_CHR definition */ 37 #include <sys/stat.h> /* S_IFCHR definition */ 38 #include <sys/pathname.h> /* name -> dev_info xlation */ 39 #include <sys/kmem.h> /* memory alloc stuff */ 40 #include <sys/debug.h> 41 #include <sys/pm.h> 42 #include <sys/ddi.h> 43 #include <sys/sunddi.h> 44 #include <sys/epm.h> 45 #include <sys/vfs.h> 46 #include <sys/mode.h> 47 #include <sys/mkdev.h> 48 #include <sys/promif.h> 49 #include <sys/consdev.h> 50 #include <sys/ddi_impldefs.h> 51 #include <sys/poll.h> 52 #include <sys/note.h> 53 #include <sys/taskq.h> 54 #include <sys/policy.h> 55 #include <sys/srn.h> 56 57 /* 58 * Minor number is instance<<8 + clone minor from range 1-255; 59 * But only one will be allocated 60 */ 61 #define SRN_MINOR_TO_CLONE(minor) ((minor) & (SRN_MAX_CLONE - 1)) 62 #define SU 0x002 63 #define SG 0x004 64 65 extern kmutex_t srn_clone_lock; /* protects srn_clones array */ 66 extern kcondvar_t srn_clones_cv[SRN_MAX_CLONE]; 67 extern uint_t srn_poll_cnt[SRN_MAX_CLONE]; 68 69 /* 70 * The soft state of the srn driver. Since there will only be 71 * one of these, just reference it through a static struct. 72 */ 73 static struct srnstate { 74 dev_info_t *srn_dip; /* ptr to our dev_info node */ 75 int srn_instance; /* for ddi_get_instance() */ 76 uchar_t srn_clones[SRN_MAX_CLONE]; /* unique opens */ 77 struct cred *srn_cred[SRN_MAX_CLONE]; /* cred for each open */ 78 int srn_type[SRN_MAX_CLONE]; /* type of handshake */ 79 int srn_delivered[SRN_MAX_CLONE]; 80 srn_event_info_t srn_pending[SRN_MAX_CLONE]; 81 int srn_fault[SRN_MAX_CLONE]; 82 } srn = { NULL, -1}; 83 typedef struct srnstate *srn_state_t; 84 85 kcondvar_t srn_clones_cv[SRN_MAX_CLONE]; 86 uint_t srn_poll_cnt[SRN_MAX_CLONE]; /* count of events for poll */ 87 int srn_apm_count; 88 int srn_autosx_count; 89 /* Number of seconds to wait for clients to ack a poll */ 90 int srn_timeout = 10; 91 92 struct pollhead srn_pollhead[SRN_MAX_CLONE]; 93 94 static int srn_open(dev_t *, int, int, cred_t *); 95 static int srn_close(dev_t, int, int, cred_t *); 96 static int srn_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 97 static int srn_chpoll(dev_t, short, int, short *, struct pollhead **); 98 99 static struct cb_ops srn_cb_ops = { 100 srn_open, /* open */ 101 srn_close, /* close */ 102 nodev, /* strategy */ 103 nodev, /* print */ 104 nodev, /* dump */ 105 nodev, /* read */ 106 nodev, /* write */ 107 srn_ioctl, /* ioctl */ 108 nodev, /* devmap */ 109 nodev, /* mmap */ 110 nodev, /* segmap */ 111 srn_chpoll, /* poll */ 112 ddi_prop_op, /* prop_op */ 113 NULL, /* streamtab */ 114 D_NEW | D_MP /* driver compatibility flag */ 115 }; 116 117 static int srn_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 118 void **result); 119 static int srn_attach(dev_info_t *dip, ddi_attach_cmd_t cmd); 120 static int srn_detach(dev_info_t *dip, ddi_detach_cmd_t cmd); 121 static void srn_notify(int type, int event); 122 123 static struct dev_ops srn_ops = { 124 DEVO_REV, /* devo_rev */ 125 0, /* refcnt */ 126 srn_getinfo, /* info */ 127 nulldev, /* identify */ 128 nulldev, /* probe */ 129 srn_attach, /* attach */ 130 srn_detach, /* detach */ 131 nodev, /* reset */ 132 &srn_cb_ops, /* driver operations */ 133 NULL, /* bus operations */ 134 NULL, /* power */ 135 ddi_quiesce_not_needed, /* quiesce */ 136 }; 137 138 static struct modldrv modldrv = { 139 &mod_driverops, 140 "srn driver", 141 &srn_ops 142 }; 143 144 static struct modlinkage modlinkage = { 145 MODREV_1, &modldrv, 0 146 }; 147 148 /* Local functions */ 149 150 int 151 _init(void) 152 { 153 return (mod_install(&modlinkage)); 154 } 155 156 int 157 _fini(void) 158 { 159 return (mod_remove(&modlinkage)); 160 } 161 162 int 163 _info(struct modinfo *modinfop) 164 { 165 return (mod_info(&modlinkage, modinfop)); 166 } 167 168 static int 169 srn_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 170 { 171 int i; 172 extern void (*srn_signal)(int, int); 173 174 switch (cmd) { 175 176 case DDI_ATTACH: 177 if (srn.srn_instance != -1) /* Only allow one instance */ 178 return (DDI_FAILURE); 179 srn.srn_instance = ddi_get_instance(dip); 180 if (ddi_create_minor_node(dip, "srn", S_IFCHR, 181 (srn.srn_instance << 8) + 0, DDI_PSEUDO, 0) 182 != DDI_SUCCESS) { 183 return (DDI_FAILURE); 184 } 185 srn.srn_dip = dip; /* srn_init and getinfo depend on it */ 186 187 for (i = 0; i < SRN_MAX_CLONE; i++) 188 cv_init(&srn_clones_cv[i], NULL, CV_DEFAULT, NULL); 189 190 srn.srn_instance = ddi_get_instance(dip); 191 mutex_enter(&srn_clone_lock); 192 srn_signal = srn_notify; 193 mutex_exit(&srn_clone_lock); 194 ddi_report_dev(dip); 195 return (DDI_SUCCESS); 196 197 default: 198 return (DDI_FAILURE); 199 } 200 } 201 202 /* ARGSUSED */ 203 static int 204 srn_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 205 { 206 int i; 207 extern int srn_inuse; 208 extern void (*srn_signal)(int, int); 209 210 switch (cmd) { 211 case DDI_DETACH: 212 213 mutex_enter(&srn_clone_lock); 214 while (srn_inuse) { 215 mutex_exit(&srn_clone_lock); 216 delay(1); 217 mutex_enter(&srn_clone_lock); 218 } 219 srn_signal = NULL; 220 mutex_exit(&srn_clone_lock); 221 222 for (i = 0; i < SRN_MAX_CLONE; i++) 223 cv_destroy(&srn_clones_cv[i]); 224 225 ddi_remove_minor_node(dip, NULL); 226 srn.srn_instance = -1; 227 return (DDI_SUCCESS); 228 229 default: 230 return (DDI_FAILURE); 231 } 232 } 233 234 235 #ifdef DEBUG 236 char *srn_cmd_string; 237 int srn_cmd; 238 #endif 239 240 /* 241 * Returns true if permission granted by credentials 242 * XXX 243 */ 244 static int 245 srn_perms(int perm, cred_t *cr) 246 { 247 if ((perm & SU) && secpolicy_power_mgmt(cr) == 0) /* privileged? */ 248 return (1); 249 if ((perm & SG) && (crgetgid(cr) == 0)) /* group 0 is ok */ 250 return (1); 251 return (0); 252 } 253 254 static int 255 srn_chpoll(dev_t dev, short events, int anyyet, short *reventsp, 256 struct pollhead **phpp) 257 { 258 extern struct pollhead srn_pollhead[]; 259 int clone; 260 261 clone = SRN_MINOR_TO_CLONE(getminor(dev)); 262 if ((events & (POLLIN | POLLRDNORM)) && srn_poll_cnt[clone]) { 263 *reventsp |= (POLLIN | POLLRDNORM); 264 } else { 265 *reventsp = 0; 266 if (!anyyet) { 267 *phpp = &srn_pollhead[clone]; 268 } 269 } 270 return (0); 271 } 272 273 /*ARGSUSED*/ 274 static int 275 srn_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 276 { 277 dev_t dev; 278 int instance; 279 280 switch (infocmd) { 281 case DDI_INFO_DEVT2DEVINFO: 282 if (srn.srn_instance == -1) 283 return (DDI_FAILURE); 284 *result = srn.srn_dip; 285 return (DDI_SUCCESS); 286 287 case DDI_INFO_DEVT2INSTANCE: 288 dev = (dev_t)arg; 289 instance = getminor(dev) >> 8; 290 *result = (void *)(uintptr_t)instance; 291 return (DDI_SUCCESS); 292 293 default: 294 return (DDI_FAILURE); 295 } 296 } 297 298 299 /*ARGSUSED1*/ 300 static int 301 srn_open(dev_t *devp, int flag, int otyp, cred_t *cr) 302 { 303 int clone; 304 305 if (otyp != OTYP_CHR) 306 return (EINVAL); 307 308 mutex_enter(&srn_clone_lock); 309 for (clone = 1; clone < SRN_MAX_CLONE - 1; clone++) 310 if (!srn.srn_clones[clone]) 311 break; 312 313 if (clone == SRN_MAX_CLONE) { 314 mutex_exit(&srn_clone_lock); 315 return (ENXIO); 316 } 317 srn.srn_cred[clone] = cr; 318 ASSERT(srn_apm_count >= 0); 319 srn_apm_count++; 320 srn.srn_type[clone] = SRN_TYPE_APM; 321 crhold(cr); 322 323 *devp = makedevice(getmajor(*devp), (srn.srn_instance << 8) + 324 clone); 325 srn.srn_clones[clone] = 1; 326 srn.srn_cred[clone] = cr; 327 crhold(cr); 328 mutex_exit(&srn_clone_lock); 329 PMD(PMD_SX, ("srn open OK\n")) 330 return (0); 331 } 332 333 /*ARGSUSED1*/ 334 static int 335 srn_close(dev_t dev, int flag, int otyp, cred_t *cr) 336 { 337 int clone; 338 339 if (otyp != OTYP_CHR) 340 return (EINVAL); 341 342 clone = SRN_MINOR_TO_CLONE(getminor(dev)); 343 PMD(PMD_SX, ("srn_close: minor %x, clone %x\n", getminor(dev), 344 clone)) 345 mutex_enter(&srn_clone_lock); 346 crfree(srn.srn_cred[clone]); 347 srn.srn_cred[clone] = 0; 348 srn_poll_cnt[clone] = 0; 349 srn.srn_fault[clone] = 0; 350 if (srn.srn_pending[clone].ae_type || srn.srn_delivered[clone]) { 351 srn.srn_pending[clone].ae_type = 0; 352 srn.srn_delivered[clone] = 0; 353 cv_signal(&srn_clones_cv[clone]); 354 } 355 switch (srn.srn_type[clone]) { 356 case SRN_TYPE_AUTOSX: 357 ASSERT(srn_autosx_count); 358 srn_autosx_count--; 359 break; 360 case SRN_TYPE_APM: 361 ASSERT(srn_apm_count); 362 srn_apm_count--; 363 break; 364 default: 365 ASSERT(0); 366 return (EINVAL); 367 } 368 srn.srn_clones[clone] = 0; 369 mutex_exit(&srn_clone_lock); 370 return (0); 371 } 372 373 /*ARGSUSED*/ 374 static int 375 srn_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cr, int *rval_p) 376 { 377 int clone = SRN_MINOR_TO_CLONE(getminor(dev)); 378 379 PMD(PMD_SX, ("ioctl: %x: begin\n", cmd)) 380 381 switch (cmd) { 382 case SRN_IOC_NEXTEVENT: 383 case SRN_IOC_SUSPEND: 384 case SRN_IOC_RESUME: 385 case SRN_IOC_AUTOSX: 386 break; 387 default: 388 return (ENOTTY); 389 } 390 391 if (!srn_perms(SU | SG, srn.srn_cred[clone])) { 392 return (EPERM); 393 } 394 switch (cmd) { 395 case SRN_IOC_AUTOSX: 396 PMD(PMD_SX, ("SRN_IOC_AUTOSX entered\n")) 397 mutex_enter(&srn_clone_lock); 398 if (!srn.srn_clones[clone]) { 399 PMD(PMD_SX, (" ioctl !srn_clones--EINVAL\n")) 400 mutex_exit(&srn_clone_lock); 401 return (EINVAL); 402 } 403 if (srn.srn_pending[clone].ae_type) { 404 PMD(PMD_SX, ("AUTOSX while pending--EBUSY\n")) 405 mutex_exit(&srn_clone_lock); 406 return (EBUSY); 407 } 408 if (srn.srn_type[clone] == SRN_TYPE_AUTOSX) { 409 PMD(PMD_SX, ("AUTOSX already--EBUSY\n")) 410 mutex_exit(&srn_clone_lock); 411 return (EBUSY); 412 } 413 ASSERT(srn.srn_type[clone] == SRN_TYPE_APM); 414 srn.srn_type[clone] = SRN_TYPE_AUTOSX; 415 srn.srn_fault[clone] = 0; 416 srn_apm_count--; 417 ASSERT(srn_apm_count >= 0); 418 ASSERT(srn_autosx_count >= 0); 419 srn_autosx_count++; 420 mutex_exit(&srn_clone_lock); 421 PMD(PMD_SX, ("SRN_IOC_AUTOSX returns success\n")) 422 return (0); 423 424 case SRN_IOC_NEXTEVENT: 425 /* 426 * return the next suspend or resume event; there should 427 * be one, cause we only get called if we've signalled a 428 * poll data completion 429 * then wake up the kernel thread sleeping for the delivery 430 */ 431 PMD(PMD_SX, ("SRN_IOC_NEXTEVENT entered\n")) 432 if (srn.srn_fault[clone]) { 433 PMD(PMD_SX, ("SRN_IOC_NEXTEVENT clone %d fault " 434 "cleared\n", clone)) 435 srn.srn_fault[clone] = 0; 436 } 437 mutex_enter(&srn_clone_lock); 438 if (srn_poll_cnt[clone] == 0) { 439 mutex_exit(&srn_clone_lock); 440 PMD(PMD_SX, ("SRN_IOC_NEXTEVENT clone %d " 441 "EWOULDBLOCK\n", clone)) 442 return (EWOULDBLOCK); 443 } 444 ASSERT(srn.srn_pending[clone].ae_type); 445 if (ddi_copyout(&srn.srn_pending[clone], (void *)arg, 446 sizeof (srn_event_info_t), mode) != 0) { 447 mutex_exit(&srn_clone_lock); 448 PMD(PMD_SX, ("SRN_IOC_NEXTEVENT clone %d EFAULT\n", 449 clone)) 450 return (EFAULT); 451 } 452 if (srn.srn_type[clone] == SRN_TYPE_APM) 453 srn.srn_delivered[clone] = 454 srn.srn_pending[clone].ae_type; 455 PMD(PMD_SX, ("SRN_IOC_NEXTEVENT clone %d delivered %x\n", 456 clone, srn.srn_pending[clone].ae_type)) 457 srn_poll_cnt[clone] = 0; 458 mutex_exit(&srn_clone_lock); 459 return (0); 460 461 case SRN_IOC_SUSPEND: 462 /* ack suspend */ 463 PMD(PMD_SX, ("SRN_IOC_SUSPEND entered clone %d\n", clone)) 464 if (srn.srn_fault[clone]) { 465 PMD(PMD_SX, ("SRN_IOC_SUSPEND clone %d fault " 466 "cleared\n", clone)) 467 srn.srn_fault[clone] = 0; 468 } 469 mutex_enter(&srn_clone_lock); 470 if (srn.srn_delivered[clone] != SRN_SUSPEND_REQ) { 471 mutex_exit(&srn_clone_lock); 472 PMD(PMD_SX, ("SRN_IOC_SUSPEND EINVAL\n")) 473 return (EINVAL); 474 } 475 srn.srn_delivered[clone] = 0; 476 srn.srn_pending[clone].ae_type = 0; 477 /* notify the kernel suspend thread to continue */ 478 PMD(PMD_SX, ("SRN_IOC_SUSPEND clone %d ok\n", clone)) 479 cv_signal(&srn_clones_cv[clone]); 480 mutex_exit(&srn_clone_lock); 481 return (0); 482 483 case SRN_IOC_RESUME: 484 /* ack resume */ 485 PMD(PMD_SX, ("SRN_IOC_RESUME entered clone %d\n", clone)) 486 if (srn.srn_fault[clone]) { 487 PMD(PMD_SX, ("SRN_IOC_RESUME clone %d fault " 488 "cleared\n", clone)) 489 srn.srn_fault[clone] = 0; 490 } 491 mutex_enter(&srn_clone_lock); 492 if (srn.srn_delivered[clone] != SRN_NORMAL_RESUME) { 493 mutex_exit(&srn_clone_lock); 494 PMD(PMD_SX, ("SRN_IOC_RESUME EINVAL\n")) 495 return (EINVAL); 496 } 497 srn.srn_delivered[clone] = 0; 498 srn.srn_pending[clone].ae_type = 0; 499 /* notify the kernel resume thread to continue */ 500 PMD(PMD_SX, ("SRN_IOC_RESUME ok for clone %d\n", clone)) 501 cv_signal(&srn_clones_cv[clone]); 502 mutex_exit(&srn_clone_lock); 503 return (0); 504 505 default: 506 PMD(PMD_SX, ("srn_ioctl unknown cmd EINVAL\n")) 507 return (EINVAL); 508 } 509 } 510 /* 511 * A very simple handshake with the srn driver, 512 * only one outstanding event at a time. 513 * The OS delivers the event and depending on type, 514 * either blocks waiting for the ack, or drives on 515 */ 516 void 517 srn_notify(int type, int event) 518 { 519 int clone, count; 520 PMD(PMD_SX, ("srn_notify entered with type %d, event 0x%x\n", 521 type, event)); 522 ASSERT(mutex_owned(&srn_clone_lock)); 523 switch (type) { 524 case SRN_TYPE_APM: 525 if (srn_apm_count == 0) { 526 PMD(PMD_SX, ("no apm types\n")) 527 return; 528 } 529 count = srn_apm_count; 530 break; 531 case SRN_TYPE_AUTOSX: 532 if (srn_autosx_count == 0) { 533 PMD(PMD_SX, ("no autosx types\n")) 534 return; 535 } 536 count = srn_autosx_count; 537 break; 538 default: 539 ASSERT(0); 540 break; 541 } 542 ASSERT(count > 0); 543 PMD(PMD_SX, ("count %d\n", count)) 544 for (clone = 0; clone < SRN_MAX_CLONE; clone++) { 545 if (srn.srn_type[clone] == type) { 546 #ifdef DEBUG 547 if (type == SRN_TYPE_APM) { 548 ASSERT(srn.srn_pending[clone].ae_type == 0); 549 ASSERT(srn_poll_cnt[clone] == 0); 550 ASSERT(srn.srn_delivered[clone] == 0); 551 } 552 #endif 553 srn.srn_pending[clone].ae_type = event; 554 srn_poll_cnt[clone] = 1; 555 PMD(PMD_SX, ("pollwake %d\n", clone)) 556 pollwakeup(&srn_pollhead[clone], (POLLRDNORM | POLLIN)); 557 count--; 558 if (count == 0) 559 break; 560 } 561 } 562 if (type == SRN_TYPE_AUTOSX) { /* we don't wait */ 563 PMD(PMD_SX, ("Not waiting for AUTOSX ack\n")) 564 return; 565 } 566 ASSERT(type == SRN_TYPE_APM); 567 /* otherwise wait for acks */ 568 restart: 569 /* 570 * We wait until all of the pending events are cleared. 571 * We have to start over every time we do a cv_wait because 572 * we give up the mutex and can be re-entered 573 */ 574 for (clone = 1; clone < SRN_MAX_CLONE; clone++) { 575 if (srn.srn_clones[clone] == 0 || 576 srn.srn_type[clone] != SRN_TYPE_APM) 577 continue; 578 if (srn.srn_pending[clone].ae_type && !srn.srn_fault[clone]) { 579 PMD(PMD_SX, ("srn_notify waiting for ack for clone %d, " 580 "event %x\n", clone, event)) 581 if (cv_timedwait(&srn_clones_cv[clone], 582 &srn_clone_lock, ddi_get_lbolt() + 583 drv_usectohz(srn_timeout * 1000000)) == -1) { 584 /* 585 * Client didn't respond, mark it as faulted 586 * and continue as if a regular signal. 587 */ 588 PMD(PMD_SX, ("srn_notify: clone %d did not " 589 "ack event %x\n", clone, event)) 590 cmn_err(CE_WARN, "srn_notify: clone %d did " 591 "not ack event %x\n", clone, event); 592 srn.srn_fault[clone] = 1; 593 } 594 goto restart; 595 } 596 } 597 PMD(PMD_SX, ("srn_notify done with %x\n", event)) 598 } 599