bsd/kern/mach_fat.c

   1 /*
   2  * Copyright (c) 1991-2005 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 #include <sys/param.h>
  29 #include <sys/types.h>
  30 #include <sys/uio.h>
  31 #include <sys/vnode.h>
  32 #include <vm/vm_kern.h>
  33 #include <mach/kern_return.h>
  34 #include <mach/vm_param.h>
  35 #include <kern/cpu_number.h>
  36 #include <mach-o/fat.h>
  37 #include <kern/mach_loader.h>
  38 #include <kern/mach_fat.h>
  39 #include <libkern/OSByteOrder.h>
  40 #include <machine/exec.h>
  41
  42 /**********************************************************************
  43  * Routine:     fatfile_getarch2()
  44  *
  45  * Function:    Locate the architecture-dependant contents of a fat
  46  *              file that match this CPU.
  47  *
  48  * Args:        vp:             The vnode for the fat file.
  49  *              header:         A pointer to the fat file header.
  50  *              req_cpu_type:   The required cpu type.
  51  *              mask_bits:      Bits to mask from the sub-image type when
  52  *                              grading it vs. the req_cpu_type
  53  *              archret (out):  Pointer to fat_arch structure to hold
  54  *                              the results.
  55  *
  56  * Returns:     KERN_SUCCESS:   Valid architecture found.
  57  *              KERN_FAILURE:   No valid architecture found.
  58  **********************************************************************/
  59 static load_return_t
  60 fatfile_getarch2(
  61 #if 0
  62         struct vnode    *vp,
  63 #else
  64         __unused struct vnode   *vp,
  65 #endif
  66         vm_offset_t     data_ptr,
  67         cpu_type_t      req_cpu_type,
  68         cpu_type_t      mask_bits,
  69         struct fat_arch *archret)
  70 {
  71         /* vm_pager_t           pager; */
  72         vm_offset_t             addr;
  73         vm_size_t               size;
  74         load_return_t           lret;
  75         struct fat_arch         *arch;
  76         struct fat_arch         *best_arch;
  77         int                     grade;
  78         int                     best_grade;
  79         int                     nfat_arch;
  80         off_t                   end_of_archs;
  81         cpu_type_t              testtype;
  82         cpu_type_t              testsubtype;
  83         struct fat_header       *header;
  84 #if 0
  85         off_t filesize;
  86 #endif
  87
  88         /*
  89          *      Get the pager for the file.
  90          */
  91
  92         header = (struct fat_header *)data_ptr;
  93
  94         /*
  95          *      Map portion that must be accessible directly into
  96          *      kernel's map.
  97          */
  98         nfat_arch = OSSwapBigToHostInt32(header->nfat_arch);
  99
 100         end_of_archs = (off_t)nfat_arch * sizeof(struct fat_arch) +
 101                         sizeof(struct fat_header);
 102 #if 0
 103         filesize = ubc_getsize(vp);
 104         if (end_of_archs > (int)filesize) {
 105                 return(LOAD_BADMACHO);
 106         }
 107 #endif
 108
 109         /*
 110          * This check is limited on the top end because we are reading
 111          * only PAGE_SIZE bytes
 112          */
 113         if (end_of_archs > PAGE_SIZE ||
 114             end_of_archs < (off_t)(sizeof(struct fat_header)+sizeof(struct fat_arch)))
 115                 return(LOAD_BADMACHO);
 116
 117         /*
 118          *      Round size of fat_arch structures up to page boundry.
 119          */
 120         size = round_page(end_of_archs);
 121         if (size == 0)
 122                 return(LOAD_BADMACHO);
 123
 124         /*
 125          * Ignore LIB64 flag so that binary slices with the flag set
 126          * don't choke in grade_binary.
 127          */
 128         mask_bits |= CPU_SUBTYPE_LIB64;
 129
 130         /*
 131          * Scan the fat_arch's looking for the best one.  */
 132         addr = data_ptr;
 133         best_arch = NULL;
 134         best_grade = 0;
 135         arch = (struct fat_arch *) (addr + sizeof(struct fat_header));
 136         for (; nfat_arch-- > 0; arch++) {
 137
 138                 /*
 139                  *      Collect flags from both cputype and cpusubtype
 140                  */
 141                 testtype = OSSwapBigToHostInt32(arch->cputype) |
 142                                 (OSSwapBigToHostInt32(arch->cpusubtype) &
 143                                         CPU_SUBTYPE_MASK);
 144                 testsubtype = OSSwapBigToHostInt32(arch->cpusubtype)
 145                         & ~CPU_SUBTYPE_MASK;
 146
 147                 /*
 148                  *      Check to see if right cpu type.
 149                  */
 150                 if((testtype & ~mask_bits) != req_cpu_type) {
 151                         continue;
 152                 }
 153
 154                 /*
 155                  *      Get the grade of the cpu subtype (without feature flags)
 156                  */
 157                 grade = grade_binary(
 158                                 (testtype & ~CPU_SUBTYPE_LIB64),
 159                                 testsubtype);
 160
 161                 /*
 162                  *      Remember it if it's the best we've seen.
 163                  */
 164                 if (grade > best_grade) {
 165                         best_grade = grade;
 166                         best_arch = arch;
 167                 }
 168         }
 169
 170         /*
 171          *      Return our results.
 172          */
 173         if (best_arch == NULL) {
 174                 lret = LOAD_BADARCH;
 175         } else {
 176                 archret->cputype        =
 177                             OSSwapBigToHostInt32(best_arch->cputype);
 178                 archret->cpusubtype     =
 179                             OSSwapBigToHostInt32(best_arch->cpusubtype);
 180                 archret->offset         =
 181                             OSSwapBigToHostInt32(best_arch->offset);
 182                 archret->size           =
 183                             OSSwapBigToHostInt32(best_arch->size);
 184                 archret->align          =
 185                             OSSwapBigToHostInt32(best_arch->align);
 186
 187                 lret = LOAD_SUCCESS;
 188         }
 189
 190         /*
 191          * Free the memory we allocated and return.
 192          */
 193         return(lret);
 194 }
 195
 196 load_return_t
 197 fatfile_getarch_affinity(
 198                 struct vnode            *vp,
 199                 vm_offset_t             data_ptr,
 200                 struct fat_arch *archret,
 201                 int                             affinity)
 202 {
 203                 load_return_t lret;
 204                 int handler = (exec_archhandler_ppc.path[0] != 0);
 205                 cpu_type_t primary_type, fallback_type;
 206
 207                 if (handler && affinity) {
 208                                 primary_type = CPU_TYPE_POWERPC;
 209                                 fallback_type = cpu_type();
 210                 } else {
 211                                 primary_type = cpu_type();
 212                                 fallback_type = CPU_TYPE_POWERPC;
 213                 }
 214                 /*
 215                  * Ignore all architectural bits when determining if an image
 216                  * in a fat file should be skipped or graded.
 217                  */
 218                 lret = fatfile_getarch2(vp, data_ptr, primary_type,
 219                                 CPU_ARCH_MASK, archret);
 220                 if ((lret != 0) && handler) {
 221                         lret = fatfile_getarch2(vp, data_ptr, fallback_type,
 222                                                 CPU_SUBTYPE_LIB64, archret);
 223                 }
 224                 return lret;
 225 }
 226
 227 /**********************************************************************
 228  * Routine:     fatfile_getarch()
 229  *
 230  * Function:    Locate the architecture-dependant contents of a fat
 231  *              file that match this CPU.
 232  *
 233  * Args:        vp:             The vnode for the fat file.
 234  *              header:         A pointer to the fat file header.
 235  *              archret (out):  Pointer to fat_arch structure to hold
 236  *                              the results.
 237  *
 238  * Returns:     KERN_SUCCESS:   Valid architecture found.
 239  *              KERN_FAILURE:   No valid architecture found.
 240  **********************************************************************/
 241 load_return_t
 242 fatfile_getarch(
 243         struct vnode            *vp,
 244         vm_offset_t     data_ptr,
 245         struct fat_arch         *archret)
 246 {
 247         return fatfile_getarch2(vp, data_ptr, cpu_type(),
 248                         CPU_SUBTYPE_LIB64, archret);
 249 }
 250
 251 /**********************************************************************
 252  * Routine:     fatfile_getarch_with_bits()
 253  *
 254  * Function:    Locate the architecture-dependant contents of a fat
 255  *              file that match this CPU.
 256  *
 257  * Args:        vp:             The vnode for the fat file.
 258  *              archbits:       Architecture specific feature bits
 259  *              header:         A pointer to the fat file header.
 260  *              archret (out):  Pointer to fat_arch structure to hold
 261  *                              the results.
 262  *
 263  * Returns:     KERN_SUCCESS:   Valid architecture found.
 264  *              KERN_FAILURE:   No valid architecture found.
 265  **********************************************************************/
 266 load_return_t
 267 fatfile_getarch_with_bits(
 268         struct vnode            *vp,
 269         integer_t               archbits,
 270         vm_offset_t     data_ptr,
 271         struct fat_arch         *archret)
 272 {
 273         return fatfile_getarch2(vp, data_ptr, archbits | cpu_type(),
 274                         CPU_SUBTYPE_LIB64, archret);
 275 }
 276