src/arch/power/process.cc

   1 /*
   2  * Copyright (c) 2007-2008 The Florida State University
   3  * Copyright (c) 2009 The University of Edinburgh
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met: redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer;
  10  * redistributions in binary form must reproduce the above copyright
  11  * notice, this list of conditions and the following disclaimer in the
  12  * documentation and/or other materials provided with the distribution;
  13  * neither the name of the copyright holders nor the names of its
  14  * contributors may be used to endorse or promote products derived from
  15  * this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * Authors: Stephen Hines
  30  *          Timothy M. Jones
  31  */
  32
  33 #include "arch/power/isa_traits.hh"
  34 #include "arch/power/process.hh"
  35 #include "arch/power/types.hh"
  36 #include "base/loader/elf_object.hh"
  37 #include "base/loader/object_file.hh"
  38 #include "base/misc.hh"
  39 #include "cpu/thread_context.hh"
  40 #include "mem/page_table.hh"
  41 #include "mem/translating_port.hh"
  42 #include "sim/process_impl.hh"
  43 #include "sim/system.hh"
  44
  45 using namespace std;
  46 using namespace PowerISA;
  47
  48 PowerLiveProcess::PowerLiveProcess(LiveProcessParams *params,
  49         ObjectFile *objFile)
  50     : LiveProcess(params, objFile)
  51 {
  52     stack_base = 0xbf000000L;
  53
  54     // Set pointer for next thread stack.  Reserve 8M for main stack.
  55     next_thread_stack_base = stack_base - (8 * 1024 * 1024);
  56
  57     // Set up break point (Top of Heap)
  58     brk_point = objFile->dataBase() + objFile->dataSize() + objFile->bssSize();
  59     brk_point = roundUp(brk_point, VMPageSize);
  60
  61     // Set up region for mmaps. For now, start at bottom of kuseg space.
  62     mmap_start = mmap_end = 0x70000000L;
  63 }
  64
  65 void
  66 PowerLiveProcess::startup()
  67 {
  68     argsInit(MachineBytes, VMPageSize);
  69 }
  70
  71 void
  72 PowerLiveProcess::argsInit(int intSize, int pageSize)
  73 {
  74     typedef AuxVector<uint32_t> auxv_t;
  75     std::vector<auxv_t> auxv;
  76
  77     string filename;
  78     if (argv.size() < 1)
  79         filename = "";
  80     else
  81         filename = argv[0];
  82
  83     //We want 16 byte alignment
  84     uint64_t align = 16;
  85
  86     // Overloaded argsInit so that we can fine-tune for POWER architecture
  87     Process::startup();
  88
  89     // load object file into target memory
  90     objFile->loadSections(initVirtMem);
  91
  92     //Setup the auxilliary vectors. These will already have endian conversion.
  93     //Auxilliary vectors are loaded only for elf formatted executables.
  94     ElfObject * elfObject = dynamic_cast<ElfObject *>(objFile);
  95     if (elfObject) {
  96         uint32_t features = 0;
  97
  98         //Bits which describe the system hardware capabilities
  99         //XXX Figure out what these should be
 100         auxv.push_back(auxv_t(M5_AT_HWCAP, features));
 101         //The system page size
 102         auxv.push_back(auxv_t(M5_AT_PAGESZ, PowerISA::VMPageSize));
 103         //Frequency at which times() increments
 104         auxv.push_back(auxv_t(M5_AT_CLKTCK, 0x64));
 105         // For statically linked executables, this is the virtual address of the
 106         // program header tables if they appear in the executable image
 107         auxv.push_back(auxv_t(M5_AT_PHDR, elfObject->programHeaderTable()));
 108         // This is the size of a program header entry from the elf file.
 109         auxv.push_back(auxv_t(M5_AT_PHENT, elfObject->programHeaderSize()));
 110         // This is the number of program headers from the original elf file.
 111         auxv.push_back(auxv_t(M5_AT_PHNUM, elfObject->programHeaderCount()));
 112         //This is the address of the elf "interpreter", It should be set
 113         //to 0 for regular executables. It should be something else
 114         //(not sure what) for dynamic libraries.
 115         auxv.push_back(auxv_t(M5_AT_BASE, 0));
 116
 117         //XXX Figure out what this should be.
 118         auxv.push_back(auxv_t(M5_AT_FLAGS, 0));
 119         //The entry point to the program
 120         auxv.push_back(auxv_t(M5_AT_ENTRY, objFile->entryPoint()));
 121         //Different user and group IDs
 122         auxv.push_back(auxv_t(M5_AT_UID, uid()));
 123         auxv.push_back(auxv_t(M5_AT_EUID, euid()));
 124         auxv.push_back(auxv_t(M5_AT_GID, gid()));
 125         auxv.push_back(auxv_t(M5_AT_EGID, egid()));
 126         //Whether to enable "secure mode" in the executable
 127         auxv.push_back(auxv_t(M5_AT_SECURE, 0));
 128         //The filename of the program
 129         auxv.push_back(auxv_t(M5_AT_EXECFN, 0));
 130         //The string "v51" with unknown meaning
 131         auxv.push_back(auxv_t(M5_AT_PLATFORM, 0));
 132     }
 133
 134     //Figure out how big the initial stack nedes to be
 135
 136     // A sentry NULL void pointer at the top of the stack.
 137     int sentry_size = intSize;
 138
 139     string platform = "v51";
 140     int platform_size = platform.size() + 1;
 141
 142     // The aux vectors are put on the stack in two groups. The first group are
 143     // the vectors that are generated as the elf is loaded. The second group
 144     // are the ones that were computed ahead of time and include the platform
 145     // string.
 146     int aux_data_size = filename.size() + 1;
 147
 148     int env_data_size = 0;
 149     for (int i = 0; i < envp.size(); ++i) {
 150         env_data_size += envp[i].size() + 1;
 151     }
 152     int arg_data_size = 0;
 153     for (int i = 0; i < argv.size(); ++i) {
 154         arg_data_size += argv[i].size() + 1;
 155     }
 156
 157     int info_block_size =
 158         sentry_size + env_data_size + arg_data_size +
 159         aux_data_size + platform_size;
 160
 161     //Each auxilliary vector is two 4 byte words
 162     int aux_array_size = intSize * 2 * (auxv.size() + 1);
 163
 164     int envp_array_size = intSize * (envp.size() + 1);
 165     int argv_array_size = intSize * (argv.size() + 1);
 166
 167     int argc_size = intSize;
 168
 169     //Figure out the size of the contents of the actual initial frame
 170     int frame_size =
 171         info_block_size +
 172         aux_array_size +
 173         envp_array_size +
 174         argv_array_size +
 175         argc_size;
 176
 177     //There needs to be padding after the auxiliary vector data so that the
 178     //very bottom of the stack is aligned properly.
 179     int partial_size = frame_size;
 180     int aligned_partial_size = roundUp(partial_size, align);
 181     int aux_padding = aligned_partial_size - partial_size;
 182
 183     int space_needed = frame_size + aux_padding;
 184
 185     stack_min = stack_base - space_needed;
 186     stack_min = roundDown(stack_min, align);
 187     stack_size = stack_base - stack_min;
 188
 189     // map memory
 190     pTable->allocate(roundDown(stack_min, pageSize),
 191                      roundUp(stack_size, pageSize));
 192
 193     // map out initial stack contents
 194     uint32_t sentry_base = stack_base - sentry_size;
 195     uint32_t aux_data_base = sentry_base - aux_data_size;
 196     uint32_t env_data_base = aux_data_base - env_data_size;
 197     uint32_t arg_data_base = env_data_base - arg_data_size;
 198     uint32_t platform_base = arg_data_base - platform_size;
 199     uint32_t auxv_array_base = platform_base - aux_array_size - aux_padding;
 200     uint32_t envp_array_base = auxv_array_base - envp_array_size;
 201     uint32_t argv_array_base = envp_array_base - argv_array_size;
 202     uint32_t argc_base = argv_array_base - argc_size;
 203
 204     DPRINTF(Stack, "The addresses of items on the initial stack:\n");
 205     DPRINTF(Stack, "0x%x - aux data\n", aux_data_base);
 206     DPRINTF(Stack, "0x%x - env data\n", env_data_base);
 207     DPRINTF(Stack, "0x%x - arg data\n", arg_data_base);
 208     DPRINTF(Stack, "0x%x - platform base\n", platform_base);
 209     DPRINTF(Stack, "0x%x - auxv array\n", auxv_array_base);
 210     DPRINTF(Stack, "0x%x - envp array\n", envp_array_base);
 211     DPRINTF(Stack, "0x%x - argv array\n", argv_array_base);
 212     DPRINTF(Stack, "0x%x - argc \n", argc_base);
 213     DPRINTF(Stack, "0x%x - stack min\n", stack_min);
 214
 215     // write contents to stack
 216
 217     // figure out argc
 218     uint32_t argc = argv.size();
 219     uint32_t guestArgc = PowerISA::htog(argc);
 220
 221     //Write out the sentry void *
 222     uint32_t sentry_NULL = 0;
 223     initVirtMem->writeBlob(sentry_base,
 224             (uint8_t*)&sentry_NULL, sentry_size);
 225
 226     //Fix up the aux vectors which point to other data
 227     for (int i = auxv.size() - 1; i >= 0; i--) {
 228         if (auxv[i].a_type == M5_AT_PLATFORM) {
 229             auxv[i].a_val = platform_base;
 230             initVirtMem->writeString(platform_base, platform.c_str());
 231         } else if (auxv[i].a_type == M5_AT_EXECFN) {
 232             auxv[i].a_val = aux_data_base;
 233             initVirtMem->writeString(aux_data_base, filename.c_str());
 234         }
 235     }
 236
 237     //Copy the aux stuff
 238     for (int x = 0; x < auxv.size(); x++)
 239     {
 240         initVirtMem->writeBlob(auxv_array_base + x * 2 * intSize,
 241                 (uint8_t*)&(auxv[x].a_type), intSize);
 242         initVirtMem->writeBlob(auxv_array_base + (x * 2 + 1) * intSize,
 243                 (uint8_t*)&(auxv[x].a_val), intSize);
 244     }
 245     //Write out the terminating zeroed auxilliary vector
 246     const uint64_t zero = 0;
 247     initVirtMem->writeBlob(auxv_array_base + 2 * intSize * auxv.size(),
 248             (uint8_t*)&zero, 2 * intSize);
 249
 250     copyStringArray(envp, envp_array_base, env_data_base, initVirtMem);
 251     copyStringArray(argv, argv_array_base, arg_data_base, initVirtMem);
 252
 253     initVirtMem->writeBlob(argc_base, (uint8_t*)&guestArgc, intSize);
 254
 255     ThreadContext *tc = system->getThreadContext(contextIds[0]);
 256
 257     //Set the stack pointer register
 258     tc->setIntReg(StackPointerReg, stack_min);
 259
 260     Addr prog_entry = objFile->entryPoint();
 261     tc->setPC(prog_entry);
 262     tc->setNextPC(prog_entry + sizeof(MachInst));
 263
 264     //Align the "stack_min" to a page boundary.
 265     stack_min = roundDown(stack_min, pageSize);
 266 }
 267
 268 PowerISA::IntReg
 269 PowerLiveProcess::getSyscallArg(ThreadContext *tc, int &i)
 270 {
 271     assert(i < 5);
 272     return tc->readIntReg(ArgumentReg0 + i++);
 273 }
 274
 275 void
 276 PowerLiveProcess::setSyscallArg(ThreadContext *tc,
 277         int i, PowerISA::IntReg val)
 278 {
 279     assert(i < 5);
 280     tc->setIntReg(ArgumentReg0 + i, val);
 281 }
 282
 283 void
 284 PowerLiveProcess::setSyscallReturn(ThreadContext *tc,
 285         SyscallReturn return_value)
 286 {
 287     tc->setIntReg(ReturnValueReg, return_value.value());
 288 }