![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to drvld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / etc|
Return to drvld.c CVS log | Up to [MW Coherent from dump] / coherent / d / etc |
1.1 root 1: /*
2: * INETCO Coherent Driver Load Program
3: *
4: * $Log: drvld.c,v $
5: * Revision 1.2 91/08/01 12:34:08 bin
6: * updated by stevesf to include :/etc/drvld in error messages
7: * produced by drvld
8: *
9: * Revision 1.3 91/07/31 13:44:11 bin
10: * steve 7/31/91
11: * Corrected additional fatal error message.
12: *
13: * Revision 1.2 91/07/31 13:40:09 bin
14: * steve 7/31/91
15: * In warn(), added line to print "/etc/drvld: " preceding warnings
16: * or fatal error messages.
17: *
18: * Revision 1.1 91/07/31 13:38:11 bin
19: * Initial revision
20: *
21: * Revision 1.2 88/07/07 09:30:37 src
22: * Bug: Drivers whose prefix consisted had a numeric third character
23: * were not recognized by the drvld(1M) command.
24: * Fix: A numeric third digit is ignored in driver symbol aliasing.
25: * ie: rs0con_ will be recognized when searching for con_.
26: *
27: * Revision 1.1 88/07/07 08:49:44 src
28: * Initial revision
29: *
30: * 87/12/01 Allan Cornish /usr/src/cmd/etc/drvld.c
31: * relocate() now properly relocates uninitialized data.
32: */
33: #include <stdio.h>
34: #include <canon.h>
35: #include <errno.h>
36: #include <l.out.h>
37: #include <signal.h>
38: #include <sys/fcntl.h>
39:
40: extern long lseek();
41:
42: /*
43: * The following three variables are obtained from kernel data space.
44: */
45: static int NSLOT; /* Number of driver data slots */
46: static int slotsz; /* Number of bytes per slot */
47: static int * slotp; /* Slot offset in kernel data */
48:
49: /*
50: * Local Variables.
51: */
52: char * ksym_file = "/coherent";/* Kernel symbol file name */
53: char * kmem_file = "/dev/kmem";/* Kernel data file name */
54: char * text_file; /* Driver code file name */
55: char * dsym_file;
56: unsigned kmem_end; /* End of kernel data space */
57: int verbose; /* Non-zero for verbose debug */
58: int ksym_fd = -1; /* Kernel obj file descriptor */
59: int dsym_fd = -1; /* Driver obj file descriptor */
60: int kmem_fd = -1; /* Kernel data file descriptor */
61: int text_fd = -1; /* Driver text file descriptor */
62: int slot; /* First slot in current driver */
63: int nslot; /* Number slots for curr driver */
64: unsigned datap; /* Ptr to driver data in kernel */
65: struct ldsym * dsym_tab; /* Driver symbol table */
66: struct ldsym * ksym_tab; /* Kernel symbol table */
67: int dsym_cnt; /* Number of driver symbols */
68: int ksym_cnt; /* Number of kernel symbols */
69: int dsym_len; /* Number of bytes of symbols */
70: unsigned char * drel_tab; /* Driver relocation table */
71: int drel_len; /* Number of relocation bytes */
72: int dflag; /* Enable debugging output */
73: int rflag; /* Remove output file after exec*/
74: int sflag; /* Strip symbols from output */
75: struct ldheader ldh_ker; /* Kernel load header */
76: struct ldheader ldh_drv; /* Driver load header */
77:
78: /*
79: * Forward referenced functions.
80: */
81: void startup();
82: void cleanup();
83: void warn();
84: void fatal();
85: void canldh();
86: void relocate();
87: long symoff();
88: void symsave();
89: struct ldsym * drvalias();
90: struct ldsym * ksymbol();
91: char * basename();
92:
93: main( argc, argv )
94: int argc;
95: char ** argv;
96: {
97: /*
98: * Perform system initialization.
99: */
100: startup( argv );
101:
102: /*
103: * Load drivers.
104: */
105: for ( argc = 0; dsym_file = *++argv; ) {
106: if ( **argv != '-' ) {
107: drvload();
108: argc++;
109: }
110: }
111:
112: /*
113: * No drivers loaded.
114: */
115: if ( argc == 0 )
116: fatal( "usage", ": drv [-k/coherent] [-r] [-s] file ..." );
117:
118: /*
119: * Perform system cleanup.
120: */
121: cleanup( 0 );
122: }
123:
124: /**
125: *
126: * void
127: * startup( argv ) -- perform system initialization.
128: * char ** argv;
129: *
130: * Input: argv = pointer to null-terminated list of arguments.
131: *
132: * Action: Process flag arguments.
133: * Obtain kernel symbolic information.
134: * Obtain kernel loadable driver characteristics.
135: */
136: void
137: startup( argv )
138: register char ** argv;
139: {
140: register struct ldsym * ksymp;
141: register char * cp;
142: register int sig;
143:
144: #if EBUG > 0
145: static char obuf[BUFSIZ];
146: setbuf( stdout, obuf );
147: #endif
148:
149: /*
150: * Only super-use can load drivers.
151: */
152: if ( getuid() != 0 )
153: fatal( "not super-user", "" );
154:
155: /*
156: * Trap non-ignored signals.
157: */
158: for ( sig = 1; sig <= NSIG; sig++ )
159: if ( signal( sig, SIG_IGN ) != SIG_IGN )
160: signal( sig, cleanup );
161:
162: /*
163: * Trap alarm signal.
164: */
165: signal( SIGALRM, cleanup );
166:
167: /*
168: * Scan argument list for flags.
169: */
170: while ( cp = *++argv ) {
171:
172: /*
173: * Ignore drivers to be loaded.
174: */
175: if ( *cp != '-' )
176: continue;
177:
178: while ( *++cp ) {
179: switch ( *cp ) {
180:
181: case 'd':
182: /*
183: * -d specifies debugging output.
184: */
185: dflag = 1;
186: break;
187:
188: case 'k':
189: /*
190: * -k <KERNEL> specifies kernel to load against.
191: */
192: if ( argv[1] == NULL )
193: fatal( "Missing file arg after ", "-k" );
194: if ( argv[1][0] == '-' )
195: fatal( "Invalid kernel file: ", *argv );
196: ksym_file = *++argv;
197: *argv = "-";
198: break;
199:
200: case 'o':
201: /*
202: * -o outputfile
203: */
204: if ( argv[1] == NULL )
205: fatal( "Missing file arg after ", "-o" );
206: if ( argv[1][0] == '-' )
207: fatal( "Invalid output file: ", *argv );
208: text_file = *++argv;
209: *argv = "-";
210: break;
211:
212: case 'r':
213: /*
214: * -r removes output file after loading.
215: */
216: rflag = 1;
217: break;
218:
219: case 's':
220: /*
221: * -s strips symbols from output file.
222: */
223: sflag = 1;
224: break;
225:
226: case 'v':
227: /*
228: * -v turns verbose monitoring on.
229: */
230: verbose++;
231: break;
232:
233: default:
234: fatal( "Invalid flag: -", cp );
235: }
236: }
237: }
238:
239: /*
240: * Obtain kernel object module header.
241: */
242: ksym_fd = get_ldh( ksym_file, &ldh_ker );
243:
244: /*
245: * Kernel must not be relocatable.
246: */
247: if ( (ldh_ker.l_flag & LF_NRB) == 0 )
248: fatal( ksym_file, ": relocatable" );
249:
250: /*
251: * Allocate memory space for kernel symbol table.
252: */
253: ksym_cnt = ldh_ker.l_ssize[L_SYM] / sizeof(struct ldsym);
254: if ( (ksym_tab = malloc( (int) ldh_ker.l_ssize[L_SYM])) == NULL )
255: fatal( ksym_file, ": symbol table too large" );
256:
257: #if EBUG > 0
258: if ( dflag ) {
259: printf("startup: ksym_cnt=%d ksym_len=%d ksym_tab=%04x\n",
260: ksym_cnt, (int) ldh_ker.l_ssize[L_SYM], ksym_tab );
261: }
262: #endif
263:
264: /*
265: * Extract kernel symbol table from object module.
266: */
267: if ( lseek( ksym_fd, (long) symoff(&ldh_ker), 0 ) < 0 )
268: fatal( ksym_file, ": bad seek" );
269: if ( read( ksym_fd, ksym_tab, (int) ldh_ker.l_ssize[L_SYM] ) <= 0 )
270: fatal( ksym_file, ": bad read" );
271:
272: /*
273: * Open kernel data space.
274: */
275: if ((kmem_fd = open( kmem_file, O_RDWR )) < 0 )
276: fatal( kmem_file, ": can't open.");
277:
278: /*
279: * Obtain address of end of kernel data space - end.
280: */
281: if ( (ksymp = ksymbol( "end_" )) == NULL )
282: fatal( ksym_file, ": symbol 'end' not found" );
283: kmem_end = ksymp->ls_addr;
284:
285: /*
286: * Read NSLOT kernel variable.
287: */
288: if ( (ksymp = ksymbol( "NSLOT_" )) == NULL )
289: fatal( ksym_file, ": symbol NSLOT not found" );
290: if ( (lseek( kmem_fd, (long) ksymp->ls_addr, 0 ) < 0)
291: || (read( kmem_fd, &NSLOT, sizeof(NSLOT) ) < 0) )
292: fatal( kmem_file, ": can't access NSLOT var");
293:
294: /*
295: * Read slotsz kernel variable.
296: */
297: if ( (ksymp = ksymbol( "slotsz_" )) == NULL )
298: fatal( ksym_file, ": symbol slotsz not found" );
299: if ( (lseek( kmem_fd, (long) ksymp->ls_addr, 0 ) < 0)
300: || (read( kmem_fd, &slotsz, sizeof(slotsz) ) < 0) )
301: fatal( kmem_file, ": can't access slotsz var");
302:
303: /*
304: * Read slotp kernel variable.
305: */
306: if ( (ksymp = ksymbol( "slotp_" )) == NULL )
307: fatal( ksym_file, ": symbol slotp not found" );
308: if ( (lseek( kmem_fd, (long) ksymp->ls_addr, 0 ) < 0)
309: || (read( kmem_fd, &slotp, sizeof(slotp) ) < 0) )
310: fatal( kmem_file, ": can't access slotp var");
311:
312: #if EBUG > 0
313: if ( dflag )
314: printf("NSLOT=%d slotsz=%d slotp=%04x end=%04x\n",
315: NSLOT, slotsz, slotp, kmem_end );
316: #endif
317:
318: /*
319: * Validate kernel variables - NSLOT, slotsz, slotp.
320: */
321: if ( (NSLOT <= 0) || (slotsz <= 0) || (slotp == NULL) )
322: fatal( kmem_file, ": loadable drivers disabled." );
323: }
324:
325: /**
326: *
327: * void
328: * cleanup( sig ) -- clean up and terminate.
329: * int sig;
330: *
331: * Input: sig = signal causing termination, or 0.
332: *
333: * Action: Close special files.
334: * Exit.
335: */
336: void
337: cleanup( sig )
338: int sig;
339: {
340: /*
341: * Quietly accept alarm signals.
342: */
343: if ( sig == SIGALRM ) {
344: signal( sig, cleanup );
345: return;
346: }
347:
348: /*
349: * Remove output files.
350: */
351: if ( (sig != 0) || (rflag != 0) && (text_file[0] != 0) )
352: unlink( text_file );
353:
354: exit( sig );
355: }
356:
357: /**
358: *
359: * void
360: * warn( s1, s2 ) -- print error message.
361: * char * s1;
362: * char * s2;
363: *
364: * Input: s1 = pointer to null-terminated error string.
365: * s2 = pointer to null-terminated error string.
366: *
367: * Action: Output error messages.
368: * Output new-line.
369: */
370: void
371: warn( s1, s2 )
372: char * s1;
373: char * s2;
374: {
375: #if EBUG > 0
376: fflush( stdout );
377: fflush( stderr );
378: #endif
379:
380: write( 2, "/etc/drvld: ", 12);
381: write( 2, s1, strlen(s1) );
382: write( 2, s2, strlen(s2) );
383: write( 2, "\n", 1 );
384: }
385:
386: /**
387: *
388: * void
389: * fatal( s1, s2 ) -- print fatal error message, terminate.
390: * char * s1;
391: * char * s2;
392: *
393: * Input: s1 = pointer to null-terminated error string.
394: * s2 = pointer to null-terminated error string.
395: *
396: * Action: Output error messages.
397: * Output new-line.
398: * Exit with status 100.
399: */
400: void
401: fatal( s1, s2 )
402: char * s1;
403: char * s2;
404: {
405: warn( s1, s2 );
406: cleanup( 100 );
407: }
408:
409: /**
410: *
411: * void
412: * canldh( ldp ) - Convert a load file header from canonical form.
413: * ldheader * ldp;
414: *
415: * Input: ldp = pointer to load file header to be [de]canonized.
416: *
417: * Action: Convert load file header to/from canonical form.
418: */
419: void
420: canldh( ldp )
421: register struct ldheader * ldp;
422: {
423: register int seg;
424:
425: canint( ldp->l_magic );
426: canint( ldp->l_flag );
427: canint( ldp->l_machine );
428: canvaddr( ldp->l_entry );
429:
430: for ( seg = 0; seg < NLSEG; seg++ )
431: cansize( ldp->l_ssize[seg] );
432: }
433:
434: /**
435: *
436: * int
437: * drvload() - Spawn a kernel process.
438: *
439: * Action: Validate object module.
440: * Allocate and initialize kernel data slots for driver.
441: * Create and initialize driver code file.
442: * Create driver symbol table.
443: * Apply relocation to driver code and data.
444: * Fork and execute the driver code.
445: */
446: drvload()
447: {
448: register int n;
449: int cpid;
450: long off;
451: static char buf[BUFSIZ];
452: static char nambuf[64];
453:
454: /*
455: * Define name of driver code file if not already specified.
456: */
457: if ( (text_file == NULL) || (text_file == nambuf) ) {
458: text_file = nambuf;
459: strcpy( nambuf, "/tmp/" );
460: strcat( nambuf, basename(dsym_file) );
461: }
462:
463: /*
464: * Obtain driver object module header.
465: */
466: dsym_fd = get_ldh( dsym_file, &ldh_drv );
467:
468: /*
469: * Driver must be relocatable.
470: */
471: if ( ldh_drv.l_flag & LF_NRB )
472: fatal( dsym_file, ": not relocatable" );
473:
474: /*
475: * Build symbol table from driver and referenced kernel symbols.
476: * Allocate kernel data space.
477: * Adjust data relative symbols.
478: */
479: symload();
480: drvalloc();
481: symadjust();
482:
483: /*
484: * Prepare to install driver data into allocated slots.
485: */
486: off = sizeof(ldh_drv)+ldh_drv.l_ssize[L_SHRI]+ldh_drv.l_ssize[L_PRVI];
487: if ( lseek( dsym_fd, (long) off, 0 ) < 0 )
488: fatal( dsym_file, ": bad seek" );
489: if ( lseek( kmem_fd, (long) datap, 0 ) < 0 )
490: fatal( kmem_file, ": bad seek" );
491:
492: #if EBUG > 0
493: if ( dflag )
494: printf("driver data at kernel offset %04x\n", datap );
495: #endif
496:
497: /*
498: * Install initialized driver data.
499: */
500: off = ldh_drv.l_ssize[L_SHRD] + ldh_drv.l_ssize[L_PRVD];
501: #if EBUG > 0
502: if ( dflag ) printf("initialized data = %ld bytes\n", off );
503: #endif
504: while ( off > 0 ) {
505: n = (off > BUFSIZ) ? BUFSIZ : off;
506: if ( read( dsym_fd, buf, n ) != n )
507: fatal( dsym_file, ": truncated" );
508: if ( write( kmem_fd, buf, n ) != n )
509: fatal( kmem_file, ": bad write" );
510: #if EBUG > 0
511: if ( dflag ) printf("write %d bytes\n", n );
512: #endif
513: off -= n;
514: }
515:
516: /*
517: * Erase uninitialized driver data.
518: */
519: memset( buf, 0, sizeof(buf) );
520: off = ldh_drv.l_ssize[L_BSSD];
521: #if EBUG > 0
522: if ( dflag ) printf("uninitialized data = %ld bytes\n", off );
523: #endif
524: while ( off > 0 ) {
525: n = (off > BUFSIZ) ? BUFSIZ : off;
526: if ( write( kmem_fd, buf, n ) != n )
527: fatal( kmem_file, ": bad write" );
528: #if EBUG > 0
529: if ( dflag ) printf("clear %d bytes\n", n );
530: #endif
531: off -= n;
532: }
533:
534: /*
535: * Create driver code file.
536: */
537: unlink( text_file );
538: if ( (text_fd = creat( text_file, 0700)) < 0 )
539: fatal( text_file, ": can't create" );
540: close( text_fd );
541: if ( (text_fd = open( text_file, O_RDWR)) < 0 )
542: fatal( text_file, ": can't reopen" );
543:
544: /*
545: * Prepare to install driver code into new file.
546: */
547: if ( lseek( dsym_fd, (long) sizeof(ldh_drv), 0 ) < 0 )
548: fatal( dsym_file, ": bad seek" );
549: if ( lseek( text_fd, (long) sizeof(ldh_drv), 0 ) < 0 )
550: fatal( text_file, ": bad seek" );
551:
552: /*
553: * Install initialized driver code.
554: */
555: off = ldh_drv.l_ssize[L_SHRI] + ldh_drv.l_ssize[L_PRVI];
556: #if EBUG > 0
557: if ( dflag ) printf("initialized code = %ld bytes\n", off );
558: #endif
559: while ( off > 0 ) {
560: n = (off > BUFSIZ) ? BUFSIZ : off;
561: if ( read( dsym_fd, buf, n ) != n )
562: fatal( dsym_file, ": truncated" );
563: if ( write( text_fd, buf, n ) != n )
564: fatal( text_file, ": bad write" );
565: off -= n;
566: }
567:
568: /*
569: * Apply relocation directives to driver code and data.
570: */
571: relocate();
572:
573: /*
574: * Save symbol table in driver code file.
575: */
576: symsave();
577:
578: /*
579: * Close driver files.
580: */
581: close( dsym_fd );
582: close( text_fd );
583: fflush( stdout );
584: sync();
585:
586: /*
587: * Load driver - spawning kernel process.
588: */
589: if ( (cpid = sload(text_file)) < 0 )
590: fatal( text_file, ": can't load driver\n" );
591:
592: /*
593: * Lock all data slots required by server process.
594: */
595: for ( n = slot + nslot; --n >= slot; ) {
596: /*
597: * Lock data slot or kill server and terminate.
598: */
599: if ( skword( &slotp[n], cpid ) < 0 ) {
600: kill( cpid, SIGKILL );
601: fatal( kmem_file, ": bad write" );
602: }
603: }
604:
605: #if EBUG > 0 )
606: if ( dflag )
607: printf("Driver process id = %d\n", cpid );
608: #endif
609:
610: /*
611: * Remove text file.
612: */
613: if ( rflag )
614: unlink( text_file );
615: }
616:
617: /**
618: *
619: * int
620: * drvalloc() - Allocate kernel data slots.
621: */
622: int
623: drvalloc()
624: {
625: int baseslot = 0;
626: int pid;
627:
628: /*
629: * Determine number of required driver data slots.
630: */
631: nslot = (ldh_drv.l_ssize[L_SHRD] + ldh_drv.l_ssize[L_PRVD] +
632: ldh_drv.l_ssize[L_BSSD] + slotsz - 1) / slotsz;
633:
634: #if EBUG > 0
635: if ( dflag )
636: printf( "drvalloc: nslot=%d\n", nslot );
637: #endif
638:
639: /*
640: * No data space required.
641: */
642: if ( nslot == 0 ) {
643: datap = (unsigned) (&slotp[NSLOT]);
644: slot = 0;
645: return;
646: }
647:
648: /*
649: * Allocate driver data slots.
650: */
651: for ( slot = 0; slot < NSLOT; ) {
652:
653: #if EBUG > 0
654: if ( dflag )
655: printf( "checking slot %d ", slot );
656: #endif
657:
658: /*
659: * Obtain slot process id.
660: */
661: if ( fkword( &slotp[slot], &pid ) < 0 )
662: fatal( kmem_file, ": bad slot pid read." );
663:
664: #if EBUG > 0
665: if ( dflag )
666: printf("pid=%d\n", pid );
667: #endif
668:
669: /*
670: * Slot is not allocated.
671: */
672: if ( pid == 0 )
673: ;
674:
675: /*
676: * Validate process id and existence.
677: */
678: else if ( (pid < 0) || (kill(pid,0) < 0) ) {
679:
680: #if EBUG > 0
681: if ( dflag )
682: printf( "clearing slot %d\n", slot );
683: #endif
684:
685: /*
686: * Erase slot process id - this makes the slot empty.
687: */
688: if ( skword( &slotp[slot], 0 ) < 0 )
689: fatal( kmem_file, ": can't free slot." );
690:
691: pid = 0;
692: }
693:
694: /*
695: * Ignore busy slots.
696: */
697: if ( pid != 0 ) {
698: baseslot = ++slot;
699: continue;
700: }
701:
702: /*
703: * Sufficient contiguous slots found.
704: */
705: if ( (++slot - baseslot) >= nslot )
706: break;
707: }
708:
709: /*
710: * Insufficient contiguous slot space.
711: */
712: if ( (slot - baseslot) < nslot )
713: fatal( dsym_file, ": out of driver memory" );
714:
715: #if EBUG > 0
716: if ( dflag )
717: printf("%d slots allocated starting at slot %d\n",
718: nslot, baseslot );
719: #endif
720:
721: /*
722: * Compute offset of driver data in kernel memory.
723: */
724: datap = (unsigned) (&slotp[NSLOT]) + (baseslot * slotsz);
725: slot = baseslot;
726: }
727:
728: /**
729: *
730: * int
731: * get_ldh( filename, ldp )
732: * char * filename;
733: * struct ldheader * ldp;
734: *
735: * Input: filename = name of object file to be accessed.
736: * ldp = pointer to load header to be initialized.
737: *
738: * Return: Read-only file descriptor on object file.
739: */
740: int
741: get_ldh( filename, ldp )
742: char * filename;
743: register struct ldheader * ldp;
744: {
745: register int fd;
746:
747: /*
748: * Obtain kernel object module header.
749: */
750: if ( (fd = open(filename, O_RDONLY)) < 0 )
751: fatal( filename, ": can't open" );
752: if ( read( fd, ldp, sizeof(*ldp) ) < 0 )
753: fatal( filename, ": truncated" );
754:
755: /*
756: * Convert from canonical to machine format.
757: */
758: canldh( ldp );
759:
760: /*
761: * Validate object module.
762: */
763: if ( ldp->l_magic != L_MAGIC )
764: fatal( filename, ": not an object file" );
765: if ( ldp->l_machine != M_8086 )
766: fatal( filename, ": not an iAPX-86 object file" );
767:
768: /*
769: * Return read-only file descriptor.
770: */
771: return( fd );
772: }
773:
774: /**
775: *
776: * void
777: * relocate() - apply relocation directives to driver code and data.
778: *
779: * NOTE: This function only works on a iAPX-86 relocating iAPX-86 code.
780: */
781: void
782: relocate()
783: {
784: register unsigned char * cp;
785: long off;
786: unsigned char opcode;
787: unsigned short addr;
788: unsigned short symno;
789: unsigned short bias;
790: int txtlen;
791:
792: #if EBUG > 0
793: if ( dflag )
794: printf("relocate()\n");
795: #endif
796:
797: /*
798: * No relocation directives.
799: */
800: if ( (drel_len = ldh_drv.l_ssize[L_REL]) == 0 )
801: return;
802:
803: /*
804: * Calculate offset of relocation information.
805: */
806: off = sizeof(ldh_drv) + ldh_drv.l_ssize[L_SHRI ] +
807: ldh_drv.l_ssize[L_PRVI ] +
808: ldh_drv.l_ssize[L_SHRD ] +
809: ldh_drv.l_ssize[L_PRVD ] +
810: ldh_drv.l_ssize[L_DEBUG] +
811: ldh_drv.l_ssize[L_SYM ];
812:
813: /*
814: * Compute boundary location between code and data relocation.
815: */
816: txtlen = ldh_drv.l_ssize[L_SHRI] +
817: ldh_drv.l_ssize[L_PRVI] +
818: ldh_drv.l_ssize[L_BSSI];
819:
820: /*
821: * Obtain in-memory copy of driver relocation directives.
822: */
823: if ( (drel_tab = malloc( drel_len )) == NULL )
824: fatal( dsym_file, ": too many relocation directives" );
825: if ( lseek( dsym_fd, off, 0 ) < 0 )
826: fatal( dsym_file, ": bad seek" );
827: if ( read( dsym_fd, drel_tab, drel_len ) != drel_len )
828: fatal( dsym_file, ": bad read" );
829:
830: #if EBUG > 0
831: if ( dflag )
832: printf("drel_tab=%04x drel_len=%d\n", drel_tab, drel_len );
833: #endif
834:
835: /*
836: * Scan driver relocation directives.
837: */
838: for ( cp = drel_tab; drel_len >= 3; ) {
839:
840: /*
841: * Clear bias [high byte may not be read]
842: */
843: bias = 0;
844:
845: /*
846: * Read opcode and address.
847: */
848: opcode = cp[0];
849: addr = (cp[2] << 8) + cp[1];
850: drel_len -= 3;
851: cp += 3;
852:
853: /*
854: * Obtain code to be relocated.
855: */
856: if ( addr < txtlen ) {
857: off = sizeof(struct ldheader) + addr;
858: if ( lseek( text_fd, off, 0 ) < 0 )
859: fatal( text_file, ": bad seek" );
860: if (read(text_fd, &bias, (opcode & LR_WORD)?2:1) < 0)
861: fatal( text_file, ": bad read" );
862: }
863:
864: /*
865: * Obtain data to be relocated.
866: */
867: else {
868: off = datap + addr - txtlen;
869: if ( lseek( kmem_fd, off, 0 ) < 0 )
870: fatal( kmem_file, ": bad seek" );
871: if (read(kmem_fd, &bias, (opcode & LR_WORD)?2:1) < 0)
872: fatal( kmem_file, ": bad read" );
873: }
874:
875: #if EBUG > 0
876: if ( dflag )
877: printf("opcode=%02x, addr=%04x, offset=%04x, bias=%04x",
878: opcode, addr, (int) off, bias );
879: #endif
880:
881: /*
882: * Perform relocation.
883: * NOTE: Program Counter Relative relocation is ignored,
884: * since no code is being inserted.
885: */
886: switch ( opcode & LR_SEG ) {
887:
888: case L_SHRI:
889: case L_PRVI:
890: case L_BSSI:
891: /*
892: * No relocation required - no code was inserted.
893: */
894: #if EBUG > 0
895: if ( dflag )
896: printf("\n");
897: #endif
898: continue;
899:
900: case L_BSSD:
901: case L_PRVD:
902: case L_SHRD:
903: bias -= txtlen;
904: bias += datap;
905: break;
906:
907: case L_SYM:
908: /*
909: * Obtain symbol number.
910: */
911: symno = (cp[1] << 8) + cp[0];
912: drel_len -= 2;
913: cp += 2;
914:
915: /*
916: * Validate symbol number.
917: */
918: if ( (symno < 0) || (symno >= dsym_cnt) )
919: fatal( dsym_file, ": bad relocation" );
920:
921: #if EBUG > 0
922: if ( dflag )
923: printf("\n\t\t\t\tsymid=%.*s symaddr=%04x ",
924: NCPLN, dsym_tab[symno].ls_id,
925: dsym_tab[symno].ls_addr );
926: #endif
927:
928: /*
929: * Access symbol.
930: */
931: bias += dsym_tab[symno].ls_addr;
932: break;
933: }
934:
935: #if EBUG > 0
936: if ( dflag )
937: printf(" --> %04x\n", bias );
938: #endif
939:
940: /*
941: * Save relocated code.
942: */
943: if ( addr < txtlen ) {
944: if ( lseek( text_fd, off, 0 ) < 0 )
945: fatal( text_file, ": bad seek" );
946: if (write(text_fd, &bias, (opcode & LR_WORD)?2:1) < 0)
947: fatal( text_file, ": bad write" );
948: }
949:
950: /*
951: * Save relocated data.
952: */
953: else {
954: if ( lseek( kmem_fd, off, 0 ) < 0 )
955: fatal( kmem_file, ": bad seek" );
956: if (write(kmem_fd, &bias, (opcode & LR_WORD)?2:1) < 0)
957: fatal( kmem_file, ": bad write" );
958: }
959: }
960:
961: /*
962: * Release malloc'ed storage.
963: */
964: free( drel_tab );
965: }
966:
967: /**
968: *
969: * int
970: * symload() - load driver symbol table
971: */
972: symload()
973: {
974: register struct ldsym * dsymp;
975: register struct ldsym * ksymp;
976: long off;
977: int undef;
978:
979: /*
980: * Allocate memory space for driver symbol table.
981: */
982: dsym_cnt = ldh_drv.l_ssize[L_SYM] / sizeof(struct ldsym);
983: dsym_len = ldh_drv.l_ssize[L_SYM];
984: if ( (dsym_cnt != 0) && ((dsym_tab = malloc(dsym_len)) == NULL) )
985: fatal( dsym_file, ": symbol table too large" );
986:
987: #if EBUG > 0
988: if ( dflag ) {
989: printf("symload: dsym_cnt=%d dsym_len=%d\n", dsym_cnt, dsym_len );
990: printf("dsym_tab=%04x\n", dsym_tab );
991: }
992: #endif
993:
994: if ( dsym_cnt == 0 )
995: return;
996:
997: /*
998: * Extract driver symbol table from object module.
999: */
1000: if ( lseek( dsym_fd, (long) symoff(&ldh_drv), 0 ) < 0 )
1001: fatal( dsym_file, ": bad seek" );
1002: if (read(dsym_fd, dsym_tab, (int) ldh_drv.l_ssize[L_SYM]) <= 0)
1003: fatal( dsym_file, ": bad read" );
1004:
1005: /*
1006: * 1st Pass: Adjust symbol offsets.
1007: */
1008: for ( dsymp = &dsym_tab[dsym_cnt]; --dsymp >= dsym_tab; ) {
1009:
1010: switch ( dsymp->ls_type & LR_SEG ) {
1011:
1012: case L_SHRI:
1013: case L_PRVI:
1014: case L_BSSI:
1015: case L_ABS:
1016: /*
1017: * Leave code/absolute data references alone.
1018: */
1019: break;
1020:
1021: case L_SHRD:
1022: case L_PRVD:
1023: case L_BSSD:
1024: /*
1025: * Convert data references to uninitialized data ref.
1026: */
1027: dsymp->ls_type &= ~LR_SEG;
1028: dsymp->ls_type |= L_BSSD;
1029: #if EBUG > 0
1030: if ( dflag )
1031: printf("%.*s: DRIVER type=%d addr=%04x\n",
1032: NCPLN, dsymp->ls_id,
1033: dsymp->ls_type, dsymp->ls_addr );
1034: #endif
1035: break;
1036: }
1037: }
1038:
1039: /*
1040: * 2nd Pass: Resolve undefined references.
1041: */
1042: for ( undef = 0, dsymp = &dsym_tab[dsym_cnt]; --dsymp >= dsym_tab; ) {
1043:
1044: if ( (dsymp->ls_type & LR_SEG) != L_REF )
1045: continue;
1046:
1047: /*
1048: * Check for aliased driver configuration.
1049: * ie: 'con_' is an alias for '??con_'
1050: */
1051: if ( ksymp = drvalias(dsymp->ls_id) ) {
1052:
1053: #if EBUG > 0
1054: if ( dflag )
1055: printf("Driver prefix = '%.2s'\n",
1056: ksymp->ls_id );
1057: #endif
1058:
1059: /*
1060: * Update symbol information.
1061: */
1062: dsymp->ls_type = ksymp->ls_type;
1063: dsymp->ls_addr = ksymp->ls_addr;
1064:
1065: #if EBUG > 0
1066: if ( dflag )
1067: printf("%.*s: ALIAS %.*s type=%d addr=%04x\n",
1068: NCPLN, dsymp->ls_id,
1069: NCPLN, ksymp->ls_id,
1070: dsymp->ls_type, dsymp->ls_addr );
1071: #endif
1072: }
1073:
1074: /*
1075: * Search for undefined symbol in kernel symbol table.
1076: */
1077: else if ( ksymp = ksymbol( dsymp->ls_id ) ) {
1078: /*
1079: * Update symbol information.
1080: */
1081: dsymp->ls_type = ksymp->ls_type;
1082: dsymp->ls_addr = ksymp->ls_addr;
1083:
1084: /*
1085: * Convert kernel data references to absolute.
1086: */
1087: if ( ((dsymp->ls_type & LR_SEG) >= L_SHRD)
1088: && ((dsymp->ls_type & LR_SEG) <= L_BSSD) ) {
1089: dsymp->ls_type &= ~LR_SEG;
1090: dsymp->ls_type |= L_ABS;
1091: }
1092:
1093: #if EBUG > 0
1094: if ( dflag )
1095: printf("%.*s: KERNEL type=%d addr=%04x\n",
1096: NCPLN, dsymp->ls_id,
1097: dsymp->ls_type, dsymp->ls_addr );
1098: #endif
1099: }
1100:
1101: /*
1102: * Define commons as uninitialized data.
1103: */
1104: else if ( dsymp->ls_addr > 0 ) {
1105: /*
1106: * Ensure data size is even.
1107: */
1108: dsymp->ls_addr += 1;
1109: dsymp->ls_addr &= ~1;
1110:
1111: /*
1112: * Convert symbol to uninitialized data.
1113: */
1114: dsymp->ls_type &= ~LR_SEG;
1115: dsymp->ls_type |= L_BSSD;
1116:
1117: /*
1118: * Calculate new location of symbol.
1119: */
1120: off = ldh_drv.l_ssize[L_SHRI] +
1121: ldh_drv.l_ssize[L_PRVI] +
1122: ldh_drv.l_ssize[L_BSSI] +
1123: ldh_drv.l_ssize[L_SHRD] +
1124: ldh_drv.l_ssize[L_PRVD] +
1125: ldh_drv.l_ssize[L_BSSD];
1126:
1127: /*
1128: * Adjust size of uninitialized data.
1129: * Record new location of symbol.
1130: */
1131: ldh_drv.l_ssize[L_BSSD] += dsymp->ls_addr;
1132: dsymp->ls_addr = off;
1133:
1134: #if EBUG > 0
1135: if ( dflag )
1136: printf("%.*s: COMMON type=%d addr=%04x\n",
1137: NCPLN, dsymp->ls_id,
1138: dsymp->ls_type, dsymp->ls_addr );
1139: #endif
1140: }
1141:
1142: /*
1143: * Undefined symbol.
1144: */
1145: else {
1146: undef++;
1147: dsymp->ls_id[NCPLN] = 0;
1148: warn( dsymp->ls_id, ": undefined symbol" );
1149: }
1150: }
1151:
1152: /*
1153: * Terminate if symbols undefined.
1154: */
1155: if ( undef )
1156: cleanup( 100 );
1157: }
1158:
1159: /**
1160: *
1161: * void
1162: * symadjust() -- Adjust addresses of driver data symbols.
1163: *
1164: * NOTE: Has to be done AFTER kernel data space allocation.
1165: */
1166: symadjust()
1167: {
1168: register struct ldsym * dsymp;
1169: register unsigned txtlen;
1170:
1171: if ( dsym_cnt == 0 )
1172: return;
1173:
1174: txtlen = ldh_drv.l_ssize[L_SHRI] +
1175: ldh_drv.l_ssize[L_PRVI] +
1176: ldh_drv.l_ssize[L_BSSI];
1177:
1178: /*
1179: * Search driver symbol table.
1180: */
1181: for ( dsymp = &dsym_tab[ dsym_cnt ]; --dsymp >= dsym_tab; ) {
1182:
1183: /*
1184: * All driver data references are specified as uninitialized.
1185: * All kernel data references are specified as absolute.
1186: */
1187: if ( (dsymp->ls_type & LR_SEG) != L_BSSD )
1188: continue;
1189:
1190: #if EBUG > 0
1191: if ( dflag )
1192: printf("adjusting %.*s [type %d] from %04x by %04x\n",
1193: NCPLN, dsymp->ls_id,
1194: dsymp->ls_type,
1195: dsymp->ls_addr,
1196: datap );
1197: #endif
1198:
1199: /*
1200: * Validate data address.
1201: */
1202: if ( dsymp->ls_addr < txtlen ) {
1203: dsymp->ls_id[NCPLN] = 0;
1204: fatal( dsymp->ls_id, ": invalid address" );
1205: }
1206:
1207: /*
1208: * Adjust address of data symbol.
1209: * Separate code/data eliminates relocation after code.
1210: * Insertion into kernel data adds slot relocation.
1211: */
1212: dsymp->ls_addr -= txtlen;
1213: dsymp->ls_addr += datap;
1214: }
1215: }
1216:
1217: /**
1218: *
1219: * struct ldsym *
1220: * drvalias( s ) - Search driver for alias for undefined symbol.
1221: * char * s;
1222: */
1223: struct ldsym *
1224: drvalias( sym_id )
1225: register char * sym_id;
1226: {
1227: register struct ldsym * symp;
1228:
1229: /*
1230: * No driver symbols.
1231: */
1232: if ( dsym_cnt == 0 )
1233: return( NULL );
1234:
1235: /*
1236: * Not a symbol which can be aliased.
1237: */
1238: if ( strncmp("con_", sym_id, NCPLN ) != 0 )
1239: return( NULL );
1240:
1241: /*
1242: * Scan driver symbol table [backwards for efficiency].
1243: */
1244: for ( symp = &dsym_tab[dsym_cnt]; --symp >= dsym_tab; ) {
1245:
1246: /*
1247: * Ignore all except code/data declarations.
1248: */
1249: if ( (symp->ls_type & LR_SEG) > L_BSSD )
1250: continue;
1251:
1252: /*
1253: * Check id after discarding two char driver prefix.
1254: */
1255: if ( strncmp( sym_id, &symp->ls_id[2], NCPLN-2 ) == 0 )
1256: return( symp );
1257:
1258: /*
1259: * Bypass id if 3rd char is not a numeric digit.
1260: */
1261: if ( (symp->ls_id[2] < '0') || (symp->ls_id[2] > '9') )
1262: continue;
1263:
1264: /*
1265: * Check id after discarding three char driver prefix.
1266: */
1267: if ( strncmp( sym_id, &symp->ls_id[3], NCPLN-3 ) == 0 )
1268: return( symp );
1269: }
1270:
1271: return( NULL );
1272: }
1273:
1274: /**
1275: *
1276: * struct ldsym *
1277: * ksymbol( s ) - Search kernel for undefined symbol.
1278: * char * s;
1279: */
1280: struct ldsym *
1281: ksymbol( sym_id )
1282: register char * sym_id;
1283: {
1284: register struct ldsym * ksymp;
1285: register int i;
1286: char id[NCPLN];
1287:
1288: /*
1289: * Find last character in symbol identifier.
1290: */
1291: for ( i = NCPLN-1; (i > 0) && (sym_id[i] == 0); --i );
1292: ;
1293:
1294: /*
1295: * Scan kernel symbol table [backwards for efficiency].
1296: */
1297: for ( ksymp = &ksym_tab[ksym_cnt]; --ksymp >= ksym_tab; ) {
1298:
1299: if ( strncmp( sym_id, ksymp->ls_id, NCPLN ) != 0 )
1300: continue;
1301:
1302: /*
1303: * Disallow references to C-callable kernel code symbols.
1304: */
1305: if((sym_id[i] == '_') && ((ksymp->ls_type & LR_SEG) == L_SHRI))
1306: return( NULL );
1307:
1308: return( ksymp );
1309: }
1310:
1311: /*
1312: * Check symbol for 'K' prefix.
1313: * If found, try again after discarding prefix.
1314: */
1315: if ( (i < 3) || (sym_id[0] != 'K') )
1316: return( NULL );
1317: strncpy( &id[0], &sym_id[1], NCPLN-1 );
1318: id[NCPLN-1] = 0;
1319:
1320: /*
1321: * Scan kernel symbol table [backwards for efficiency].
1322: */
1323: for ( ksymp = &ksym_tab[ksym_cnt]; --ksymp >= ksym_tab; ) {
1324:
1325: /*
1326: * Only shared kernel code symbols accessible via K prefix.
1327: */
1328: if ( (ksymp->ls_type & LR_SEG) != L_SHRI)
1329: continue;
1330:
1331: if ( strncmp( id, ksymp->ls_id, NCPLN ) == 0 )
1332: return( ksymp );
1333: }
1334:
1335: return( NULL );
1336: }
1337:
1338: /**
1339: *
1340: * void
1341: * symsave() -- save revised driver symbol table in code file.
1342: */
1343: void
1344: symsave()
1345: {
1346: /*
1347: * Format driver code header.
1348: */
1349: ldh_drv.l_flag = LF_SEP | LF_NRB | LF_KER;
1350: ldh_drv.l_ssize[L_SHRD] = 0;
1351: ldh_drv.l_ssize[L_PRVD] = 0;
1352: ldh_drv.l_ssize[L_BSSD] = kmem_end;
1353: ldh_drv.l_ssize[L_DEBUG] = 0;
1354: ldh_drv.l_ssize[L_SYM ] = 0;
1355: ldh_drv.l_ssize[L_REL ] = 0;
1356:
1357: /*
1358: * Save symbol table BEFORE canonizing header.
1359: * NOTE: Reversing sequence will cause errors with symoff().
1360: * Don't save if removing or stripping object.
1361: */
1362: if ( (rflag == 0) && (sflag == 0) && (dsym_cnt != 0) ) {
1363:
1364: ldh_drv.l_ssize[L_SYM] = dsym_len;
1365:
1366: if ( lseek( text_fd, (long) symoff(&ldh_drv), 0 ) < 0 )
1367: fatal( text_file, ": bad seek" );
1368:
1369: if ( write( text_fd, (char *) dsym_tab, dsym_len ) < 0 )
1370: fatal( text_file, ": bad write" );
1371: }
1372:
1373: /*
1374: * Canonize and save driver code header AFTER saving symbol table.
1375: */
1376: canldh( &ldh_drv );
1377: if ( lseek( text_fd, 0L, 0 ) < 0 )
1378: fatal( text_file, ": bad seek" );
1379: if ( write( text_fd, &ldh_drv, sizeof(ldh_drv) ) < 0 )
1380: fatal( text_file, ": bad write" );
1381:
1382: /*
1383: * Release the malloc'ed storage.
1384: */
1385: if ( dsym_tab != NULL ) {
1386: free( dsym_tab );
1387: dsym_tab = NULL;
1388: }
1389: }
1390:
1391: /**
1392: *
1393: * long
1394: * symoff( ldp ) -- compute offset of symbol table in object module
1395: * struct ldheadr * ldp;
1396: */
1397: long
1398: symoff( ldp )
1399: register struct ldheader * ldp;
1400: {
1401: return( sizeof(*ldp) +
1402: ldp->l_ssize[L_SHRI] +
1403: ldp->l_ssize[L_PRVI] +
1404: ldp->l_ssize[L_SHRD] +
1405: ldp->l_ssize[L_PRVD] +
1406: ldp->l_ssize[L_DEBUG] );
1407: }
1408:
1409: /**
1410: *
1411: * int
1412: * fkword( kp, up ) - Fetch word from kernel locn 'kp' to user locn 'up'.
1413: * int * ip;
1414: * int * up;
1415: */
1416: int
1417: fkword( kp, up )
1418: int * kp;
1419: int * up;
1420: {
1421: if ( lseek( kmem_fd, (long) kp, 0 ) < 0 )
1422: return( -1 );
1423:
1424: if ( read( kmem_fd, up, sizeof(*up) ) < 0 )
1425: return( -1 );
1426:
1427: return( 0 );
1428: }
1429:
1430: /**
1431: *
1432: * int
1433: * skword( kp, w ) - Store word 'w' into kernel locn 'kp'.
1434: * int * kp;
1435: * int w;
1436: */
1437: int
1438: skword( kp, w )
1439: int * kp;
1440: int w;
1441: {
1442: if ( lseek( kmem_fd, (long) kp, 0 ) < 0 )
1443: return( -1 );
1444:
1445: if ( write( kmem_fd, &w, sizeof(w) ) < 0 )
1446: return( -1 );
1447:
1448: return( 0 );
1449: }
1450:
1451: char *
1452: basename( s )
1453: register char * s;
1454: {
1455: register char * base;
1456:
1457: for ( base = s; *s != '\0'; s++ ) {
1458: if ( (s[0] == '/') && (s[1] != '/') && (s[1] != '\0') )
1459: base = s+1;
1460: }
1461:
1462: return( base );
1463: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.