[apple/xnu.git] / bsd / kern / kern_symfile.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/* Copyright (c) 1998 Apple Computer, Inc.  All rights reserved.
 *
 *	File:	bsd/kern/kern_symfile.c
 *
 *	This file contains creates a dummy symbol file for mach_kernel based on
 *      the symbol table information passed by the SecondaryLoader/PlatformExpert.
 *      This allows us to correctly link other executables (drivers, etc) against the 
 *      the kernel in cases where the kernel image on the root device does not match
 *      the live kernel. This can occur during net-booting where the actual kernel
 *      image is obtained from the network via tftp rather than the root
 *      device.
 *
 *      If a symbol table is available, then the file /mach.sym will be created
 *      containing a Mach Header and a LC_SYMTAB load command followed by the
 *      the symbol table data for mach_kernel.
 *
 * HISTORY
 * 
 *	.
 */

#include <mach/vm_param.h>

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/signalvar.h>
#include <sys/resourcevar.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/proc.h>
#include <sys/timeb.h>
#include <sys/times.h>
#include <sys/buf.h>
#include <sys/acct.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/kernel.h>
#include <sys/stat.h>

#include <mach-o/loader.h>
#include <mach-o/nlist.h>

#include <vm/vm_kern.h>

extern unsigned char 	rootdevice[];
extern vm_size_t	page_size;


int kernel_symfile_opened = 0;
int error_code = 0;

extern int  IODTGetLoaderInfo(  char *key, void **infoAddr, int *infoSize );
extern void IODTFreeLoaderInfo( char *key, void *infoAddr, int infoSize );

struct segment_command *findSegmentByName( struct mach_header *mh, const char *section_name );

/*
 * 
 */
int get_kernel_symfile( struct proc *p, char **symfile )
{
    if ( kernel_symfile_opened == 0 )
    {
        kernel_symfile_opened = 1;
        error_code = output_kernel_symbols( p );
    }
    if ( error_code == 0 ) *symfile = "\\mach.sym";

    return error_code;
}

/*
 * 
 */
