Subversion Repositories HelenOS

Rev

Rev 3204 | Rev 4344 | 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 name      Name to set for the program's task.
  70.  * @param p     Buffer for storing program information.
  71.  */
  72. void program_create(as_t *as, uintptr_t entry_addr, char *name, 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, name);
  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 name      Name to set for the program's task.
  110.  * @param p     Buffer for storing program info. If image_addr
  111.  *          points to a loader image, p->task will be set to
  112.  *          NULL and EOK will be returned.
  113.  *
  114.  * @return EOK on success or negative error code.
  115.  */
  116. int program_create_from_image(void *image_addr, char *name, program_t *p)
  117. {
  118.     as_t *as;
  119.     unsigned int rc;
  120.  
  121.     as = as_create(0);
  122.     ASSERT(as);
  123.  
  124.     rc = elf_load((elf_header_t *) image_addr, as, 0);
  125.     if (rc != EE_OK) {
  126.         as_destroy(as);
  127.         p->task = NULL;
  128.         p->main_thread = NULL;
  129.         if (rc != EE_LOADER)
  130.             return ENOTSUP;
  131.        
  132.         /* Register image as the program loader */
  133.         ASSERT(program_loader == NULL);
  134.         program_loader = image_addr;
  135.         return EOK;
  136.     }
  137.  
  138.     program_create(as, ((elf_header_t *) image_addr)->e_entry, name, p);
  139.  
  140.     return EOK;
  141. }
  142.  
  143. /** Create a task from the program loader image.
  144.  *
  145.  * @param p Buffer for storing program info.
  146.  * @param name  Name to set for the program's task.
  147.  *
  148.  * @return EOK on success or negative error code.
  149.  */
  150. int program_create_loader(program_t *p, char *name)
  151. {
  152.     as_t *as;
  153.     unsigned int rc;
  154.     void *loader;
  155.  
  156.     as = as_create(0);
  157.     ASSERT(as);
  158.  
  159.     loader = program_loader;
  160.     if (!loader) return ENOENT;
  161.  
  162.     rc = elf_load((elf_header_t *) program_loader, as, ELD_F_LOADER);
  163.     if (rc != EE_OK) {
  164.         as_destroy(as);
  165.         return ENOENT;
  166.     }
  167.  
  168.     program_create(as, ((elf_header_t *) program_loader)->e_entry,
  169.         name, p);
  170.  
  171.     return EOK;
  172. }
  173.  
  174. /** Make program ready.
  175.  *
  176.  * Switch program's main thread to the ready state.
  177.  *
  178.  * @param p Program to make ready.
  179.  */
  180. void program_ready(program_t *p)
  181. {
  182.     thread_ready(p->main_thread);
  183. }
  184.  
  185. /** Syscall for creating a new loader instance from userspace.
  186.  *
  187.  * Creates a new task from the program loader image, connects a phone
  188.  * to it and stores the phone id into the provided buffer.
  189.  *
  190.  * @param uspace_phone_id   Userspace address where to store the phone id.
  191.  * @param name          Name to set on the new task (typically the same
  192.  *              as the command used to execute it).
  193.  *
  194.  * @return 0 on success or an error code from @ref errno.h.
  195.  */
  196. unative_t sys_program_spawn_loader(int *uspace_phone_id, char *uspace_name,
  197.     size_t name_len)
  198. {
  199.     program_t p;
  200.     int fake_id;
  201.     int rc;
  202.     int phone_id;
  203.     char namebuf[TASK_NAME_BUFLEN];
  204.  
  205.     fake_id = 0;
  206.  
  207.     /* Before we even try creating the task, see if we can write the id */
  208.     rc = (unative_t) copy_to_uspace(uspace_phone_id, &fake_id,
  209.         sizeof(fake_id));
  210.     if (rc != 0)
  211.         return rc;
  212.  
  213.     /* Cap length of name and copy it from userspace. */
  214.  
  215.     if (name_len > THREAD_NAME_BUFLEN - 1)
  216.         name_len = THREAD_NAME_BUFLEN - 1;
  217.  
  218.     rc = copy_from_uspace(namebuf, uspace_name, name_len);
  219.     if (rc != 0)
  220.         return (unative_t) rc;
  221.  
  222.     namebuf[name_len] = '\0';
  223.  
  224.     /* Allocate the phone for communicating with the new task. */
  225.  
  226.     phone_id = phone_alloc();
  227.     if (phone_id < 0)
  228.         return ELIMIT;
  229.  
  230.     /* Spawn the new task. */
  231.  
  232.     rc = program_create_loader(&p, namebuf);
  233.     if (rc != 0)
  234.         return rc;
  235.  
  236.     phone_connect(phone_id, &p.task->answerbox);
  237.  
  238.     /* No need to aquire lock before task_ready() */
  239.     rc = (unative_t) copy_to_uspace(uspace_phone_id, &phone_id,
  240.         sizeof(phone_id));
  241.     if (rc != 0) {
  242.         /* Ooops */
  243.         ipc_phone_hangup(&TASK->phones[phone_id]);
  244.         task_kill(p.task->taskid);
  245.         return rc;
  246.     }
  247.  
  248.     // FIXME: control the capabilities
  249.     cap_set(p.task, cap_get(TASK));
  250.  
  251.     program_ready(&p);
  252.  
  253.     return EOK;
  254. }
  255.  
  256. /** @}
  257.  */
  258.