X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/d7e50217d7adf6e52786a38bcaa4cd698cb9a79e..060df5ea7c632b1ac8cc8aac1fb59758165c2084:/bsd/kern/kern_symfile.c diff --git a/bsd/kern/kern_symfile.c b/bsd/kern/kern_symfile.c index 4fd60fab2..ffbff213f 100644 --- a/bsd/kern/kern_symfile.c +++ b/bsd/kern/kern_symfile.c @@ -1,16 +1,19 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ - * - * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in - * compliance with the License. Please obtain a copy of the License at - * http://www.opensource.apple.com/apsl/ and read it before using this - * file. + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER @@ -20,27 +23,13 @@ * Please see the License for the specific language governing rights and * limitations under the License. * - * @APPLE_LICENSE_HEADER_END@ + * @APPLE_OSREFERENCE_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 @@ -50,290 +39,278 @@ #include #include #include -#include -#include +#include +#include +#include #include #include -#include #include -#include +#include #include #include #include +#include +#include #include #include +#include #include +#include +#include -extern unsigned char rootdevice[]; -extern struct mach_header _mh_execute_header; +/* This function is called from kern_sysctl in the current process context; + * it is exported with the System6.0.exports, but this appears to be a legacy + * export, as there are no internal consumers. + */ +int +get_kernel_symfile(__unused proc_t p, __unused char const **symfile) +{ + return KERN_FAILURE; +} -static int kernel_symfile_opened = 0; -static int error_code = 0; +struct kern_direct_file_io_ref_t +{ + vfs_context_t ctx; + struct vnode *vp; +}; -extern int IODTGetLoaderInfo(char *key, void **infoAddr, int *infoSize); -extern void IODTFreeLoaderInfo(char *key, void *infoAddr, int infoSize); -/* - * - */ -static int output_kernel_symbols(struct proc *p) +static int file_ioctl(void * p1, void * p2, int theIoctl, caddr_t result) { - struct vnode *vp; - struct pcred *pcred = p->p_cred; - struct ucred *cred = pcred->pc_ucred; - struct nameidata nd; - struct vattr vattr; - struct load_command *cmd; - struct mach_header *orig_mh, *mh; - struct segment_command *orig_ds, *orig_ts, *orig_le, *sg; - struct section *se, *const_text; - struct symtab_command *st, *orig_st; - struct nlist *sym; - vm_size_t orig_mhsize, orig_st_size; - vm_offset_t header; - vm_size_t header_size; - int error, error1; - int i, j; - caddr_t addr; - vm_offset_t offset; - int rc_mh, rc_sc; + dev_t device = *(dev_t*) p1; - error = EFAULT; + return ((*bdevsw[major(device)].d_ioctl) + (device, theIoctl, result, S_IFBLK, p2)); +} + +static int device_ioctl(void * p1, __unused void * p2, int theIoctl, caddr_t result) +{ + return (VNOP_IOCTL(p1, theIoctl, result, 0, p2)); +} + +struct kern_direct_file_io_ref_t * +kern_open_file_for_direct_io(const char * name, + kern_get_file_extents_callback_t callback, + void * callback_ref, + dev_t * device_result, + uint64_t * partitionbase_result, + uint64_t * maxiocount_result, + boolean_t * solid_state) +{ + struct kern_direct_file_io_ref_t * ref; + + proc_t p; + struct vnode_attr va; + int error; + off_t f_offset; + uint32_t blksize; + uint64_t size; + dev_t device; + off_t maxiocount, count; + + int (*do_ioctl)(void * p1, void * p2, int theIoctl, caddr_t result); + void * p1; + void * p2; - vp = NULL; - header = NULL; - orig_mh = NULL; - orig_st = NULL; - - // Dispose of unnecessary gumf, the booter doesn't need to load these - rc_mh = IODTGetLoaderInfo("Kernel-__HEADER", - (void **)&orig_mh, &orig_mhsize); - if (rc_mh && orig_mh) - IODTFreeLoaderInfo("Kernel-__HEADER", - (void *)orig_mh, round_page_32(orig_mhsize)); - - rc_sc = IODTGetLoaderInfo("Kernel-__SYMTAB", - (void **) &orig_st, &orig_st_size); - if (rc_sc && orig_st) - IODTFreeLoaderInfo("Kernel-__SYMTAB", - (void *)orig_st, round_page_32(orig_st_size)); - - if (pcred->p_svuid != pcred->p_ruid || pcred->p_svgid != pcred->p_rgid) - goto out; - - // Check to see if the root is 'e' or 'n', is this a test for network? - 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))) 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; - - // If the file type is MH_EXECUTE then this must be a kernel - // as all Kernel extensions must be of type MH_OBJECT - orig_ds = orig_ts = orig_le = NULL; - orig_st = NULL; - orig_mh = &_mh_execute_header; - cmd = (struct load_command *) &orig_mh[1]; - for (i = 0; i < orig_mh->ncmds; i++) { - if (cmd->cmd == LC_SEGMENT) { - struct segment_command *sg = (struct segment_command *) cmd; - - if (!strcmp(SEG_TEXT, sg->segname)) - orig_ts = sg; - else if (!strcmp(SEG_DATA, sg->segname)) - orig_ds = sg; - else if (!strcmp(SEG_LINKEDIT, sg->segname)) - orig_le = sg; - } - else if (cmd->cmd == LC_SYMTAB) - orig_st = (struct symtab_command *) cmd; - - cmd = (struct load_command *) ((caddr_t) cmd + cmd->cmdsize); + + ref = (struct kern_direct_file_io_ref_t *) kalloc(sizeof(struct kern_direct_file_io_ref_t)); + if (!ref) + { + error = EFAULT; + goto out; } - if (!orig_ts || !orig_ds || !orig_le || !orig_st) - goto out; + ref->vp = NULL; + p = current_proc(); // kernproc; + ref->ctx = vfs_context_create(vfs_context_current()); - const_text = NULL; - se = (struct section *) &orig_ts[1]; - for (i = 0; i < orig_ts->nsects; i++, se++) { - if (!strcmp("__const", se->sectname)) { - const_text = se; - break; - } - } - if (!const_text) - 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) - bzero((void *) header, header_size); - else - goto out; - - /* - * 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); - mh->flags = orig_mh->flags; - - // Initialise the current file offset and addr - offset = round_page_32(header_size); - addr = (caddr_t) const_text->addr; // Load address of __TEXT,__const - - /* - * Construct a TEXT segment load command - * the only part of the TEXT segment we keep is the __TEXT,__const - * which contains the kernel vtables. - */ - sg = (struct segment_command *) &mh[1]; - bcopy(orig_ts, sg, orig_ts->cmdsize); - sg->vmaddr = (unsigned long) addr; - sg->vmsize = const_text->size; - sg->fileoff = 0; - sg->filesize = const_text->size + round_page_32(header_size); - sg->maxprot = 0; - sg->initprot = 0; - sg->flags = 0; - se = (struct section *)(sg+1); - for ( j = 0; j < sg->nsects; j++, se++ ) { - se->addr = (unsigned long) addr; - se->size = 0; - se->offset = offset; - se->nreloc = 0; - if (!strcmp("__const", se->sectname)) { - se->size = const_text->size; - addr += const_text->size; - offset += const_text->size; - const_text = se; - } + if ((error = vnode_open(name, (O_CREAT | FWRITE), (0), 0, &ref->vp, ref->ctx))) + goto out; + + VATTR_INIT(&va); + VATTR_WANTED(&va, va_rdev); + VATTR_WANTED(&va, va_fsid); + VATTR_WANTED(&va, va_data_size); + VATTR_WANTED(&va, va_nlink); + error = EFAULT; + if (vnode_getattr(ref->vp, &va, ref->ctx)) + goto out; + + kprintf("vp va_rdev major %d minor %d\n", major(va.va_rdev), minor(va.va_rdev)); + kprintf("vp va_fsid major %d minor %d\n", major(va.va_fsid), minor(va.va_fsid)); + kprintf("vp size %qd\n", va.va_data_size); + + if (ref->vp->v_type == VREG) + { + /* Don't dump files with links. */ + if (va.va_nlink != 1) + goto out; + + device = va.va_fsid; + p1 = &device; + p2 = p; + do_ioctl = &file_ioctl; } - offset = round_page_32((vm_address_t) offset); - - // Now copy of the __DATA segment load command, the image need - // not be stored to disk nobody needs it, yet! - sg = (struct segment_command *)((int)sg + sg->cmdsize); - bcopy(orig_ds, sg, orig_ds->cmdsize); - - sg->vmaddr = (unsigned long) addr; - sg->vmsize = 0x1000; // One page for some reason? - sg->fileoff = offset; - 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 = (unsigned long) addr; - se->size = 0; - se->offset = offset; - se->nreloc = 0; + else if ((ref->vp->v_type == VBLK) || (ref->vp->v_type == VCHR)) + { + /* Partition. */ + device = va.va_rdev; + + p1 = ref->vp; + p2 = ref->ctx; + do_ioctl = &device_ioctl; } - offset = round_page_32(offset); - - - /* - * Set up LC_SYMTAB command - */ - st = (struct symtab_command *)((int)sg + sg->cmdsize); - st->cmd = LC_SYMTAB; - st->cmdsize = sizeof(struct symtab_command); - st->symoff = offset; - st->nsyms = orig_st->nsyms; - st->strsize = orig_st->strsize; - st->stroff = offset + st->nsyms * sizeof(struct nlist); - - /* - * Convert the symbol table in place from section references - * to absolute references. - */ - sym = (struct nlist *) orig_le->vmaddr; - for (i = 0; i < st->nsyms; i++, sym++ ) { - if ( (sym->n_type & N_TYPE) == N_SECT) { - sym->n_sect = NO_SECT; - sym->n_type = (sym->n_type & ~N_TYPE) | N_ABS; - } + else + { + /* Don't dump to non-regular files. */ + error = EFAULT; + goto out; } - /* - * 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); + // get partition base + + error = do_ioctl(p1, p2, DKIOCGETBASE, (caddr_t) partitionbase_result); if (error) - goto out; - - /* - * Write out the __TEXT,__const data segment. - */ - error = vn_rdwr(UIO_WRITE, vp, (caddr_t) const_text->addr, - const_text->size, const_text->offset, - UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *) 0, p); + goto out; + + // get block size & constraints + + error = do_ioctl(p1, p2, DKIOCGETBLOCKSIZE, (caddr_t) &blksize); if (error) - goto out; - - /* - * Write out kernel symbols - */ - offset = st->nsyms * sizeof(struct nlist) + st->strsize; // symtab size - error = vn_rdwr(UIO_WRITE, vp, - (caddr_t) orig_le->vmaddr, offset, st->symoff, - UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *) 0, p); + goto out; + + maxiocount = 1*1024*1024*1024; + + error = do_ioctl(p1, p2, DKIOCGETMAXBLOCKCOUNTREAD, (caddr_t) &count); if (error) - goto out; + count = 0; + count *= blksize; + if (count && (count < maxiocount)) + maxiocount = count; + + error = do_ioctl(p1, p2, DKIOCGETMAXBLOCKCOUNTWRITE, (caddr_t) &count); + if (error) + count = 0; + count *= blksize; + if (count && (count < maxiocount)) + maxiocount = count; + + error = do_ioctl(p1, p2, DKIOCGETMAXBYTECOUNTREAD, (caddr_t) &count); + if (error) + count = 0; + if (count && (count < maxiocount)) + maxiocount = count; + + error = do_ioctl(p1, p2, DKIOCGETMAXBYTECOUNTWRITE, (caddr_t) &count); + if (error) + count = 0; + if (count && (count < maxiocount)) + maxiocount = count; + + error = do_ioctl(p1, p2, DKIOCGETMAXSEGMENTBYTECOUNTREAD, (caddr_t) &count); + if (error) + count = 0; + if (count && (count < maxiocount)) + maxiocount = count; + + error = do_ioctl(p1, p2, DKIOCGETMAXSEGMENTBYTECOUNTWRITE, (caddr_t) &count); + if (error) + count = 0; + if (count && (count < maxiocount)) + maxiocount = count; + + kprintf("max io 0x%qx bytes\n", maxiocount); + if (maxiocount_result) + *maxiocount_result = maxiocount; + + if (solid_state) + { + int isssd = 0; + error = do_ioctl(p1, p2, DKIOCISSOLIDSTATE, (caddr_t)&isssd); + if (error) + *solid_state = FALSE; + else + *solid_state = isssd; + } + + // generate the block list + + error = 0; + if (ref->vp->v_type == VREG) + { + f_offset = 0; + while(f_offset < (off_t) va.va_data_size) + { + size_t io_size = 1*1024*1024*1024; + daddr64_t blkno; + + error = VNOP_BLOCKMAP(ref->vp, f_offset, io_size, &blkno, (size_t *)&io_size, NULL, 0, NULL); + if (error) + goto out; + callback(callback_ref, ((uint64_t) blkno) * blksize, (uint64_t) io_size); + f_offset += io_size; + } + callback(callback_ref, 0ULL, 0ULL); + } + else if ((ref->vp->v_type == VBLK) || (ref->vp->v_type == VCHR)) + { + error = do_ioctl(p1, p2, DKIOCGETBLOCKCOUNT, (caddr_t) &size); + if (error) + goto out; + size *= blksize; + callback(callback_ref, 0ULL, size); + callback(callback_ref, size, 0ULL); + } + + if (device_result) + *device_result = device; out: - if (header) - kmem_free(kernel_map, header, header_size); + kprintf("kern_open_file_for_direct_io(%d)\n", error); + + if (error && ref) { + if (ref->vp) { + vnode_close(ref->vp, FWRITE, ref->ctx); + ref->vp = NULLVP; + } - if (vp) { - VOP_UNLOCK(vp, 0, p); - error1 = vn_close(vp, FWRITE, cred, p); - if (!error) error = error1; + vfs_context_rele(ref->ctx); + kfree(ref, sizeof(struct kern_direct_file_io_ref_t)); + ref = NULL; } - return(error); + return(ref); } -/* - * - */ -int get_kernel_symfile(struct proc *p, char **symfile) + +int +kern_write_file(struct kern_direct_file_io_ref_t * ref, off_t offset, caddr_t addr, vm_size_t len) { - if (!kernel_symfile_opened) { - kernel_symfile_opened = 1; - error_code = output_kernel_symbols(p); - } - if (!error_code) - *symfile = "\\mach.sym"; + return (vn_rdwr(UIO_WRITE, ref->vp, + addr, len, offset, + UIO_SYSSPACE, IO_SYNC|IO_NODELOCKED|IO_UNIT, + vfs_context_ucred(ref->ctx), (int *) 0, + vfs_context_proc(ref->ctx))); +} + +void +kern_close_file_for_direct_io(struct kern_direct_file_io_ref_t * ref) +{ + kprintf("kern_close_file_for_direct_io\n"); - return error_code; + if (ref) { + int error; + + if (ref->vp) { + error = vnode_close(ref->vp, FWRITE, ref->ctx); + ref->vp = NULLVP; + kprintf("vnode_close(%d)\n", error); + } + vfs_context_rele(ref->ctx); + ref->ctx = NULL; + kfree(ref, sizeof(struct kern_direct_file_io_ref_t)); + } } +