Changeset 4c6fd56 in mainline for uspace/lib/ipcgfx/test/ipcgfx.c


Ignore:
Timestamp:
2023-09-16T19:58:18Z (9 months ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7d7f5e3
Parents:
6a0b2cc
git-author:
Jiri Svoboda <jiri@…> (2023-09-16 19:48:07)
git-committer:
Jiri Svoboda <jiri@…> (2023-09-16 19:58:18)
Message:

loc_server_register() should be callable more than once (API only)

Now loc_server_register() returns a pointer to a loc_srv_t object,
that is then passed to loc_service_register() and
loc_service_add_to_cat().

Added loc_server_unregister() that unregisters the server
and frees the loc_srv_t object.

Updated all callers. The implementation, however, is a stub.
It is not actually possible to call loc_server_register() more
than once, yet.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/ipcgfx/test/ipcgfx.c

    r6a0b2cc r4c6fd56  
    11/*
    2  * Copyright (c) 2021 Jiri Svoboda
     2 * Copyright (c) 2023 Jiri Svoboda
    33 * All rights reserved.
    44 *
     
    120120        async_sess_t *sess;
    121121        ipc_gc_t *ipcgc;
    122 
    123         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    124 
    125         // FIXME This causes this test to be non-reentrant!
    126         rc = loc_server_register(test_ipcgfx_server);
    127         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    128 
    129         rc = loc_service_register(test_ipcgfx_svc, &sid);
     122        loc_srv_t *srv;
     123
     124        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     125
     126        // FIXME This causes this test to be non-reentrant!
     127        rc = loc_server_register(test_ipcgfx_server, &srv);
     128        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     129
     130        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    130131        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    131132
     
    156157        async_hangup(sess);
    157158
    158         rc = loc_service_unregister(sid);
    159         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     159        rc = loc_service_unregister(srv, sid);
     160        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     161        loc_server_unregister(srv);
    160162}
    161163
     
    170172        async_sess_t *sess;
    171173        ipc_gc_t *ipcgc;
    172 
    173         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    174 
    175         // FIXME This causes this test to be non-reentrant!
    176         rc = loc_server_register(test_ipcgfx_server);
    177         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    178 
    179         rc = loc_service_register(test_ipcgfx_svc, &sid);
     174        loc_srv_t *srv;
     175
     176        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     177
     178        // FIXME This causes this test to be non-reentrant!
     179        rc = loc_server_register(test_ipcgfx_server, &srv);
     180        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     181
     182        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    180183        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    181184
     
    207210        async_hangup(sess);
    208211
    209         rc = loc_service_unregister(sid);
    210         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     212        rc = loc_service_unregister(srv, sid);
     213        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     214        loc_server_unregister(srv);
    211215}
    212216
     
    220224        async_sess_t *sess;
    221225        ipc_gc_t *ipcgc;
    222 
    223         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    224 
    225         // FIXME This causes this test to be non-reentrant!
    226         rc = loc_server_register(test_ipcgfx_server);
    227         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    228 
    229         rc = loc_service_register(test_ipcgfx_svc, &sid);
     226        loc_srv_t *srv;
     227
     228        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     229
     230        // FIXME This causes this test to be non-reentrant!
     231        rc = loc_server_register(test_ipcgfx_server, &srv);
     232        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     233
     234        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    230235        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    231236
     
    250255        async_hangup(sess);
    251256
    252         rc = loc_service_unregister(sid);
    253         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     257        rc = loc_service_unregister(srv, sid);
     258        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     259        loc_server_unregister(srv);
    254260}
    255261
     
    264270        async_sess_t *sess;
    265271        ipc_gc_t *ipcgc;
    266 
    267         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    268 
    269         // FIXME This causes this test to be non-reentrant!
    270         rc = loc_server_register(test_ipcgfx_server);
    271         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    272 
    273         rc = loc_service_register(test_ipcgfx_svc, &sid);
     272        loc_srv_t *srv;
     273
     274        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     275
     276        // FIXME This causes this test to be non-reentrant!
     277        rc = loc_server_register(test_ipcgfx_server, &srv);
     278        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     279
     280        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    274281        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    275282
     
    300307        async_hangup(sess);
    301308
    302         rc = loc_service_unregister(sid);
    303         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     309        rc = loc_service_unregister(srv, sid);
     310        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     311        loc_server_unregister(srv);
    304312}
    305313
     
    314322        async_sess_t *sess;
    315323        ipc_gc_t *ipcgc;
    316 
    317         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    318 
    319         // FIXME This causes this test to be non-reentrant!
    320         rc = loc_server_register(test_ipcgfx_server);
    321         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    322 
    323         rc = loc_service_register(test_ipcgfx_svc, &sid);
     324        loc_srv_t *srv;
     325
     326        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     327
     328        // FIXME This causes this test to be non-reentrant!
     329        rc = loc_server_register(test_ipcgfx_server, &srv);
     330        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     331
     332        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    324333        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    325334
     
    350359        async_hangup(sess);
    351360
    352         rc = loc_service_unregister(sid);
    353         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     361        rc = loc_service_unregister(srv, sid);
     362        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     363        loc_server_unregister(srv);
    354364}
    355365
     
    364374        async_sess_t *sess;
    365375        ipc_gc_t *ipcgc;
    366 
    367         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    368 
    369         // FIXME This causes this test to be non-reentrant!
    370         rc = loc_server_register(test_ipcgfx_server);
    371         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    372 
    373         rc = loc_service_register(test_ipcgfx_svc, &sid);
     376        loc_srv_t *srv;
     377
     378        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     379
     380        // FIXME This causes this test to be non-reentrant!
     381        rc = loc_server_register(test_ipcgfx_server, &srv);
     382        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     383
     384        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    374385        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    375386
     
    400411        async_hangup(sess);
    401412
    402         rc = loc_service_unregister(sid);
    403         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     413        rc = loc_service_unregister(srv, sid);
     414        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     415        loc_server_unregister(srv);
    404416}
    405417
     
    414426        async_sess_t *sess;
    415427        ipc_gc_t *ipcgc;
    416 
    417         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    418 
    419         // FIXME This causes this test to be non-reentrant!
    420         rc = loc_server_register(test_ipcgfx_server);
    421         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    422 
    423         rc = loc_service_register(test_ipcgfx_svc, &sid);
     428        loc_srv_t *srv;
     429
     430        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     431
     432        // FIXME This causes this test to be non-reentrant!
     433        rc = loc_server_register(test_ipcgfx_server, &srv);
     434        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     435
     436        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    424437        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    425438
     
    450463        async_hangup(sess);
    451464
    452         rc = loc_service_unregister(sid);
    453         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     465        rc = loc_service_unregister(srv, sid);
     466        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     467        loc_server_unregister(srv);
    454468}
    455469
     
    463477        async_sess_t *sess;
    464478        ipc_gc_t *ipcgc;
    465 
    466         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    467 
    468         // FIXME This causes this test to be non-reentrant!
    469         rc = loc_server_register(test_ipcgfx_server);
    470         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    471 
    472         rc = loc_service_register(test_ipcgfx_svc, &sid);
     479        loc_srv_t *srv;
     480
     481        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     482
     483        // FIXME This causes this test to be non-reentrant!
     484        rc = loc_server_register(test_ipcgfx_server, &srv);
     485        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     486
     487        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    473488        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    474489
     
    491506        async_hangup(sess);
    492507
    493         rc = loc_service_unregister(sid);
    494         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     508        rc = loc_service_unregister(srv, sid);
     509        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     510        loc_server_unregister(srv);
    495511}
    496512
     
    504520        async_sess_t *sess;
    505521        ipc_gc_t *ipcgc;
    506 
    507         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    508 
    509         // FIXME This causes this test to be non-reentrant!
    510         rc = loc_server_register(test_ipcgfx_server);
    511         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    512 
    513         rc = loc_service_register(test_ipcgfx_svc, &sid);
     522        loc_srv_t *srv;
     523
     524        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     525
     526        // FIXME This causes this test to be non-reentrant!
     527        rc = loc_server_register(test_ipcgfx_server, &srv);
     528        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     529
     530        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    514531        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    515532
     
    532549        async_hangup(sess);
    533550
    534         rc = loc_service_unregister(sid);
    535         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     551        rc = loc_service_unregister(srv, sid);
     552        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     553        loc_server_unregister(srv);
    536554}
    537555
     
    547565        async_sess_t *sess;
    548566        ipc_gc_t *ipcgc;
    549 
    550         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    551 
    552         // FIXME This causes this test to be non-reentrant!
    553         rc = loc_server_register(test_ipcgfx_server);
    554         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    555 
    556         rc = loc_service_register(test_ipcgfx_svc, &sid);
     567        loc_srv_t *srv;
     568
     569        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     570
     571        // FIXME This causes this test to be non-reentrant!
     572        rc = loc_server_register(test_ipcgfx_server, &srv);
     573        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     574
     575        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    557576        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    558577
     
    591610        async_hangup(sess);
    592611
    593         rc = loc_service_unregister(sid);
    594         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     612        rc = loc_service_unregister(srv, sid);
     613        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     614        loc_server_unregister(srv);
    595615}
    596616
     
    606626        async_sess_t *sess;
    607627        ipc_gc_t *ipcgc;
    608 
    609         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    610 
    611         // FIXME This causes this test to be non-reentrant!
    612         rc = loc_server_register(test_ipcgfx_server);
    613         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    614 
    615         rc = loc_service_register(test_ipcgfx_svc, &sid);
     628        loc_srv_t *srv;
     629
     630        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     631
     632        // FIXME This causes this test to be non-reentrant!
     633        rc = loc_server_register(test_ipcgfx_server, &srv);
     634        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     635
     636        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    616637        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    617638
     
    655676        async_hangup(sess);
    656677
    657         rc = loc_service_unregister(sid);
    658         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     678        rc = loc_service_unregister(srv, sid);
     679        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     680        loc_server_unregister(srv);
    659681}
    660682
     
    670692        async_sess_t *sess;
    671693        ipc_gc_t *ipcgc;
    672 
    673         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    674 
    675         // FIXME This causes this test to be non-reentrant!
    676         rc = loc_server_register(test_ipcgfx_server);
    677         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    678 
    679         rc = loc_service_register(test_ipcgfx_svc, &sid);
     694        loc_srv_t *srv;
     695
     696        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     697
     698        // FIXME This causes this test to be non-reentrant!
     699        rc = loc_server_register(test_ipcgfx_server, &srv);
     700        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     701
     702        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    680703        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    681704
     
    708731        async_hangup(sess);
    709732
    710         rc = loc_service_unregister(sid);
    711         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     733        rc = loc_service_unregister(srv, sid);
     734        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     735        loc_server_unregister(srv);
    712736}
    713737
     
    723747        async_sess_t *sess;
    724748        ipc_gc_t *ipcgc;
    725 
    726         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    727 
    728         // FIXME This causes this test to be non-reentrant!
    729         rc = loc_server_register(test_ipcgfx_server);
    730         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    731 
    732         rc = loc_service_register(test_ipcgfx_svc, &sid);
     749        loc_srv_t *srv;
     750
     751        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     752
     753        // FIXME This causes this test to be non-reentrant!
     754        rc = loc_server_register(test_ipcgfx_server, &srv);
     755        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     756
     757        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    733758        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    734759
     
    768793        async_hangup(sess);
    769794
    770         rc = loc_service_unregister(sid);
    771         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     795        rc = loc_service_unregister(srv, sid);
     796        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     797        loc_server_unregister(srv);
    772798}
    773799
     
    783809        async_sess_t *sess;
    784810        ipc_gc_t *ipcgc;
    785 
    786         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    787 
    788         // FIXME This causes this test to be non-reentrant!
    789         rc = loc_server_register(test_ipcgfx_server);
    790         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    791 
    792         rc = loc_service_register(test_ipcgfx_svc, &sid);
     811        loc_srv_t *srv;
     812
     813        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     814
     815        // FIXME This causes this test to be non-reentrant!
     816        rc = loc_server_register(test_ipcgfx_server, &srv);
     817        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     818
     819        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    793820        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    794821
     
    833860        async_hangup(sess);
    834861
    835         rc = loc_service_unregister(sid);
    836         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     862        rc = loc_service_unregister(srv, sid);
     863        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     864        loc_server_unregister(srv);
    837865}
    838866
     
    850878        async_sess_t *sess;
    851879        ipc_gc_t *ipcgc;
    852 
    853         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    854 
    855         // FIXME This causes this test to be non-reentrant!
    856         rc = loc_server_register(test_ipcgfx_server);
    857         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    858 
    859         rc = loc_service_register(test_ipcgfx_svc, &sid);
     880        loc_srv_t *srv;
     881
     882        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     883
     884        // FIXME This causes this test to be non-reentrant!
     885        rc = loc_server_register(test_ipcgfx_server, &srv);
     886        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     887
     888        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    860889        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    861890
     
    901930        async_hangup(sess);
    902931
    903         rc = loc_service_unregister(sid);
    904         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     932        rc = loc_service_unregister(srv, sid);
     933        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     934        loc_server_unregister(srv);
    905935}
    906936
     
    918948        async_sess_t *sess;
    919949        ipc_gc_t *ipcgc;
    920 
    921         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    922 
    923         // FIXME This causes this test to be non-reentrant!
    924         rc = loc_server_register(test_ipcgfx_server);
    925         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    926 
    927         rc = loc_service_register(test_ipcgfx_svc, &sid);
     950        loc_srv_t *srv;
     951
     952        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     953
     954        // FIXME This causes this test to be non-reentrant!
     955        rc = loc_server_register(test_ipcgfx_server, &srv);
     956        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     957
     958        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    928959        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    929960
     
    9691000        async_hangup(sess);
    9701001
    971         rc = loc_service_unregister(sid);
    972         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1002        rc = loc_service_unregister(srv, sid);
     1003        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1004        loc_server_unregister(srv);
    9731005}
    9741006
     
    9851017        async_sess_t *sess;
    9861018        ipc_gc_t *ipcgc;
    987 
    988         async_set_fallback_port_handler(test_ipcgc_conn, &resp);
    989 
    990         // FIXME This causes this test to be non-reentrant!
    991         rc = loc_server_register(test_ipcgfx_server);
    992         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    993 
    994         rc = loc_service_register(test_ipcgfx_svc, &sid);
     1019        loc_srv_t *srv;
     1020
     1021        async_set_fallback_port_handler(test_ipcgc_conn, &resp);
     1022
     1023        // FIXME This causes this test to be non-reentrant!
     1024        rc = loc_server_register(test_ipcgfx_server, &srv);
     1025        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1026
     1027        rc = loc_service_register(srv, test_ipcgfx_svc, &sid);
    9951028        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9961029
     
    10291062        async_hangup(sess);
    10301063
    1031         rc = loc_service_unregister(sid);
    1032         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1064        rc = loc_service_unregister(srv, sid);
     1065        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     1066        loc_server_unregister(srv);
    10331067}
    10341068
Note: See TracChangeset for help on using the changeset viewer.