![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_lkm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / kern|
Return to kern_lkm.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 ! root 1: /* ! 2: * kern_lkm.c ! 3: * ! 4: * functions and pseudo-device for loadable kernel modules ! 5: * ! 6: * 05 Jun 93 Terry Lambert Release cleanup ! 7: * 10 Feb 93 Terry Lambert Original ! 8: * ! 9: * Copyright (c) 1992 Terrence R. Lambert. ! 10: * All rights reserved. ! 11: * ! 12: * Redistribution and use in source and binary forms, with or without ! 13: * modification, are permitted provided that the following conditions ! 14: * are met: ! 15: * 1. Redistributions of source code must retain the above copyright ! 16: * notice, this list of conditions and the following disclaimer. ! 17: * 2. Redistributions in binary form must reproduce the above copyright ! 18: * notice, this list of conditions and the following disclaimer in the ! 19: * documentation and/or other materials provided with the distribution. ! 20: * 3. All advertising materials mentioning features or use of this software ! 21: * must display the following acknowledgement: ! 22: * This product includes software developed by Terrence R. Lambert. ! 23: * 4. The name Terrence R. Lambert may not be used to endorse or promote ! 24: * products derived from this software without specific prior written ! 25: * permission. ! 26: * ! 27: * THIS SOFTWARE IS PROVIDED BY TERRENCE R. LAMBERT ``AS IS'' AND ANY ! 28: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 29: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 30: * ARE DISCLAIMED. IN NO EVENT SHALL THE TERRENCE R. LAMBERT BE LIABLE ! 31: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 32: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 33: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 34: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 35: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 36: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 37: * SUCH DAMAGE. ! 38: * ! 39: * kern_lkm.c,v 1.3.2.1 1993/07/22 13:01:55 cgd Exp ! 40: */ ! 41: ! 42: #include "param.h" ! 43: #include "systm.h" ! 44: #include "ioctl.h" ! 45: #include "tty.h" ! 46: #include "conf.h" ! 47: #include "file.h" ! 48: #include "proc.h" ! 49: #include "uio.h" ! 50: #include "kernel.h" ! 51: #include "vnode.h" ! 52: #include "malloc.h" ! 53: #include "vm/vm.h" ! 54: #include "vm/vm_param.h" ! 55: #include "vm/vm_kern.h" ! 56: #include "mount.h" ! 57: #include "exec.h" ! 58: #include "lkm.h" ! 59: ! 60: #define PAGESIZE 1024 /* kmem_alloc() allocation quantum*/ ! 61: ! 62: #define LKM_ALLOC 0x01 ! 63: #define LKM_WANT 0x02 ! 64: ! 65: ! 66: #define LKMS_IDLE 0x00 ! 67: #define LKMS_RESERVED 0x01 ! 68: #define LKMS_LOADING 0x02 ! 69: #define LKMS_LOADED 0x04 ! 70: #define LKMS_UNLOADING 0x08 ! 71: ! 72: static int lkm_v = 0; ! 73: static int lkm_state = LKMS_IDLE; ! 74: ! 75: #ifndef MAXLKMS ! 76: #define MAXLKMS 20 ! 77: #endif ! 78: ! 79: static struct lkm_table lkmods[ MAXLKMS]; /* table of loaded modules*/ ! 80: static struct lkm_table *curp; /* global for in-progress ops*/ ! 81: ! 82: /*ARGSUSED*/ ! 83: lkmopen( dev, flag, devtype, p) ! 84: dev_t dev; ! 85: int flag; ! 86: int devtype; ! 87: struct proc *p; ! 88: { ! 89: int error; ! 90: ! 91: if( minor( dev) != 0) ! 92: return( ENXIO); /* bad minor #*/ ! 93: ! 94: /* ! 95: * Use of the loadable kernel module device must be exclusive; we ! 96: * may try to remove this restriction later, but it's really no ! 97: * hardship. ! 98: */ ! 99: while( lkm_v & LKM_ALLOC) { ! 100: if( flag & FNONBLOCK) /* don't hang*/ ! 101: return( EBUSY); ! 102: lkm_v |= LKM_WANT; ! 103: /* ! 104: * Sleep pending unlock; we use tsleep() to allow ! 105: * an alarm out of the open. ! 106: */ ! 107: if( error = tsleep( (caddr_t)&lkm_v, TTIPRI|PCATCH, "LKM", 0)) ! 108: return( error); /* leave LKM_WANT set -- no problem*/ ! 109: } ! 110: lkm_v |= LKM_ALLOC; ! 111: ! 112: return( 0); /* pseudo-device open*/ ! 113: } ! 114: ! 115: ! 116: /* ! 117: * l k m u n r e s e r v e ! 118: * ! 119: * Unreserve the memory associated with the current loaded module; done on ! 120: * a coerced close of the lkm device (close on premature exit of modload) ! 121: * or explicitly by modload as a result of a link failure. ! 122: */ ! 123: static int ! 124: lkmunreserve() ! 125: { ! 126: if( lkm_state == LKMS_IDLE) ! 127: return; ! 128: ! 129: /* ! 130: * Actually unreserve the memory ! 131: */ ! 132: kmem_free( kmem_map, curp->area, curp->size);/**/ ! 133: ! 134: lkm_state = LKMS_IDLE; ! 135: } ! 136: ! 137: ! 138: lkmclose( dev, flag, mode, p) ! 139: dev_t dev; ! 140: int flag; ! 141: int mode; ! 142: struct proc *p; ! 143: { ! 144: if( !( lkm_v & LKM_ALLOC)) { ! 145: #ifdef DEBUG ! 146: printf( "LKM: close before open!\n"); ! 147: #endif /* DEBUG*/ ! 148: return( EBADF); ! 149: } ! 150: ! 151: /* do this before waking the herd...*/ ! 152: if( !curp->used) { ! 153: /* ! 154: * If we close before setting used, we have aborted ! 155: * by way of error or by way of close-on-exit from ! 156: * a premature exit of "modload". ! 157: */ ! 158: lkmunreserve(); /* coerce state to LKM_IDLE*/ ! 159: } ! 160: ! 161: lkm_v &= ~LKM_ALLOC; ! 162: wakeup( (caddr_t)&lkm_v); /* thundering herd "problem" here*/ ! 163: ! 164: return( 0); /* pseudo-device closed*/ ! 165: } ! 166: ! 167: ! 168: /*ARGSUSED*/ ! 169: lkmioctl( dev, cmd, data, flag) ! 170: dev_t dev; ! 171: int cmd; ! 172: caddr_t data; ! 173: int flag; ! 174: { ! 175: int err = 0; ! 176: int i; ! 177: struct lmc_resrv *resrvp; ! 178: struct lmc_loadbuf *loadbufp; ! 179: struct lmc_unload *unloadp; ! 180: struct lmc_stat *statp; ! 181: int (*funcp)(); ! 182: char istr[ MAXLKMNAME]; ! 183: ! 184: switch( cmd) { ! 185: case LMRESERV: /* reserve pages for a module*/ ! 186: if ((flag & FWRITE) == 0) /* only allow this if writing */ ! 187: return EPERM; ! 188: ! 189: resrvp = (struct lmc_resrv *)data; ! 190: ! 191: /* ! 192: * Find a free slot. ! 193: */ ! 194: for( i = 0; i < MAXLKMS; i++) { ! 195: if( !lkmods[ i].used) ! 196: break; ! 197: } ! 198: if( i == MAXLKMS) { ! 199: err = ENOMEM; /* no slots available*/ ! 200: break; ! 201: } ! 202: curp = &lkmods[ i]; ! 203: curp->id = i; /* self reference slot offset*/ ! 204: ! 205: resrvp->slot = i; /* return slot*/ ! 206: ! 207: /* ! 208: * Get memory for module ! 209: */ ! 210: curp->size = resrvp->size; ! 211: ! 212: curp->area = (char *)kmem_alloc( kmem_map, curp->size);/**/ ! 213: ! 214: curp->offset = 0; /* load offset*/ ! 215: ! 216: resrvp->addr = (unsigned long)curp->area; /* ret kernel addr*/ ! 217: ! 218: #ifdef DEBUG ! 219: printf( "LKM: LMRESERV (actual = 0x%08x)\n", curp->area); ! 220: printf( "LKM: LMRESERV (adjusted = 0x%08x)\n", ! 221: trunc_page(curp->area)); ! 222: #endif /* DEBUG*/ ! 223: lkm_state = LKMS_RESERVED; ! 224: break; ! 225: ! 226: case LMLOADBUF: /* Copy in; stateful, follows LMRESERV*/ ! 227: if ((flag & FWRITE) == 0) /* only allow this if writing */ ! 228: return EPERM; ! 229: ! 230: loadbufp = (struct lmc_loadbuf *)data; ! 231: if( lkm_state != LKMS_RESERVED && lkm_state != LKMS_LOADING) { ! 232: err = ENOMEM; ! 233: break; ! 234: } ! 235: ! 236: /* account for odd size (non-page multiple) copyin*/ ! 237: i = MIN( curp->size - curp->offset, MODIOBUF); ! 238: ! 239: /* copy in buffer full of data*/ ! 240: if( err = copyin( (caddr_t)loadbufp->data, (caddr_t)curp->area + curp->offset, i)) ! 241: break; ! 242: ! 243: if( ( curp->offset + i) < curp->size) { ! 244: lkm_state = LKMS_LOADING; ! 245: #ifdef DEBUG ! 246: printf( "LKM: LMLOADBUF (loading @ %d of %d, i = %d)\n", ! 247: curp->offset, curp->size, i); ! 248: #endif /* DEBUG*/ ! 249: } else { ! 250: lkm_state = LKMS_LOADED; ! 251: #ifdef DEBUG ! 252: printf( "LKM: LMLOADBUF (loaded)\n"); ! 253: #endif /* DEBUG*/ ! 254: } ! 255: curp->offset += MODIOBUF; ! 256: break; ! 257: ! 258: case LMUNRESRV: /* discard reserved pages for a module*/ ! 259: if ((flag & FWRITE) == 0) /* only allow this if writing */ ! 260: return EPERM; ! 261: ! 262: lkmunreserve(); /* coerce state to LKM_IDLE*/ ! 263: #ifdef DEBUG ! 264: printf( "LKM: LMUNRESERV\n"); ! 265: #endif /* DEBUG*/ ! 266: break; ! 267: ! 268: case LMREADY: /* module loaded: call entry*/ ! 269: if ((flag & FWRITE) == 0) /* only allow this if writing */ ! 270: return EPERM; ! 271: ! 272: if( lkm_state != LKMS_LOADED) { ! 273: ! 274: #ifdef DEBUG ! 275: printf( "lkm_state is %02x\n", lkm_state); ! 276: #endif /* DEBUG*/ ! 277: err = ENXIO; ! 278: break; ! 279: } ! 280: ! 281: curp->entry = (int (*)()) (*((int *) ( data))); ! 282: ! 283: /* call entry(load)... (assigns "private" portion)*/ ! 284: if( err = (*(curp->entry))( curp, LKM_E_LOAD, LKM_VERSION)) { ! 285: /* ! 286: * Module may refuse loading or may have a ! 287: * version mismatch... ! 288: */ ! 289: lkm_state = LKMS_UNLOADING; /* for lkmunreserve*/ ! 290: lkmunreserve(); /* free memory*/ ! 291: curp->used = 0; /* free slot*/ ! 292: break; ! 293: } ! 294: ! 295: curp->used = 1; ! 296: #ifdef DEBUG ! 297: printf( "LKM: LMREADY\n"); ! 298: #endif /* DEBUG*/ ! 299: lkm_state = LKMS_IDLE; ! 300: break; ! 301: ! 302: case LMUNLOAD: /* unload a module*/ ! 303: if ((flag & FWRITE) == 0) /* only allow this if writing */ ! 304: return EPERM; ! 305: ! 306: unloadp = (struct lmc_unload *)data; ! 307: ! 308: if( ( i = unloadp->id) == -1) { /* unload by name*/ ! 309: /* ! 310: * Copy name and lookup id from all loaded ! 311: * modules. ! 312: */ ! 313: copystr( unloadp->name, istr, MAXLKMNAME-1, NULL); ! 314: /* ! 315: * look up id... ! 316: */ ! 317: for( i = 0; i < MAXLKMS; i++) { ! 318: if( !lkmods[ i].used) ! 319: continue; ! 320: if( !strcmp( istr, ! 321: lkmods[ i].private.lkm_any->lkm_name)) ! 322: break; ! 323: } ! 324: } ! 325: ! 326: /* ! 327: * Range check the value; on failure, return EINVAL ! 328: */ ! 329: if( i < 0 || i >= MAXLKMS) { ! 330: err = EINVAL; ! 331: break; ! 332: } ! 333: ! 334: curp = &lkmods[ i]; ! 335: ! 336: /* call entry(unload)*/ ! 337: if( (*(curp->entry))( curp, LKM_E_UNLOAD, LKM_VERSION)) { ! 338: err = EBUSY; ! 339: break; ! 340: } ! 341: ! 342: lkm_state = LKMS_UNLOADING; /* non-idle for lkmunreserve*/ ! 343: lkmunreserve(); /* free memory*/ ! 344: curp->used = 0; /* free slot*/ ! 345: break; ! 346: ! 347: case LMSTAT: /* stat a module by id/name*/ ! 348: /* allow readers and writers to stat */ ! 349: ! 350: statp = (struct lmc_stat *)data; ! 351: ! 352: if( ( i = statp->id) == -1) { /* stat by name*/ ! 353: /* ! 354: * Copy name and lookup id from all loaded ! 355: * modules. ! 356: */ ! 357: copystr( statp->name, istr, MAXLKMNAME-1, NULL); ! 358: /* ! 359: * look up id... ! 360: */ ! 361: for( i = 0; i < MAXLKMS; i++) { ! 362: if( !lkmods[ i].used) ! 363: continue; ! 364: if( !strcmp( istr, ! 365: lkmods[ i].private.lkm_any->lkm_name)) ! 366: break; ! 367: } ! 368: ! 369: if( i == MAXLKMS) { /* Not found*/ ! 370: err = ENOENT; ! 371: break; ! 372: } ! 373: } ! 374: ! 375: /* ! 376: * Range check the value; on failure, return EINVAL ! 377: */ ! 378: if( i < 0 || i >= MAXLKMS) { ! 379: err = EINVAL; ! 380: break; ! 381: } ! 382: ! 383: curp = &lkmods[ i]; ! 384: ! 385: if( !curp->used) { /* Not found*/ ! 386: err = ENOENT; ! 387: break; ! 388: } ! 389: ! 390: /* ! 391: * Copy out stat information for this module... ! 392: */ ! 393: statp->id = curp->id; ! 394: statp->offset = curp->private.lkm_any->lkm_offset; ! 395: statp->type = curp->private.lkm_any->lkm_type; ! 396: statp->area = curp->area; ! 397: statp->size = curp->size / PAGESIZE; ! 398: statp->private = (unsigned long)curp->private.lkm_any; ! 399: statp->ver = curp->private.lkm_any->lkm_ver; ! 400: copystr( curp->private.lkm_any->lkm_name, ! 401: statp->name, ! 402: MAXLKMNAME - 2, ! 403: NULL); ! 404: ! 405: break; ! 406: ! 407: default: /* bad ioctl()...*/ ! 408: err = ENOTTY; ! 409: break; ! 410: } ! 411: ! 412: return (err); ! 413: } ! 414: ! 415: ! 416: /*********************************************************************/ ! 417: ! 418: ! 419: /* ! 420: * l k m n o s y s ! 421: * ! 422: * Acts like "nosys" but can be identified in sysent for dynamic call ! 423: * number assignment for a limited number of calls. ! 424: * ! 425: * Place holder for system call slots reserved for loadable modules. ! 426: */ ! 427: lkmnosys() ! 428: { ! 429: return( nosys()); ! 430: } ! 431: ! 432: /* ! 433: * l k m e n o d e v ! 434: * ! 435: * Acts like "enodev", but can be identified in cdevsw and bdevsw for ! 436: * dynamic driver major number assignment for a limited number of ! 437: * drivers. ! 438: * ! 439: * Place holder for device switch slots reserved for loadable modules. ! 440: */ ! 441: int ! 442: lkmenodev() ! 443: { ! 444: return( enodev()); ! 445: } ! 446: ! 447: /*********************************************************************/ ! 448: ! 449: ! 450: int ! 451: lkmexists( lkmtp) ! 452: struct lkm_table *lkmtp; ! 453: { ! 454: int i; ! 455: ! 456: /* ! 457: * see if name exists... ! 458: */ ! 459: for( i = 0; i < MAXLKMS; i++) { ! 460: /* ! 461: * An unused module and the one we are testing are not ! 462: * considered. ! 463: */ ! 464: if( !lkmods[ i].used || &lkmods[ i] == lkmtp) ! 465: continue; ! 466: if( !strcmp( lkmtp->private.lkm_any->lkm_name, ! 467: lkmods[ i].private.lkm_any->lkm_name)) ! 468: return( 1); /* already loaded...*/ ! 469: } ! 470: ! 471: return( 0); /* module not loaded...*/ ! 472: } ! 473: ! 474: ! 475: /* ! 476: * For the loadable system call described by the structure pointed to ! 477: * by lkmtp, load/unload/stat it depending on the cmd requested. ! 478: */ ! 479: static int ! 480: _lkm_syscall( lkmtp, cmd) ! 481: struct lkm_table *lkmtp; ! 482: int cmd; ! 483: { ! 484: struct lkm_syscall *args = lkmtp->private.lkm_syscall; ! 485: int i; ! 486: int err = 0; ! 487: extern int nsysent; /* init_sysent.c*/ ! 488: ! 489: switch( cmd) { ! 490: case LKM_E_LOAD: ! 491: /* don't load twice!*/ ! 492: if( lkmexists( lkmtp)) ! 493: return( EEXIST); ! 494: if( ( i = args->lkm_offset) == -1) { /* auto*/ ! 495: /* ! 496: * Search the table looking for a slot... ! 497: */ ! 498: for( i = 0; i < nsysent; i++) ! 499: if( sysent[ i].sy_call == lkmnosys) ! 500: break; /* found it!*/ ! 501: /* out of allocable slots?*/ ! 502: if( i == nsysent) { ! 503: err = ENFILE; ! 504: break; ! 505: } ! 506: } else { /* assign*/ ! 507: if( i < 0 || i >= nsysent) { ! 508: err = EINVAL; ! 509: break; ! 510: } ! 511: } ! 512: ! 513: /* save old*/ ! 514: bcopy( &sysent[ i], &(args->lkm_oldent), sizeof( struct sysent)); ! 515: ! 516: /* replace with new*/ ! 517: bcopy( args->lkm_sysent, &sysent[ i], sizeof( struct sysent)); ! 518: ! 519: /* done!*/ ! 520: args->lkm_offset = i; /* slot in sysent[]*/ ! 521: ! 522: break; ! 523: ! 524: case LKM_E_UNLOAD: ! 525: /* current slot...*/ ! 526: i = args->lkm_offset; ! 527: ! 528: /* replace current slot contents with old contents*/ ! 529: bcopy( &(args->lkm_oldent), &sysent[ i], sizeof( struct sysent)); ! 530: ! 531: break; ! 532: ! 533: case LKM_E_STAT: /* no special handling...*/ ! 534: break; ! 535: } ! 536: ! 537: return( err); ! 538: } ! 539: ! 540: ! 541: /* ! 542: * For the loadable virtual file system described by the structure pointed ! 543: * to by lkmtp, load/unload/stat it depending on the cmd requested. ! 544: */ ! 545: static int ! 546: _lkm_vfs( lkmtp, cmd) ! 547: struct lkm_table *lkmtp; ! 548: int cmd; ! 549: { ! 550: struct lkm_vfs *args = lkmtp->private.lkm_vfs; ! 551: int i; ! 552: int err = 0; ! 553: ! 554: switch( cmd) { ! 555: case LKM_E_LOAD: ! 556: /* don't load twice!*/ ! 557: if( lkmexists( lkmtp)) ! 558: return( EEXIST); ! 559: /* ! 560: * Currently, the VFS and mount code in 386BSD is malformed; ! 561: * this means that the per volume file system identifier is ! 562: * the index into the table rather than the name; this means ! 563: * that only the file systems already known to 386BSD are ! 564: * allowable, since all others don't have fixed offsets. ! 565: * Interestingly, Dell UNIX has this same bug with their VFS ! 566: * implementation, but generic AT&T SVR4 does not. ! 567: * ! 568: * I will correct the VFS code when I get a chance. ! 569: */ ! 570: i = args->lkm_offset; ! 571: if( i < 0 || i > MOUNT_MAXTYPE) { ! 572: err = EINVAL; ! 573: break; ! 574: } ! 575: ! 576: if( vfssw[ i] != (struct vfsops *)0) { ! 577: err = EEXIST; ! 578: break; ! 579: } ! 580: ! 581: /* ! 582: * Set up file system ! 583: */ ! 584: vfssw[ i] = args->lkm_vfsops; ! 585: ! 586: /* ! 587: * Call init function for this VFS... ! 588: */ ! 589: ( *(vfssw[ i]->vfs_init))( args->lkm_flags); ! 590: ! 591: /* done!*/ ! 592: args->lkm_offset = i; /* slot in sysent[]*/ ! 593: ! 594: break; ! 595: ! 596: case LKM_E_UNLOAD: ! 597: /* current slot...*/ ! 598: i = args->lkm_offset; ! 599: ! 600: /* replace current slot contents with old contents*/ ! 601: vfssw[ i] = (struct vfsops *)0; ! 602: ! 603: break; ! 604: ! 605: case LKM_E_STAT: /* no special handling...*/ ! 606: break; ! 607: } ! 608: ! 609: return( err); ! 610: } ! 611: ! 612: ! 613: /* ! 614: * For the loadable device driver described by the structure pointed to ! 615: * by lkmtp, load/unload/stat it depending on the cmd requested. ! 616: */ ! 617: static int ! 618: _lkm_dev( lkmtp, cmd) ! 619: struct lkm_table *lkmtp; ! 620: int cmd; ! 621: { ! 622: struct lkm_dev *args = lkmtp->private.lkm_dev; ! 623: int i; ! 624: int err = 0; ! 625: extern int nblkdev; /* i386/i386/conf.c*/ ! 626: extern int nchrdev; /* i386/i386/conf.c*/ ! 627: ! 628: switch( cmd) { ! 629: case LKM_E_LOAD: ! 630: /* don't load twice!*/ ! 631: if( lkmexists( lkmtp)) ! 632: return( EEXIST); ! 633: switch( args->lkm_devtype) { ! 634: case LM_DT_BLOCK: ! 635: if( ( i = args->lkm_offset) == -1) { /* auto*/ ! 636: /* ! 637: * Search the table looking for a slot... ! 638: */ ! 639: for( i = 0; i < nblkdev; i++) ! 640: if( bdevsw[ i].d_open == lkmenodev) ! 641: break; /* found it!*/ ! 642: /* out of allocable slots?*/ ! 643: if( i == nblkdev) { ! 644: err = ENFILE; ! 645: break; ! 646: } ! 647: } else { /* assign*/ ! 648: if( i < 0 || i >= nblkdev) { ! 649: err = EINVAL; ! 650: break; ! 651: } ! 652: } ! 653: ! 654: /* save old*/ ! 655: bcopy( &bdevsw[ i], &(args->lkm_olddev.bdev), sizeof( struct bdevsw)); ! 656: ! 657: /* replace with new*/ ! 658: bcopy( args->lkm_dev.bdev, &bdevsw[ i], sizeof( struct bdevsw)); ! 659: ! 660: /* done!*/ ! 661: args->lkm_offset = i; /* slot in bdevsw[]*/ ! 662: break; ! 663: ! 664: case LM_DT_CHAR: ! 665: if( ( i = args->lkm_offset) == -1) { /* auto*/ ! 666: /* ! 667: * Search the table looking for a slot... ! 668: */ ! 669: for( i = 0; i < nchrdev; i++) ! 670: if( cdevsw[ i].d_open == lkmenodev) ! 671: break; /* found it!*/ ! 672: /* out of allocable slots?*/ ! 673: if( i == nchrdev) { ! 674: err = ENFILE; ! 675: break; ! 676: } ! 677: } else { /* assign*/ ! 678: if( i < 0 || i >= nchrdev) { ! 679: err = EINVAL; ! 680: break; ! 681: } ! 682: } ! 683: ! 684: /* save old*/ ! 685: bcopy( &cdevsw[ i], &(args->lkm_olddev.cdev), sizeof( struct cdevsw)); ! 686: ! 687: /* replace with new*/ ! 688: bcopy( args->lkm_dev.cdev, &cdevsw[ i], sizeof( struct cdevsw)); ! 689: ! 690: /* done!*/ ! 691: args->lkm_offset = i; /* slot in cdevsw[]*/ ! 692: ! 693: break; ! 694: ! 695: default: ! 696: err = ENODEV; ! 697: break; ! 698: } ! 699: break; ! 700: ! 701: case LKM_E_UNLOAD: ! 702: /* current slot...*/ ! 703: i = args->lkm_offset; ! 704: ! 705: switch( args->lkm_devtype) { ! 706: case LM_DT_BLOCK: ! 707: /* replace current slot contents with old contents*/ ! 708: bcopy( &(args->lkm_olddev.bdev), &bdevsw[ i], sizeof( struct bdevsw)); ! 709: break; ! 710: ! 711: case LM_DT_CHAR: ! 712: /* replace current slot contents with old contents*/ ! 713: bcopy( &(args->lkm_olddev.cdev), &cdevsw[ i], sizeof( struct cdevsw)); ! 714: break; ! 715: ! 716: default: ! 717: err = ENODEV; ! 718: break; ! 719: } ! 720: break; ! 721: ! 722: case LKM_E_STAT: /* no special handling...*/ ! 723: break; ! 724: } ! 725: ! 726: return( err); ! 727: } ! 728: ! 729: ! 730: #ifdef STREAMS ! 731: /* ! 732: * For the loadable streams module described by the structure pointed to ! 733: * by lkmtp, load/unload/stat it depending on the cmd requested. ! 734: */ ! 735: static int ! 736: _lkm_strmod( lkmtp, cmd) ! 737: struct lkm_table *lkmtp; ! 738: int cmd; ! 739: { ! 740: struct lkm_strmod *args = lkmtp->private.lkm_strmod; ! 741: int i; ! 742: int err = 0; ! 743: ! 744: switch( cmd) { ! 745: case LKM_E_LOAD: ! 746: /* don't load twice!*/ ! 747: if( lkmexists( lkmtp)) ! 748: return( EEXIST); ! 749: break; ! 750: ! 751: case LKM_E_UNLOAD: ! 752: break; ! 753: ! 754: case LKM_E_STAT: /* no special handling...*/ ! 755: break; ! 756: } ! 757: ! 758: return( err); ! 759: } ! 760: #endif /* STREAMS*/ ! 761: ! 762: #ifdef LKM_EXEC /* XXX NOTDEF YET!!! - cgd */ ! 763: /* ! 764: * For the loadable execution class described by the structure pointed to ! 765: * by lkmtp, load/unload/stat it depending on the cmd requested. ! 766: */ ! 767: static int ! 768: _lkm_exec( lkmtp, cmd) ! 769: struct lkm_table *lkmtp; ! 770: int cmd; ! 771: { ! 772: struct lkm_exec *args = lkmtp->private.lkm_exec; ! 773: int i; ! 774: int err = 0; ! 775: ! 776: switch( cmd) { ! 777: case LKM_E_LOAD: ! 778: /* don't load twice!*/ ! 779: if( lkmexists( lkmtp)) ! 780: return( EEXIST); ! 781: if( ( i = args->lkm_offset) == -1) { /* auto*/ ! 782: /* ! 783: * Search the table looking for a slot... ! 784: */ ! 785: for( i = 0; i < nexecs; i++) ! 786: if( execsw[ i].m_size == 0) ! 787: break; /* found it!*/ ! 788: /* out of allocable slots?*/ ! 789: if( i == nexecs) { ! 790: err = ENFILE; ! 791: break; ! 792: } ! 793: } else { /* assign*/ ! 794: if( i < 0 || i >= nexecs) { ! 795: err = EINVAL; ! 796: break; ! 797: } ! 798: } ! 799: ! 800: /* save old*/ ! 801: bcopy( &execsw[ i], &(args->lkm_oldexec), sizeof( struct execsw)); ! 802: ! 803: /* replace with new*/ ! 804: bcopy( args->lkm_exec, &execsw[ i], sizeof( struct execsw)); ! 805: ! 806: /* done!*/ ! 807: args->lkm_offset = i; /* slot in execsw[]*/ ! 808: ! 809: break; ! 810: ! 811: case LKM_E_UNLOAD: ! 812: /* current slot...*/ ! 813: i = args->lkm_offset; ! 814: ! 815: /* replace current slot contents with old contents*/ ! 816: bcopy( &execsw[ i], &(args->lkm_oldexec), sizeof( struct execsw)); ! 817: ! 818: break; ! 819: ! 820: case LKM_E_STAT: /* no special handling...*/ ! 821: break; ! 822: } ! 823: ! 824: return( err); ! 825: } ! 826: #endif /* LKM_EXEC */ ! 827: ! 828: /* ! 829: * This code handles the per-module type "wiring-in" of loadable modules ! 830: * into existing kernel tables. For "LM_MISC" modules, wiring and unwiring ! 831: * is assumed to be done in their entry routines internal to the module ! 832: * itself. ! 833: */ ! 834: lkmdispatch( lkmtp, cmd) ! 835: struct lkm_table *lkmtp; ! 836: int cmd; ! 837: { ! 838: int err = 0; /* default = success*/ ! 839: ! 840: switch( lkmtp->private.lkm_any->lkm_type) { ! 841: case LM_SYSCALL: ! 842: err = _lkm_syscall( lkmtp, cmd); ! 843: break; ! 844: ! 845: case LM_VFS: ! 846: err = _lkm_vfs( lkmtp, cmd); ! 847: break; ! 848: ! 849: case LM_DEV: ! 850: { ! 851: struct lkm_dev *args = lkmtp->private.lkm_dev; ! 852: } ! 853: break; ! 854: ! 855: #ifdef STREAMS ! 856: case LM_STRMOD: ! 857: { ! 858: struct lkm_strmod *args = lkmtp->private.lkm_strmod; ! 859: } ! 860: break; ! 861: ! 862: #endif /* STREAMS*/ ! 863: ! 864: #ifdef LKM_EXEC ! 865: case LM_EXEC: ! 866: err = _lkm_exec( lkmtp, cmd); ! 867: break; ! 868: #endif /* LKM_EXEC */ ! 869: ! 870: case LM_MISC: /* ignore content -- no "misc-specific" procedure*/ ! 871: break; ! 872: ! 873: default: ! 874: err = ENXIO; /* unknown type*/ ! 875: break; ! 876: } ! 877: ! 878: return( err); ! 879: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.