| /* |
| * CDDL HEADER START |
| * |
| * The contents of this file are subject to the terms of the |
| * Common Development and Distribution License (the "License"). |
| * You may not use this file except in compliance with the License. |
| * |
| * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE |
| * or http://www.opensolaris.org/os/licensing. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * |
| * When distributing Covered Code, include this CDDL HEADER in each |
| * file and include the License file at usr/src/OPENSOLARIS.LICENSE. |
| * If applicable, add the following below this CDDL HEADER, with the |
| * fields enclosed by brackets "[]" replaced with your own identifying |
| * information: Portions Copyright [yyyy] [name of copyright owner] |
| * |
| * CDDL HEADER END |
| */ |
| /* |
| * Copyright 2008 Sun Microsystems, Inc. All rights reserved. |
| * Use is subject to license terms. |
| */ |
| |
| |
| /* |
| * ksyms driver - exports a single symbol/string table for the kernel |
| * by concatenating all the module symbol/string tables. |
| */ |
| |
| #include <sys/types.h> |
| #include <sys/sysmacros.h> |
| #include <sys/cmn_err.h> |
| #include <sys/uio.h> |
| #include <sys/kmem.h> |
| #include <sys/cred.h> |
| #include <sys/mman.h> |
| #include <sys/errno.h> |
| #include <sys/stat.h> |
| #include <sys/conf.h> |
| #include <sys/debug.h> |
| #include <sys/kobj.h> |
| #include <sys/ksyms.h> |
| #include <sys/vmsystm.h> |
| #include <vm/seg_vn.h> |
| #include <sys/atomic.h> |
| #include <sys/compress.h> |
| #include <sys/ddi.h> |
| #include <sys/sunddi.h> |
| #include <sys/list.h> |
| |
| typedef struct ksyms_image { |
| caddr_t ksyms_base; /* base address of image */ |
| size_t ksyms_size; /* size of image */ |
| } ksyms_image_t; |
| |
| typedef struct ksyms_buflist { |
| list_node_t buflist_node; |
| char buf[1]; |
| } ksyms_buflist_t; |
| |
| typedef struct ksyms_buflist_hdr { |
| list_t blist; |
| int nchunks; |
| ksyms_buflist_t *cur; |
| size_t curbuf_off; |
| } ksyms_buflist_hdr_t; |
| |
| #define BUF_SIZE (PAGESIZE - (size_t)offsetof(ksyms_buflist_t, buf)) |
| |
| int nksyms_clones; /* tunable: max clones of this device */ |
| |
| static ksyms_image_t *ksyms_clones; /* clone device array */ |
| static dev_info_t *ksyms_devi; |
| |
| static void |
| ksyms_bcopy(const void *srcptr, void *ptr, size_t rsize) |
| { |
| |
| size_t sz; |
| const char *src = (const char *)srcptr; |
| ksyms_buflist_hdr_t *hptr = (ksyms_buflist_hdr_t *)ptr; |
| |
| if (hptr->cur == NULL) |
| return; |
| |
| while (rsize) { |
| sz = MIN(rsize, (BUF_SIZE - hptr->curbuf_off)); |
| bcopy(src, (hptr->cur->buf + hptr->curbuf_off), sz); |
| |
| hptr->curbuf_off += sz; |
| if (hptr->curbuf_off == BUF_SIZE) { |
| hptr->curbuf_off = 0; |
| hptr->cur = list_next(&hptr->blist, hptr->cur); |
| if (hptr->cur == NULL) |
| break; |
| } |
| src += sz; |
| rsize -= sz; |
| } |
| } |
| |
| static void |
| ksyms_buflist_free(ksyms_buflist_hdr_t *hdr) |
| { |
| ksyms_buflist_t *list; |
| |
| while (list = list_head(&hdr->blist)) { |
| list_remove(&hdr->blist, list); |
| kmem_free(list, PAGESIZE); |
| } |
| list_destroy(&hdr->blist); |
| hdr->cur = NULL; |
| } |
| |
| |
| /* |
| * Allocate 'size'(rounded to BUF_SIZE) bytes in chunks of BUF_SIZE, and |
| * add it to the buf list. |
| * Returns the total size rounded to BUF_SIZE. |
| */ |
| static size_t |
| ksyms_buflist_alloc(ksyms_buflist_hdr_t *hdr, size_t size) |
| { |
| int chunks, i; |
| ksyms_buflist_t *list; |
| |
| chunks = howmany(size, BUF_SIZE); |
| |
| if (hdr->nchunks >= chunks) |
| return (hdr->nchunks * BUF_SIZE); |
| |
| /* |
| * Allocate chunks - hdr->nchunks buffers and add them to |
| * the list. |
| */ |
| for (i = chunks - hdr->nchunks; i > 0; i--) { |
| |
| if ((list = kmem_alloc(PAGESIZE, KM_NOSLEEP)) == NULL) |
| break; |
| |
| list_insert_tail(&hdr->blist, list); |
| } |
| |
| /* |
| * If we are running short of memory, free memory allocated till now |
| * and return. |
| */ |
| if (i > 0) { |
| ksyms_buflist_free(hdr); |
| return (0); |
| } |
| |
| hdr->nchunks = chunks; |
| hdr->cur = list_head(&hdr->blist); |
| hdr->curbuf_off = 0; |
| |
| return (chunks * BUF_SIZE); |
| } |
| |
| /* |
| * rlen is in multiples of PAGESIZE |
| */ |
| static char * |
| ksyms_asmap(struct as *as, size_t rlen) |
| { |
| char *addr = NULL; |
| |
| as_rangelock(as); |
| map_addr(&addr, rlen, 0, 1, 0); |
| if (addr == NULL || as_map(as, addr, rlen, segvn_create, zfod_argsp)) { |
| as_rangeunlock(as); |
| return (NULL); |
| } |
| as_rangeunlock(as); |
| return (addr); |
| } |
| |
| static char * |
| ksyms_mapin(ksyms_buflist_hdr_t *hdr, size_t size) |
| { |
| size_t sz, rlen = roundup(size, PAGESIZE); |
| struct as *as = curproc->p_as; |
| char *addr, *raddr; |
| ksyms_buflist_t *list = list_head(&hdr->blist); |
| |
| if ((addr = ksyms_asmap(as, rlen)) == NULL) |
| return (NULL); |
| |
| raddr = addr; |
| while (size > 0 && list != NULL) { |
| sz = MIN(size, BUF_SIZE); |
| |
| if (copyout(list->buf, raddr, sz)) { |
| (void) as_unmap(as, addr, rlen); |
| return (NULL); |
| } |
| list = list_next(&hdr->blist, list); |
| raddr += sz; |
| size -= sz; |
| } |
| return (addr); |
| } |
| |
| /* |
| * Copy a snapshot of the kernel symbol table into the user's address space. |
| * The symbol table is copied in fragments so that we do not have to |
| * do a large kmem_alloc() which could fail/block if the kernel memory is |
| * fragmented. |
| */ |
| /* ARGSUSED */ |
| static int |
| ksyms_open(dev_t *devp, int flag, int otyp, struct cred *cred) |
| { |
| minor_t clone; |
| size_t size = 0; |
| size_t realsize; |
| char *addr; |
| void *hptr = NULL; |
| ksyms_buflist_hdr_t hdr; |
| bzero(&hdr, sizeof (struct ksyms_buflist_hdr)); |
| list_create(&hdr.blist, PAGESIZE, |
| offsetof(ksyms_buflist_t, buflist_node)); |
| |
| if (getminor(*devp) != 0) |
| return (ENXIO); |
| |
| for (;;) { |
| realsize = ksyms_snapshot(ksyms_bcopy, hptr, size); |
| if (realsize <= size) |
| break; |
| size = realsize; |
| size = ksyms_buflist_alloc(&hdr, size); |
| if (size == 0) |
| return (ENOMEM); |
| hptr = (void *)&hdr; |
| } |
| |
| addr = ksyms_mapin(&hdr, realsize); |
| ksyms_buflist_free(&hdr); |
| if (addr == NULL) |
| return (EOVERFLOW); |
| |
| /* |
| * Reserve a clone entry. Note that we don't use clone 0 |
| * since that's the "real" minor number. |
| */ |
| for (clone = 1; clone < nksyms_clones; clone++) { |
| if (atomic_cas_ptr(&ksyms_clones[clone].ksyms_base, 0, addr) == |
| 0) { |
| ksyms_clones[clone].ksyms_size = realsize; |
| *devp = makedevice(getemajor(*devp), clone); |
| (void) ddi_prop_update_int(*devp, ksyms_devi, |
| "size", realsize); |
| modunload_disable(); |
| return (0); |
| } |
| } |
| cmn_err(CE_NOTE, "ksyms: too many open references"); |
| (void) as_unmap(curproc->p_as, addr, roundup(realsize, PAGESIZE)); |
| return (ENXIO); |
| } |
| |
| /* ARGSUSED */ |
| static int |
| ksyms_close(dev_t dev, int flag, int otyp, struct cred *cred) |
| { |
| minor_t clone = getminor(dev); |
| |
| (void) as_unmap(curproc->p_as, ksyms_clones[clone].ksyms_base, |
| roundup(ksyms_clones[clone].ksyms_size, PAGESIZE)); |
| ksyms_clones[clone].ksyms_base = 0; |
| modunload_enable(); |
| (void) ddi_prop_remove(dev, ksyms_devi, "size"); |
| return (0); |
| } |
| |
| static int |
| ksyms_symtbl_copy(ksyms_image_t *kip, struct uio *uio, size_t len) |
| { |
| char *buf; |
| int error = 0; |
| caddr_t base; |
| off_t off = uio->uio_offset; |
| size_t size; |
| |
| /* |
| * The symbol table is stored in the user address space, |
| * so we have to copy it into the kernel first, |
| * then copy it back out to the specified user address. |
| */ |
| buf = kmem_alloc(PAGESIZE, KM_SLEEP); |
| base = kip->ksyms_base + off; |
| while (len) { |
| size = MIN(PAGESIZE, len); |
| if (copyin(base, buf, size)) |
| error = EFAULT; |
| else |
| error = uiomove(buf, size, UIO_READ, uio); |
| |
| if (error) |
| break; |
| |
| len -= size; |
| base += size; |
| } |
| kmem_free(buf, PAGESIZE); |
| return (error); |
| } |
| |
| /* ARGSUSED */ |
| static int |
| ksyms_read(dev_t dev, struct uio *uio, struct cred *cred) |
| { |
| ksyms_image_t *kip = &ksyms_clones[getminor(dev)]; |
| off_t off = uio->uio_offset; |
| size_t len = uio->uio_resid; |
| |
| if (off < 0 || off > kip->ksyms_size) |
| return (EFAULT); |
| |
| if (len > kip->ksyms_size - off) |
| len = kip->ksyms_size - off; |
| |
| if (len == 0) |
| return (0); |
| |
| return (ksyms_symtbl_copy(kip, uio, len)); |
| } |
| |
| /* ARGSUSED */ |
| static int |
| ksyms_segmap(dev_t dev, off_t off, struct as *as, caddr_t *addrp, off_t len, |
| uint_t prot, uint_t maxprot, uint_t flags, struct cred *cred) |
| { |
| ksyms_image_t *kip = &ksyms_clones[getminor(dev)]; |
| int error = 0; |
| char *addr = NULL; |
| size_t rlen = 0; |
| struct iovec aiov; |
| struct uio auio; |
| |
| if (flags & MAP_FIXED) |
| return (ENOTSUP); |
| |
| if (off < 0 || len <= 0 || off > kip->ksyms_size || |
| len > kip->ksyms_size - off) |
| return (EINVAL); |
| |
| rlen = roundup(len, PAGESIZE); |
| if ((addr = ksyms_asmap(as, rlen)) == NULL) |
| return (EOVERFLOW); |
| |
| aiov.iov_base = addr; |
| aiov.iov_len = len; |
| auio.uio_offset = off; |
| auio.uio_iov = &aiov; |
| auio.uio_iovcnt = 1; |
| auio.uio_resid = len; |
| auio.uio_segflg = UIO_USERSPACE; |
| auio.uio_llimit = MAXOFFSET_T; |
| auio.uio_fmode = FREAD; |
| auio.uio_extflg = UIO_COPY_CACHED; |
| |
| error = ksyms_symtbl_copy(kip, &auio, len); |
| |
| if (error) |
| (void) as_unmap(as, addr, rlen); |
| else |
| *addrp = addr; |
| return (error); |
| } |
| |
| /* ARGSUSED */ |
| static int |
| ksyms_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) |
| { |
| switch (infocmd) { |
| case DDI_INFO_DEVT2DEVINFO: |
| *result = ksyms_devi; |
| return (DDI_SUCCESS); |
| case DDI_INFO_DEVT2INSTANCE: |
| *result = 0; |
| return (DDI_SUCCESS); |
| } |
| return (DDI_FAILURE); |
| } |
| |
| static int |
| ksyms_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) |
| { |
| if (cmd != DDI_ATTACH) |
| return (DDI_FAILURE); |
| if (ddi_create_minor_node(devi, "ksyms", S_IFCHR, 0, DDI_PSEUDO, NULL) |
| == DDI_FAILURE) { |
| ddi_remove_minor_node(devi, NULL); |
| return (DDI_FAILURE); |
| } |
| ksyms_devi = devi; |
| return (DDI_SUCCESS); |
| } |
| |
| static int |
| ksyms_detach(dev_info_t *devi, ddi_detach_cmd_t cmd) |
| { |
| if (cmd != DDI_DETACH) |
| return (DDI_FAILURE); |
| ddi_remove_minor_node(devi, NULL); |
| return (DDI_SUCCESS); |
| } |
| |
| static struct cb_ops ksyms_cb_ops = { |
| ksyms_open, /* open */ |
| ksyms_close, /* close */ |
| nodev, /* strategy */ |
| nodev, /* print */ |
| nodev, /* dump */ |
| ksyms_read, /* read */ |
| nodev, /* write */ |
| nodev, /* ioctl */ |
| nodev, /* devmap */ |
| nodev, /* mmap */ |
| ksyms_segmap, /* segmap */ |
| nochpoll, /* poll */ |
| ddi_prop_op, /* prop_op */ |
| 0, /* streamtab */ |
| D_NEW | D_MP /* Driver compatibility flag */ |
| }; |
| |
| static struct dev_ops ksyms_ops = { |
| DEVO_REV, /* devo_rev, */ |
| 0, /* refcnt */ |
| ksyms_info, /* info */ |
| nulldev, /* identify */ |
| nulldev, /* probe */ |
| ksyms_attach, /* attach */ |
| ksyms_detach, /* detach */ |
| nodev, /* reset */ |
| &ksyms_cb_ops, /* driver operations */ |
| (struct bus_ops *)0, /* no bus operations */ |
| NULL, /* power */ |
| ddi_quiesce_not_needed, /* quiesce */ |
| }; |
| |
| static struct modldrv modldrv = { |
| &mod_driverops, "kernel symbols driver", &ksyms_ops, |
| }; |
| |
| static struct modlinkage modlinkage = { |
| MODREV_1, { (void *)&modldrv } |
| }; |
| |
| int |
| _init(void) |
| { |
| int error; |
| |
| if (nksyms_clones == 0) |
| nksyms_clones = maxusers + 50; |
| |
| ksyms_clones = kmem_zalloc(nksyms_clones * |
| sizeof (ksyms_image_t), KM_SLEEP); |
| |
| if ((error = mod_install(&modlinkage)) != 0) |
| kmem_free(ksyms_clones, nksyms_clones * sizeof (ksyms_image_t)); |
| |
| return (error); |
| } |
| |
| int |
| _fini(void) |
| { |
| int error; |
| |
| if ((error = mod_remove(&modlinkage)) == 0) |
| kmem_free(ksyms_clones, nksyms_clones * sizeof (ksyms_image_t)); |
| return (error); |
| } |
| |
| int |
| _info(struct modinfo *modinfop) |
| { |
| return (mod_info(&modlinkage, modinfop)); |
| } |