int output_kernel_symbols( register struct proc *p )
{
	register struct vnode		*vp;
	register struct pcred 		*pcred = p->p_cred;
	register struct ucred 		*cred = pcred->pc_ucred;
	struct nameidata 		nd;
	struct vattr			vattr;
	struct mach_header		*orig_mh, *mh;
        struct load_command		*lc;
        struct segment_command		*orig_ds, *orig_ts, *sg;
        struct section			*se;
	struct symtab_command 		*sc, *sc0;
        struct nlist                    *nl;
	vm_size_t			orig_mhsize, sc0_size;
        vm_offset_t			header;
        vm_size_t			header_size;
	int				error, error1;
        int				i, j;
        int				symfoffset, symsize;
        int                             rc_mh, rc_sc;

        error = EFAULT;

        vp       = NULL;
        header   = NULL;
        orig_mh  = NULL;
        sc0      = NULL;
        
        rc_mh = IODTGetLoaderInfo( "Kernel-__HEADER", (void **)&orig_mh, &orig_mhsize );
        rc_sc = IODTGetLoaderInfo( "Kernel-__SYMTAB", (void **)&sc0, &sc0_size );
        
        if ( rc_mh != 0 || orig_mh == 0 || orig_mhsize < sizeof(struct mach_header) )    goto out;
        if ( rc_sc != 0 || sc0 == 0     || sc0_size    < sizeof(struct symtab_command) ) goto out;

	if ( pcred->p_svuid != pcred->p_ruid || pcred->p_svgid != pcred->p_rgid ) goto out;

        if ( rootdevice[0] == 'e' && rootdevice[1] == 'n' ) goto out;

	NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, "mach.sym", p);
	if( (error = vn_open(&nd, O_CREAT | FWRITE, S_IRUSR | S_IRGRP | S_IROTH )) != 0 ) goto out;

	vp = nd.ni_vp;
	
	/* Don't dump to non-regular files or files with links. */
        error = EFAULT;
	if (vp->v_type != VREG || VOP_GETATTR(vp, &vattr, cred, p) || vattr.va_nlink != 1) goto out;

	VATTR_NULL(&vattr);
	vattr.va_size = 0;
	VOP_LEASE(vp, p, cred, LEASE_WRITE);
	VOP_SETATTR(vp, &vattr, cred, p);
	p->p_acflag |= ACORE;

        orig_ts = findSegmentByName(orig_mh, "__TEXT");
        orig_ds = findSegmentByName(orig_mh, "__DATA");

        if ( orig_ts == NULL || orig_ds == NULL ) goto out;

	header_size =   sizeof(struct mach_header) 
                      + orig_ts->cmdsize
                      + orig_ds->cmdsize
                      + sizeof(struct symtab_command);

	(void) kmem_alloc_wired( kernel_map,
			        (vm_offset_t *)&header,
			        (vm_size_t)header_size);

        if ( header == NULL ) goto out;

        bzero( (void *)header, header_size );

	/*
	 *	Set up Mach-O header.
	 */
	mh = (struct mach_header *) header;
	mh->magic = orig_mh->magic;
	mh->cputype = orig_mh->cputype;
	mh->cpusubtype = orig_mh->cpusubtype;
	mh->filetype = orig_mh->filetype;
	mh->ncmds = 3;
	mh->sizeofcmds = header_size - sizeof(struct mach_header);

	/*
	 *	Copy __DATA and __TEXT segment commands from mach_kernel so loadable drivers
         *	get correct section alignment hints.
	 */
        sg = (struct segment_command *)(mh+1);
        bcopy( orig_ts, sg, orig_ts->cmdsize );

        sg = (struct segment_command *)((int)sg + sg->cmdsize);
        bcopy( orig_ds, sg, orig_ds->cmdsize );

        sg = (struct segment_command *)(mh+1);
        
        for ( i = 0; i < 2; i++ )
        {
            sg->vmaddr   = 0;
            sg->vmsize   = 0x1000;
            sg->fileoff  = 0;
            sg->filesize = 0;
            sg->maxprot  = 0;
            sg->initprot = 0;
            sg->flags    = 0;

            se = (struct section *)(sg+1);
            for ( j = 0; j < sg->nsects; j++, se++ )
            {
                se->addr  = 0;
                se->size  = 0;
                se->offset = 0;
                se->nreloc = 0;
            }

            sg = (struct segment_command *)((int)sg + sg->cmdsize);
        }

        symfoffset = round_page(header_size);

	/*
	 *	Set up LC_SYMTAB command
	 */
	sc          = (struct symtab_command *)sg;
	sc->cmd     = LC_SYMTAB;
	sc->cmdsize = sizeof(struct symtab_command);
        sc->symoff  = symfoffset;
        sc->nsyms   = sc0->nsyms;
        sc->strsize = sc0->strsize;
        sc->stroff =  symfoffset + sc->nsyms * sizeof(struct nlist);    

        symsize = sc->nsyms * sizeof(struct nlist) + sc->strsize;

        nl = (struct nlist *)(sc0+1);
        for (i = 0; i < sc->nsyms; i++, nl++ )
        {
            if ( (nl->n_type & N_TYPE) == N_SECT )
            {
                nl->n_sect = NO_SECT;
                nl->n_type = (nl->n_type & ~N_TYPE) | N_ABS;
            }
        }

	/*
	 *	Write out the load commands at the beginning of the
	 *	file.
	 */
	error = vn_rdwr(UIO_WRITE, vp, (caddr_t)mh, header_size, (off_t)0,
   		        UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *) 0, p);
        if ( error != 0 ) goto out;
        
        /*
         * 	Write out kernel symbols
         */
	error = vn_rdwr(UIO_WRITE, vp, (caddr_t)(sc0+1), symsize, symfoffset,
	    		UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *) 0, p);
        if ( error != 0 ) goto out;

out:
        if ( header != 0 ) kmem_free(kernel_map, header, header_size);
        if ( orig_mh != 0 ) IODTFreeLoaderInfo( "Kernel-__HEADER", (void *)orig_mh, round_page(orig_mhsize) );
        if ( sc0     != 0 ) IODTFreeLoaderInfo( "Kernel-__SYMTAB", (void *)sc0,     round_page(sc0_size) );        
  
        if ( vp != 0 )
        {
	    VOP_UNLOCK(vp, 0, p);
	    error1 = vn_close(vp, FWRITE, cred, p);
	    if (error == 0) error = error1;
        }

	return(error);
}

/*
 * 
 */
struct segment_command *findSegmentByName( struct mach_header *mh, const char *section_name )
{
    struct segment_command 	*sg;
    int				i;
     
    sg = (struct segment_command *)(mh+1);

    for ( i=0; i < mh->ncmds; i++ )
    {
        if ( (sg->cmd == LC_SEGMENT) && (strcmp(sg->segname, section_name) == 0) )
        {
            return sg;
        }
        
        sg = (struct segment_command *)((int)sg + sg->cmdsize);
    }

