Changes in / [9a487cc:49c94a3] in mainline


Ignore:
Location:
uspace
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/devctl/devctl.c

    r9a487cc r49c94a3  
    4444#define MAX_NAME_LENGTH 1024
    4545
    46 char name[MAX_NAME_LENGTH];
    47 char drv_name[MAX_NAME_LENGTH];
    48 
    4946static int fun_subtree_print(devman_handle_t funh, int lvl)
    5047{
     48        char name[MAX_NAME_LENGTH];
    5149        devman_handle_t devh;
    5250        devman_handle_t *cfuns;
    … …  
    5957
    6058        rc = devman_fun_get_name(funh, name, MAX_NAME_LENGTH);
    61         if (rc != EOK)
    62                 return ELIMIT;
     59        if (rc != EOK) {
     60                str_cpy(name, MAX_NAME_LENGTH, "unknown");
     61                return ENOMEM;
     62        }
    6363
    6464        if (name[0] == '\0')
    6565                str_cpy(name, MAX_NAME_LENGTH, "/");
    6666
    67         rc = devman_fun_get_driver_name(funh, drv_name, MAX_NAME_LENGTH);
    68         if (rc != EOK && rc != EINVAL)
    69                 return ELIMIT;
    70 
    71         if (rc == EINVAL)
    72                 printf("%s\n", name);
    73         else
    74                 printf("%s : %s\n", name, drv_name);
     67        printf("%s (%" PRIun ")\n", name, funh);
    7568
    7669        rc = devman_fun_get_child(funh, &devh);

  • uspace/app/loc/loc.c

    r9a487cc r49c94a3  
    4848        size_t svc_cnt;
    4949        char *svc_name;
    50         char *server_name;
    5150        int rc;
    5251        size_t j;
    5352
    54         printf("%s:\n", cat_name);
     53        printf("%s (%" PRIun "):\n", cat_name, cat_id);
    5554
    5655        rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt);
    … …  
    6867                        continue;
    6968                }
    70 
    71                 rc = loc_service_get_server_name(svc_ids[j], &server_name);
    72                 if (rc != EOK && rc != EINVAL) {
    73                         free(svc_name);
    74                         printf(NAME ": Unknown service name (SID %"
    75                             PRIun ").\n", svc_ids[j]);
    76                         continue;
    77                 }
    78 
    79                 if (rc == EOK)
    80                         printf("\t%s : %s\n", svc_name, server_name);
    81                 else
    82                         printf("\t%s\n", svc_name);
    83        
     69                printf("\t%s (%" PRIun ")\n", svc_name, svc_ids[j]);
    8470                free(svc_name);
    85                 free(server_name);
    8671        }
    8772

  • uspace/lib/c/generic/async.c

    r9a487cc r49c94a3  
    13881388
    13891389        futex_down(&async_futex);
    1390         if (msg->done) {
     1390        if (msg->done)
    13911391                amsg_destroy(msg);
    1392         } else {
    1393                 msg->dataptr = NULL;
     1392        else
    13941393                msg->forget = true;
    1395         }
    13961394        futex_up(&async_futex);
    13971395}

  • uspace/lib/c/generic/devman.c

    r9a487cc r49c94a3  
    430430        async_wait_for(req, &retval);
    431431       
    432         if (retval != EOK) {
    433                 return retval;
    434         }
     432        if (retval != EOK)
     433                return retval;
    435434       
    436435        act_size = IPC_GET_ARG2(dreply);
    … …  
    450449{
    451450        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
    452             buf_size);
    453 }
    454 
    455 int devman_fun_get_driver_name(devman_handle_t handle, char *buf, size_t buf_size)
    456 {
    457         return devman_get_str_internal(DEVMAN_FUN_GET_DRIVER_NAME, handle, buf,
    458451            buf_size);
    459452}

  • uspace/lib/c/generic/loc.c

    r9a487cc r49c94a3  
    450450}
    451451
    452 /** Get service server name.
    453  *
    454  * Provided ID of a service, return the name of its server.
    455  *
    456  * @param svc_id        Service ID
    457  * @param name          Place to store pointer to new string. Caller should
    458  *                      free it using free().
    459  * @return              EOK on success or negative error code
    460  */
    461 int loc_service_get_server_name(service_id_t svc_id, char **name)
    462 {
    463         return loc_get_name_internal(LOC_SERVICE_GET_SERVER_NAME, svc_id, name);
    464 }
    465 
    466452int loc_namespace_get_id(const char *name, service_id_t *handle,
    467453    unsigned int flags)

  • uspace/lib/c/include/devman.h

    r9a487cc r49c94a3  
    6464    size_t *);
    6565extern int devman_fun_get_name(devman_handle_t, char *, size_t);
    66 extern int devman_fun_get_driver_name(devman_handle_t, char *, size_t);
    6766extern int devman_fun_get_path(devman_handle_t, char *, size_t);
    6867extern int devman_fun_online(devman_handle_t);

  • uspace/lib/c/include/ipc/devman.h

    r9a487cc r49c94a3  
    157157        DEVMAN_FUN_GET_CHILD,
    158158        DEVMAN_FUN_GET_NAME,
    159         DEVMAN_FUN_GET_DRIVER_NAME,
    160159        DEVMAN_FUN_ONLINE,
    161160        DEVMAN_FUN_OFFLINE,

  • uspace/lib/c/include/ipc/loc.h

    r9a487cc r49c94a3  
    5656        LOC_SERVICE_GET_ID,
    5757        LOC_SERVICE_GET_NAME,
    58         LOC_SERVICE_GET_SERVER_NAME,
    5958        LOC_NAMESPACE_GET_ID,
    6059        LOC_CALLBACK_CREATE,

  • uspace/lib/c/include/loc.h

    r9a487cc r49c94a3  
    5656    unsigned int);
    5757extern int loc_service_get_name(service_id_t, char **);
    58 extern int loc_service_get_server_name(service_id_t, char **);
    5958extern int loc_namespace_get_id(const char *, service_id_t *,
    6059    unsigned int);

  • uspace/srv/devman/main.c

    r9a487cc r49c94a3  
    855855}
    856856
    857 /** Get function driver name. */
    858 static void devman_fun_get_driver_name(ipc_callid_t iid, ipc_call_t *icall)
    859 {
    860         devman_handle_t handle = IPC_GET_ARG1(*icall);
    861 
    862         fun_node_t *fun = find_fun_node(&device_tree, handle);
    863         if (fun == NULL) {
    864                 async_answer_0(iid, ENOMEM);
    865                 return;
    866         }
    867 
    868         ipc_callid_t data_callid;
    869         size_t data_len;
    870         if (!async_data_read_receive(&data_callid, &data_len)) {
    871                 async_answer_0(iid, EINVAL);
    872                 fun_del_ref(fun);
    873                 return;
    874         }
    875 
    876         void *buffer = malloc(data_len);
    877         if (buffer == NULL) {
    878                 async_answer_0(data_callid, ENOMEM);
    879                 async_answer_0(iid, ENOMEM);
    880                 fun_del_ref(fun);
    881                 return;
    882         }
    883 
    884         fibril_rwlock_read_lock(&device_tree.rwlock);
    885 
    886         /* Check function state */
    887         if (fun->state == FUN_REMOVED) {
    888                 fibril_rwlock_read_unlock(&device_tree.rwlock);
    889                 free(buffer);
    890 
    891                 async_answer_0(data_callid, ENOENT);
    892                 async_answer_0(iid, ENOENT);
    893                 fun_del_ref(fun);
    894                 return;
    895         }
    896 
    897         /* Check whether function has a driver */
    898         if (fun->child == NULL || fun->child->drv == NULL) {
    899                 fibril_rwlock_read_unlock(&device_tree.rwlock);
    900                 free(buffer);
    901 
    902                 async_answer_0(data_callid, EINVAL);
    903                 async_answer_0(iid, EINVAL);
    904                 fun_del_ref(fun);
    905                 return;
    906         }
    907 
    908         size_t sent_length = str_size(fun->child->drv->name);
    909         if (sent_length > data_len) {
    910                 sent_length = data_len;
    911         }
    912 
    913         async_data_read_finalize(data_callid, fun->child->drv->name,
    914             sent_length);
    915         async_answer_0(iid, EOK);
    916 
    917         fibril_rwlock_read_unlock(&device_tree.rwlock);
    918         fun_del_ref(fun);
    919         free(buffer);
    920 }
    921857
    922858/** Get device path. */
    … …  
    11461082                case DEVMAN_FUN_GET_NAME:
    11471083                        devman_fun_get_name(callid, &call);
    1148                         break;
    1149                 case DEVMAN_FUN_GET_DRIVER_NAME:
    1150                         devman_fun_get_driver_name(callid, &call);
    11511084                        break;
    11521085                case DEVMAN_FUN_GET_PATH:

  • uspace/srv/locsrv/locsrv.c

    r9a487cc r49c94a3  
    656656}
    657657
    658 static void loc_service_get_server_name(ipc_callid_t iid, ipc_call_t *icall)
    659 {
    660         ipc_callid_t callid;
    661         size_t size;
    662         size_t act_size;
    663         loc_service_t *svc;
    664        
    665         if (!async_data_read_receive(&callid, &size)) {
    666                 async_answer_0(callid, EREFUSED);
    667                 async_answer_0(iid, EREFUSED);
    668                 return;
    669         }
    670        
    671         fibril_mutex_lock(&services_list_mutex);
    672        
    673         svc = loc_service_find_id(IPC_GET_ARG1(*icall));
    674         if (svc == NULL) {
    675                 fibril_mutex_unlock(&services_list_mutex);
    676                 async_answer_0(callid, ENOENT);
    677                 async_answer_0(iid, ENOENT);
    678                 return;
    679         }
    680        
    681         if (svc->server == NULL) {
    682                 fibril_mutex_unlock(&services_list_mutex);
    683                 async_answer_0(callid, EINVAL);
    684                 async_answer_0(iid, EINVAL);
    685                 return;
    686         }
    687        
    688         act_size = str_size(svc->server->name);
    689         if (act_size > size) {
    690                 fibril_mutex_unlock(&services_list_mutex);
    691                 async_answer_0(callid, EOVERFLOW);
    692                 async_answer_0(iid, EOVERFLOW);
    693                 return;
    694         }
    695        
    696         sysarg_t retval = async_data_read_finalize(callid, svc->server->name,
    697             min(size, act_size));
    698        
    699         fibril_mutex_unlock(&services_list_mutex);
    700        
    701         async_answer_0(iid, retval);
    702 }
    703 
    704658/** Connect client to the service.
    705659 *
    … …  
    14511405                        loc_service_get_name(callid, &call);
    14521406                        break;
    1453                 case LOC_SERVICE_GET_SERVER_NAME:
    1454                         loc_service_get_server_name(callid, &call);
    1455                         break;
    14561407                case LOC_NAMESPACE_GET_ID:
    14571408                        loc_namespace_get_id(callid, &call);
Note: See TracChangeset for help on using the changeset viewer.