sys/dev/pud/pud.c

   1 /*      $NetBSD: pud.c,v 1.7 2009/01/20 18:20:48 drochner Exp $ */
   2
   3 /*
   4  * Copyright (c) 2007  Antti Kantee.  All Rights Reserved.
   5  *
   6  * Development of this software was supported by the
   7  * Research Foundation of Helsinki University of Technology
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  19  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  24  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __KERNEL_RCSID(0, "$NetBSD: pud.c,v 1.7 2009/01/20 18:20:48 drochner Exp $");
  33
  34 #include <sys/param.h>
  35 #include <sys/conf.h>
  36 #include <sys/kmem.h>
  37 #include <sys/poll.h>
  38 #include <sys/queue.h>
  39
  40 #include <dev/pud/pud_sys.h>
  41 #include <dev/putter/putter_sys.h>
  42
  43 void    pudattach(void);
  44
  45 static int      pud_putter_getout(void *, size_t, int, uint8_t **,
  46                                   size_t *, void **);
  47 static void     pud_putter_releaseout(void *, void *, int);
  48 static int      pud_putter_dispatch(void *, struct putter_hdr *);
  49 static size_t   pud_putter_waitcount(void *);
  50 static int      pud_putter_close(void *);
  51
  52 struct putter_ops pud_putter = {
  53         .pop_getout     = pud_putter_getout,
  54         .pop_releaseout = pud_putter_releaseout,
  55         .pop_waitcount  = pud_putter_waitcount,
  56         .pop_dispatch   = pud_putter_dispatch,
  57         .pop_close      = pud_putter_close,
  58 };
  59
  60 extern struct bdevsw pud_bdevsw;
  61 extern struct cdevsw pud_cdevsw;
  62
  63 kmutex_t pud_mtx;
  64 static LIST_HEAD(, pud_dev) pudlist = LIST_HEAD_INITIALIZER(pudlist);
  65
  66 static uint64_t
  67 nextreq(struct pud_dev *pd)
  68 {
  69         uint64_t rv;
  70
  71         mutex_enter(&pd->pd_mtx);
  72         rv = pd->pd_nextreq++;
  73         mutex_exit(&pd->pd_mtx);
  74
  75         return rv;
  76 }
  77
  78 static int
  79 pud_putter_getout(void *this, size_t maxsize, int nonblock,
  80         uint8_t **data, size_t *dlen, void **cookie)
  81 {
  82         struct pud_dev *pd = this;
  83         struct pud_touser *putp;
  84         int error = 0;
  85
  86         mutex_enter(&pd->pd_mtx);
  87         for (;;) {
  88                 if (TAILQ_EMPTY(&pd->pd_waitq_req)) {
  89                         if (nonblock) {
  90                                 error = EWOULDBLOCK;
  91                                 break;
  92                         }
  93
  94                         error = cv_wait_sig(&pd->pd_waitq_req_cv, &pd->pd_mtx);
  95                         if (error)
  96                                 break;
  97                         else
  98                                 continue;
  99                 }
 100
 101                 putp = TAILQ_FIRST(&pd->pd_waitq_req);
 102                 TAILQ_REMOVE(&pd->pd_waitq_req, putp, pt_entries);
 103                 KASSERT(error == 0);
 104                 break;
 105         }
 106         mutex_exit(&pd->pd_mtx);
 107
 108         if (error == 0) {
 109                 *data = (uint8_t *)putp->pt_pdr;
 110                 *dlen = putp->pt_pdr->pdr_pth.pth_framelen;
 111                 *cookie = putp;
 112         }
 113
 114         return error;
 115 }
 116
 117 static void
 118 pud_putter_releaseout(void *this, void *cookie, int status)
 119 {
 120         struct pud_dev *pd = this;
 121         struct pud_touser *putp = cookie;
 122
 123         mutex_enter(&pd->pd_mtx);
 124         TAILQ_INSERT_TAIL(&pd->pd_waitq_resp, putp, pt_entries);
 125         mutex_exit(&pd->pd_mtx);
 126
 127 }
 128
 129 static size_t
 130 pud_putter_waitcount(void *this)
 131 {
 132         struct pud_dev *pd = this;
 133         size_t rv;
 134
 135         mutex_enter(&pd->pd_mtx);
 136         rv = pd->pd_waitcount;
 137         mutex_exit(&pd->pd_mtx);
 138
 139         return rv;
 140 }
 141
 142 static int
 143 pudop_dev(struct pud_dev *pd, struct pud_req *pdr)
 144 {
 145         struct putter_hdr *pth = (void *)pdr;
 146         struct pud_touser *putp;
 147
 148         mutex_enter(&pd->pd_mtx);
 149         TAILQ_FOREACH(putp, &pd->pd_waitq_resp, pt_entries)
 150                 if (putp->pt_pdr->pdr_reqid == pdr->pdr_reqid)
 151                         break;
 152         if (putp == NULL) {
 153                 mutex_exit(&pd->pd_mtx);
 154                 return EINVAL;
 155         }
 156         TAILQ_REMOVE(&pd->pd_waitq_resp, putp, pt_entries);
 157         mutex_exit(&pd->pd_mtx);
 158
 159         if (pth->pth_framelen > putp->pt_pdr->pdr_len) {
 160                 return EINVAL;
 161         }
 162         memcpy(putp->pt_pdr, pth, pth->pth_framelen);
 163         cv_signal(&putp->pt_cv);
 164
 165         return 0;
 166 }
 167
 168 /*
 169  * Register our major number.  Always register char device functions,
 170  * register block devices optionally.
 171  *
 172  * XXX: no way to configure "any major you like" currently.
 173  */
 174 static int
 175 pudconf_reg(struct pud_dev *pd, struct pud_conf_reg *pcr)
 176 {
 177         struct bdevsw *bsw;
 178         devmajor_t cmajor, bmajor;
 179         int error;
 180
 181         if (pcr->pm_version != (PUD_DEVELVERSION | PUD_VERSION)) {
 182                 printf("pud version mismatch %d vs %d\n",
 183                     pcr->pm_version & ~PUD_DEVELVERSION, PUD_VERSION);
 184                 return EINVAL; /* XXX */
 185         }
 186
 187         cmajor = major(pcr->pm_regdev);
 188         if (pcr->pm_flags & PUD_CONFFLAG_BDEV) {
 189                 bsw = &pud_bdevsw;
 190                 bmajor = cmajor;
 191         } else {
 192                 bsw = NULL;
 193                 bmajor = NODEVMAJOR;
 194         }
 195
 196         pcr->pm_devname[PUD_DEVNAME_MAX] = '\0';
 197         error = devsw_attach(pcr->pm_devname, bsw, &bmajor,
 198             &pud_cdevsw, &cmajor);
 199         if (error == 0)
 200                 pd->pd_dev = pcr->pm_regdev;
 201
 202         return error;
 203 }
 204
 205 static int
 206 pudop_conf(struct pud_dev *pd, struct pud_req *pdr)
 207 {
 208         int rv;
 209
 210         switch (pdr->pdr_reqtype) {
 211         case PUD_CONF_REG:
 212                 rv = pudconf_reg(pd, (struct pud_conf_reg *)pdr);
 213                 break;
 214         case PUD_CONF_DEREG:
 215                 /* unimplemented */
 216                 rv = 0;
 217                 break;
 218         default:
 219                 rv = EINVAL;
 220                 break;
 221         }
 222
 223         return rv;
 224 }
 225
 226 static int
 227 pud_putter_dispatch(void *this, struct putter_hdr *pth)
 228 {
 229         struct pud_dev *pd = this;
 230         struct pud_req *pdr = (void *)pth;
 231         int rv;
 232
 233         if (pdr->pdr_pth.pth_framelen < sizeof(struct pud_req))
 234                 return EINVAL;
 235
 236         switch (pdr->pdr_reqclass) {
 237         case PUD_REQ_CDEV:
 238         case PUD_REQ_BDEV:
 239                 rv = pudop_dev(pd, pdr);
 240                 break;
 241         case PUD_REQ_CONF:
 242                 rv = pudop_conf(pd, pdr);
 243                 break;
 244         default:
 245                 rv = EINVAL;
 246                 break;
 247         }
 248
 249         return rv;
 250 }
 251
 252 /* Device server severed the umbilical cord */
 253 static int
 254 pud_putter_close(void *this)
 255 {
 256         struct pud_dev *pd = this;
 257         struct pud_touser *putp;
 258
 259         mutex_enter(&pud_mtx);
 260         LIST_REMOVE(pd, pd_entries);
 261         mutex_exit(&pud_mtx);
 262
 263         mutex_enter(&pd->pd_mtx);
 264         while ((putp = TAILQ_FIRST(&pd->pd_waitq_req)) != NULL) {
 265                 putp->pt_pdr->pdr_rv = ENXIO;
 266                 cv_signal(&putp->pt_cv);
 267                 TAILQ_REMOVE(&pd->pd_waitq_req, putp, pt_entries);
 268         }
 269
 270         while ((putp = TAILQ_FIRST(&pd->pd_waitq_resp)) != NULL) {
 271                 putp->pt_pdr->pdr_rv = ENXIO;
 272                 cv_signal(&putp->pt_cv);
 273                 TAILQ_REMOVE(&pd->pd_waitq_resp, putp, pt_entries);
 274         }
 275         if (pd->pd_waitcount)
 276                 cv_wait(&pd->pd_draincv, &pd->pd_mtx);
 277         KASSERT(pd->pd_waitcount == 0);
 278
 279         mutex_exit(&pd->pd_mtx);
 280
 281         if (pd->pd_dev)
 282                 devsw_detach(&pud_bdevsw /* XXX */, &pud_cdevsw);
 283
 284         putter_detach(pd->pd_pi);
 285
 286         mutex_destroy(&pd->pd_mtx);
 287         cv_destroy(&pd->pd_draincv);
 288         cv_destroy(&pd->pd_waitq_req_cv);
 289         kmem_free(pd, sizeof(struct pud_dev));
 290
 291         return 0;
 292 }
 293
 294 struct pud_dev *
 295 pud_dev2pud(dev_t dev)
 296 {
 297         struct pud_dev *pd;
 298
 299         mutex_enter(&pud_mtx);
 300         LIST_FOREACH(pd, &pudlist, pd_entries)
 301                 if (major(pd->pd_dev) == major(dev))
 302                         break;
 303         mutex_exit(&pud_mtx);
 304
 305         return pd;
 306 }
 307
 308 /* Toss request to the device server and wait for result */
 309 int
 310 pud_request(dev_t dev, void *data, size_t dlen, int class, int type)
 311 {
 312         struct pud_touser put;
 313         struct pud_req *pdr = data;
 314         struct pud_dev *pd;
 315
 316         pd = pud_dev2pud(dev);
 317         if (pd == NULL)
 318                 return ENXIO;
 319
 320         pdr->pdr_dev = dev;
 321         pdr->pdr_len = pdr->pdr_pth.pth_framelen = dlen;
 322         pdr->pdr_reqid = nextreq(pd);
 323
 324         pdr->pdr_reqclass = class;
 325         pdr->pdr_reqtype = type;
 326
 327         put.pt_pdr = pdr;
 328         cv_init(&put.pt_cv, "pudresp");
 329
 330         mutex_enter(&pd->pd_mtx);
 331         pd->pd_waitcount++;
 332
 333         TAILQ_INSERT_TAIL(&pd->pd_waitq_req, &put, pt_entries);
 334         putter_notify(pd->pd_pi);
 335         cv_broadcast(&pd->pd_waitq_req_cv);
 336         cv_wait(&put.pt_cv, &pd->pd_mtx);
 337
 338         if (--pd->pd_waitcount == 0)
 339                 cv_signal(&pd->pd_draincv);
 340         mutex_exit(&pd->pd_mtx);
 341         cv_destroy(&put.pt_cv);
 342
 343         return pdr->pdr_rv;
 344 }
 345
 346 /* Called from putter based on minor dev number */
 347 int
 348 pud_config(int fd, int flags, int fmt)
 349 {
 350         struct pud_dev *pd;
 351
 352         pd = kmem_zalloc(sizeof(struct pud_dev), KM_SLEEP);
 353         pd->pd_pi = putter_attach(curlwp->l_proc->p_pid, fd, pd, &pud_putter);
 354         if (pd->pd_pi == NULL) {
 355                 kmem_free(pd, sizeof(struct pud_dev));
 356                 return ENOENT; /* XXX */
 357         }
 358         pd->pd_dev = NODEV;
 359
 360         mutex_init(&pd->pd_mtx, MUTEX_DEFAULT, IPL_NONE);
 361         TAILQ_INIT(&pd->pd_waitq_req);
 362         TAILQ_INIT(&pd->pd_waitq_resp);
 363         cv_init(&pd->pd_waitq_req_cv, "pudreq");
 364         cv_init(&pd->pd_draincv, "pudrain");
 365
 366         mutex_enter(&pud_mtx);
 367         LIST_INSERT_HEAD(&pudlist, pd, pd_entries);
 368         mutex_exit(&pud_mtx);
 369
 370         return 0;
 371 }
 372
 373 void
 374 pudattach(void)
 375 {
 376         int error;
 377
 378         if ((error = putter_register(pud_config, PUTTER_MINOR_PUD)) != 0) {
 379                 printf("pudattach: can't register to putter: %d\n", error);
 380                 return;
 381         }
 382         mutex_init(&pud_mtx, MUTEX_DEFAULT, IPL_NONE);
 383 }