FreeBSD/Linux Kernel Cross Reference
sys/cddl/contrib/opensolaris/uts/common/ctf/ctf_mod.c

     /*
      * CDDL HEADER START
      *
      * The contents of this file are subject to the terms of the
      * Common Development and Distribution License, Version 1.0 only
      * (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 2003 Sun Microsystems, Inc.  All rights reserved.
     * Use is subject to license terms.
     */
    
    #pragma ident   "%Z%%M% %I%     %E% SMI"
    
    #include <sys/sysmacros.h>
    #include <sys/modctl.h>
    #include <sys/debug.h>
    #include <sys/mman.h>
    #include <sys/modctl.h>
    #include <sys/kobj.h>
    #include <ctf_impl.h>
    
    int ctf_leave_compressed = 0;
    
    static struct modlmisc modlmisc = {
            &mod_miscops, "Compact C Type Format routines"
    };
    
    static struct modlinkage modlinkage = {
            MODREV_1, &modlmisc, NULL
    };
    
    int
    _init(void)
    {
            return (mod_install(&modlinkage));
    }
    
    int
    _info(struct modinfo *mip)
    {
            return (mod_info(&modlinkage, mip));
    }
    
    int
    _fini(void)
    {
            return (mod_remove(&modlinkage));
    }
    
    /*ARGSUSED*/
    void *
    ctf_zopen(int *errp)
    {
            return ((void *)1); /* zmod is always loaded because we depend on it */
    }
    
    /*ARGSUSED*/
    const void *
    ctf_sect_mmap(ctf_sect_t *sp, int fd)
    {
            return (MAP_FAILED); /* we don't support this in the kernel */
    }
    
    /*ARGSUSED*/
    void
    ctf_sect_munmap(const ctf_sect_t *sp)
    {
            /* we don't support this in the kernel */
    }
    
    /*ARGSUSED*/
    ctf_file_t *
    ctf_fdopen(int fd, int *errp)
    {
            return (ctf_set_open_errno(errp, ENOTSUP));
    }
    
    /*ARGSUSED*/
    ctf_file_t *
    ctf_open(const char *filename, int *errp)
    {
            return (ctf_set_open_errno(errp, ENOTSUP));
    }
    
   /*ARGSUSED*/
   int
   ctf_write(ctf_file_t *fp, int fd)
   {
           return (ctf_set_errno(fp, ENOTSUP));
   }
   
   int
   ctf_version(int version)
   {
           ASSERT(version > 0 && version <= CTF_VERSION);
   
           if (version > 0)
                   _libctf_version = MIN(CTF_VERSION, version);
   
           return (_libctf_version);
   }
   
   /*ARGSUSED*/
   ctf_file_t *
   ctf_modopen(struct module *mp, int *error)
   {
           ctf_sect_t ctfsect, symsect, strsect;
           ctf_file_t *fp = NULL;
           int err;
   
           if (error == NULL)
                   error = &err;
   
           ctfsect.cts_name = ".SUNW_ctf";
           ctfsect.cts_type = SHT_PROGBITS;
           ctfsect.cts_flags = SHF_ALLOC;
           ctfsect.cts_data = mp->ctfdata;
           ctfsect.cts_size = mp->ctfsize;
           ctfsect.cts_entsize = 1;
           ctfsect.cts_offset = 0;
   
           symsect.cts_name = ".symtab";
           symsect.cts_type = SHT_SYMTAB;
           symsect.cts_flags = 0;
           symsect.cts_data = mp->symtbl;
           symsect.cts_size = mp->symhdr->sh_size;
   #ifdef _LP64
           symsect.cts_entsize = sizeof (Elf64_Sym);
   #else
           symsect.cts_entsize = sizeof (Elf32_Sym);
   #endif
           symsect.cts_offset = 0;
   
           strsect.cts_name = ".strtab";
           strsect.cts_type = SHT_STRTAB;
           strsect.cts_flags = 0;
           strsect.cts_data = mp->strings;
           strsect.cts_size = mp->strhdr->sh_size;
           strsect.cts_entsize = 1;
           strsect.cts_offset = 0;
   
           ASSERT(MUTEX_HELD(&mod_lock));
   
           if ((fp = ctf_bufopen(&ctfsect, &symsect, &strsect, error)) == NULL)
                   return (NULL);
   
           if (!ctf_leave_compressed && (caddr_t)fp->ctf_base != mp->ctfdata) {
                   /*
                    * We must have just uncompressed the CTF data.  To avoid
                    * others having to pay the (substantial) cost of decompressing
                    * the data, we're going to substitute the uncompressed version
                    * for the compressed version.  Note that this implies that the
                    * first CTF consumer will induce memory impact on the system
                    * (but in the name of performance of future CTF consumers).
                    */
                   kobj_set_ctf(mp, (caddr_t)fp->ctf_base, fp->ctf_size);
                   fp->ctf_data.cts_data = fp->ctf_base;
                   fp->ctf_data.cts_size = fp->ctf_size;
           }
   
           return (fp);
   }

Cache object: d9d3a7212444b8cbb115aaaf29553fe1