1/* $NetBSD: putter.c,v 1.31 2011/02/06 14:29:25 haad Exp $ */ 2 3/* 4 * Copyright (c) 2006, 2007 Antti Kantee. All Rights Reserved. 5 * 6 * Development of this software was supported by the 7 * Ulla Tuominen Foundation and the Finnish Cultural Foundation and the 8 * Research Foundation of Helsinki University of Technology 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 20 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 22 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 25 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32/* 33 * Pass-to-Userspace TransporTER: generic kernel-user request-response 34 * transport interface. 35 */ 36 37#include <sys/cdefs.h> 38__KERNEL_RCSID(0, "$NetBSD: putter.c,v 1.31 2011/02/06 14:29:25 haad Exp $"); 39 40#include <sys/param.h> 41#include <sys/systm.h> 42#include <sys/conf.h> 43#include <sys/file.h> 44#include <sys/filedesc.h> 45#include <sys/kmem.h> 46#include <sys/poll.h> 47#include <sys/stat.h> 48#include <sys/socketvar.h> 49#include <sys/module.h> 50#include <sys/kauth.h> 51 52#include <dev/putter/putter_sys.h> 53 54/* 55 * Device routines. These are for when /dev/putter is initially 56 * opened before it has been cloned. 57 */ 58 59dev_type_open(puttercdopen); 60dev_type_close(puttercdclose); 61dev_type_ioctl(puttercdioctl); 62 63/* dev */ 64const struct cdevsw putter_cdevsw = { 65 puttercdopen, puttercdclose, noread, nowrite, 66 noioctl, nostop, notty, nopoll, 67 nommap, nokqfilter, D_OTHER 68}; 69 70/* 71 * Configuration data. 72 * 73 * This is static-size for now. Will be redone for devfs. 74 */ 75 76#define PUTTER_CONFSIZE 16 77 78static struct putter_config { 79 int pc_minor; 80 int (*pc_config)(int, int, int); 81} putterconf[PUTTER_CONFSIZE]; 82 83static int 84putter_configure(dev_t dev, int flags, int fmt, int fd) 85{ 86 struct putter_config *pc; 87 88 /* are we the catch-all node? */ 89 if (minor(dev) == PUTTER_MINOR_WILDCARD 90 || minor(dev) == PUTTER_MINOR_COMPAT) 91 return 0; 92 93 /* nopes? try to configure us */ 94 for (pc = putterconf; pc->pc_config; pc++) 95 if (minor(dev) == pc->pc_minor) 96 return pc->pc_config(fd, flags, fmt); 97 return ENXIO; 98} 99 100int 101putter_register(putter_config_fn pcfn, int minor) 102{ 103 int i; 104 105 for (i = 0; i < PUTTER_CONFSIZE; i++) 106 if (putterconf[i].pc_config == NULL) 107 break; 108 if (i == PUTTER_CONFSIZE) 109 return EBUSY; 110 111 putterconf[i].pc_minor = minor; 112 putterconf[i].pc_config = pcfn; 113 return 0; 114} 115 116/* 117 * putter instance structures. these are always allocated and freed 118 * from the context of the transport user. 119 */ 120struct putter_instance { 121 pid_t pi_pid; 122 int pi_idx; 123 int pi_fd; 124 struct selinfo pi_sel; 125 126 void *pi_private; 127 struct putter_ops *pi_pop; 128 129 uint8_t *pi_curput; 130 size_t pi_curres; 131 void *pi_curopaq; 132 struct timespec pi_atime; 133 struct timespec pi_mtime; 134 struct timespec pi_btime; 135 136 TAILQ_ENTRY(putter_instance) pi_entries; 137}; 138#define PUTTER_EMBRYO ((void *)-1) /* before attach */ 139#define PUTTER_DEAD ((void *)-2) /* after detach */ 140 141static TAILQ_HEAD(, putter_instance) putter_ilist 142 = TAILQ_HEAD_INITIALIZER(putter_ilist); 143 144static int get_pi_idx(struct putter_instance *); 145 146#ifdef DEBUG 147#ifndef PUTTERDEBUG 148#define PUTTERDEBUG 149#endif 150#endif 151 152#ifdef PUTTERDEBUG 153int putterdebug = 0; 154#define DPRINTF(x) if (putterdebug > 0) printf x 155#define DPRINTF_VERBOSE(x) if (putterdebug > 1) printf x 156#else 157#define DPRINTF(x) 158#define DPRINTF_VERBOSE(x) 159#endif 160 161/* 162 * public init / deinit 163 */ 164 165/* protects both the list and the contents of the list elements */ 166static kmutex_t pi_mtx; 167 168void putterattach(void); 169 170void 171putterattach(void) 172{ 173 174 mutex_init(&pi_mtx, MUTEX_DEFAULT, IPL_NONE); 175} 176 177#if 0 178void 179putter_destroy(void) 180{ 181 182 mutex_destroy(&pi_mtx); 183} 184#endif 185 186/* 187 * fd routines, for cloner 188 */ 189static int putter_fop_read(file_t *, off_t *, struct uio *, 190 kauth_cred_t, int); 191static int putter_fop_write(file_t *, off_t *, struct uio *, 192 kauth_cred_t, int); 193static int putter_fop_ioctl(file_t*, u_long, void *); 194static int putter_fop_poll(file_t *, int); 195static int putter_fop_stat(file_t *, struct stat *); 196static int putter_fop_close(file_t *); 197static int putter_fop_kqfilter(file_t *, struct knote *); 198 199 200static const struct fileops putter_fileops = { 201 .fo_read = putter_fop_read, 202 .fo_write = putter_fop_write, 203 .fo_ioctl = putter_fop_ioctl, 204 .fo_fcntl = fnullop_fcntl, 205 .fo_poll = putter_fop_poll, 206 .fo_stat = putter_fop_stat, 207 .fo_close = putter_fop_close, 208 .fo_kqfilter = putter_fop_kqfilter, 209 .fo_restart = fnullop_restart, 210}; 211 212static int 213putter_fop_read(file_t *fp, off_t *off, struct uio *uio, 214 kauth_cred_t cred, int flags) 215{ 216 struct putter_instance *pi = fp->f_data; 217 size_t origres, moved; 218 int error; 219 220 KERNEL_LOCK(1, NULL); 221 getnanotime(&pi->pi_atime); 222 223 if (pi->pi_private == PUTTER_EMBRYO || pi->pi_private == PUTTER_DEAD) { 224 printf("putter_fop_read: private %d not inited\n", pi->pi_idx); 225 KERNEL_UNLOCK_ONE(NULL); 226 return ENOENT; 227 } 228 229 if (pi->pi_curput == NULL) { 230 error = pi->pi_pop->pop_getout(pi->pi_private, uio->uio_resid, 231 fp->f_flag & O_NONBLOCK, &pi->pi_curput, 232 &pi->pi_curres, &pi->pi_curopaq); 233 if (error) { 234 KERNEL_UNLOCK_ONE(NULL); 235 return error; 236 } 237 } 238 239 origres = uio->uio_resid; 240 error = uiomove(pi->pi_curput, pi->pi_curres, uio); 241 moved = origres - uio->uio_resid; 242 DPRINTF(("putter_fop_read (%p): moved %zu bytes from %p, error %d\n", 243 pi, moved, pi->pi_curput, error)); 244 245 KASSERT(pi->pi_curres >= moved); 246 pi->pi_curres -= moved; 247 pi->pi_curput += moved; 248 249 if (pi->pi_curres == 0) { 250 pi->pi_pop->pop_releaseout(pi->pi_private, 251 pi->pi_curopaq, error); 252 pi->pi_curput = NULL; 253 } 254 255 KERNEL_UNLOCK_ONE(NULL); 256 return error; 257} 258 259static int 260putter_fop_write(file_t *fp, off_t *off, struct uio *uio, 261 kauth_cred_t cred, int flags) 262{ 263 struct putter_instance *pi = fp->f_data; 264 struct putter_hdr pth; 265 uint8_t *buf; 266 size_t frsize; 267 int error; 268 269 KERNEL_LOCK(1, NULL); 270 getnanotime(&pi->pi_mtime); 271 272 DPRINTF(("putter_fop_write (%p): writing response, resid %zu\n", 273 pi->pi_private, uio->uio_resid)); 274 275 if (pi->pi_private == PUTTER_EMBRYO || pi->pi_private == PUTTER_DEAD) { 276 printf("putter_fop_write: putter %d not inited\n", pi->pi_idx); 277 KERNEL_UNLOCK_ONE(NULL); 278 return ENOENT; 279 } 280 281 error = uiomove(&pth, sizeof(struct putter_hdr), uio); 282 if (error) { 283 KERNEL_UNLOCK_ONE(NULL); 284 return error; 285 } 286 287 /* Sorry mate, the kernel doesn't buffer. */ 288 frsize = pth.pth_framelen - sizeof(struct putter_hdr); 289 if (uio->uio_resid < frsize) { 290 KERNEL_UNLOCK_ONE(NULL); 291 return EINVAL; 292 } 293 294 buf = kmem_alloc(frsize + sizeof(struct putter_hdr), KM_SLEEP); 295 memcpy(buf, &pth, sizeof(pth)); 296 error = uiomove(buf+sizeof(struct putter_hdr), frsize, uio); 297 if (error == 0) { 298 pi->pi_pop->pop_dispatch(pi->pi_private, 299 (struct putter_hdr *)buf); 300 } 301 kmem_free(buf, frsize + sizeof(struct putter_hdr)); 302 303 KERNEL_UNLOCK_ONE(NULL); 304 return error; 305} 306 307/* 308 * Poll query interface. The question is only if an event 309 * can be read from us. 310 */ 311#define PUTTERPOLL_EVSET (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI) 312static int 313putter_fop_poll(file_t *fp, int events) 314{ 315 struct putter_instance *pi = fp->f_data; 316 int revents; 317 318 KERNEL_LOCK(1, NULL); 319 320 if (pi->pi_private == PUTTER_EMBRYO || pi->pi_private == PUTTER_DEAD) { 321 printf("putter_fop_ioctl: putter %d not inited\n", pi->pi_idx); 322 KERNEL_UNLOCK_ONE(NULL); 323 return ENOENT; 324 } 325 326 revents = events & (POLLOUT | POLLWRNORM | POLLWRBAND); 327 if ((events & PUTTERPOLL_EVSET) == 0) { 328 KERNEL_UNLOCK_ONE(NULL); 329 return revents; 330 } 331 332 /* check queue */ 333 if (pi->pi_pop->pop_waitcount(pi->pi_private)) 334 revents |= PUTTERPOLL_EVSET; 335 else 336 selrecord(curlwp, &pi->pi_sel); 337 338 KERNEL_UNLOCK_ONE(NULL); 339 return revents; 340} 341 342/* 343 * device close = forced unmount. 344 * 345 * unmounting is a frightfully complex operation to avoid races 346 */ 347static int 348putter_fop_close(file_t *fp) 349{ 350 struct putter_instance *pi = fp->f_data; 351 int rv; 352 353 DPRINTF(("putter_fop_close: device closed\n")); 354 355 KERNEL_LOCK(1, NULL); 356 357 restart: 358 mutex_enter(&pi_mtx); 359 /* 360 * First check if the driver was never born. In that case 361 * remove the instance from the list. If mount is attempted later, 362 * it will simply fail. 363 */ 364 if (pi->pi_private == PUTTER_EMBRYO) { 365 TAILQ_REMOVE(&putter_ilist, pi, pi_entries); 366 mutex_exit(&pi_mtx); 367 368 DPRINTF(("putter_fop_close: data associated with fp %p was " 369 "embryonic\n", fp)); 370 371 goto out; 372 } 373 374 /* 375 * Next, analyze if unmount was called and the instance is dead. 376 * In this case we can just free the structure and go home, it 377 * was removed from the list by putter_rmprivate(). 378 */ 379 if (pi->pi_private == PUTTER_DEAD) { 380 mutex_exit(&pi_mtx); 381 382 DPRINTF(("putter_fop_close: putter associated with fp %p (%d) " 383 "dead, freeing\n", fp, pi->pi_idx)); 384 385 goto out; 386 } 387 388 /* 389 * So we have a reference. Proceed to unravel the 390 * underlying driver. 391 */ 392 mutex_exit(&pi_mtx); 393 394 /* hmm? suspicious locking? */ 395 while ((rv = pi->pi_pop->pop_close(pi->pi_private)) == ERESTART) 396 goto restart; 397 398 out: 399 KERNEL_UNLOCK_ONE(NULL); 400 /* 401 * Finally, release the instance information. It was already 402 * removed from the list by putter_rmprivate() and we know it's 403 * dead, so no need to lock. 404 */ 405 kmem_free(pi, sizeof(struct putter_instance)); 406 407 return 0; 408} 409 410static int 411putter_fop_stat(file_t *fp, struct stat *st) 412{ 413 struct putter_instance *pi = fp->f_data; 414 415 (void)memset(st, 0, sizeof(*st)); 416 KERNEL_LOCK(1, NULL); 417 st->st_dev = makedev(cdevsw_lookup_major(&putter_cdevsw), pi->pi_idx); 418 st->st_atimespec = pi->pi_atime; 419 st->st_mtimespec = pi->pi_mtime; 420 st->st_ctimespec = st->st_birthtimespec = pi->pi_btime; 421 st->st_uid = kauth_cred_geteuid(fp->f_cred); 422 st->st_gid = kauth_cred_getegid(fp->f_cred); 423 st->st_mode = S_IFCHR; 424 KERNEL_UNLOCK_ONE(NULL); 425 return 0; 426} 427 428static int 429putter_fop_ioctl(file_t *fp, u_long cmd, void *data) 430{ 431 432 /* 433 * work already done in sys_ioctl(). skip sanity checks to enable 434 * setting non-blocking fd on an embryotic driver. 435 */ 436 if (cmd == FIONBIO) 437 return 0; 438 439 return EINVAL; 440} 441 442/* kqueue stuff */ 443 444static void 445filt_putterdetach(struct knote *kn) 446{ 447 struct putter_instance *pi = kn->kn_hook; 448 449 KERNEL_LOCK(1, NULL); 450 mutex_enter(&pi_mtx); 451 SLIST_REMOVE(&pi->pi_sel.sel_klist, kn, knote, kn_selnext); 452 mutex_exit(&pi_mtx); 453 KERNEL_UNLOCK_ONE(NULL); 454} 455 456static int 457filt_putter(struct knote *kn, long hint) 458{ 459 struct putter_instance *pi = kn->kn_hook; 460 int error, rv; 461 462 KERNEL_LOCK(1, NULL); 463 error = 0; 464 mutex_enter(&pi_mtx); 465 if (pi->pi_private == PUTTER_EMBRYO || pi->pi_private == PUTTER_DEAD) 466 error = 1; 467 mutex_exit(&pi_mtx); 468 if (error) { 469 KERNEL_UNLOCK_ONE(NULL); 470 return 0; 471 } 472 473 kn->kn_data = pi->pi_pop->pop_waitcount(pi->pi_private); 474 rv = kn->kn_data != 0; 475 KERNEL_UNLOCK_ONE(NULL); 476 return rv; 477} 478 479static const struct filterops putter_filtops = 480 { 1, NULL, filt_putterdetach, filt_putter }; 481 482static int 483putter_fop_kqfilter(file_t *fp, struct knote *kn) 484{ 485 struct putter_instance *pi = fp->f_data; 486 struct klist *klist; 487 488 KERNEL_LOCK(1, NULL); 489 490 switch (kn->kn_filter) { 491 case EVFILT_READ: 492 klist = &pi->pi_sel.sel_klist; 493 kn->kn_fop = &putter_filtops; 494 kn->kn_hook = pi; 495 496 mutex_enter(&pi_mtx); 497 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 498 mutex_exit(&pi_mtx); 499 500 break; 501 case EVFILT_WRITE: 502 kn->kn_fop = &seltrue_filtops; 503 break; 504 default: 505 KERNEL_UNLOCK_ONE(NULL); 506 return EINVAL; 507 } 508 509 KERNEL_UNLOCK_ONE(NULL); 510 return 0; 511} 512 513int 514puttercdopen(dev_t dev, int flags, int fmt, struct lwp *l) 515{ 516 struct putter_instance *pi; 517 file_t *fp; 518 int error, fd, idx; 519 proc_t *p; 520 521 p = curproc; 522 pi = kmem_alloc(sizeof(struct putter_instance), KM_SLEEP); 523 mutex_enter(&pi_mtx); 524 idx = get_pi_idx(pi); 525 526 pi->pi_pid = p->p_pid; 527 pi->pi_idx = idx; 528 pi->pi_curput = NULL; 529 pi->pi_curres = 0; 530 pi->pi_curopaq = NULL; 531 getnanotime(&pi->pi_btime); 532 pi->pi_atime = pi->pi_mtime = pi->pi_btime; 533 selinit(&pi->pi_sel); 534 mutex_exit(&pi_mtx); 535 536 if ((error = fd_allocfile(&fp, &fd)) != 0) 537 goto bad1; 538 539 if ((error = putter_configure(dev, flags, fmt, fd)) != 0) 540 goto bad2; 541 542 DPRINTF(("puttercdopen: registered embryonic pmp for pid: %d\n", 543 pi->pi_pid)); 544 545 error = fd_clone(fp, fd, FREAD|FWRITE, &putter_fileops, pi); 546 KASSERT(error == EMOVEFD); 547 return error; 548 549 bad2: 550 fd_abort(p, fp, fd); 551 bad1: 552 putter_detach(pi); 553 kmem_free(pi, sizeof(struct putter_instance)); 554 return error; 555} 556 557int 558puttercdclose(dev_t dev, int flags, int fmt, struct lwp *l) 559{ 560 561 panic("puttercdclose impossible\n"); 562 563 return 0; 564} 565 566 567/* 568 * Set the private structure for the file descriptor. This is 569 * typically done immediately when the counterpart has knowledge 570 * about the private structure's address and the file descriptor 571 * (e.g. vfs mount routine). 572 * 573 * We only want to make sure that the caller had the right to open the 574 * device, we don't so much care about which context it gets in case 575 * the same process opened multiple (since they are equal at this point). 576 */ 577struct putter_instance * 578putter_attach(pid_t pid, int fd, void *ppriv, struct putter_ops *pop) 579{ 580 struct putter_instance *pi = NULL; 581 582 mutex_enter(&pi_mtx); 583 TAILQ_FOREACH(pi, &putter_ilist, pi_entries) { 584 if (pi->pi_pid == pid && pi->pi_private == PUTTER_EMBRYO) { 585 pi->pi_private = ppriv; 586 pi->pi_fd = fd; 587 pi->pi_pop = pop; 588 break; 589 } 590 } 591 mutex_exit(&pi_mtx); 592 593 DPRINTF(("putter_setprivate: pi at %p (%d/%d)\n", pi, 594 pi ? pi->pi_pid : 0, pi ? pi->pi_fd : 0)); 595 596 return pi; 597} 598 599/* 600 * Remove fp <-> private mapping. 601 */ 602void 603putter_detach(struct putter_instance *pi) 604{ 605 606 mutex_enter(&pi_mtx); 607 TAILQ_REMOVE(&putter_ilist, pi, pi_entries); 608 pi->pi_private = PUTTER_DEAD; 609 mutex_exit(&pi_mtx); 610 seldestroy(&pi->pi_sel); 611 612 DPRINTF(("putter_nukebypmp: nuked %p\n", pi)); 613} 614 615void 616putter_notify(struct putter_instance *pi) 617{ 618 619 selnotify(&pi->pi_sel, 0, 0); 620} 621 622/* search sorted list of instances for free minor, sorted insert arg */ 623static int 624get_pi_idx(struct putter_instance *pi_i) 625{ 626 struct putter_instance *pi; 627 int i; 628 629 KASSERT(mutex_owned(&pi_mtx)); 630 631 i = 0; 632 TAILQ_FOREACH(pi, &putter_ilist, pi_entries) { 633 if (i != pi->pi_idx) 634 break; 635 i++; 636 } 637 638 pi_i->pi_private = PUTTER_EMBRYO; 639 640 if (pi == NULL) 641 TAILQ_INSERT_TAIL(&putter_ilist, pi_i, pi_entries); 642 else 643 TAILQ_INSERT_BEFORE(pi, pi_i, pi_entries); 644 645 return i; 646} 647 648MODULE(MODULE_CLASS_DRIVER, putter, NULL); 649 650static int 651putter_modcmd(modcmd_t cmd, void *arg) 652{ 653#ifdef _MODULE 654 devmajor_t bmajor = NODEVMAJOR, cmajor = NODEVMAJOR; 655 656 switch (cmd) { 657 case MODULE_CMD_INIT: 658 putterattach(); 659 return devsw_attach("putter", NULL, &bmajor, 660 &putter_cdevsw, &cmajor); 661 case MODULE_CMD_FINI: 662 return ENOTTY; /* XXX: putterdetach */ 663 default: 664 return ENOTTY; 665 } 666#else 667 if (cmd == MODULE_CMD_INIT) 668 return 0; 669 return ENOTTY; 670#endif 671} 672