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, NULL }
 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 && !srn.srn_fault[clone]) {
 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 }