Changeset c0757e1f in mainline for uspace/lib/dispcfg


Ignore:
Timestamp:
2023-04-19T11:13:06Z (2 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
37087c8
Parents:
ec8ef12
Message:

UI display configuration utility

In addition to the command-line utility 'disp', we introduce its UI
equivalent 'display-cfg'. Currently this allows the user to configure
seats in a very comfortable way.

Location:
uspace/lib/dispcfg
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/dispcfg/include/dispcfg.h

    rec8ef12 rc0757e1f  
    5151extern errno_t dispcfg_dev_assign(dispcfg_t *, sysarg_t, sysarg_t);
    5252extern errno_t dispcfg_dev_unassign(dispcfg_t *, sysarg_t);
     53extern errno_t dispcfg_get_asgn_dev_list(dispcfg_t *, sysarg_t,
     54    dispcfg_dev_list_t **);
     55extern void dispcfg_free_dev_list(dispcfg_dev_list_t *);
    5356
    5457#endif

  • uspace/lib/dispcfg/include/dispcfg_srv.h

    rec8ef12 rc0757e1f  
    5656        errno_t (*dev_assign)(void *, sysarg_t, sysarg_t);
    5757        errno_t (*dev_unassign)(void *, sysarg_t);
     58        errno_t (*get_asgn_dev_list)(void *, sysarg_t, dispcfg_dev_list_t **);
    5859        errno_t (*get_event)(void *, dispcfg_ev_t *);
    5960};

  • uspace/lib/dispcfg/include/ipc/dispcfg.h

    rec8ef12 rc0757e1f  
    4646        DISPCFG_DEV_ASSIGN,
    4747        DISPCFG_DEV_UNASSIGN,
     48        DISPCFG_GET_ASGN_DEV_LIST,
    4849        DISPCFG_GET_EVENT,
    4950} dispcfg_request_t;

  • uspace/lib/dispcfg/include/types/dispcfg.h

    rec8ef12 rc0757e1f  
    8585} dispcfg_seat_info_t;
    8686
     87/** Assigned device list */
     88typedef struct {
     89        /** Number of devices */
     90        size_t ndevs;
     91        /** ID for each device */
     92        sysarg_t *devs;
     93} dispcfg_dev_list_t;
     94
    8795#endif
    8896

  • uspace/lib/dispcfg/src/dispcfg.c

    rec8ef12 rc0757e1f  
    206206/** Free seat list.
    207207 *
    208  * @param list Display configuration list
     208 * @param list Seat list
    209209 */
    210210void dispcfg_free_seat_list(dispcfg_seat_list_t *list)
    … …  
    277277/** Free seat information.
    278278 *
    279  * @param info Display configuration information
     279 * @param info Seat information
    280280 */
    281281void dispcfg_free_seat_info(dispcfg_seat_info_t *info)
    … …  
    378378        async_exchange_end(exch);
    379379        return rc;
     380}
     381
     382/** Get list of devices assigned to a seat.
     383 *
     384 * @param dispcfg Display configuration
     385 * @param seat_id Seat ID
     386 * @param rlist Place to store pointer to new device list structure
     387 * @return EOK on success or an error code
     388 */
     389errno_t dispcfg_get_asgn_dev_list(dispcfg_t *dispcfg, sysarg_t seat_id,
     390    dispcfg_dev_list_t **rlist)
     391{
     392        async_exch_t *exch;
     393        aid_t req;
     394        ipc_call_t answer;
     395        dispcfg_dev_list_t *list;
     396        sysarg_t ndevs;
     397        sysarg_t *devs;
     398        errno_t rc;
     399
     400        exch = async_exchange_begin(dispcfg->sess);
     401        req = async_send_1(exch, DISPCFG_GET_ASGN_DEV_LIST, seat_id, &answer);
     402
     403        /* Receive device list length */
     404        rc = async_data_read_start(exch, &ndevs, sizeof (ndevs));
     405        if (rc != EOK) {
     406                async_exchange_end(exch);
     407                async_wait_for(req, &rc);
     408                return rc;
     409        }
     410
     411        devs = calloc(ndevs, sizeof(sysarg_t));
     412        if (devs == NULL) {
     413                async_exchange_end(exch);
     414                async_forget(req);
     415                return ENOMEM;
     416        }
     417
     418        /* Receive device list */
     419        rc = async_data_read_start(exch, devs, ndevs * sizeof (sysarg_t));
     420        async_exchange_end(exch);
     421
     422        if (rc != EOK) {
     423                async_forget(req);
     424                return rc;
     425        }
     426
     427        async_wait_for(req, &rc);
     428        if (rc != EOK)
     429                return rc;
     430
     431        list = calloc(1, sizeof(dispcfg_dev_list_t));
     432        if (list == NULL)
     433                return ENOMEM;
     434
     435        list->ndevs = ndevs;
     436        list->devs = devs;
     437        *rlist = list;
     438        return EOK;
     439}
     440
     441/** Free device list.
     442 *
     443 * @param list Device list
     444 */
     445void dispcfg_free_dev_list(dispcfg_dev_list_t *list)
     446{
     447        free(list->devs);
     448        free(list);
    380449}
    381450

  • uspace/lib/dispcfg/src/dispcfg_srv.c

    rec8ef12 rc0757e1f  
    293293}
    294294
     295static void dispcfg_get_asgn_dev_list_srv(dispcfg_srv_t *srv, ipc_call_t *icall)
     296{
     297        sysarg_t seat_id;
     298        ipc_call_t call;
     299        dispcfg_dev_list_t *list = NULL;
     300        size_t size;
     301        errno_t rc;
     302
     303        seat_id = ipc_get_arg1(icall);
     304
     305        if (srv->ops->get_asgn_dev_list == NULL) {
     306                async_answer_0(icall, ENOTSUP);
     307                return;
     308        }
     309
     310        rc = srv->ops->get_asgn_dev_list(srv->arg, seat_id, &list);
     311        if (rc != EOK) {
     312                async_answer_0(icall, rc);
     313                return;
     314        }
     315
     316        /* Send list size */
     317
     318        if (!async_data_read_receive(&call, &size)) {
     319                dispcfg_free_dev_list(list);
     320                async_answer_0(&call, EREFUSED);
     321                async_answer_0(icall, EREFUSED);
     322                return;
     323        }
     324
     325        if (size != sizeof(list->ndevs)) {
     326                dispcfg_free_dev_list(list);
     327                async_answer_0(&call, EINVAL);
     328                async_answer_0(icall, EINVAL);
     329                return;
     330        }
     331
     332        rc = async_data_read_finalize(&call, &list->ndevs, size);
     333        if (rc != EOK) {
     334                dispcfg_free_dev_list(list);
     335                async_answer_0(&call, rc);
     336                async_answer_0(icall, rc);
     337                return;
     338        }
     339
     340        /* Send device list */
     341
     342        if (!async_data_read_receive(&call, &size)) {
     343                dispcfg_free_dev_list(list);
     344                async_answer_0(&call, EREFUSED);
     345                async_answer_0(icall, EREFUSED);
     346                return;
     347        }
     348
     349        if (size != list->ndevs * sizeof(sysarg_t)) {
     350                dispcfg_free_dev_list(list);
     351                async_answer_0(&call, EINVAL);
     352                async_answer_0(icall, EINVAL);
     353                return;
     354        }
     355
     356        rc = async_data_read_finalize(&call, list->devs, size);
     357        if (rc != EOK) {
     358                dispcfg_free_dev_list(list);
     359                async_answer_0(&call, rc);
     360                async_answer_0(icall, rc);
     361                return;
     362        }
     363
     364        async_answer_0(icall, EOK);
     365        dispcfg_free_dev_list(list);
     366}
     367
    295368static void dispcfg_get_event_srv(dispcfg_srv_t *srv, ipc_call_t *icall)
    296369{
    … …  
    372445                case DISPCFG_DEV_UNASSIGN:
    373446                        dispcfg_dev_unassign_srv(srv, &call);
     447                        break;
     448                case DISPCFG_GET_ASGN_DEV_LIST:
     449                        dispcfg_get_asgn_dev_list_srv(srv, &call);
    374450                        break;
    375451                case DISPCFG_GET_EVENT:

  • uspace/lib/dispcfg/test/dispcfg.c

    rec8ef12 rc0757e1f  
    5252static errno_t test_dev_assign(void *, sysarg_t, sysarg_t);
    5353static errno_t test_dev_unassign(void *, sysarg_t);
     54static errno_t test_get_asgn_dev_list(void *, sysarg_t, dispcfg_dev_list_t **);
    5455static errno_t test_get_event(void *, dispcfg_ev_t *);
    5556
    … …  
    6465        .dev_assign = test_dev_assign,
    6566        .dev_unassign = test_dev_unassign,
     67        .get_asgn_dev_list = test_get_asgn_dev_list,
    6668        .get_event = test_get_event
    6769};
    … …  
    102104        bool dev_unassign_called;
    103105        sysarg_t dev_unassign_svc_id;
     106
     107        bool get_asgn_dev_list_called;
     108        sysarg_t get_asgn_dev_list_seat_id;
     109        dispcfg_dev_list_t *get_asgn_dev_list_rlist;
    104110
    105111        bool get_event_called;
    … …  
    604610}
    605611
     612/** dispcfg_get_asgn_dev_list() with server returning error response works */
     613PCUT_TEST(get_asgn_dev_list_failure)
     614{
     615        errno_t rc;
     616        service_id_t sid;
     617        dispcfg_t *dispcfg = NULL;
     618        dispcfg_dev_list_t *list;
     619        sysarg_t seat_id;
     620        test_response_t resp;
     621
     622        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     623
     624        // FIXME This causes this test to be non-reentrant!
     625        rc = loc_server_register(test_dispcfg_server);
     626        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     627
     628        rc = loc_service_register(test_dispcfg_svc, &sid);
     629        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     630
     631        rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
     632        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     633        PCUT_ASSERT_NOT_NULL(dispcfg);
     634
     635        resp.rc = ENOMEM;
     636        resp.get_asgn_dev_list_called = false;
     637        seat_id = 42;
     638
     639        rc = dispcfg_get_asgn_dev_list(dispcfg, seat_id, &list);
     640        PCUT_ASSERT_TRUE(resp.get_asgn_dev_list_called);
     641        PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_asgn_dev_list_seat_id);
     642        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     643
     644        dispcfg_close(dispcfg);
     645        rc = loc_service_unregister(sid);
     646        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     647}
     648
     649/** dispcfg_get_asgn_dev_list() with server returning success response works */
     650PCUT_TEST(get_asgn_dev_list_success)
     651{
     652        errno_t rc;
     653        service_id_t sid;
     654        dispcfg_t *dispcfg = NULL;
     655        dispcfg_dev_list_t *list;
     656        sysarg_t seat_id;
     657        test_response_t resp;
     658
     659        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     660
     661        // FIXME This causes this test to be non-reentrant!
     662        rc = loc_server_register(test_dispcfg_server);
     663        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     664
     665        rc = loc_service_register(test_dispcfg_svc, &sid);
     666        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     667
     668        rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
     669        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     670        PCUT_ASSERT_NOT_NULL(dispcfg);
     671
     672        resp.rc = EOK;
     673        resp.get_asgn_dev_list_called = false;
     674        resp.get_asgn_dev_list_rlist = calloc(1, sizeof(dispcfg_dev_list_t));
     675        PCUT_ASSERT_NOT_NULL(resp.get_asgn_dev_list_rlist);
     676        resp.get_asgn_dev_list_rlist->ndevs = 2;
     677        resp.get_asgn_dev_list_rlist->devs = calloc(2, sizeof(sysarg_t));
     678        PCUT_ASSERT_NOT_NULL(resp.get_asgn_dev_list_rlist->devs);
     679        resp.get_asgn_dev_list_rlist->devs[0] = 11;
     680        resp.get_asgn_dev_list_rlist->devs[1] = 12;
     681        seat_id = 42;
     682
     683        rc = dispcfg_get_asgn_dev_list(dispcfg, seat_id, &list);
     684        PCUT_ASSERT_TRUE(resp.get_asgn_dev_list_called);
     685        PCUT_ASSERT_INT_EQUALS(seat_id, resp.get_asgn_dev_list_seat_id);
     686        PCUT_ASSERT_ERRNO_VAL(resp.rc, rc);
     687
     688        PCUT_ASSERT_INT_EQUALS(2, list->ndevs);
     689        PCUT_ASSERT_INT_EQUALS(11, list->devs[0]);
     690        PCUT_ASSERT_INT_EQUALS(12, list->devs[1]);
     691
     692        dispcfg_free_dev_list(list);
     693        dispcfg_close(dispcfg);
     694        rc = loc_service_unregister(sid);
     695        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     696}
     697
    606698/** Window added event can be delivered from server to client callback function */
    607699PCUT_TEST(seat_added_deliver)
    … …  
    808900}
    809901
     902static errno_t test_get_asgn_dev_list(void *arg, sysarg_t seat_id,
     903    dispcfg_dev_list_t **rlist)
     904{
     905        test_response_t *resp = (test_response_t *) arg;
     906
     907        resp->get_asgn_dev_list_called = true;
     908        resp->get_asgn_dev_list_seat_id = seat_id;
     909
     910        if (resp->rc != EOK)
     911                return resp->rc;
     912
     913        *rlist = resp->get_asgn_dev_list_rlist;
     914        return EOK;
     915}
     916
    810917static errno_t test_get_event(void *arg, dispcfg_ev_t *event)
    811918{
Note: See TracChangeset for help on using the changeset viewer.