Subversion Repositories HelenOS

Rev

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 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 and sets
  188.  * the task name.
  189.  *
  190.  * @param name          Name to set on the new task (typically the same
  191.  *              as the command used to execute it).
  192.  *
  193.  * @return 0 on success or an error code from @ref errno.h.
  194.  */
  195. unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
  196. {
  197.     program_t p;
  198.     int rc;
  199.     char namebuf[TASK_NAME_BUFLEN];
  200.  
  201.     /* Cap length of name and copy it from userspace. */
  202.  
  203.     if (name_len > TASK_NAME_BUFLEN - 1)
  204.         name_len = TASK_NAME_BUFLEN - 1;
  205.  
  206.     rc = copy_from_uspace(namebuf, uspace_name, name_len);
  207.     if (rc != 0)
  208.         return (unative_t) rc;
  209.  
  210.     namebuf[name_len] = '\0';
  211.  
  212.     /* Spawn the new task. */
  213.  
  214.     rc = program_create_loader(&p, namebuf);
  215.     if (rc != 0)
  216.         return rc;
  217.  
  218.     // FIXME: control the capabilities
  219.     cap_set(p.task, cap_get(TASK));
  220.  
  221.     program_ready(&p);
  222.  
  223.     return EOK;
  224. }
  225.  
  226. /** @}
  227.  */
  228.