    return NULL;
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/* Copyright (c) 1998 Apple Computer, Inc. All rights reserved.
	23	*
	24	* File: bsd/kern/kern_symfile.c
	25	*
	26	* This file contains creates a dummy symbol file for mach_kernel based on
	27	* the symbol table information passed by the SecondaryLoader/PlatformExpert.
	28	* This allows us to correctly link other executables (drivers, etc) against the
	29	* the kernel in cases where the kernel image on the root device does not match
	30	* the live kernel. This can occur during net-booting where the actual kernel
	31	* image is obtained from the network via tftp rather than the root
	32	* device.
	33	*
	34	* If a symbol table is available, then the file /mach.sym will be created
	35	* containing a Mach Header and a LC_SYMTAB load command followed by the
	36	* the symbol table data for mach_kernel.
	37	*
	38	* HISTORY
	39	*
	40	* .
	41	*/
	42
	43	#include <mach/vm_param.h>
	44
	45	#include <sys/param.h>
	46	#include <sys/systm.h>
	47	#include <sys/signalvar.h>
	48	#include <sys/resourcevar.h>
	49	#include <sys/namei.h>
	50	#include <sys/vnode.h>
	51	#include <sys/proc.h>
	52	#include <sys/timeb.h>
	53	#include <sys/times.h>
	54	#include <sys/buf.h>
	55	#include <sys/acct.h>
	56	#include <sys/file.h>
	57	#include <sys/uio.h>
	58	#include <sys/kernel.h>
	59	#include <sys/stat.h>
	60
	61	#include <mach-o/loader.h>
	62	#include <mach-o/nlist.h>
	63
	64	#include <vm/vm_kern.h>
65
66	extern unsigned char rootdevice[];
67	extern vm_size_t page_size;
68
69
70	int kernel_symfile_opened = 0;
71	int error_code = 0;
72
73	extern int IODTGetLoaderInfo( char key, void infoAddr, int infoSize );
74	extern void IODTFreeLoaderInfo( char key, void infoAddr, int infoSize );
75
76	struct segment_command findSegmentByName( struct mach_header mh, const char *section_name );
77
78	/*
79	*
80	*/
81	int get_kernel_symfile( struct proc p, char *symfile )
82	{
83	if ( kernel_symfile_opened == 0 )
84	{
85	kernel_symfile_opened = 1;
86	error_code = output_kernel_symbols( p );
87	}
88	if ( error_code == 0 ) *symfile = "\\mach.sym";
89
90	return error_code;
91	}
92
93	/*
94	*
95	*/
96	int output_kernel_symbols( register struct proc *p )
97	{
98	register struct vnode *vp;
99	register struct pcred *pcred = p->p_cred;
100	register struct ucred *cred = pcred->pc_ucred;
101	struct nameidata nd;
102	struct vattr vattr;
103	struct mach_header orig_mh, mh;
104	struct load_command *lc;
105	struct segment_command orig_ds, orig_ts, *sg;
106	struct section *se;
107	struct symtab_command sc, sc0;
108	struct nlist *nl;
109	vm_size_t orig_mhsize, sc0_size;
110	vm_offset_t header;
111	vm_size_t header_size;
112	int error, error1;
113	int i, j;
114	int symfoffset, symsize;
115	int rc_mh, rc_sc;
116
117	error = EFAULT;
118
119	vp = NULL;
120	header = NULL;
121	orig_mh = NULL;
122	sc0 = NULL;
123
124	rc_mh = IODTGetLoaderInfo( "Kernel-__HEADER", (void **)&orig_mh, &orig_mhsize );
125	rc_sc = IODTGetLoaderInfo( "Kernel-__SYMTAB", (void **)&sc0, &sc0_size );
126
127	if ( rc_mh != 0 \|\| orig_mh == 0 \|\| orig_mhsize < sizeof(struct mach_header) ) goto out;
128	if ( rc_sc != 0 \|\| sc0 == 0 \|\| sc0_size < sizeof(struct symtab_command) ) goto out;
129
130	if ( pcred->p_svuid != pcred->p_ruid \|\| pcred->p_svgid != pcred->p_rgid ) goto out;
131
132	if ( rootdevice[0] == 'e' && rootdevice[1] == 'n' ) goto out;
133
134	NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, "mach.sym", p);
135	if( (error = vn_open(&nd, O_CREAT \| FWRITE, S_IRUSR \| S_IRGRP \| S_IROTH )) != 0 ) goto out;
136
137	vp = nd.ni_vp;
138
139	/* Don't dump to non-regular files or files with links. */
140	error = EFAULT;
141	if (vp->v_type != VREG \|\| VOP_GETATTR(vp, &vattr, cred, p) \|\| vattr.va_nlink != 1) goto out;
142
143	VATTR_NULL(&vattr);
144	vattr.va_size = 0;
145	VOP_LEASE(vp, p, cred, LEASE_WRITE);
146	VOP_SETATTR(vp, &vattr, cred, p);
147	p->p_acflag \|= ACORE;
148
149	orig_ts = findSegmentByName(orig_mh, "__TEXT");
150	orig_ds = findSegmentByName(orig_mh, "__DATA");
151
152	if ( orig_ts == NULL \|\| orig_ds == NULL ) goto out;
153
154	header_size = sizeof(struct mach_header)
155	+ orig_ts->cmdsize
156	+ orig_ds->cmdsize
157	+ sizeof(struct symtab_command);
158
159	(void) kmem_alloc_wired( kernel_map,
160	(vm_offset_t *)&header,
161	(vm_size_t)header_size);
162
163	if ( header == NULL ) goto out;
164
165	bzero( (void *)header, header_size );
166
167	/*
168	* Set up Mach-O header.
169	*/
170	mh = (struct mach_header *) header;
171	mh->magic = orig_mh->magic;
172	mh->cputype = orig_mh->cputype;
173	mh->cpusubtype = orig_mh->cpusubtype;
174	mh->filetype = orig_mh->filetype;
175	mh->ncmds = 3;
176	mh->sizeofcmds = header_size - sizeof(struct mach_header);
177
178	/*
179	* Copy __DATA and __TEXT segment commands from mach_kernel so loadable drivers
180	* get correct section alignment hints.
181	*/
182	sg = (struct segment_command *)(mh+1);
183	bcopy( orig_ts, sg, orig_ts->cmdsize );
184
185	sg = (struct segment_command *)((int)sg + sg->cmdsize);
186	bcopy( orig_ds, sg, orig_ds->cmdsize );
187
188	sg = (struct segment_command *)(mh+1);
189
190	for ( i = 0; i < 2; i++ )
191	{
192	sg->vmaddr = 0;
193	sg->vmsize = 0x1000;
194	sg->fileoff = 0;
195	sg->filesize = 0;
196	sg->maxprot = 0;
197	sg->initprot = 0;
198	sg->flags = 0;
199
200	se = (struct section *)(sg+1);
201	for ( j = 0; j < sg->nsects; j++, se++ )
202	{
203	se->addr = 0;
204	se->size = 0;
205	se->offset = 0;
206	se->nreloc = 0;
207	}
208
209	sg = (struct segment_command *)((int)sg + sg->cmdsize);
210	}
211
212	symfoffset = round_page(header_size);
213
214	/*
215	* Set up LC_SYMTAB command
216	*/
217	sc = (struct symtab_command *)sg;
218	sc->cmd = LC_SYMTAB;
219	sc->cmdsize = sizeof(struct symtab_command);
220	sc->symoff = symfoffset;
221	sc->nsyms = sc0->nsyms;
222	sc->strsize = sc0->strsize;
223	sc->stroff = symfoffset + sc->nsyms * sizeof(struct nlist);
224
225	symsize = sc->nsyms * sizeof(struct nlist) + sc->strsize;
226
227	nl = (struct nlist *)(sc0+1);
228	for (i = 0; i < sc->nsyms; i++, nl++ )
229	{
230	if ( (nl->n_type & N_TYPE) == N_SECT )
231	{
232	nl->n_sect = NO_SECT;
233	nl->n_type = (nl->n_type & ~N_TYPE) \| N_ABS;
234	}
235	}
236
237	/*
238	* Write out the load commands at the beginning of the
239	* file.
240	*/
241	error = vn_rdwr(UIO_WRITE, vp, (caddr_t)mh, header_size, (off_t)0,
242	UIO_SYSSPACE, IO_NODELOCKED\|IO_UNIT, cred, (int *) 0, p);
243	if ( error != 0 ) goto out;
244
245	/*
246	* Write out kernel symbols
247	*/
248	error = vn_rdwr(UIO_WRITE, vp, (caddr_t)(sc0+1), symsize, symfoffset,
249	UIO_SYSSPACE, IO_NODELOCKED\|IO_UNIT, cred, (int *) 0, p);
250	if ( error != 0 ) goto out;
251
252	out:
253	if ( header != 0 ) kmem_free(kernel_map, header, header_size);
254	if ( orig_mh != 0 ) IODTFreeLoaderInfo( "Kernel-__HEADER", (void *)orig_mh, round_page(orig_mhsize) );
255	if ( sc0 != 0 ) IODTFreeLoaderInfo( "Kernel-__SYMTAB", (void *)sc0, round_page(sc0_size) );
256
257	if ( vp != 0 )
258	{
259	VOP_UNLOCK(vp, 0, p);
260	error1 = vn_close(vp, FWRITE, cred, p);
261	if (error == 0) error = error1;
262	}
263
264	return(error);
265	}
266
267	/*
268	*
269	*/
270	struct segment_command findSegmentByName( struct mach_header mh, const char *section_name )
271	{
272	struct segment_command *sg;
273	int i;
274
275	sg = (struct segment_command *)(mh+1);
276
277	for ( i=0; i < mh->ncmds; i++ )
278	{
279	if ( (sg->cmd == LC_SEGMENT) && (strcmp(sg->segname, section_name) == 0) )
280	{
281	return sg;
282	}
283
284	sg = (struct segment_command *)((int)sg + sg->cmdsize);
285	}
286
287	return NULL;
288	}
289
290
291
292
293