usr/src/uts/common/io/srn.c

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