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


Ignore:
Timestamp:
2023-09-16T19:58:18Z (8 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/dispcfg/test/dispcfg.c

    r6a0b2cc r4c6fd56  
    5252        dispcfg_t *dispcfg = NULL;
    5353        test_response_t resp;
    54 
    55         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    56 
    57         // FIXME This causes this test to be non-reentrant!
    58         rc = loc_server_register(test_dispcfg_server);
    59         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    60 
    61         rc = loc_service_register(test_dispcfg_svc, &sid);
    62         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    63 
    64         rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
    65         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    66         PCUT_ASSERT_NOT_NULL(dispcfg);
    67 
    68         dispcfg_close(dispcfg);
    69         rc = loc_service_unregister(sid);
    70         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     54        loc_srv_t *srv;
     55
     56        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     57
     58        // FIXME This causes this test to be non-reentrant!
     59        rc = loc_server_register(test_dispcfg_server, &srv);
     60        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     61
     62        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
     63        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     64
     65        rc = dispcfg_open(test_dispcfg_svc, NULL, NULL, &dispcfg);
     66        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     67        PCUT_ASSERT_NOT_NULL(dispcfg);
     68
     69        dispcfg_close(dispcfg);
     70        rc = loc_service_unregister(srv, sid);
     71        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     72        loc_server_unregister(srv);
    7173}
    7274
    … …  
    7981        dispcfg_seat_list_t *list;
    8082        test_response_t resp;
    81 
    82         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    83 
    84         // FIXME This causes this test to be non-reentrant!
    85         rc = loc_server_register(test_dispcfg_server);
    86         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    87 
    88         rc = loc_service_register(test_dispcfg_svc, &sid);
     83        loc_srv_t *srv;
     84
     85        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     86
     87        // FIXME This causes this test to be non-reentrant!
     88        rc = loc_server_register(test_dispcfg_server, &srv);
     89        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     90
     91        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    8992        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    9093
    … …  
    101104
    102105        dispcfg_close(dispcfg);
    103         rc = loc_service_unregister(sid);
    104         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     106        rc = loc_service_unregister(srv, sid);
     107        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     108        loc_server_unregister(srv);
    105109}
    106110
    … …  
    113117        dispcfg_seat_list_t *list;
    114118        test_response_t resp;
    115 
    116         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    117 
    118         // FIXME This causes this test to be non-reentrant!
    119         rc = loc_server_register(test_dispcfg_server);
    120         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    121 
    122         rc = loc_service_register(test_dispcfg_svc, &sid);
     119        loc_srv_t *srv;
     120
     121        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     122
     123        // FIXME This causes this test to be non-reentrant!
     124        rc = loc_server_register(test_dispcfg_server, &srv);
     125        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     126
     127        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    123128        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    124129
    … …  
    147152        dispcfg_free_seat_list(list);
    148153        dispcfg_close(dispcfg);
    149         rc = loc_service_unregister(sid);
    150         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     154        rc = loc_service_unregister(srv, sid);
     155        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     156        loc_server_unregister(srv);
    151157}
    152158
    … …  
    160166        dispcfg_seat_info_t *info;
    161167        test_response_t resp;
    162 
    163         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    164 
    165         // FIXME This causes this test to be non-reentrant!
    166         rc = loc_server_register(test_dispcfg_server);
    167         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    168 
    169         rc = loc_service_register(test_dispcfg_svc, &sid);
     168        loc_srv_t *srv;
     169
     170        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     171
     172        // FIXME This causes this test to be non-reentrant!
     173        rc = loc_server_register(test_dispcfg_server, &srv);
     174        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     175
     176        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    170177        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    171178
    … …  
    184191
    185192        dispcfg_close(dispcfg);
    186         rc = loc_service_unregister(sid);
    187         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     193        rc = loc_service_unregister(srv, sid);
     194        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     195        loc_server_unregister(srv);
    188196}
    189197
    … …  
    197205        dispcfg_seat_info_t *info;
    198206        test_response_t resp;
    199 
    200         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    201 
    202         // FIXME This causes this test to be non-reentrant!
    203         rc = loc_server_register(test_dispcfg_server);
    204         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    205 
    206         rc = loc_service_register(test_dispcfg_svc, &sid);
     207        loc_srv_t *srv;
     208
     209        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     210
     211        // FIXME This causes this test to be non-reentrant!
     212        rc = loc_server_register(test_dispcfg_server, &srv);
     213        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     214
     215        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    207216        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    208217
    … …  
    228237        dispcfg_free_seat_info(info);
    229238        dispcfg_close(dispcfg);
    230         rc = loc_service_unregister(sid);
    231         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     239        rc = loc_service_unregister(srv, sid);
     240        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     241        loc_server_unregister(srv);
    232242}
    233243
    … …  
    240250        sysarg_t seat_id;
    241251        test_response_t resp;
    242 
    243         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    244 
    245         // FIXME This causes this test to be non-reentrant!
    246         rc = loc_server_register(test_dispcfg_server);
    247         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    248 
    249         rc = loc_service_register(test_dispcfg_svc, &sid);
     252        loc_srv_t *srv;
     253
     254        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     255
     256        // FIXME This causes this test to be non-reentrant!
     257        rc = loc_server_register(test_dispcfg_server, &srv);
     258        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     259
     260        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    250261        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    251262
    … …  
    266277
    267278        dispcfg_close(dispcfg);
    268         rc = loc_service_unregister(sid);
    269         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     279        rc = loc_service_unregister(srv, sid);
     280        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     281        loc_server_unregister(srv);
    270282}
    271283
    … …  
    278290        sysarg_t seat_id;
    279291        test_response_t resp;
    280 
    281         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    282 
    283         // FIXME This causes this test to be non-reentrant!
    284         rc = loc_server_register(test_dispcfg_server);
    285         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    286 
    287         rc = loc_service_register(test_dispcfg_svc, &sid);
     292        loc_srv_t *srv;
     293
     294        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     295
     296        // FIXME This causes this test to be non-reentrant!
     297        rc = loc_server_register(test_dispcfg_server, &srv);
     298        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     299
     300        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    288301        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    289302
    … …  
    304317
    305318        dispcfg_close(dispcfg);
    306         rc = loc_service_unregister(sid);
    307         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     319        rc = loc_service_unregister(srv, sid);
     320        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     321        loc_server_unregister(srv);
    308322}
    309323
    … …  
    316330        sysarg_t seat_id;
    317331        test_response_t resp;
    318 
    319         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    320 
    321         // FIXME This causes this test to be non-reentrant!
    322         rc = loc_server_register(test_dispcfg_server);
    323         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    324 
    325         rc = loc_service_register(test_dispcfg_svc, &sid);
     332        loc_srv_t *srv;
     333
     334        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     335
     336        // FIXME This causes this test to be non-reentrant!
     337        rc = loc_server_register(test_dispcfg_server, &srv);
     338        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     339
     340        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    326341        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    327342
    … …  
    340355
    341356        dispcfg_close(dispcfg);
    342         rc = loc_service_unregister(sid);
    343         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     357        rc = loc_service_unregister(srv, sid);
     358        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     359        loc_server_unregister(srv);
    344360}
    345361
    … …  
    352368        sysarg_t seat_id;
    353369        test_response_t resp;
    354 
    355         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    356 
    357         // FIXME This causes this test to be non-reentrant!
    358         rc = loc_server_register(test_dispcfg_server);
    359         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    360 
    361         rc = loc_service_register(test_dispcfg_svc, &sid);
     370        loc_srv_t *srv;
     371
     372        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     373
     374        // FIXME This causes this test to be non-reentrant!
     375        rc = loc_server_register(test_dispcfg_server, &srv);
     376        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     377
     378        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    362379        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    363380
    … …  
    376393
    377394        dispcfg_close(dispcfg);
    378         rc = loc_service_unregister(sid);
    379         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     395        rc = loc_service_unregister(srv, sid);
     396        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     397        loc_server_unregister(srv);
    380398}
    381399
    … …  
    389407        sysarg_t seat_id;
    390408        test_response_t resp;
    391 
    392         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    393 
    394         // FIXME This causes this test to be non-reentrant!
    395         rc = loc_server_register(test_dispcfg_server);
    396         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    397 
    398         rc = loc_service_register(test_dispcfg_svc, &sid);
     409        loc_srv_t *srv;
     410
     411        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     412
     413        // FIXME This causes this test to be non-reentrant!
     414        rc = loc_server_register(test_dispcfg_server, &srv);
     415        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     416
     417        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    399418        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    400419
    … …  
    415434
    416435        dispcfg_close(dispcfg);
    417         rc = loc_service_unregister(sid);
    418         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     436        rc = loc_service_unregister(srv, sid);
     437        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     438        loc_server_unregister(srv);
    419439}
    420440
    … …  
    428448        sysarg_t seat_id;
    429449        test_response_t resp;
    430 
    431         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    432 
    433         // FIXME This causes this test to be non-reentrant!
    434         rc = loc_server_register(test_dispcfg_server);
    435         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    436 
    437         rc = loc_service_register(test_dispcfg_svc, &sid);
     450        loc_srv_t *srv;
     451
     452        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     453
     454        // FIXME This causes this test to be non-reentrant!
     455        rc = loc_server_register(test_dispcfg_server, &srv);
     456        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     457
     458        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    438459        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    439460
    … …  
    454475
    455476        dispcfg_close(dispcfg);
    456         rc = loc_service_unregister(sid);
    457         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     477        rc = loc_service_unregister(srv, sid);
     478        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     479        loc_server_unregister(srv);
    458480}
    459481
    … …  
    466488        sysarg_t svc_id;
    467489        test_response_t resp;
    468 
    469         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    470 
    471         // FIXME This causes this test to be non-reentrant!
    472         rc = loc_server_register(test_dispcfg_server);
    473         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    474 
    475         rc = loc_service_register(test_dispcfg_svc, &sid);
     490        loc_srv_t *srv;
     491
     492        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     493
     494        // FIXME This causes this test to be non-reentrant!
     495        rc = loc_server_register(test_dispcfg_server, &srv);
     496        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     497
     498        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    476499        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    477500
    … …  
    490513
    491514        dispcfg_close(dispcfg);
    492         rc = loc_service_unregister(sid);
    493         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     515        rc = loc_service_unregister(srv, sid);
     516        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     517        loc_server_unregister(srv);
    494518}
    495519
    … …  
    502526        sysarg_t svc_id;
    503527        test_response_t resp;
    504 
    505         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    506 
    507         // FIXME This causes this test to be non-reentrant!
    508         rc = loc_server_register(test_dispcfg_server);
    509         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    510 
    511         rc = loc_service_register(test_dispcfg_svc, &sid);
     528        loc_srv_t *srv;
     529
     530        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     531
     532        // FIXME This causes this test to be non-reentrant!
     533        rc = loc_server_register(test_dispcfg_server, &srv);
     534        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     535
     536        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    512537        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    513538
    … …  
    526551
    527552        dispcfg_close(dispcfg);
    528         rc = loc_service_unregister(sid);
    529         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     553        rc = loc_service_unregister(srv, sid);
     554        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     555        loc_server_unregister(srv);
    530556}
    531557
    … …  
    539565        sysarg_t seat_id;
    540566        test_response_t resp;
    541 
    542         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    543 
    544         // FIXME This causes this test to be non-reentrant!
    545         rc = loc_server_register(test_dispcfg_server);
    546         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    547 
    548         rc = loc_service_register(test_dispcfg_svc, &sid);
     567        loc_srv_t *srv;
     568
     569        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     570
     571        // FIXME This causes this test to be non-reentrant!
     572        rc = loc_server_register(test_dispcfg_server, &srv);
     573        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     574
     575        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    549576        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    550577
    … …  
    563590
    564591        dispcfg_close(dispcfg);
    565         rc = loc_service_unregister(sid);
    566         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     592        rc = loc_service_unregister(srv, sid);
     593        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     594        loc_server_unregister(srv);
    567595}
    568596
    … …  
    576604        sysarg_t seat_id;
    577605        test_response_t resp;
    578 
    579         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    580 
    581         // FIXME This causes this test to be non-reentrant!
    582         rc = loc_server_register(test_dispcfg_server);
    583         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    584 
    585         rc = loc_service_register(test_dispcfg_svc, &sid);
     606        loc_srv_t *srv;
     607
     608        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     609
     610        // FIXME This causes this test to be non-reentrant!
     611        rc = loc_server_register(test_dispcfg_server, &srv);
     612        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     613
     614        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    586615        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    587616
    … …  
    612641        dispcfg_free_dev_list(list);
    613642        dispcfg_close(dispcfg);
    614         rc = loc_service_unregister(sid);
    615         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     643        rc = loc_service_unregister(srv, sid);
     644        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     645        loc_server_unregister(srv);
    616646}
    617647
    … …  
    623653        dispcfg_t *dispcfg = NULL;
    624654        test_response_t resp;
    625 
    626         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    627 
    628         // FIXME This causes this test to be non-reentrant!
    629         rc = loc_server_register(test_dispcfg_server);
    630         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    631 
    632         rc = loc_service_register(test_dispcfg_svc, &sid);
     655        loc_srv_t *srv;
     656
     657        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     658
     659        // FIXME This causes this test to be non-reentrant!
     660        rc = loc_server_register(test_dispcfg_server, &srv);
     661        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     662
     663        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    633664        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    634665
    … …  
    659690        dispcfg_close(dispcfg);
    660691
    661         rc = loc_service_unregister(sid);
    662         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     692        rc = loc_service_unregister(srv, sid);
     693        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     694        loc_server_unregister(srv);
    663695}
    664696
    … …  
    670702        dispcfg_t *dispcfg = NULL;
    671703        test_response_t resp;
    672 
    673         async_set_fallback_port_handler(test_dispcfg_conn, &resp);
    674 
    675         // FIXME This causes this test to be non-reentrant!
    676         rc = loc_server_register(test_dispcfg_server);
    677         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    678 
    679         rc = loc_service_register(test_dispcfg_svc, &sid);
     704        loc_srv_t *srv;
     705
     706        async_set_fallback_port_handler(test_dispcfg_conn, &resp);
     707
     708        // FIXME This causes this test to be non-reentrant!
     709        rc = loc_server_register(test_dispcfg_server, &srv);
     710        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     711
     712        rc = loc_service_register(srv, test_dispcfg_svc, &sid);
    680713        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
    681714
    … …  
    706739        dispcfg_close(dispcfg);
    707740
    708         rc = loc_service_unregister(sid);
    709         PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     741        rc = loc_service_unregister(srv, sid);
     742        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
     743        loc_server_unregister(srv);
    710744}
    711745
Note: See TracChangeset for help on using the changeset viewer.