Subversion Repositories HelenOS

Rev

Rev 3203 | Rev 4343 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2001-2004 Jakub Jermar
  3.  * Copyright (c) 2008 Jiri Svoboda
  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
  8.  * are met:
  9.  *
  10.  * - Redistributions of source code must retain the above copyright
  11.  *   notice, this list of conditions and the following disclaimer.
  12.  * - 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.  * - The name of the author may not be used to endorse or promote products
  16.  *   derived from this software without specific prior written permission.
  17.  *
  18.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23.  * NOT 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 OF
  27.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28.  */
  29.  
  30. /** @addtogroup genericproc
  31.  * @{
  32.  */
  33.  
  34. /**
  35.  * @file
  36.  * @brief   Running userspace programs.
  37.  */
  38.  
  39. #include <main/uinit.h>
  40. #include <proc/thread.h>
  41. #include <proc/task.h>
  42. #include <proc/uarg.h>
  43. #include <mm/as.h>
  44. #include <mm/slab.h>
  45. #include <arch.h>
  46. #include <adt/list.h>
  47. #include <ipc/ipc.h>
  48. #include <ipc/ipcrsc.h>
  49. #include <security/cap.h>
  50. #include <lib/elf.h>
  51. #include <errno.h>
  52. #include <syscall/copy.h>
  53. #include <proc/program.h>
  54.  
  55. #ifndef LOADED_PROG_STACK_PAGES_NO
  56. #define LOADED_PROG_STACK_PAGES_NO 1
  57. #endif
  58.  
  59. /**
  60.  * Points to the binary image used as the program loader. All non-initial
  61.  * tasks are created from this executable image.
  62.  */
  63. void *program_loader = NULL;
  64.  
  65. /** Create a program using an existing address space.
  66.  *
  67.  * @param as        Address space containing a binary program image.
  68.  * @param entry_addr    Program entry-point address in program address space.
  69.  * @param p     Buffer for storing program information.
  70.  */
  71. void program_create(as_t *as, uintptr_t entry_addr, program_t *p)
  72. {
  73.     as_area_t *a;
  74.     uspace_arg_t *kernel_uarg;
  75.  
  76.     kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
  77.     kernel_uarg->uspace_entry = (void *) entry_addr;
  78.     kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
  79.     kernel_uarg->uspace_thread_function = NULL;
  80.     kernel_uarg->uspace_thread_arg = NULL;
  81.     kernel_uarg->uspace_uarg = NULL;
  82.    
  83.     p->task = task_create(as, "app");
  84.     ASSERT(p->task);
  85.  
  86.     /*
  87.      * Create the data as_area.
  88.      */
  89.     a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
  90.         LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
  91.         AS_AREA_ATTR_NONE, &anon_backend, NULL);
  92.  
  93.     /*
  94.      * Create the main thread.
  95.      */
  96.     p->main_thread = thread_create(uinit, kernel_uarg, p->task,
  97.         THREAD_FLAG_USPACE, "uinit", false);
  98.     ASSERT(p->main_thread);
  99. }
  100.  
  101. /** Parse an executable image in the kernel memory.
  102.  *
  103.  * If the image belongs to a program loader, it is registered as such,
  104.  * (and *task is set to NULL). Otherwise a task is created from the
  105.  * executable image. The task is returned in *task.
  106.  *
  107.  * @param image_addr    Address of an executable program image.
  108.  * @param p     Buffer for storing program info. If image_addr
  109.  *          points to a loader image, p->task will be set to
  110.  *          NULL and EOK will be returned.
  111.  *
  112.  * @return EOK on success or negative error code.
  113.  */
  114. int program_create_from_image(void *image_addr, program_t *p)
  115. {
  116.     as_t *as;
  117.     unsigned int rc;
  118.  
  119.     as = as_create(0);
  120.     ASSERT(as);
  121.  
  122.     rc = elf_load((elf_header_t *) image_addr, as, 0);
  123.     if (rc != EE_OK) {
  124.         as_destroy(as);
  125.         p->task = NULL;
  126.         p->main_thread = NULL;
  127.         if (rc != EE_LOADER)
  128.             return ENOTSUP;
  129.        
  130.         /* Register image as the program loader */
  131.         ASSERT(program_loader == NULL);
  132.         program_loader = image_addr;
  133.         return EOK;
  134.     }
  135.  
  136.     program_create(as, ((elf_header_t *) image_addr)->e_entry, p);
  137.  
  138.     return EOK;
  139. }
  140.  
  141. /** Create a task from the program loader image.
  142.  *
  143.  * @param p Buffer for storing program info.
  144.  * @return EOK on success or negative error code.
  145.  */
  146. int program_create_loader(program_t *p)
  147. {
  148.     as_t *as;
  149.     unsigned int rc;
  150.     void *loader;
  151.  
  152.     as = as_create(0);
  153.     ASSERT(as);
  154.  
  155.     loader = program_loader;
  156.     if (!loader) return ENOENT;
  157.  
  158.     rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);
  159.     if (rc != EE_OK) {
  160.         as_destroy(as);
  161.         return ENOENT;
  162.     }
  163.  
  164.     program_create(as, ((elf_header_t *) program_loader)->e_entry, p);
  165.  
  166.     return EOK;
  167. }
  168.  
  169. /** Make program ready.
  170.  *
  171.  * Switch program's main thread to the ready state.
  172.  *
  173.  * @param p Program to make ready.
  174.  */
  175. void program_ready(program_t *p)
  176. {
  177.     thread_ready(p->main_thread);
  178. }
  179.  
  180. /** Syscall for creating a new loader instance from userspace.
  181.  *
  182.  * Creates a new task from the program loader image, connects a phone
  183.  * to it and stores the phone id into the provided buffer.
  184.  *
  185.  * @param uspace_phone_id Userspace address where to store the phone id.
  186.  *
  187.  * @return 0 on success or an error code from @ref errno.h.
  188.  */
  189. unative_t sys_program_spawn_loader(int *uspace_phone_id)
  190. {
  191.     program_t p;
  192.     int fake_id;
  193.     int rc;
  194.     int phone_id;
  195.  
  196.     fake_id = 0;
  197.  
  198.     /* Before we even try creating the task, see if we can write the id */
  199.     rc = (unative_t) copy_to_uspace(uspace_phone_id, &fake_id,
  200.         sizeof(fake_id));
  201.     if (rc != 0)
  202.         return rc;
  203.  
  204.     phone_id = phone_alloc();
  205.     if (phone_id < 0)
  206.         return ELIMIT;
  207.  
  208.     rc = program_create_loader(&p);
  209.     if (rc != 0)
  210.         return rc;
  211.  
  212.     phone_connect(phone_id, &p.task->answerbox);
  213.  
  214.     /* No need to aquire lock before task_ready() */
  215.     rc = (unative_t) copy_to_uspace(uspace_phone_id, &phone_id,
  216.         sizeof(phone_id));
  217.     if (rc != 0) {
  218.         /* Ooops */
  219.         ipc_phone_hangup(&TASK->phones[phone_id]);
  220.         task_kill(p.task->taskid);
  221.         return rc;
  222.     }
  223.  
  224.     // FIXME: control the capabilities
  225.     cap_set(p.task, cap_get(TASK));
  226.  
  227.     program_ready(&p);
  228.  
  229.     return EOK;
  230. }
  231.  
  232. /** @}
  233.  */
  234.