| /* |
| * Copyright 2017, Data61, CSIRO (ABN 41 687 119 230) |
| * |
| * SPDX-License-Identifier: BSD-2-Clause |
| */ |
| #include <string.h> |
| #include <stdio.h> |
| |
| #include <sel4/sel4.h> |
| #include <vka/capops.h> |
| #include <allocman/allocman.h> |
| #include <allocman/vka.h> |
| #include <allocman/bootstrap.h> |
| #include <sel4utils/thread.h> |
| #include <serial_server/parent.h> |
| #include <serial_server/client.h> |
| |
| #include "../test.h" |
| #include "../helpers.h" |
| |
| #define SERSERV_TEST_PRIO_SERVER (seL4_MaxPrio - 1) |
| #define SERSERV_TEST_PRIO_CLIENT (seL4_MinPrio) |
| |
| #define SERSERV_TEST_N_CLIENTS (1) |
| |
| #define SERSERV_TEST_ALLOCMAN_PREALLOCATED_MEMSIZE (64 * 1024) |
| #define SERSERV_TEST_UT_SIZE (512 * 1024) |
| |
| static const char *test_str = "Hello, world!\n"; |
| |
| |
| /* These next few tests test the same things from client threads. |
| * |
| * We spawn a bunch of helper threads and then ask those helper threads to |
| * run these same tests, and then have the helpers return the values they |
| * got when they called the Server. |
| * |
| * We keep it simple as well by using some global state to pass data to the |
| * client threads so they can do their work. Then, so that each client knows |
| * which one it is, we pass the clients a numeric ID invented by the test |
| * to identify that client. |
| */ |
| typedef struct _client_test_data { |
| helper_thread_t thread; |
| /* "badged_server_ep_cspath2" is used in the disconnect/reconnect tests: |
| * the client can't reconnect using the same badged ep as the first |
| * connection. |
| * |
| * We could make each client seL4_Call() the main thread and ask |
| * it to re-mint the ep-cap to each client, but that imposes extra |
| * complexity for a simple test. So for that particular test we just mint 2 |
| * ep caps from the start. |
| */ |
| volatile void **parent_used_pages_list, *client_used_pages_list; |
| int n_used_pages; |
| cspacepath_t badged_server_ep_cspath, badged_server_ep_cspath2, ut_512k_cspath; |
| serial_client_context_t conn; |
| } client_test_data_t; |
| |
| typedef int (client_test_fn)(client_test_data_t *, vka_t *, vspace_t *); |
| |
| struct { |
| vka_t *vka; |
| vspace_t *vspace; |
| simple_t *simple; |
| client_test_data_t client_test_data[SERSERV_TEST_N_CLIENTS]; |
| uint8_t allocman_mem[SERSERV_TEST_N_CLIENTS][SERSERV_TEST_ALLOCMAN_PREALLOCATED_MEMSIZE]; |
| } static client_globals; |
| |
| /* These next few functions (client_*_main())are the actual tests that are run |
| * by the client threads and processes for the concurrency tests. |
| */ |
| |
| /** This function will guide a client thread to connect to the server and return the |
| * result. |
| */ |
| static int client_connect_main(client_test_data_t *self, vka_t *vka, vspace_t *vspace) |
| { |
| int error = 0; |
| serial_client_context_t conn; |
| |
| error = serial_server_client_connect(self->badged_server_ep_cspath.capPtr, |
| vka, vspace, |
| &conn); |
| return error; |
| } |
| |
| /** This function will guide a client thread to connect to the server, send a |
| * printf() request, and return the result. |
| */ |
| static int client_printf_main(client_test_data_t *self, vka_t *vka, vspace_t *vspace) |
| { |
| int error; |
| serial_client_context_t conn; |
| |
| error = serial_server_client_connect(self->badged_server_ep_cspath.capPtr, |
| vka, vspace, |
| &conn); |
| if (error != 0) { |
| return error; |
| } |
| |
| error = serial_server_printf(&conn, test_str); |
| if (error != strlen(test_str)) { |
| return -1; |
| } |
| return 0; |
| } |
| |
| /** This function will guide a client thread to connect to the server, send a |
| * write() request, and return the result. |
| */ |
| static int client_write_main(client_test_data_t *self, vka_t *vka, vspace_t *vspace) |
| { |
| int error; |
| serial_client_context_t conn; |
| |
| error = serial_server_client_connect(self->badged_server_ep_cspath.capPtr, |
| vka, vspace, |
| &conn); |
| if (error != 0) { |
| return error; |
| } |
| |
| error = serial_server_write(&conn, test_str, strlen(test_str)); |
| if (error != strlen(test_str)) { |
| return -1; |
| } |
| return 0; |
| } |
| |
| /** This function will guide a client thread to connect to the server, send a |
| * printf() request, then a write() request, then disconnect(), and then |
| * reconnect to the Server and send another printf() and another write(), |
| * and return the result. |
| */ |
| static int client_disconnect_reconnect_printf_write_main(client_test_data_t *self, vka_t *vka, vspace_t *vspace) |
| { |
| int error; |
| serial_client_context_t conn; |
| |
| error = serial_server_client_connect(self->badged_server_ep_cspath.capPtr, |
| vka, vspace, |
| &conn); |
| if (error != 0) { |
| return error; |
| } |
| error = serial_server_printf(&conn, test_str); |
| if (error != strlen(test_str)) { |
| return -1; |
| } |
| error = serial_server_write(&conn, test_str, strlen(test_str)); |
| if (error != strlen(test_str)) { |
| return error; |
| } |
| |
| serial_server_disconnect(&conn); |
| |
| error = serial_server_client_connect(self->badged_server_ep_cspath2.capPtr, |
| vka, vspace, |
| &conn); |
| if (error != 0) { |
| return error; |
| } |
| error = serial_server_printf(&conn, test_str); |
| if (error != strlen(test_str)) { |
| return -1; |
| } |
| error = serial_server_write(&conn, test_str, strlen(test_str)); |
| if (error != strlen(test_str)) { |
| return -1; |
| } |
| return 0; |
| } |
| |
| /** This function will guide a client thread to connect to the server, and then |
| * send a kill() request. |
| */ |
| static int client_disconnect_main(client_test_data_t *self, vka_t *vka, vspace_t *vspace) |
| { |
| int error; |
| serial_client_context_t conn; |
| |
| error = serial_server_client_connect(self->badged_server_ep_cspath.capPtr, |
| vka, vspace, |
| &conn); |
| if (error != 0) { |
| return error; |
| } |
| |
| serial_server_disconnect(&conn); |
| return 0; |
| } |
| |
| static void init_file_globals(struct env *env) |
| { |
| memset(client_globals.client_test_data, 0, |
| sizeof(client_globals.client_test_data)); |
| |
| memset(client_globals.allocman_mem, 0, sizeof(client_globals.allocman_mem)); |
| |
| client_globals.vka = &env->vka; |
| client_globals.vspace = &env->vspace; |
| client_globals.simple = &env->simple; |
| } |
| |
| static int mint_server_ep_to_clients(struct env *env, bool mint_2nd_ep) |
| { |
| int error; |
| |
| for (int i = 0; i < SERSERV_TEST_N_CLIENTS; i++) { |
| /* Ask the serserv library to mint the Server's EP to all the new clients. */ |
| client_test_data_t *curr_client = &client_globals.client_test_data[i]; |
| |
| if (curr_client->thread.is_process) { |
| curr_client->badged_server_ep_cspath.capPtr = serial_server_parent_mint_endpoint_to_process( |
| &curr_client->thread.process); |
| if (curr_client->badged_server_ep_cspath.capPtr == 0) { |
| return -1; |
| } |
| } else { |
| error = serial_server_parent_vka_mint_endpoint(&env->vka, |
| &curr_client->badged_server_ep_cspath); |
| if (error != 0) { |
| return -1; |
| } |
| } |
| |
| if (mint_2nd_ep) { |
| if (curr_client->thread.is_process) { |
| curr_client->badged_server_ep_cspath2.capPtr = serial_server_parent_mint_endpoint_to_process( |
| &curr_client->thread.process); |
| if (curr_client->badged_server_ep_cspath2.capPtr == 0) { |
| return -1; |
| } |
| } else { |
| error = serial_server_parent_vka_mint_endpoint(&env->vka, |
| &curr_client->badged_server_ep_cspath2); |
| if (error != 0) { |
| return -1; |
| } |
| } |
| } |
| } |
| return 0; |
| } |
| |
| static void create_clients(struct env *env, bool is_process) |
| { |
| for (int i = 0; i < SERSERV_TEST_N_CLIENTS; i++) { |
| client_test_data_t *curr_client = &client_globals.client_test_data[i]; |
| |
| if (is_process) { |
| create_helper_process(env, &curr_client->thread); |
| } else { |
| create_helper_thread(env, &curr_client->thread); |
| } |
| } |
| } |
| |
| /** Guides a client "process" to set up a vspace_t instance for its new VSpace. |
| * |
| * This basically entails setting up an allocman_t instance, followed by a |
| * vka_t instance and finally a vspace_t instance. The function requires an |
| * untyped of a "reasonable" size (you determine this based on what this new |
| * process will be doing), a list of used pages in the new process' VSpace, |
| * some allocman initial mem and your pointers. |
| * |
| * @param ut_cap CPtr to an untyped of "reasonable" size that was copied to the |
| * new process before this function was invoked. |
| * @param ut_size_bits The size in bits of the untyped "ut_cap". |
| * @param used_pages_list A NULL-terminated list of virtual pages that are |
| * already occupied within this new process' VSpace. |
| * @param allocman_mem Initial memory set aside for bootstrapping an allocman_t. |
| * @param allocman_mem_size Size of the initial allocman_t memory. |
| * @param allocman[out] Pointer to a pointer to an uninitialized allocman_t |
| * instance. Will be returned with an initialized |
| * allocman_t if this function completes successfully. |
| * @param vka[out] Pointer to an uninitialized vka_t instance. |
| * @param vspace[out] Pointer to an uninitialized vspace_t instance. |
| * @param alloc_data[out] Pointer to an uninitialized alloc data structure. |
| * @return 0 on success; non-zero on error. |
| */ |
| static int setup_client_process_allocman_vka_and_vspace(seL4_CPtr ut_cap, size_t ut_size_bits, |
| seL4_CPtr first_free_cptr, |
| volatile void **used_pages_list, |
| uint8_t *allocman_mem, size_t allocman_mem_size, |
| allocman_t **allocman, |
| vka_t *vka, vspace_t *vspace, |
| sel4utils_alloc_data_t *alloc_data) |
| { |
| cspacepath_t ut_cspath; |
| uintptr_t paddr; |
| int error; |
| |
| if (used_pages_list == NULL || allocman_mem == NULL |
| || allocman == NULL || vspace == NULL || vka == NULL |
| || alloc_data == NULL || allocman_mem_size == 0) { |
| return seL4_InvalidArgument; |
| } |
| *allocman = bootstrap_use_current_1level(SEL4UTILS_CNODE_SLOT, |
| TEST_PROCESS_CSPACE_SIZE_BITS, |
| first_free_cptr, |
| BIT(TEST_PROCESS_CSPACE_SIZE_BITS), |
| allocman_mem_size, |
| allocman_mem); |
| if (*allocman == NULL) { |
| return -1; |
| } |
| |
| allocman_make_vka(vka, *allocman); |
| vka_cspace_make_path(vka, ut_cap, &ut_cspath); |
| error = allocman_utspace_add_uts(*allocman, 1, &ut_cspath, |
| &ut_size_bits, |
| &paddr, ALLOCMAN_UT_KERNEL); |
| if (error != 0) { |
| return error; |
| } |
| |
| /* Pass the shmem page containing the list of already allocated frames, to |
| * the vspace bootstrap. |
| */ |
| return sel4utils_bootstrap_vspace_leaky(vspace, alloc_data, |
| SEL4UTILS_PD_SLOT, vka, |
| (void **)used_pages_list); |
| } |
| |
| /** Common entry point for all client thread and processes alike. |
| * |
| * This is what is passed to start_helper so that it can do its init work. |
| * This function invokes the actual test routine after it finishes working. |
| * |
| * Determines whether the new client is a thread or process. If it's a process |
| * we do some extra processing, vis-a-vis setting up the new process' own |
| * vka, vspace and allocman, so it can call the library. |
| * |
| * @param _test_fn The actual test function that is to be invoked. |
| * @param _used_pages_list List of used virtual pages in the VSpace of the new |
| * client. This is used to initialize the new client's |
| * vspace_t instance. |
| * @param n_used_pages Number of elements in the _used_pages_list. |
| * @param thread_num The "ID" of this thread as the parent assigned it. |
| * @return 0 on success; non-zero on error. |
| */ |
| static int client_common_entry_point(seL4_Word _test_fn, seL4_Word _used_pages_list, |
| seL4_Word n_used_pages, seL4_Word thread_num) |
| { |
| bool is_process; |
| client_test_data_t *client_data; |
| volatile void **used_pages_list = (volatile void **)_used_pages_list; |
| client_test_fn *test_fn = (client_test_fn *)_test_fn; |
| int error; |
| vka_t *vka, _vka; |
| vspace_t *vspace, _vspace; |
| sel4utils_alloc_data_t alloc_data; |
| allocman_t *allocman; |
| |
| is_process = used_pages_list != NULL; |
| |
| if (is_process) { |
| /* +1 because the list is NULL terminated and we want to get past the |
| * end of the list. |
| */ |
| client_data = (client_test_data_t *)&used_pages_list[n_used_pages + 1]; |
| vka = &_vka; |
| vspace = &_vspace; |
| error = setup_client_process_allocman_vka_and_vspace(client_data->ut_512k_cspath.capPtr, |
| BYTES_TO_SIZE_BITS(SERSERV_TEST_UT_SIZE), |
| client_data->ut_512k_cspath.capPtr + 0x8, |
| used_pages_list, |
| client_globals.allocman_mem[thread_num], |
| SERSERV_TEST_ALLOCMAN_PREALLOCATED_MEMSIZE, |
| &allocman, |
| vka, vspace, |
| &alloc_data); |
| test_eq(error, 0); |
| } else { |
| client_data = &client_globals.client_test_data[thread_num]; |
| vka = client_globals.vka; |
| vspace = client_globals.vspace; |
| } |
| return test_fn(client_data, vka, vspace); |
| } |
| |
| static void start_clients(struct env *env, client_test_fn *test_fn) |
| { |
| bool is_process = client_globals.client_test_data[0].thread.is_process; |
| |
| for (int i = 0; i < SERSERV_TEST_N_CLIENTS; i++) { |
| client_test_data_t *curr_client = &client_globals.client_test_data[i]; |
| /* The client threads don't need a list of used pages. The client |
| * processes do need it -- so if the used pages list is NULL, the newly |
| * spawned client assumes it's a thread and not a process. |
| */ |
| volatile void **used_pages_list = ((is_process) |
| ? (volatile void **)curr_client->client_used_pages_list |
| : NULL); |
| |
| set_helper_priority(env, &curr_client->thread, SERSERV_TEST_PRIO_CLIENT); |
| start_helper(env, &curr_client->thread, &client_common_entry_point, |
| (seL4_Word)test_fn, |
| (seL4_Word)used_pages_list, |
| curr_client->n_used_pages, |
| i); |
| } |
| } |
| |
| static void cleanup_clients(struct env *env) |
| { |
| for (int i = 0; i < SERSERV_TEST_N_CLIENTS; i++) { |
| helper_thread_t *curr_client = &client_globals.client_test_data[i].thread; |
| cleanup_helper(env, curr_client); |
| } |
| } |
| |
| /** Compiles a list of pages that libsel4utils allocated while creating a |
| * thread in a new VSpace. |
| * |
| * This is useful if you want your new process to be able to initialize its own |
| * vspace_t, because you will need to have a list of pages that are occupied in |
| * the new VSpace, in order to get a usable vspace_t for that VSpace. |
| * You need to allocate the memory for page_list yourself. |
| * |
| * @param page_list The base vaddr of a page in the PARENT VSpace (the thread |
| * that is spawning the new thread), that will be used as the |
| * shared mem for telling the new thread which pages in its |
| * VSpace are occupied. |
| * @param p Initialized sel4utils_process_t handle for the new thread. |
| * @return 0 on success; Positive integer count of the number of used pages |
| * whose vaddrs were filled into the page_list on success. |
| */ |
| static int fill_sel4utils_used_pages_list(volatile void **page_list, sel4utils_process_t *p) |
| { |
| seL4_Word sel4utils_stack_n_pages, sel4utils_stack_base_vaddr; |
| |
| if (page_list == NULL || p == NULL) { |
| return -1; |
| } |
| |
| /* Need to fill in the vaddrs for its stack and IPC buffer. |
| */ |
| |
| /* libsel4utils adds another page for guard */ |
| sel4utils_stack_n_pages = BYTES_TO_4K_PAGES(CONFIG_SEL4UTILS_STACK_SIZE) + 1; |
| sel4utils_stack_base_vaddr = (uintptr_t)p->thread.stack_top - (sel4utils_stack_n_pages * BIT(seL4_PageBits)); |
| for (int i = 0; i < sel4utils_stack_n_pages; i++) { |
| *page_list = (void *)sel4utils_stack_base_vaddr; |
| sel4utils_stack_base_vaddr += BIT(seL4_PageBits); |
| page_list++; |
| } |
| |
| /* Next take care of the IPC buffer */ |
| *page_list = (void *)p->thread.ipc_buffer_addr; |
| page_list++; |
| /* NULL terminate the list */ |
| *page_list = NULL; |
| |
| /* Stack pages + IPC buffer */ |
| return sel4utils_stack_n_pages + 1; |
| } |
| |
| /** Shares a used page list to a target process that was created by sel4utils. |
| * |
| * @param page_list Page that has been filled out with a list of pages used by |
| * sel4utils_configure_process. |
| * @param n_entries Number of entries in the page_list. |
| * @param from_vspace Initialized vspace_t for the parent process (that is doing |
| * the spawning). |
| * @param p Initialized sel4utils_process_t for the new process. |
| * @param target_vaddr[out] The vaddr that the NEW process can access the |
| * used pages list at, within ITS own VSpace. |
| * @return Negative integer on failure. Positive integer on success, which |
| * represents the number of ADDITIONAL used pages filled in by this |
| * function invocation. |
| */ |
| static int share_sel4utils_used_pages_list(volatile void **page_list, size_t n_entries, |
| vspace_t *from_vspace, |
| sel4utils_process_t *p, |
| volatile void **target_vaddr) |
| { |
| vspace_t *to_vspace; |
| |
| if (page_list == NULL || from_vspace == NULL || p == NULL |
| || target_vaddr == NULL) { |
| return -1; |
| } |
| |
| to_vspace = &p->vspace; |
| *target_vaddr = vspace_share_mem(from_vspace, to_vspace, |
| (void *)ALIGN_DOWN((uintptr_t)page_list, BIT(seL4_PageBits)), |
| 1, seL4_PageBits, |
| seL4_AllRights, true); |
| if (*target_vaddr == NULL) { |
| return -1; |
| } |
| /* Don't forget to add the offset back if the page_list vaddr was not |
| * page aligned |
| */ |
| *target_vaddr = (void *)((uintptr_t) * target_vaddr |
| + ((uintptr_t)page_list & (BIT(seL4_PageBits) - 1))); |
| /* Next, take care of the shmem page we ourselves created in this |
| * function |
| */ |
| page_list[n_entries] = *target_vaddr; |
| return 1; |
| } |
| |
| /** For each new client process, fill out a list of virtual pages that will be |
| * occupied in its VSpace before it even begins executing. |
| * |
| * The client will use this list to initialize a vspace_t instance. This is |
| * called in the Parent, before the clients are allowed to execute. |
| * @return 0 on success; non-zero on error. |
| */ |
| static int setup_pclient_used_pages_lists(struct env *env) |
| { |
| int error; |
| |
| for (int i = 0; i < SERSERV_TEST_N_CLIENTS; i++) { |
| client_test_data_t *curr_client = &client_globals.client_test_data[i]; |
| |
| /* Allocate the page in our VSpace */ |
| curr_client->parent_used_pages_list = (volatile void **)vspace_new_pages( |
| &env->vspace, |
| seL4_AllRights, |
| 1, seL4_PageBits); |
| if (curr_client->parent_used_pages_list == NULL) { |
| return -1; |
| } |
| |
| /* Give the page to fill_sel4utils_used_pages and let it fill out the |
| * pages it used in the new process' VSpace. |
| */ |
| curr_client->n_used_pages = fill_sel4utils_used_pages_list( |
| curr_client->parent_used_pages_list, |
| &curr_client->thread.process); |
| if (curr_client->n_used_pages < 0) { |
| return -1; |
| } |
| |
| /* Share the page containing the used pages list with the new process */ |
| error = share_sel4utils_used_pages_list(curr_client->parent_used_pages_list, |
| curr_client->n_used_pages, |
| &env->vspace, |
| &curr_client->thread.process, |
| &curr_client->client_used_pages_list); |
| if (error < 0) { |
| return -1; |
| } |
| curr_client->n_used_pages += error; |
| /* NULL terminate the list since we added to it. */ |
| curr_client->parent_used_pages_list[curr_client->n_used_pages] = NULL; |
| } |
| return 0; |
| } |
| |
| /** The new client processes each need an untyped of some size so they can |
| * allocate memory. |
| * |
| * 512k seems reasonably large (if not a little too large). Allocate an untyped |
| * for each new client process. This is called in the parent, before the test |
| * clients are allowed to execute. |
| * @return 0 on success; Non-zero on error. |
| */ |
| static int alloc_untypeds_for_clients(struct env *env) |
| { |
| int error; |
| |
| for (int i = 0; i < SERSERV_TEST_N_CLIENTS; i++) { |
| client_test_data_t *curr_client = &client_globals.client_test_data[i]; |
| vka_object_t tmp; |
| |
| error = vka_alloc_untyped(&env->vka, BYTES_TO_SIZE_BITS(SERSERV_TEST_UT_SIZE), &tmp); |
| if (error != 0) { |
| return error; |
| } |
| |
| vka_cspace_make_path(&env->vka, tmp.cptr, &curr_client->ut_512k_cspath); |
| curr_client->ut_512k_cspath.capPtr = sel4utils_move_cap_to_process( |
| &curr_client->thread.process, |
| curr_client->ut_512k_cspath, |
| &env->vka); |
| if (curr_client->ut_512k_cspath.capPtr == 0) { |
| return -1; |
| } |
| } |
| return 0; |
| } |
| |
| static void copy_client_data_to_shmem(struct env *env) |
| { |
| for (int i = 0; i < SERSERV_TEST_N_CLIENTS; i++) { |
| client_test_data_t *curr_client = &client_globals.client_test_data[i]; |
| /* +1 because the list is NULL terminated and we want to get past the |
| * end of the list. |
| */ |
| void *client_data_copy = &curr_client->parent_used_pages_list[ |
| curr_client->n_used_pages + 1]; |
| |
| memcpy(client_data_copy, curr_client, sizeof(*curr_client)); |
| } |
| } |
| |
| static int concurrency_test_common(struct env *env, bool is_process, client_test_fn *test_fn, bool mint_2nd_ep_cap) |
| { |
| int error; |
| |
| error = serial_server_parent_spawn_thread(&env->simple, |
| &env->vka, &env->vspace, |
| SERSERV_TEST_PRIO_SERVER); |
| |
| test_eq(error, 0); |
| |
| init_file_globals(env); |
| create_clients(env, is_process); |
| error = mint_server_ep_to_clients(env, mint_2nd_ep_cap); |
| test_eq(error, 0); |
| |
| if (is_process) { |
| /* Setup the extra things that a new VSpace/CSpace needs. |
| */ |
| error = setup_pclient_used_pages_lists(env); |
| test_eq(error, 0); |
| error = alloc_untypeds_for_clients(env); |
| test_eq(error, 0); |
| copy_client_data_to_shmem(env); |
| }; |
| |
| start_clients(env, test_fn); |
| |
| for (int i = 0; i < SERSERV_TEST_N_CLIENTS; i++) { |
| error = wait_for_helper(&client_globals.client_test_data[i].thread); |
| test_eq(error, 0); |
| } |
| |
| cleanup_clients(env); |
| return 0; |
| } |
| |
| static int test_client_connect(struct env *env) |
| { |
| int error; |
| |
| error = concurrency_test_common(env, false, &client_connect_main, false); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLIENT_001, "Connect from client threads", |
| test_client_connect, true) |
| |
| static int |
| test_client_printf(struct env *env) |
| { |
| int error; |
| |
| error = concurrency_test_common(env, false, &client_printf_main, false); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLIENT_002, "Printf from client threads", |
| test_client_printf, true) |
| |
| static int |
| test_client_write(struct env *env) |
| { |
| int error; |
| |
| error = concurrency_test_common(env, false, &client_write_main, false); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLIENT_003, "Write from client threads", |
| test_client_write, true) |
| |
| static int |
| test_client_disconnect_reconnect_printf_write(struct env *env) |
| { |
| int error; |
| |
| error = concurrency_test_common(env, false, &client_disconnect_reconnect_printf_write_main, true); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLIENT_004, "Printf, then write, then reset connection, and " |
| "Printf, then write again, from client threads", |
| test_client_disconnect_reconnect_printf_write, true) |
| |
| static int |
| test_client_kill(struct env *env) |
| { |
| int error; |
| cspacepath_t parent_badged_server_ep_cspath; |
| serial_client_context_t conn; |
| |
| error = concurrency_test_common(env, false, &client_disconnect_main, false); |
| test_eq(error, 0); |
| |
| error = serial_server_parent_vka_mint_endpoint(&env->vka, |
| &parent_badged_server_ep_cspath); |
| test_eq(error, 0); |
| |
| error = serial_server_client_connect(parent_badged_server_ep_cspath.capPtr, |
| &env->vka, &env->vspace, &conn); |
| test_eq(error, 0); |
| |
| error = serial_server_kill(&conn); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLIENT_005, "Connect, then disconnect from server on all " |
| "threads, then kill server from parent thread", |
| test_client_kill, true) |
| |
| static int |
| test_client_process_connect(struct env *env) |
| { |
| int error; |
| |
| error = concurrency_test_common(env, true, &client_connect_main, false); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLI_PROC_001, "Connect to server from a client in another " |
| "VSpace and CSpace", test_client_process_connect, true) |
| |
| static int |
| test_client_process_printf(struct env *env) |
| { |
| int error; |
| |
| error = concurrency_test_common(env, true, &client_printf_main, false); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLI_PROC_002, "Connect to server and printf(, true), from a client " |
| "in another VSpace and CSpace", test_client_process_printf, true) |
| |
| static int |
| test_client_process_write(struct env *env) |
| { |
| int error; |
| |
| error = concurrency_test_common(env, true, &client_write_main, false); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLI_PROC_003, "Connect to server and write(, true), from a client " |
| "in another VSpace and CSpace", test_client_process_write, true) |
| |
| static int |
| test_client_process_disconnect_reconnect_printf_write(struct env *env) |
| { |
| int error; |
| |
| error = concurrency_test_common(env, true, |
| &client_disconnect_reconnect_printf_write_main, |
| true); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLI_PROC_004, "Connect to server, printf(), write(, true), then " |
| "disconnect, then reconnect and printf() and write() again, from " |
| "clients in other VSpaces and CSpaces", |
| test_client_process_disconnect_reconnect_printf_write, true) |
| |
| static int |
| test_client_process_kill(struct env *env) |
| { |
| int error; |
| serial_client_context_t conn; |
| cspacepath_t badged_server_ep_cspath; |
| |
| error = concurrency_test_common(env, true, &client_disconnect_main, false); |
| test_eq(error, 0); |
| |
| error = serial_server_parent_vka_mint_endpoint(&env->vka, &badged_server_ep_cspath); |
| test_eq(error, 0); |
| |
| error = serial_server_client_connect(badged_server_ep_cspath.capPtr, |
| &env->vka, &env->vspace, &conn); |
| test_eq(error, 0); |
| error = serial_server_kill(&conn); |
| test_eq(error, 0); |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST(SERSERV_CLI_PROC_005, "Connect to server then disconnect on all " |
| "clients (in different VSpace/CSpace containers), and finally kill " |
| "the server from the parent", |
| test_client_process_kill, true) |
