kloader.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: kloader.c,v 1.11 2006/07/21 16:48:47 ad Exp $  */
    2 
    3 /*-
    4  * Copyright (c) 2001, 2002, 2004 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *        This product includes software developed by the NetBSD
   18  *        Foundation, Inc. and its contributors.
   19  * 4. Neither the name of The NetBSD Foundation nor the names of its
   20  *    contributors may be used to endorse or promote products derived
   21  *    from this software without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   25  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   26  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   27  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   33  * POSSIBILITY OF SUCH DAMAGE.
   34  */
   35 
   36 #include <sys/cdefs.h>
   37 __KERNEL_RCSID(0, "$NetBSD: kloader.c,v 1.11 2006/07/21 16:48:47 ad Exp $");
   38 
   39 #include "debug_kloader.h"
   40 
   41 #include <sys/param.h>
   42 #include <sys/systm.h>
   43 #include <sys/malloc.h>
   44 #include <sys/proc.h>
   45 #include <sys/vnode.h>
   46 #include <sys/namei.h>
   47 #include <sys/fcntl.h>
   48 #define ELFSIZE 32
   49 #include <sys/exec_elf.h>
   50 
   51 #include <uvm/uvm_extern.h>
   52 
   53 #include <machine/kloader.h>
   54 
   55 #define PRINTF(fmt, args...)    printf("kloader: " fmt, ##args)
   56 
   57 #ifdef KLOADER_DEBUG
   58 int     kloader_debug = 1;
   59 #define DPRINTF(fmt, args...)                                           \
   60         if (kloader_debug)                                              \
   61                 printf("%s: " fmt, __FUNCTION__ , ##args)
   62 #define _DPRINTF(fmt, args...)                                          \
   63         if (kloader_debug)                                              \
   64                 printf(fmt, ##args)
   65 #define DPRINTFN(n, fmt, args...)                                       \
   66         if (kloader_debug > (n))                                        \
   67                 printf("%s: " fmt, __FUNCTION__ , ##args)
   68 #define _DPRINTFN(n, fmt, args...)                                      \
   69         if (kloader_debug > (n))                                        \
   70                 printf(fmt, ##args)
   71 #define STATIC
   72 #else
   73 #define DPRINTF(fmt, args...)           ((void)0)
   74 #define _DPRINTF(fmt, args...)          ((void)0)
   75 #define DPRINTFN(n, fmt, args...)       ((void)0)
   76 #define _DPRINTFN(n, fmt, args...)      ((void)0)
   77 #define STATIC  static
   78 #endif
   79 
   80 struct kloader {
   81         struct pglist pg_head;
   82         struct vm_page *cur_pg;
   83         struct kloader_page_tag *cur_tag;
   84         struct vnode *vp;
   85         struct kloader_page_tag *tagstart;
   86         struct kloader_bootinfo *bootinfo;
   87         struct kloader_bootinfo *rebootinfo;
   88         vaddr_t loader_sp;
   89         kloader_bootfunc_t *loader;
   90         int setuped;
   91         int called;
   92         struct kloader_ops *ops;
   93 };
   94 
   95 #define BUCKET_SIZE     (PAGE_SIZE - sizeof(struct kloader_page_tag))
   96 #define KLOADER_LWP     (&lwp0)
   97 STATIC struct kloader kloader;
   98 
   99 #define ROUND4(x)       (((x) + 3) & ~3)
  100 
  101 STATIC int kloader_load(void);
  102 
  103 STATIC int kloader_alloc_memory(size_t);
  104 STATIC struct kloader_page_tag *kloader_get_tag(vaddr_t);
  105 STATIC void kloader_from_file(vaddr_t, off_t, size_t);
  106 STATIC void kloader_copy(vaddr_t, const void *, size_t);
  107 STATIC void kloader_zero(vaddr_t, size_t);
  108 
  109 STATIC void kloader_load_segment(Elf_Phdr *);
  110 
  111 STATIC struct vnode *kloader_open(const char *);
  112 STATIC void kloader_close(void);
  113 STATIC int kloader_read(size_t, size_t, void *);
  114 
  115 #ifdef KLOADER_DEBUG
  116 STATIC void kloader_pagetag_dump(void);
  117 #endif
  118 
  119 void
  120 __kloader_reboot_setup(struct kloader_ops *ops, const char *filename)
  121 {
  122 
  123         if (kloader.bootinfo == NULL) {
  124                 PRINTF("No bootinfo.\n");
  125                 return;
  126         }
  127 
  128         if (ops == NULL || ops->jump == NULL || ops->boot == NULL) {
  129                 PRINTF("No boot operations.\n");
  130                 return;
  131         }
  132         kloader.ops = ops;
  133 
  134         if (kloader.called++ == 0) {
  135                 PRINTF("kernel file name: %s\n", filename);
  136                 kloader.vp = kloader_open(filename);
  137                 if (kloader.vp == NULL)
  138                         return;
  139 
  140                 if (kloader_load() == 0) {
  141                         kloader.setuped = TRUE;
  142 #ifdef KLOADER_DEBUG
  143                         kloader_pagetag_dump();
  144 #endif
  145                 }
  146                 kloader_close();
  147         } else {
  148                 /* Fatal case. reboot from DDB etc. */
  149                 kloader_reboot();
  150         }
  151 }
  152 
  153 
  154 void
  155 kloader_reboot()
  156 {
  157 
  158         if (kloader.setuped) {
  159                 PRINTF("Rebooting...\n");
  160                 (*kloader.ops->jump)(kloader.loader, kloader.loader_sp,
  161                     kloader.rebootinfo, kloader.tagstart);
  162         }
  163 
  164         if (kloader.ops->reset != NULL) {
  165                 PRINTF("Resetting...\n");
  166                 (*kloader.ops->reset)();
  167         }
  168         while (/*CONSTCOND*/1)
  169                 ;
  170         /* NOTREACHED */
  171 }
  172 
  173 
  174 int
  175 kloader_load()
  176 {
  177         Elf_Ehdr eh;
  178         Elf_Phdr *ph, *p;
  179         Elf_Shdr *sh;
  180         Elf_Addr entry;
  181         vaddr_t kv;
  182         size_t sz;
  183         size_t shstrsz;
  184         char *shstrtab;
  185         int symndx, strndx;
  186         size_t ksymsz;
  187         struct kloader_bootinfo nbi; /* new boot info */
  188         char *oldbuf, *newbuf;
  189         char **ap;
  190         int i;
  191 
  192         ph = NULL;
  193         sh = NULL;
  194         shstrtab = NULL;
  195 
  196         /* read kernel's ELF header */
  197         kloader_read(0, sizeof(Elf_Ehdr), &eh);
  198 
  199         if (eh.e_ident[EI_MAG0] != ELFMAG0 ||
  200             eh.e_ident[EI_MAG1] != ELFMAG1 ||
  201             eh.e_ident[EI_MAG2] != ELFMAG2 ||
  202             eh.e_ident[EI_MAG3] != ELFMAG3) {
  203                 PRINTF("not an ELF file\n");
  204                 goto err;
  205         }
  206 
  207         /* read program headers */
  208         sz = eh.e_phentsize * eh.e_phnum;
  209         if ((ph = malloc(sz, M_TEMP, M_NOWAIT)) == NULL) {
  210                 PRINTF("can't allocate program header table.\n");
  211                 goto err;
  212         }
  213         if (kloader_read(eh.e_phoff, sz, ph) != 0) {
  214                 PRINTF("program header read error.\n");
  215                 goto err;
  216         }
  217 
  218         /* read section headers */
  219         sz = eh.e_shentsize * eh.e_shnum;
  220         if ((sh = malloc(sz, M_TEMP, M_NOWAIT)) == NULL) {
  221                 PRINTF("can't allocate section header table.\n");
  222                 goto err;
  223         }
  224         if (kloader_read(eh.e_shoff, eh.e_shentsize * eh.e_shnum, sh) != 0) {
  225                 PRINTF("section header read error.\n");
  226                 goto err;
  227         }
  228 
  229         /* read section names */
  230         shstrsz = ROUND4(sh[eh.e_shstrndx].sh_size);
  231         shstrtab = malloc(shstrsz, M_TEMP, M_NOWAIT);
  232         if (shstrtab == NULL) {
  233                 PRINTF("unable to allocate memory for .shstrtab\n");
  234                 goto err;
  235         }
  236         DPRINTF("reading 0x%x bytes of .shstrtab at 0x%x\n",
  237                 sh[eh.e_shstrndx].sh_size, sh[eh.e_shstrndx].sh_offset);
  238         kloader_read(sh[eh.e_shstrndx].sh_offset, sh[eh.e_shstrndx].sh_size,
  239                      shstrtab);
  240 
  241         /* save entry point, code to construct symbol table overwrites it */
  242         entry = eh.e_entry;
  243 
  244 
  245         /*
  246          * Calculate memory size
  247          */
  248         sz = 0;
  249 
  250         /* loadable segments */
  251         for (i = 0; i < eh.e_phnum; i++) {
  252                 if (ph[i].p_type == PT_LOAD) {
  253                         DPRINTF("segment %d size = file 0x%x memory 0x%x\n",
  254                                 i, ph[i].p_filesz, ph[i].p_memsz);
  255 #ifdef KLOADER_ZERO_BSS
  256                         sz += round_page(ph[i].p_memsz);
  257 #else
  258                         sz += round_page(ph[i].p_filesz);
  259 #endif
  260                         sz += PAGE_SIZE; /* compensate for partial last tag */
  261                 }
  262         }
  263 
  264         if (sz == 0)            /* nothing to load? */
  265                 goto err;
  266 
  267         /* symbols/strings sections */
  268         symndx = strndx = -1;
  269         for (i = 0; i < eh.e_shnum; i++) {
  270             if (strcmp(shstrtab + sh[i].sh_name, ".symtab") == 0)
  271                     symndx = i;
  272             else if (strcmp(shstrtab + sh[i].sh_name, ".strtab") == 0)
  273                     strndx = i;
  274             else if (i != eh.e_shstrndx)
  275                     /* while here, mark all other sections as unused */
  276                     sh[i].sh_type = SHT_NULL;
  277         }
  278 
  279         if (symndx < 0 || strndx < 0) {
  280                 if (symndx < 0)
  281                         PRINTF("no .symtab section\n");
  282                 if (strndx < 0)
  283                         PRINTF("no .strtab section\n");
  284                 ksymsz = SELFMAG; /* just a bad magic */
  285         } else {
  286                 ksymsz = sizeof(Elf_Ehdr)
  287                         + eh.e_shentsize * eh.e_shnum
  288                         + shstrsz               /* rounded to 4 bytes */
  289                         + sh[symndx].sh_size
  290                         + sh[strndx].sh_size;
  291                 DPRINTF("ksyms size = 0x%zx\n", ksymsz);
  292         }
  293         sz += ROUND4(ksymsz);
  294 
  295         /* boot info for the new kernel */
  296         sz += sizeof(struct kloader_bootinfo);
  297 
  298         /* get memory for new kernel */
  299         if (kloader_alloc_memory(sz) != 0)
  300                 goto err;
  301 
  302 
  303         /*
  304          * Copy new kernel in.
  305          */
  306         kv = 0;                 /* XXX: -Wuninitialized */
  307         for (i = 0, p = ph; i < eh.e_phnum; i++, p++) {
  308                 if (p->p_type == PT_LOAD) {
  309                         kloader_load_segment(p);
  310                         kv = p->p_vaddr + ROUND4(p->p_memsz);
  311                 }
  312         }
  313 
  314 
  315         /*
  316          * Construct symbol table for ksyms.
  317          */
  318         if (symndx < 0 || strndx < 0) {
  319                 kloader_zero(kv, SELFMAG);
  320                 kv += SELFMAG;
  321         } else {
  322                 Elf_Off eoff;
  323                 off_t symoff, stroff;
  324 
  325                 /* save offsets of .symtab and .strtab before we change them */
  326                 symoff = sh[symndx].sh_offset;
  327                 stroff = sh[strndx].sh_offset;
  328 
  329                 /* no loadable segments */
  330                 eh.e_entry = 0;
  331                 eh.e_phnum = 0;
  332                 eh.e_phoff = 0;
  333 
  334                 /* change offsets to reflect new layout */
  335                 eoff = sizeof(Elf_Ehdr);
  336                 eh.e_shoff = eoff;
  337 
  338                 eoff += eh.e_shentsize * eh.e_shnum;
  339                 sh[eh.e_shstrndx].sh_offset = eoff;
  340 
  341                 eoff += shstrsz;
  342                 sh[symndx].sh_offset = eoff;
  343 
  344                 eoff += sh[symndx].sh_size;
  345                 sh[strndx].sh_offset = eoff;
  346 
  347                 /* local copies massaged, can serve them now */
  348                 DPRINTF("ksyms ELF header\n");
  349                 kloader_copy(kv, &eh, sizeof(Elf_Ehdr));
  350                 kv += sizeof(Elf_Ehdr);
  351 
  352                 DPRINTF("ksyms section headers\n");
  353                 kloader_copy(kv, sh, eh.e_shentsize * eh.e_shnum);
  354                 kv += eh.e_shentsize * eh.e_shnum;
  355 
  356                 DPRINTF("ksyms .shstrtab\n");
  357                 kloader_copy(kv, shstrtab, shstrsz);
  358                 kv += shstrsz;
  359 
  360                 DPRINTF("ksyms .symtab\n");
  361                 kloader_from_file(kv, symoff, sh[symndx].sh_size);
  362                 kv += sh[symndx].sh_size;
  363 
  364                 DPRINTF("ksyms .strtab\n");
  365                 kloader_from_file(kv, stroff, ROUND4(sh[strndx].sh_size));
  366                 kv += ROUND4(sh[strndx].sh_size);
  367         }
  368 
  369         /*
  370          * Create boot info to pass to the new kernel.
  371          * All pointers in it are *not* valid until the new kernel runs!
  372          */
  373 
  374         /* get a private copy of current bootinfo to vivisect */
  375         memcpy(&nbi, kloader.bootinfo,
  376                sizeof(struct kloader_bootinfo));
  377 
  378         /* new kernel entry point */
  379         nbi.entry = entry;
  380 
  381         /* where args currently are, see kloader_bootinfo_set() */
  382         oldbuf = &kloader.bootinfo->_argbuf[0];
  383 
  384         /* where args *will* be after boot code copied them */
  385         newbuf = (char *)(void *)kv
  386                 + offsetof(struct kloader_bootinfo, _argbuf);
  387 
  388         DPRINTF("argv: old %p -> new %p\n", oldbuf, newbuf);
  389 
  390         /* not a valid pointer in this kernel! */
  391         nbi.argv = (void *)newbuf;
  392 
  393         /* local copy that we populate with new (not yet valid) pointers */
  394         ap = (char **)(void *)nbi._argbuf;
  395 
  396         for (i = 0; i < kloader.bootinfo->argc; ++i) {
  397                 DPRINTFN(1, " [%d]: %p -> ", i, kloader.bootinfo->argv[i]);
  398                 ap[i] = newbuf +
  399                         (kloader.bootinfo->argv[i] - oldbuf);
  400                 _DPRINTFN(1, "%p\n", ap[i]);
  401         }
  402 
  403         /* arrange for the new bootinfo to get copied */
  404         DPRINTF("bootinfo\n");
  405         kloader_copy(kv, &nbi, sizeof(struct kloader_bootinfo));
  406 
  407         /* will be valid by the time the new kernel starts */
  408         kloader.rebootinfo = (void *)kv;
  409         /* kv += sizeof(struct kloader_bootinfo); */
  410 
  411         /*
  412          * Copy loader code
  413          */
  414         KDASSERT(kloader.cur_pg);
  415         kloader.loader = (void *)PG_VADDR(kloader.cur_pg);
  416         memcpy(kloader.loader, kloader.ops->boot, PAGE_SIZE);
  417 
  418         /* loader stack starts at the bottom of that page */
  419         kloader.loader_sp = (vaddr_t)kloader.loader + PAGE_SIZE;
  420 
  421         DPRINTF("[loader] addr=%p sp=%p [kernel] entry=%p\n",
  422                 kloader.loader, (void *)kloader.loader_sp, (void *)nbi.entry);
  423 
  424         return (0);
  425  err:
  426         if (ph != NULL)
  427                 free(ph, M_TEMP);
  428         if (sh != NULL)
  429                 free(sh, M_TEMP);
  430         if (shstrtab != NULL)
  431                 free(shstrtab, M_TEMP);
  432 
  433         return 1;
  434 }
  435 
  436 
  437 int
  438 kloader_alloc_memory(size_t sz)
  439 {
  440         extern paddr_t avail_start, avail_end;
  441         int n, error;
  442 
  443         n = (sz + BUCKET_SIZE - 1) / BUCKET_SIZE        /* kernel &co */
  444             + 1;                                        /* 2nd loader */
  445 
  446         error = uvm_pglistalloc(n * PAGE_SIZE, avail_start, avail_end,
  447                                 PAGE_SIZE, 0, &kloader.pg_head, n, 0);
  448         if (error) {
  449                 PRINTF("can't allocate memory.\n");
  450                 return (1);
  451         }
  452         DPRINTF("allocated %d pages.\n", n);
  453 
  454         kloader.cur_pg = TAILQ_FIRST(&kloader.pg_head);
  455         kloader.tagstart = (void *)PG_VADDR(kloader.cur_pg);
  456         kloader.cur_tag = NULL;
  457 
  458         return (0);
  459 }
  460 
  461 
  462 struct kloader_page_tag *
  463 kloader_get_tag(vaddr_t dst)
  464 {
  465         struct vm_page *pg;
  466         vaddr_t addr;
  467         struct kloader_page_tag *tag;
  468 
  469         tag = kloader.cur_tag;
  470         if (tag != NULL         /* has tag */
  471             && tag->sz < BUCKET_SIZE /* that has free space */
  472             && tag->dst + tag->sz == dst) /* and new data are contiguous */
  473         {
  474                 DPRINTFN(1, "current tag %x/%x ok\n", tag->dst, tag->sz);
  475                 return (tag);
  476         }
  477 
  478         pg = kloader.cur_pg;
  479         KDASSERT(pg != NULL);
  480         kloader.cur_pg = TAILQ_NEXT(pg, pageq);
  481 
  482         addr = PG_VADDR(pg);
  483         tag = (void *)addr;
  484 
  485         /*
  486          * 2nd loader uses simple word-by-word copy, so destination
  487          * address of a tag must be properly aligned.
  488          */
  489         KASSERT(ALIGNED_POINTER(dst, register_t));
  490 
  491         tag->src = addr + sizeof(struct kloader_page_tag);
  492         tag->dst = dst;
  493         tag->sz = 0;
  494         tag->next = 0;  /* Terminate. this member may overwrite after. */
  495         if (kloader.cur_tag)
  496                 kloader.cur_tag->next = addr;
  497         kloader.cur_tag = tag;
  498 
  499         return (tag);
  500 }
  501 
  502 
  503 /*
  504  * Operations to populate kloader_page_tag's with data.
  505  */
  506 
  507 void
  508 kloader_from_file(vaddr_t dst, off_t ofs, size_t sz)
  509 {
  510         struct kloader_page_tag *tag;
  511         size_t freesz;
  512 
  513         while (sz > 0) {
  514                 tag = kloader_get_tag(dst);
  515                 KDASSERT(tag != NULL);
  516                 freesz = BUCKET_SIZE - tag->sz;
  517                 if (freesz > sz)
  518                         freesz = sz;
  519 
  520                 DPRINTFN(1, "0x%08lx + 0x%zx <- 0x%lx\n", dst, freesz,
  521                     (unsigned long)ofs);
  522                 kloader_read(ofs, freesz, (void *)(tag->src + tag->sz));
  523 
  524                 tag->sz += freesz;
  525                 sz -= freesz;
  526                 ofs += freesz;
  527                 dst += freesz;
  528         }
  529 }
  530 
  531 
  532 void
  533 kloader_copy(vaddr_t dst, const void *src, size_t sz)
  534 {
  535         struct kloader_page_tag *tag;
  536         size_t freesz;
  537 
  538         while (sz > 0) {
  539                 tag = kloader_get_tag(dst);
  540                 KDASSERT(tag != NULL);
  541                 freesz = BUCKET_SIZE - tag->sz;
  542                 if (freesz > sz)
  543                         freesz = sz;
  544 
  545                 DPRINTFN(1, "0x%08lx + 0x%zx <- %p\n", dst, freesz, src);
  546                 memcpy((void *)(tag->src + tag->sz), src, freesz);
  547 
  548                 tag->sz += freesz;
  549                 sz -= freesz;
  550                 src = (const char *)src + freesz;
  551                 dst += freesz;
  552         }
  553 }
  554 
  555 
  556 void
  557 kloader_zero(vaddr_t dst, size_t sz)
  558 {
  559         struct kloader_page_tag *tag;
  560         size_t freesz;
  561 
  562         while (sz > 0) {
  563                 tag = kloader_get_tag(dst);
  564                 KDASSERT(tag != NULL);
  565                 freesz = BUCKET_SIZE - tag->sz;
  566                 if (freesz > sz)
  567                         freesz = sz;
  568 
  569                 DPRINTFN(1, "0x%08lx + 0x%zx\n", dst, freesz);
  570                 memset((void *)(tag->src + tag->sz), 0, freesz);
  571 
  572                 tag->sz += freesz;
  573                 sz -= freesz;
  574                 dst += freesz;
  575         }
  576 }
  577 
  578 
  579 void
  580 kloader_load_segment(Elf_Phdr *p)
  581 {
  582 
  583         DPRINTF("memory 0x%08x 0x%x <- file 0x%x 0x%x\n",
  584                 p->p_vaddr, p->p_memsz, p->p_offset, p->p_filesz);
  585 
  586         kloader_from_file(p->p_vaddr, p->p_offset, p->p_filesz);
  587 #ifdef KLOADER_ZERO_BSS
  588         kloader_zero(p->p_vaddr + p->p_filesz, p->p_memsz - p->p_filesz);
  589 #endif
  590 }
  591 
  592 
  593 /*
  594  * file access
  595  */
  596 struct vnode *
  597 kloader_open(const char *filename)
  598 {
  599         struct lwp *l = KLOADER_LWP;
  600         struct nameidata nid;
  601         int error;
  602 
  603         NDINIT(&nid, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, l);
  604 
  605         error = namei(&nid);
  606         if (error != 0) {
  607                 PRINTF("%s: namei failed, errno=%d\n", filename, error);
  608                 return (NULL);
  609         }
  610 
  611         error = vn_open(&nid, FREAD, 0);
  612         if (error != 0) {
  613                 PRINTF("%s: open failed, errno=%d\n", filename, error);
  614                 return (NULL);
  615         }
  616 
  617         return (nid.ni_vp);
  618 }
  619 
  620 void
  621 kloader_close()
  622 {
  623         struct lwp *l = KLOADER_LWP;
  624         struct vnode *vp = kloader.vp;
  625 
  626         VOP_UNLOCK(vp, 0);
  627         vn_close(vp, FREAD, l->l_cred, l);
  628 }
  629 
  630 int
  631 kloader_read(size_t ofs, size_t size, void *buf)
  632 {
  633         struct lwp *l = KLOADER_LWP;
  634         struct vnode *vp = kloader.vp;
  635         size_t resid;
  636         int error;
  637 
  638         error = vn_rdwr(UIO_READ, vp, buf, size, ofs, UIO_SYSSPACE,
  639             IO_NODELOCKED | IO_SYNC, l->l_cred, &resid, NULL);
  640 
  641         if (error)
  642                 PRINTF("read error.\n");
  643 
  644         return (error);
  645 }
  646 
  647 
  648 /*
  649  * bootinfo
  650  */
  651 void
  652 kloader_bootinfo_set(struct kloader_bootinfo *kbi, int argc, char *argv[],
  653     struct bootinfo *bi, int printok)
  654 {
  655         char *p, *pend, *buf;
  656         int i;
  657 
  658         kloader.bootinfo = kbi;
  659         buf = kbi->_argbuf;
  660         if (bi != NULL)
  661                 memcpy(&kbi->bootinfo, bi, sizeof(struct bootinfo));
  662         kbi->argc = argc;
  663         kbi->argv = (char **)buf;
  664 
  665         p = &buf[argc * sizeof(char **)];
  666         pend = &buf[KLOADER_KERNELARGS_MAX - 1];
  667 
  668         for (i = 0; i < argc; i++) {
  669                 char *q = argv[i];
  670                 int len = strlen(q) + 1;
  671                 if ((p + len) > pend) {
  672                         kloader.bootinfo = NULL;
  673                         if (printok)
  674                                 PRINTF("buffer insufficient.\n");
  675                         return;
  676                 }
  677                 kbi->argv[i] = p;
  678                 memcpy(p, q, len);
  679                 p += len;
  680         }
  681 }
  682 
  683 
  684 #ifdef KLOADER_DEBUG
  685 void
  686 kloader_pagetag_dump()
  687 {
  688         struct kloader_page_tag *tag = kloader.tagstart;
  689         struct kloader_page_tag *p, *op;
  690         boolean_t print;
  691         int i, n;
  692 
  693         p = tag;
  694         op = NULL;
  695         i = 0, n = 15;
  696 
  697         PRINTF("[page tag chain]\n");
  698         do  {
  699                 print = FALSE;
  700                 if (i < n)
  701                         print = TRUE;
  702                 if ((uint32_t)p & 3) {
  703                         printf("tag alignment error\n");
  704                         break;
  705                 }
  706                 if ((p->src & 3) || (p->dst & 3)) {
  707                         printf("data alignement error.\n");
  708                         print = TRUE;
  709                 }
  710 
  711                 if (print) {
  712                         printf("[%2d] next 0x%08x src 0x%08x dst 0x%08x"
  713                             " sz 0x%x\n", i, p->next, p->src, p->dst, p->sz);
  714                 } else if (i == n) {
  715                         printf("[...]\n");
  716                 }
  717                 op = p;
  718                 i++;
  719         } while ((p = (struct kloader_page_tag *)(p->next)) != 0);
  720 
  721         if (op != NULL)
  722                 printf("[%d(last)] next 0x%08x src 0x%08x dst 0x%08x sz 0x%x\n",
  723                     i - 1, op->next, op->src, op->dst, op->sz);
  724 }
  725 
  726 #endif /* KLOADER_DEBUG */
Cache object: 0684c882918f406a34b3e7f91e6a2cb1
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/kloader.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/kloader.c
