Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset cce8a83 in mainline


Ignore:
Timestamp:
2011-08-16T17:31:34Z (10 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
45058baa
Parents:
6d605e6
Message:

loc_service_get_name() to translate service ID to name.

Location:
uspace
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/loc.c

    r6d605e6 rcce8a83  
    291291}
    292292
     293/** Get service name.
     294 *
     295 * Provided ID of a service, return its name.
     296 *
     297 * @param svc_id        Service ID
     298 * @param name          Place to store pointer to new string. Caller should
     299 *                      free it using free().
     300 * @return              EOK on success or negative error code
     301 */
     302int loc_service_get_name(service_id_t svc_id, char **name)
     303{
     304        async_exch_t *exch;
     305        char name_buf[LOC_NAME_MAXLEN + 1];
     306       
     307        *name = NULL;
     308        memset(name_buf, 0, LOC_NAME_MAXLEN + 1);
     309        exch = loc_exchange_begin_blocking(LOC_PORT_CONSUMER);
     310       
     311        ipc_call_t answer;
     312        aid_t req = async_send_1(exch, LOC_SERVICE_GET_NAME, svc_id, &answer);
     313        int rc = async_data_read_start(exch, name_buf, LOC_NAME_MAXLEN);
     314       
     315        loc_exchange_end(exch);
     316       
     317        if (rc != EOK) {
     318                async_wait_for(req, NULL);
     319                return rc;
     320        }
     321       
     322        sysarg_t retval;
     323        async_wait_for(req, &retval);
     324       
     325        if (retval != EOK)
     326                return retval;
     327       
     328        *name = str_dup(name_buf);
     329        if (*name == NULL)
     330                return ENOMEM;
     331       
     332        return EOK;
     333}
     334
     335
    293336int loc_namespace_get_id(const char *name, service_id_t *handle,
    294337    unsigned int flags)
  • uspace/lib/c/include/ipc/loc.h

    r6d605e6 rcce8a83  
    5555        LOC_SERVICE_UNREGISTER,
    5656        LOC_SERVICE_GET_ID,
     57        LOC_SERVICE_GET_NAME,
    5758        LOC_NAMESPACE_GET_ID,
    5859        LOC_CATEGORY_GET_ID,
  • uspace/lib/c/include/loc.h

    r6d605e6 rcce8a83  
    5252extern int loc_service_get_id(const char *, service_id_t *,
    5353    unsigned int);
     54extern int loc_service_get_name(service_id_t, char **);
    5455extern int loc_namespace_get_id(const char *, service_id_t *,
    5556    unsigned int);
    5657extern int loc_category_get_id(const char *, category_id_t *,
    5758    unsigned int);
     59extern int loc_category_get_name(category_id_t, char **);
    5860extern int loc_category_get_svcs(category_id_t, category_id_t **, size_t *);
    5961extern loc_object_type_t loc_id_probe(service_id_t);
  • uspace/srv/hid/input/ctl/kbdev.c

    r6d605e6 rcce8a83  
    9898        async_exch_t *exch;
    9999        kbdev_t *kbdev;
    100         char *svc_name;
    101100        int rc;
    102101
    103         if (asprintf(&svc_name, "devname%" PRIun, kdev->service_id) > 0)
    104                 svc_name = (char *) "unknown";
    105 
    106         sess = loc_service_connect(EXCHANGE_SERIALIZE, kdev->service_id, 0);
     102        sess = loc_service_connect(EXCHANGE_SERIALIZE, kdev->svc_id, 0);
    107103        if (sess == NULL) {
    108104                printf("%s: Failed starting session with '%s.'\n", NAME,
    109                     svc_name);
     105                    kdev->svc_name);
    110106                return -1;
    111107        }
     
    114110        if (kbdev == NULL) {
    115111                printf("%s: Failed allocating device structure for '%s'.\n",
    116                     NAME, svc_name);
     112                    NAME, kdev->svc_name);
    117113                return -1;
    118114        }
     
    123119        if (exch == NULL) {
    124120                printf("%s: Failed starting exchange with '%s'.\n", NAME,
    125                     svc_name);
     121                    kdev->svc_name);
    126122                kbdev_destroy(kbdev);
    127123                return -1;
     
    131127        if (rc != EOK) {
    132128                printf("%s: Failed creating callback connection from '%s'.\n",
    133                     NAME, svc_name);
     129                    NAME, kdev->svc_name);
    134130                async_exchange_end(exch);
    135131                kbdev_destroy(kbdev);
  • uspace/srv/hid/input/generic/input.c

    r6d605e6 rcce8a83  
    276276        kdev->port_ops = port;
    277277        kdev->ctl_ops = ctl;
    278         kdev->service_id = 0;
     278        kdev->svc_id = 0;
    279279       
    280280        /* Initialize port driver. */
     
    304304        mdev->port_ops = port;
    305305        mdev->proto_ops = proto;
    306         mdev->service_id = 0;
     306        mdev->svc_id = 0;
    307307       
    308308        /* Initialize port driver. */
     
    328328 *
    329329 */
    330 static int kbd_add_kbdev(service_id_t service_id)
     330static int kbd_add_kbdev(service_id_t service_id, kbd_dev_t **kdevp)
    331331{
    332332        kbd_dev_t *kdev = kbd_dev_new();
     
    334334                return -1;
    335335       
    336         kdev->service_id = service_id;
     336        kdev->svc_id = service_id;
    337337        kdev->port_ops = NULL;
    338338        kdev->ctl_ops = &kbdev_ctl;
    339339       
     340        int rc = loc_service_get_name(service_id, &kdev->svc_name);
     341        if (rc != EOK) {
     342                kdev->svc_name = NULL;
     343                goto fail;
     344        }
     345       
    340346        /* Initialize controller driver. */
    341347        if ((*kdev->ctl_ops->init)(kdev) != 0) {
     
    344350       
    345351        list_append(&kdev->kbd_devs, &kbd_devs);
     352        *kdevp = kdev;
    346353        return EOK;
    347354       
    348355fail:
     356        if (kdev->svc_name != NULL)
     357                free(kdev->svc_name);
    349358        free(kdev);
    350359        return -1;
     
    356365 *
    357366 */
    358 static int mouse_add_mousedev(service_id_t service_id)
     367static int mouse_add_mousedev(service_id_t service_id, mouse_dev_t **mdevp)
    359368{
    360369        mouse_dev_t *mdev = mouse_dev_new();
     
    362371                return -1;
    363372       
    364         mdev->service_id = service_id;
     373        mdev->svc_id = service_id;
    365374        mdev->port_ops = NULL;
    366375        mdev->proto_ops = &mousedev_proto;
    367376       
     377        int rc = loc_service_get_name(service_id, &mdev->svc_name);
     378        if (rc != EOK) {
     379                mdev->svc_name = NULL;
     380                goto fail;
     381        }
     382       
    368383        /* Initialize controller driver. */
    369384        if ((*mdev->proto_ops->init)(mdev) != 0) {
     
    372387       
    373388        list_append(&mdev->mouse_devs, &mouse_devs);
     389        *mdevp = mdev;
    374390        return EOK;
    375391       
     
    494510        size_t count, i;
    495511        bool already_known;
    496         const char *dev_name = "todo";
    497512        int rc;
    498513       
     
    529544                                kbd_dev_t *kdev = list_get_instance(kdev_link,
    530545                                    kbd_dev_t, kbd_devs);
    531                                 if (kdev->service_id == svcs[i]) {
     546                                if (kdev->svc_id == svcs[i]) {
    532547                                        already_known = true;
    533548                                        break;
     
    536551
    537552                        if (!already_known) {
    538                                 if (kbd_add_kbdev(svcs[i]) == EOK) {
     553                                kbd_dev_t *kdev;
     554                                if (kbd_add_kbdev(svcs[i], &kdev) == EOK) {
    539555                                        printf("%s: Connected keyboard device '%s'\n",
    540                                             NAME, dev_name);
     556                                            NAME, kdev->svc_name);
    541557                                }
    542558                        }
     
    562578                                mouse_dev_t *mdev = list_get_instance(mdev_link,
    563579                                    mouse_dev_t, mouse_devs);
    564                                 if (mdev->service_id == svcs[i]) {
     580                                if (mdev->svc_id == svcs[i]) {
    565581                                        already_known = true;
    566582                                        break;
     
    569585
    570586                        if (!already_known) {
    571                                 if (mouse_add_mousedev(svcs[i]) == EOK) {
     587                                mouse_dev_t *mdev;
     588                                if (mouse_add_mousedev(svcs[i], &mdev) == EOK) {
    572589                                        printf("%s: Connected mouse device '%s'\n",
    573                                             NAME, dev_name);
     590                                            NAME, mdev->svc_name);
    574591                                }
    575592                        }
  • uspace/srv/hid/input/include/kbd.h

    r6d605e6 rcce8a83  
    5151
    5252        /** Service ID (only for kbdev devices) */
    53         service_id_t service_id;
     53        service_id_t svc_id;
     54
     55        /** Device service name (only for kbdev devices) */
     56        char *svc_name;
    5457
    5558        /** Port ops */
  • uspace/srv/hid/input/include/mouse.h

    r6d605e6 rcce8a83  
    4949       
    5050        /** Service ID (only for mousedev devices) */
    51         service_id_t service_id;
     51        service_id_t svc_id;
     52       
     53        /** Device service name (only for mousedev devices) */
     54        char *svc_name;
    5255       
    5356        /** Port ops */
  • uspace/srv/hid/input/proto/mousedev.c

    r6d605e6 rcce8a83  
    117117static int mousedev_proto_init(mouse_dev_t *mdev)
    118118{
    119         char *svc_name;
    120        
    121         if (asprintf(&svc_name, "devname%" PRIun, mdev->service_id) > 0)
    122                 svc_name = (char *) "unknown";
    123        
    124119        async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE,
    125             mdev->service_id, 0);
     120            mdev->svc_id, 0);
    126121        if (sess == NULL) {
    127                 printf("%s: Failed starting session with '%s'\n", NAME, svc_name);
     122                printf("%s: Failed starting session with '%s'\n", NAME,
     123                    mdev->svc_name);
    128124                return -1;
    129125        }
     
    132128        if (mousedev == NULL) {
    133129                printf("%s: Failed allocating device structure for '%s'.\n",
    134                     NAME, svc_name);
     130                    NAME, mdev->svc_name);
    135131                return -1;
    136132        }
     
    141137        if (exch == NULL) {
    142138                printf("%s: Failed starting exchange with '%s'.\n", NAME,
    143                     svc_name);
     139                    mdev->svc_name);
    144140                mousedev_destroy(mousedev);
    145141                return -1;
     
    151147        if (rc != EOK) {
    152148                printf("%s: Failed creating callback connection from '%s'.\n",
    153                     NAME, svc_name);
     149                    NAME, mdev->svc_name);
    154150                mousedev_destroy(mousedev);
    155151                return -1;
  • uspace/srv/loc/loc.c

    r6d605e6 rcce8a83  
    4444#include <bool.h>
    4545#include <fibril_synch.h>
     46#include <macros.h>
    4647#include <stdlib.h>
    4748#include <str.h>
     
    532533}
    533534
     535static void loc_service_get_name(ipc_callid_t iid, ipc_call_t *icall)
     536{
     537        ipc_callid_t callid;
     538        size_t size;
     539        size_t act_size;
     540        loc_service_t *svc;
     541       
     542        if (!async_data_read_receive(&callid, &size)) {
     543                async_answer_0(callid, EREFUSED);
     544                async_answer_0(iid, EREFUSED);
     545                return;
     546        }
     547       
     548        fibril_mutex_lock(&services_list_mutex);
     549       
     550        svc = loc_service_find_id(IPC_GET_ARG1(*icall));
     551        if (svc == NULL) {
     552                fibril_mutex_unlock(&services_list_mutex);
     553                async_answer_0(callid, ENOENT);
     554                async_answer_0(iid, ENOENT);
     555                return;
     556        }
     557       
     558        act_size = str_size(svc->name);
     559        if (act_size > size) {
     560                fibril_mutex_unlock(&services_list_mutex);
     561                async_answer_0(callid, EOVERFLOW);
     562                async_answer_0(iid, EOVERFLOW);
     563                return;
     564        }
     565       
     566        sysarg_t retval = async_data_read_finalize(callid, svc->name,
     567            min(size, act_size));
     568       
     569        fibril_mutex_unlock(&services_list_mutex);
     570       
     571        async_answer_0(iid, retval);
     572}
     573
     574
    534575/** Connect client to the service.
    535576 *
     
    11971238                        loc_service_get_id(callid, &call);
    11981239                        break;
     1240                case LOC_SERVICE_GET_NAME:
     1241                        loc_service_get_name(callid, &call);
     1242                        break;
    11991243                case LOC_NAMESPACE_GET_ID:
    12001244                        loc_namespace_get_id(callid, &call);
Note: See TracChangeset for help on using the changeset viewer.