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

Changeset 9a487cc in mainline


Ignore:
Timestamp:
2012-06-18T09:55:40Z (8 years ago)
Author:
Frantisek Princ <frantisek.princ@…>
Branches:
master
Children:
06d85e5
Parents:
49c94a3 (diff), 75b9c3d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge with mainline

Location:
uspace
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/devctl/devctl.c

    r49c94a3 r9a487cc  
    4444#define MAX_NAME_LENGTH 1024
    4545
     46char name[MAX_NAME_LENGTH];
     47char drv_name[MAX_NAME_LENGTH];
     48
    4649static int fun_subtree_print(devman_handle_t funh, int lvl)
    4750{
    48         char name[MAX_NAME_LENGTH];
    4951        devman_handle_t devh;
    5052        devman_handle_t *cfuns;
     
    5759
    5860        rc = devman_fun_get_name(funh, name, MAX_NAME_LENGTH);
    59         if (rc != EOK) {
    60                 str_cpy(name, MAX_NAME_LENGTH, "unknown");
    61                 return ENOMEM;
    62         }
     61        if (rc != EOK)
     62                return ELIMIT;
    6363
    6464        if (name[0] == '\0')
    6565                str_cpy(name, MAX_NAME_LENGTH, "/");
    6666
    67         printf("%s (%" PRIun ")\n", name, funh);
     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);
    6875
    6976        rc = devman_fun_get_child(funh, &devh);
  • uspace/app/loc/loc.c

    r49c94a3 r9a487cc  
    4848        size_t svc_cnt;
    4949        char *svc_name;
     50        char *server_name;
    5051        int rc;
    5152        size_t j;
    5253
    53         printf("%s (%" PRIun "):\n", cat_name, cat_id);
     54        printf("%s:\n", cat_name);
    5455
    5556        rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt);
     
    6768                        continue;
    6869                }
    69                 printf("\t%s (%" PRIun ")\n", svc_name, svc_ids[j]);
     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       
    7084                free(svc_name);
     85                free(server_name);
    7186        }
    7287
  • uspace/lib/c/generic/async.c

    r49c94a3 r9a487cc  
    13881388
    13891389        futex_down(&async_futex);
    1390         if (msg->done)
     1390        if (msg->done) {
    13911391                amsg_destroy(msg);
    1392         else
     1392        } else {
     1393                msg->dataptr = NULL;
    13931394                msg->forget = true;
     1395        }
    13941396        futex_up(&async_futex);
    13951397}
  • uspace/lib/c/generic/devman.c

    r49c94a3 r9a487cc  
    430430        async_wait_for(req, &retval);
    431431       
    432         if (retval != EOK)
    433                 return retval;
     432        if (retval != EOK) {
     433                return retval;
     434        }
    434435       
    435436        act_size = IPC_GET_ARG2(dreply);
     
    449450{
    450451        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
     452            buf_size);
     453}
     454
     455int 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,
    451458            buf_size);
    452459}
  • uspace/lib/c/generic/loc.c

    r49c94a3 r9a487cc  
    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 */
     461int 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
    452466int loc_namespace_get_id(const char *name, service_id_t *handle,
    453467    unsigned int flags)
  • uspace/lib/c/include/devman.h

    r49c94a3 r9a487cc  
    6464    size_t *);
    6565extern int devman_fun_get_name(devman_handle_t, char *, size_t);
     66extern int devman_fun_get_driver_name(devman_handle_t, char *, size_t);
    6667extern int devman_fun_get_path(devman_handle_t, char *, size_t);
    6768extern int devman_fun_online(devman_handle_t);
  • uspace/lib/c/include/ipc/devman.h

    r49c94a3 r9a487cc  
    157157        DEVMAN_FUN_GET_CHILD,
    158158        DEVMAN_FUN_GET_NAME,
     159        DEVMAN_FUN_GET_DRIVER_NAME,
    159160        DEVMAN_FUN_ONLINE,
    160161        DEVMAN_FUN_OFFLINE,
  • uspace/lib/c/include/ipc/loc.h

    r49c94a3 r9a487cc  
    5656        LOC_SERVICE_GET_ID,
    5757        LOC_SERVICE_GET_NAME,
     58        LOC_SERVICE_GET_SERVER_NAME,
    5859        LOC_NAMESPACE_GET_ID,
    5960        LOC_CALLBACK_CREATE,
  • uspace/lib/c/include/loc.h

    r49c94a3 r9a487cc  
    5656    unsigned int);
    5757extern int loc_service_get_name(service_id_t, char **);
     58extern int loc_service_get_server_name(service_id_t, char **);
    5859extern int loc_namespace_get_id(const char *, service_id_t *,
    5960    unsigned int);
  • uspace/srv/devman/main.c

    r49c94a3 r9a487cc  
    855855}
    856856
     857/** Get function driver name. */
     858static 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}
    857921
    858922/** Get device path. */
     
    10821146                case DEVMAN_FUN_GET_NAME:
    10831147                        devman_fun_get_name(callid, &call);
     1148                        break;
     1149                case DEVMAN_FUN_GET_DRIVER_NAME:
     1150                        devman_fun_get_driver_name(callid, &call);
    10841151                        break;
    10851152                case DEVMAN_FUN_GET_PATH:
  • uspace/srv/locsrv/locsrv.c

    r49c94a3 r9a487cc  
    656656}
    657657
     658static 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
    658704/** Connect client to the service.
    659705 *
     
    14041450                case LOC_SERVICE_GET_NAME:
    14051451                        loc_service_get_name(callid, &call);
     1452                        break;
     1453                case LOC_SERVICE_GET_SERVER_NAME:
     1454                        loc_service_get_server_name(callid, &call);
    14061455                        break;
    14071456                case LOC_NAMESPACE_GET_ID:
Note: See TracChangeset for help on using the changeset viewer.