Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/test/ipc-test/main.c

    rd53a5ab0 rfafb8e5  
    11/*
    2  * Copyright (c) 2023 Jiri Svoboda
     2 * Copyright (c) 2018 Jiri Svoboda
    33 * All rights reserved.
    44 *
     
    4848#include <mem.h>
    4949#include <stdio.h>
    50 #include <stdlib.h>
    5150#include <task.h>
    5251
     
    5453
    5554static service_id_t svc_id;
    56 
    57 enum {
    58         max_rw_buf_size = 16384,
    59 };
    6055
    6156/** Object in read-only memory area that will be shared.
     
    7267 */
    7368static char rw_data[] = "Hello, world!";
    74 
    75 /** Buffer for reading/writing via read/write messages.
    76  *
    77  * It is allocated / size is set by IPC_TEST_SET_RW_BUF_SIZE
    78  */
    79 static void *rw_buf;
    80 /** Read/write buffer size */
    81 size_t rw_buf_size;
    8269
    8370static void ipc_test_get_ro_area_size_srv(ipc_call_t *icall)
     
    195182}
    196183
    197 static void ipc_test_set_rw_buf_size_srv(ipc_call_t *icall)
    198 {
    199         size_t size;
    200         void *nbuf;
    201 
    202         log_msg(LOG_DEFAULT, LVL_DEBUG, "ipc_test_set_rw_buf_size_srv");
    203 
    204         size = ipc_get_arg1(icall);
    205 
    206         if (size == 0) {
    207                 async_answer_0(icall, ERANGE);
    208                 log_msg(LOG_DEFAULT, LVL_ERROR,
    209                     "Requested read/write buffer size is zero.");
    210                 return;
    211         }
    212 
    213         if (size > max_rw_buf_size) {
    214                 async_answer_0(icall, ERANGE);
    215                 log_msg(LOG_DEFAULT, LVL_ERROR, "Requested read/write buffer "
    216                     "size > %u", max_rw_buf_size);
    217                 return;
    218         }
    219 
    220         nbuf = realloc(rw_buf, size);
    221         if (nbuf == NULL) {
    222                 async_answer_0(icall, ENOMEM);
    223                 log_msg(LOG_DEFAULT, LVL_ERROR, "Out of memory.");
    224                 return;
    225         }
    226 
    227         rw_buf = nbuf;
    228         rw_buf_size = size;
    229         async_answer_0(icall, EOK);
    230 }
    231 
    232 static void ipc_test_read_srv(ipc_call_t *icall)
    233 {
    234         ipc_call_t call;
    235         errno_t rc;
    236         size_t size;
    237 
    238         log_msg(LOG_DEFAULT, LVL_DEBUG, "ipc_test_read_srv");
    239 
    240         if (!async_data_read_receive(&call, &size)) {
    241                 async_answer_0(icall, EREFUSED);
    242                 log_msg(LOG_DEFAULT, LVL_ERROR, "data_read_receive failed");
    243                 return;
    244         }
    245 
    246         if (size > rw_buf_size) {
    247                 async_answer_0(&call, EINVAL);
    248                 async_answer_0(icall, EINVAL);
    249                 log_msg(LOG_DEFAULT, LVL_ERROR, "Invalid read size.");
    250                 return;
    251         }
    252 
    253         rc = async_data_read_finalize(&call, rw_buf, size);
    254         if (rc != EOK) {
    255                 log_msg(LOG_DEFAULT, LVL_ERROR,
    256                     "data_read_finalize failed");
    257                 async_answer_0(icall, EINVAL);
    258                 return;
    259         }
    260 
    261         async_answer_0(icall, EOK);
    262 }
    263 
    264 static void ipc_test_write_srv(ipc_call_t *icall)
    265 {
    266         ipc_call_t call;
    267         errno_t rc;
    268         size_t size;
    269 
    270         log_msg(LOG_DEFAULT, LVL_DEBUG, "ipc_test_write_srv");
    271 
    272         if (!async_data_write_receive(&call, &size)) {
    273                 async_answer_0(icall, EREFUSED);
    274                 log_msg(LOG_DEFAULT, LVL_ERROR, "data_write_receive failed");
    275                 return;
    276         }
    277 
    278         if (size > rw_buf_size) {
    279                 async_answer_0(&call, EINVAL);
    280                 async_answer_0(icall, EINVAL);
    281                 log_msg(LOG_DEFAULT, LVL_ERROR, "Invalid write size.");
    282                 return;
    283         }
    284 
    285         rc = async_data_write_finalize(&call, rw_buf, size);
    286         if (rc != EOK) {
    287                 log_msg(LOG_DEFAULT, LVL_ERROR,
    288                     "data_write_finalize failed");
    289                 async_answer_0(icall, EINVAL);
    290                 return;
    291         }
    292 
    293         async_answer_0(icall, EOK);
    294 }
    295 
    296184static void ipc_test_connection(ipc_call_t *icall, void *arg)
    297185{
     
    324212                        ipc_test_share_in_rw_srv(&call);
    325213                        break;
    326                 case IPC_TEST_SET_RW_BUF_SIZE:
    327                         ipc_test_set_rw_buf_size_srv(&call);
    328                         break;
    329                 case IPC_TEST_READ:
    330                         ipc_test_read_srv(&call);
    331                         break;
    332                 case IPC_TEST_WRITE:
    333                         ipc_test_write_srv(&call);
    334                         break;
    335214                default:
    336215                        async_answer_0(&call, ENOTSUP);
     
    343222{
    344223        errno_t rc;
    345         loc_srv_t *srv;
    346224
    347225        printf("%s: IPC test service\n", NAME);
     
    354232        }
    355233
    356         rc = loc_server_register(NAME, &srv);
     234        rc = loc_server_register(NAME);
    357235        if (rc != EOK) {
    358236                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server. (%s)\n",
     
    361239        }
    362240
    363         rc = loc_service_register(srv, SERVICE_NAME_IPC_TEST, &svc_id);
    364         if (rc != EOK) {
    365                 loc_server_unregister(srv);
     241        rc = loc_service_register(SERVICE_NAME_IPC_TEST, &svc_id);
     242        if (rc != EOK) {
    366243                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service. (%s)\n",
    367244                    str_error(rc));
Note: See TracChangeset for help on using the changeset viewer.