12399 kobj printf functions should be checked

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright 2020 Joyent, Inc.
  27  */
  28 
  29 /*
  30  * x86 relocation code.
  31  */
  32 
  33 #include <sys/types.h>
  34 #include <sys/param.h>
  35 #include <sys/sysmacros.h>
  36 #include <sys/systm.h>
  37 #include <sys/user.h>
  38 #include <sys/bootconf.h>
  39 #include <sys/modctl.h>
  40 #include <sys/elf.h>
  41 #include <sys/kobj.h>
  42 #include <sys/kobj_impl.h>
  43 #include <sys/tnf.h>
  44 #include <sys/tnf_probe.h>
  45 
  46 #include "reloc.h"
  47 
  48 
  49 /*
  50  * Probe Discovery
  51  */
  52 
  53 #define PROBE_MARKER_SYMBOL     "__tnf_probe_version_1"
  54 #define TAG_MARKER_SYMBOL       "__tnf_tag_version_1"
  55 
  56 extern int tnf_splice_probes(int, tnf_probe_control_t *, tnf_tag_data_t *);
  57 
  58 /*
  59  * The kernel run-time linker calls this to try to resolve a reference
  60  * it can't otherwise resolve.  We see if it's marking a probe control
  61  * block; if so, we do the resolution and return 0.  If not, we return
  62  * 1 to show that we can't resolve it, either.
  63  */
  64 static int
  65 tnf_reloc_resolve(char *symname, Addr *value_p,
  66     Elf64_Sxword *addend_p,
  67     long offset,
  68     tnf_probe_control_t **probelist,
  69     tnf_tag_data_t **taglist)
  70 {
  71         if (strcmp(symname, PROBE_MARKER_SYMBOL) == 0) {
  72                 *addend_p = 0;
  73                 ((tnf_probe_control_t *)offset)->next = *probelist;
  74                 *probelist = (tnf_probe_control_t *)offset;
  75                 return (0);
  76         }
  77         if (strcmp(symname, TAG_MARKER_SYMBOL) == 0) {
  78                 *addend_p = 0;
  79                 *value_p = (Addr)*taglist;
  80                 *taglist = (tnf_tag_data_t *)offset;
  81                 return (0);
  82         }
  83         return (1);
  84 }
  85 
  86 #define SDT_NOP         0x90
  87 #define SDT_NOPS        5
  88 
  89 static int
  90 sdt_reloc_resolve(struct module *mp, char *symname, uint8_t *instr)
  91 {
  92         sdt_probedesc_t *sdp;
  93         int i;
  94 
  95         /*
  96          * The "statically defined tracing" (SDT) provider for DTrace uses
  97          * a mechanism similar to TNF, but somewhat simpler.  (Surprise,
  98          * surprise.)  The SDT mechanism works by replacing calls to the
  99          * undefined routine __dtrace_probe_[name] with nop instructions.
 100          * The relocations are logged, and SDT itself will later patch the
 101          * running binary appropriately.
 102          */
 103         if (strncmp(symname, sdt_prefix, strlen(sdt_prefix)) != 0)
 104                 return (1);
 105 
 106         symname += strlen(sdt_prefix);
 107 
 108         sdp = kobj_alloc(sizeof (sdt_probedesc_t), KM_WAIT);
 109         sdp->sdpd_name = kobj_alloc(strlen(symname) + 1, KM_WAIT);
 110         bcopy(symname, sdp->sdpd_name, strlen(symname) + 1);
 111 
 112         sdp->sdpd_offset = (uintptr_t)instr;
 113         sdp->sdpd_next = mp->sdt_probes;
 114         mp->sdt_probes = sdp;
 115 
 116         for (i = 0; i < SDT_NOPS; i++)
 117                 instr[i - 1] = SDT_NOP;
 118 
 119         return (0);
 120 }
 121 
 122 int
 123 do_relocate(struct module *mp, char *reltbl, int nreloc, int relocsize,
 124     Addr baseaddr)
 125 {
 126         unsigned long stndx;
 127         unsigned long off;      /* can't be register for tnf_reloc_resolve() */
 128         register unsigned long reladdr, rend;
 129         register unsigned int rtype;
 130         unsigned long value;
 131         Elf64_Sxword addend;
 132         Sym *symref = NULL;
 133         int err = 0;
 134         tnf_probe_control_t *probelist = NULL;
 135         tnf_tag_data_t *taglist = NULL;
 136         int symnum;
 137         reladdr = (unsigned long)reltbl;
 138         rend = reladdr + nreloc * relocsize;
 139 
 140 #ifdef  KOBJ_DEBUG
 141         if (kobj_debug & D_RELOCATIONS) {
 142                 _kobj_printf(ops, "krtld:\ttype\t\t\toffset\t   addend"
 143                     "      symbol\n");
 144                 _kobj_printf(ops, "krtld:\t\t\t\t\t   value\n");
 145         }
 146 #endif
 147 
 148         symnum = -1;
 149         /* loop through relocations */
 150         while (reladdr < rend) {
 151                 symnum++;
 152                 rtype = ELF_R_TYPE(((Rela *)reladdr)->r_info);
 153                 off = ((Rela *)reladdr)->r_offset;
 154                 stndx = ELF_R_SYM(((Rela *)reladdr)->r_info);
 155                 if (stndx >= mp->nsyms) {
 156                         _kobj_printf(ops, "do_relocate: bad strndx %d\n",
 157                             symnum);
 158                         return (-1);
 159                 }
 160                 if ((rtype > R_AMD64_NUM) || IS_TLS_INS(rtype)) {
 161                         _kobj_printf(ops, "krtld: invalid relocation type %d",
 162                             rtype);
 163                         _kobj_printf(ops, " at 0x%lx:", off);
 164                         _kobj_printf(ops, " file=%s\n", mp->filename);
 165                         err = 1;
 166                         continue;
 167                 }
 168 
 169 
 170                 addend = (long)(((Rela *)reladdr)->r_addend);
 171                 reladdr += relocsize;
 172 
 173 
 174                 if (rtype == R_AMD64_NONE)
 175                         continue;
 176 
 177 #ifdef  KOBJ_DEBUG
 178                 if (kobj_debug & D_RELOCATIONS) {
 179                         Sym *   symp;
 180                         symp = (Sym *)
 181                             (mp->symtbl+(stndx * mp->symhdr->sh_entsize));
 182                         _kobj_printf(ops, "krtld:\t%s",
 183                             conv_reloc_amd64_type(rtype));
 184                         _kobj_printf(ops, "\t0x%8lx", off);
 185                         _kobj_printf(ops, " %8lld", (longlong_t)addend);
 186                         _kobj_printf(ops, "  %s\n",
 187                             (const char *)mp->strings + symp->st_name);
 188                 }
 189 #endif
 190 
 191                 if (!(mp->flags & KOBJ_EXEC))
 192                         off += baseaddr;
 193 
 194                 /*
 195                  * if R_AMD64_RELATIVE, simply add base addr
 196                  * to reloc location
 197                  */
 198 
 199                 if (rtype == R_AMD64_RELATIVE) {
 200                         value = baseaddr;
 201                 } else {
 202                         /*
 203                          * get symbol table entry - if symbol is local
 204                          * value is base address of this object
 205                          */
 206                         symref = (Sym *)
 207                             (mp->symtbl+(stndx * mp->symhdr->sh_entsize));
 208 
 209                         if (ELF_ST_BIND(symref->st_info) == STB_LOCAL) {
 210                                 /* *** this is different for .o and .so */
 211                                 value = symref->st_value;
 212                         } else {
 213                                 /*
 214                                  * It's global. Allow weak references.  If
 215                                  * the symbol is undefined, give TNF (the
 216                                  * kernel probes facility) a chance to see
 217                                  * if it's a probe site, and fix it up if so.
 218                                  */
 219                                 if (symref->st_shndx == SHN_UNDEF &&
 220                                     sdt_reloc_resolve(mp, mp->strings +
 221                                     symref->st_name, (uint8_t *)off) == 0)
 222                                         continue;
 223 
 224                                 if (symref->st_shndx == SHN_UNDEF &&
 225                                     tnf_reloc_resolve(mp->strings +
 226                                     symref->st_name, &symref->st_value,
 227                                     &addend, off, &probelist, &taglist) != 0) {
 228                                         if (ELF_ST_BIND(symref->st_info)
 229                                             != STB_WEAK) {
 230                                                 _kobj_printf(ops,
 231                                                     "not found: %s\n",
 232                                                     mp->strings +
 233                                                     symref->st_name);
 234                                                 err = 1;
 235                                         }
 236                                         continue;
 237                                 } else { /* symbol found  - relocate */
 238                                         /*
 239                                          * calculate location of definition
 240                                          * - symbol value plus base address of
 241                                          * containing shared object
 242                                          */
 243                                         value = symref->st_value;
 244 
 245                                 } /* end else symbol found */
 246                         } /* end global or weak */
 247                 } /* end not R_AMD64_RELATIVE */
 248 
 249                 value += addend;
 250                 /*
 251                  * calculate final value -
 252                  * if PC-relative, subtract ref addr
 253                  */
 254                 if (IS_PC_RELATIVE(rtype))
 255                         value -= off;
 256 
 257 #ifdef  KOBJ_DEBUG
 258                 if (kobj_debug & D_RELOCATIONS) {
 259                         _kobj_printf(ops, "krtld:\t\t\t\t0x%8lx", off);
 260                         _kobj_printf(ops, " 0x%8lx\n", value);
 261                 }
 262 #endif
 263 
 264                 if (do_reloc_krtld(rtype, (unsigned char *)off, &value,
 265                     (const char *)mp->strings + symref->st_name,
 266                     mp->filename) == 0)
 267                         err = 1;
 268 
 269         } /* end of while loop */
 270         if (err)
 271                 return (-1);
 272 
 273         if (tnf_splice_probes(mp->flags & KOBJ_PRIM, probelist, taglist))
 274                 mp->flags |= KOBJ_TNF_PROBE;
 275 
 276         return (0);
 277 }
 278 
 279 int
 280 do_relocations(struct module *mp)
 281 {
 282         uint_t shn;
 283         Shdr *shp, *rshp;
 284         uint_t nreloc;
 285 
 286         /* do the relocations */
 287         for (shn = 1; shn < mp->hdr.e_shnum; shn++) {
 288                 rshp = (Shdr *)
 289                     (mp->shdrs + shn * mp->hdr.e_shentsize);
 290                 if (rshp->sh_type == SHT_REL) {
 291                         _kobj_printf(ops, "%s can't process type SHT_REL\n",
 292                             mp->filename);
 293                         return (-1);
 294                 }
 295                 if (rshp->sh_type != SHT_RELA)
 296                         continue;
 297                 if (rshp->sh_link != mp->symtbl_section) {
 298                         _kobj_printf(ops, "%s reloc for non-default symtab\n",
 299                             mp->filename);
 300                         return (-1);
 301                 }
 302                 if (rshp->sh_info >= mp->hdr.e_shnum) {
 303                         _kobj_printf(ops, "do_relocations: %s sh_info ",
 304                             mp->filename);
 305                         _kobj_printf(ops, "out of range %d\n", shn);
 306                         goto bad;
 307                 }
 308                 nreloc = rshp->sh_size / rshp->sh_entsize;
 309 
 310                 /* get the section header that this reloc table refers to */
 311                 shp = (Shdr *)
 312                     (mp->shdrs + rshp->sh_info * mp->hdr.e_shentsize);
 313 
 314                 /*
 315                  * Do not relocate any section that isn't loaded into memory.
 316                  * Most commonly this will skip over the .rela.stab* sections
 317                  */
 318                 if (!(shp->sh_flags & SHF_ALLOC))
 319                         continue;
 320 #ifdef  KOBJ_DEBUG
 321                 if (kobj_debug & D_RELOCATIONS) {
 322                         _kobj_printf(ops, "krtld: relocating: file=%s ",
 323                             mp->filename);
 324                         _kobj_printf(ops, "section=%d\n", shn);
 325                 }
 326 #endif
 327 
 328                 if (do_relocate(mp, (char *)rshp->sh_addr, nreloc,
 329                     rshp->sh_entsize, shp->sh_addr) < 0) {
 330                         _kobj_printf(ops,
 331                             "do_relocations: %s do_relocate failed\n",
 332                             mp->filename);
 333                         goto bad;
 334                 }
 335                 kobj_free((void *)rshp->sh_addr, rshp->sh_size);
 336                 rshp->sh_addr = 0;
 337         }
 338         mp->flags |= KOBJ_RELOCATED;
 339         return (0);
 340 bad:
 341         kobj_free((void *)rshp->sh_addr, rshp->sh_size);
 342         rshp->sh_addr = 0;
 343         return (-1);
 344 }
--- EOF ---