Subversion Repositories HelenOS

Rev

Rev 3222 | Rev 4153 | 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 <print.h>
  53. #include <syscall/copy.h>
  54. #include <proc/program.h>
  55.  
  56. #ifndef LOADED_PROG_STACK_PAGES_NO
  57. #define LOADED_PROG_STACK_PAGES_NO 1
  58. #endif
  59.  
  60. /**
  61.  * Points to the binary image used as the program loader. All non-initial
  62.  * tasks are created from this executable image.
  63.  */
  64. void *program_loader = NULL;
  65.  
  66. /** Create a program using an existing address space.
  67.  *
  68.  * @param as        Address space containing a binary program image.
  69.  * @param entry_addr    Program entry-point address in program address space.
  70.  * @param p     Buffer for storing program information.
  71.  */
  72. void program_create(as_t *as, uintptr_t entry_addr, program_t *p)
  73. {
  74.     as_area_t *a;
  75.     uspace_arg_t *kernel_uarg;
  76.  
  77.     kernel_uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t), 0);
  78.     kernel_uarg->uspace_entry = (void *) entry_addr;
  79.     kernel_uarg->uspace_stack = (void *) USTACK_ADDRESS;
  80.     kernel_uarg->uspace_thread_function = NULL;
  81.     kernel_uarg->uspace_thread_arg = NULL;
  82.     kernel_uarg->uspace_uarg = NULL;
  83.    
  84.     p->task = task_create(as, "app");
  85.     ASSERT(p->task);
  86.  
  87.     /*
  88.      * Create the data as_area.
  89.      */
  90.     a = as_area_create(as, AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE,
  91.         LOADED_PROG_STACK_PAGES_NO * PAGE_SIZE, USTACK_ADDRESS,
  92.         AS_AREA_ATTR_NONE, &anon_backend, NULL);
  93.  
  94.     /*
  95.      * Create the main thread.
  96.      */
  97.     p->main_thread = thread_create(uinit, kernel_uarg, p->task,
  98.         THREAD_FLAG_USPACE, "uinit", false);
  99.     ASSERT(p->main_thread);
  100. }
  101.  
  102. /** Parse an executable image in the kernel memory.
  103.  *
  104.  * If the image belongs to a program loader, it is registered as such,
  105.  * (and *task is set to NULL). Otherwise a task is created from the
  106.  * executable image. The task is returned in *task.
  107.  *
  108.  * @param image_addr    Address of an executable program image.
  109.  * @param p     Buffer for storing program info. If image_addr
  110.  *          points to a loader image, p->task will be set to
  111.  *          NULL and EOK will be returned.
  112.  *
  113.  * @return EOK on success or negative error code.
  114.  */
  115. int program_create_from_image(void *image_addr, program_t *p)
  116. {
  117.     as_t *as;
  118.     unsigned int rc;
  119.  
  120.     as = as_create(0);
  121.     ASSERT(as);
  122.  
  123.     rc = elf_load((elf_header_t *) image_addr, as, 0);
  124.     if (rc != EE_OK) {
  125.         as_destroy(as);
  126.         p->task = NULL;
  127.         p->main_thread = NULL;
  128.         if (rc != EE_LOADER)
  129.             return ENOTSUP;
  130.        
  131.         /* Register image as the program loader */
  132.         ASSERT(program_loader == NULL);
  133.         program_loader = image_addr;
  134.         printf("Registered program loader at 0x%" PRIp "\n",
  135.             image_addr);
  136.         return EOK;
  137.     }
  138.  
  139.     program_create(as, ((elf_header_t *) image_addr)->e_entry, p);
  140.  
  141.     return EOK;
  142. }
  143.  
  144. /** Create a task from the program loader image.
  145.  *
  146.  * @param p Buffer for storing program info.
  147.  * @return EOK on success or negative error code.
  148.  */
  149. int program_create_loader(program_t *p)
  150. {
  151.     as_t *as;
  152.     unsigned int rc;
  153.     void *loader;
  154.  
  155.     as = as_create(0);
  156.     ASSERT(as);
  157.  
  158.     loader = program_loader;
  159.     if (!loader) {
  160.         printf("Cannot spawn loader as none was registered\n");
  161.         return ENOENT;
  162.     }
  163.  
  164.     rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);
  165.     if (rc != EE_OK) {
  166.         as_destroy(as);
  167.         return ENOENT;
  168.     }
  169.  
  170.     program_create(as, ((elf_header_t *) program_loader)->e_entry, p);
  171.  
  172.     return EOK;
  173. }
  174.  
  175. /** Make program ready.
  176.  *
  177.  * Switch program's main thread to the ready state.
  178.  *
  179.  * @param p Program to make ready.
  180.  */
  181. void program_ready(program_t *p)
  182. {
  183.     thread_ready(p->main_thread);
  184. }
  185.  
  186. /** Syscall for creating a new loader instance from userspace.
  187.  *
  188.  * Creates a new task from the program loader image, connects a phone
  189.  * to it and stores the phone id into the provided buffer.
  190.  *
  191.  * @param uspace_phone_id Userspace address where to store the phone id.
  192.  *
  193.  * @return 0 on success or an error code from @ref errno.h.
  194.  */
  195. unative_t sys_program_spawn_loader(int *uspace_phone_id)
  196. {
  197.     program_t p;
  198.     int fake_id;
  199.     int rc;
  200.     int phone_id;
  201.  
  202.     fake_id = 0;
  203.  
  204.     /* Before we even try creating the task, see if we can write the id */
  205.     rc = (unative_t) copy_to_uspace(uspace_phone_id, &fake_id,
  206.         sizeof(fake_id));
  207.     if (rc != 0)
  208.         return rc;
  209.  
  210.     phone_id = phone_alloc();
  211.     if (phone_id < 0)
  212.         return ELIMIT;
  213.  
  214.     rc = program_create_loader(&p);
  215.     if (rc != 0)
  216.         return rc;
  217.  
  218.     phone_connect(phone_id, &p.task->answerbox);
  219.  
  220.     /* No need to aquire lock before task_ready() */
  221.     rc = (unative_t) copy_to_uspace(uspace_phone_id, &phone_id,
  222.         sizeof(phone_id));
  223.     if (rc != 0) {
  224.         /* Ooops */
  225.         ipc_phone_hangup(&TASK->phones[phone_id]);
  226.         task_kill(p.task->taskid);
  227.         return rc;
  228.     }
  229.  
  230.     // FIXME: control the capabilities
  231.     cap_set(p.task, cap_get(TASK));
  232.  
  233.     program_ready(&p);
  234.  
  235.     return EOK;
  236. }
  237.  
  238. /** @}
  239.  */
  240.