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

Changeset 1db5669 in mainline


Ignore:
Timestamp:
2013-09-11T12:35:55Z (7 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
48bd6f4, 4c9b28a
Parents:
cd3b380
Message:

devctl show-drv lists attached devices, add device count to list-drv.

Location:
uspace
Files:
7 edited

Legend:

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

    rcd3b380 r1db5669  
    4747char drv_name[MAX_NAME_LENGTH];
    4848
     49static const char *drv_state_str(driver_state_t state)
     50{
     51        const char *sstate;
     52
     53        switch (state) {
     54        case DRIVER_NOT_STARTED:
     55                sstate = "not started";
     56                break;
     57        case DRIVER_STARTING:
     58                sstate = "starting";
     59                break;
     60        case DRIVER_RUNNING:
     61                sstate = "running";
     62                break;
     63        default:
     64                sstate = "unknown";
     65        }
     66
     67        return sstate;
     68}
     69
    4970static int fun_subtree_print(devman_handle_t funh, int lvl)
    5071{
     
    161182static int drv_list(void)
    162183{
     184        devman_handle_t *devs;
    163185        devman_handle_t *drvs;
    164186        driver_state_t state;
    165187        const char *sstate;
    166188        size_t ndrvs;
     189        size_t ndevs;
    167190        size_t i;
    168191        int rc;
     
    173196
    174197        for (i = 0; i < ndrvs; i++) {
     198                devs = NULL;
     199
    175200                rc = devman_driver_get_name(drvs[i], drv_name, MAX_NAME_LENGTH);
    176201                if (rc != EOK)
    177                         continue;
     202                        goto skip;
    178203                rc = devman_driver_get_state(drvs[i], &state);
    179204                if (rc != EOK)
    180                         continue;
    181                 switch (state) {
    182                 case DRIVER_NOT_STARTED:
    183                         sstate = "not started";
    184                         break;
    185                 case DRIVER_STARTING:
    186                         sstate = "starting";
    187                         break;
    188                 case DRIVER_RUNNING:
    189                         sstate = "running";
    190                         break;
    191                 default:
    192                         sstate = "unknown";
    193                 }
    194                 printf("%3d %-10s %s\n", (int)drvs[i], drv_name, sstate);
     205                        goto skip;
     206                rc = devman_driver_get_devices(drvs[i], &devs, &ndevs);
     207                if (rc != EOK)
     208                        goto skip;
     209
     210                sstate = drv_state_str(state);
     211
     212                printf("%-11s %3d %s\n", sstate, ndevs, drv_name);
     213skip:
     214                free(devs);
    195215        }
    196216        free(drvs);
     217
     218        return EOK;
     219}
     220
     221static int drv_show(char *drvname)
     222{
     223        devman_handle_t *devs;
     224        devman_handle_t drvh;
     225        devman_handle_t funh;
     226        driver_state_t state;
     227        const char *sstate;
     228        size_t ndevs;
     229        size_t i;
     230        int rc;
     231
     232        rc = devman_driver_get_handle(drvname, &drvh);
     233        if (rc != EOK)
     234                return rc;
     235
     236        devs = NULL;
     237
     238        rc = devman_driver_get_name(drvh, drv_name, MAX_NAME_LENGTH);
     239        if (rc != EOK)
     240                return rc;
     241
     242        rc = devman_driver_get_state(drvh, &state);
     243        if (rc != EOK)
     244                return rc;
     245
     246        rc = devman_driver_get_devices(drvh, &devs, &ndevs);
     247        if (rc != EOK)
     248                return rc;
     249
     250        sstate = drv_state_str(state);
     251
     252        printf("Driver: %s\n", drv_name);
     253        printf("State: %s\n", sstate);
     254        printf("Attached devices:\n");
     255
     256        for (i = 0; i < ndevs; i++) {
     257                rc = devman_dev_get_parent(devs[i], &funh);
     258                if (rc != EOK)
     259                        goto error;
     260
     261                rc = devman_fun_get_path(funh, name, MAX_NAME_LENGTH);
     262                if (rc != EOK)
     263                        goto error;
     264                printf("\t%s\n", name);
     265        }
     266
     267error:
     268        free(devs);
    197269
    198270        return EOK;
     
    226298        printf("\tdevctl offline <function>]\n");
    227299        printf("\tdevctl list-drv\n");
     300        printf("\tdevctl show-drv <driver-name>\n");
    228301        printf("\tdevctl load-drv <driver-name>\n");
    229302}
     
    263336                if (rc != EOK)
    264337                        return 2;
     338        } else if (str_cmp(argv[1], "show-drv") == 0) {
     339                if (argc < 3) {
     340                        printf(NAME ": Argument missing.\n");
     341                        print_syntax();
     342                        return 1;
     343                }
     344
     345                rc = drv_show(argv[2]);
     346                if (rc != EOK) {
     347                        return 2;
     348                }
    265349        } else if (str_cmp(argv[1], "load-drv") == 0) {
    266350                if (argc < 3) {
  • uspace/lib/c/generic/devman.c

    rcd3b380 r1db5669  
    579579}
    580580
     581int devman_dev_get_parent(devman_handle_t devh, devman_handle_t *funh)
     582{
     583        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     584        if (exch == NULL)
     585                return ENOMEM;
     586       
     587        sysarg_t retval = async_req_1_1(exch, DEVMAN_DEV_GET_PARENT,
     588            devh, funh);
     589       
     590        devman_exchange_end(exch);
     591        return (int) retval;
     592}
     593
    581594int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
    582595{
     
    596609{
    597610        return devman_get_handles_internal(DEVMAN_GET_DRIVERS, 0, drvs, count);
     611}
     612
     613int devman_driver_get_devices(devman_handle_t drvh, devman_handle_t **devs,
     614    size_t *count)
     615{
     616        return devman_get_handles_internal(DEVMAN_DRIVER_GET_DEVICES,
     617            drvh, devs, count);
    598618}
    599619
  • uspace/lib/c/include/devman.h

    rcd3b380 r1db5669  
    6161    unsigned int);
    6262extern int devman_fun_get_child(devman_handle_t, devman_handle_t *);
     63extern int devman_dev_get_parent(devman_handle_t, devman_handle_t *);
    6364extern int devman_dev_get_functions(devman_handle_t, devman_handle_t **,
    6465    size_t *);
     
    7273extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *);
    7374extern int devman_get_drivers(devman_handle_t **, size_t *);
     75extern int devman_driver_get_devices(devman_handle_t, devman_handle_t **,
     76    size_t *);
    7477extern int devman_driver_get_handle(const char *, devman_handle_t *);
    7578extern int devman_driver_get_name(devman_handle_t, char *, size_t);
  • uspace/lib/c/include/ipc/devman.h

    rcd3b380 r1db5669  
    169169        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
    170170        DEVMAN_DEV_GET_FUNCTIONS,
     171        DEVMAN_DEV_GET_PARENT,
    171172        DEVMAN_FUN_GET_CHILD,
    172173        DEVMAN_FUN_GET_NAME,
     
    177178        DEVMAN_FUN_SID_TO_HANDLE,
    178179        DEVMAN_GET_DRIVERS,
     180        DEVMAN_DRIVER_GET_DEVICES,
    179181        DEVMAN_DRIVER_GET_HANDLE,
    180182        DEVMAN_DRIVER_GET_NAME,
  • uspace/srv/devman/client_conn.c

    rcd3b380 r1db5669  
    11/*
    22 * Copyright (c) 2010 Lenka Trochtova
     3 * Copyright (c) 2013 Jiri Svoboda
    34 * All rights reserved.
    45 *
     
    269270}
    270271
     272/** Get handle for parent function of a device. */
     273static void devman_dev_get_parent(ipc_callid_t iid, ipc_call_t *icall)
     274{
     275        dev_node_t *dev;
     276       
     277        fibril_rwlock_read_lock(&device_tree.rwlock);
     278       
     279        dev = find_dev_node_no_lock(&device_tree, IPC_GET_ARG1(*icall));
     280        if (dev == NULL || dev->state == DEVICE_REMOVED) {
     281                fibril_rwlock_read_unlock(&device_tree.rwlock);
     282                async_answer_0(iid, ENOENT);
     283                return;
     284        }
     285       
     286        if (dev->pfun == NULL) {
     287                fibril_rwlock_read_unlock(&device_tree.rwlock);
     288                async_answer_0(iid, ENOENT);
     289                return;
     290        }
     291       
     292        async_answer_1(iid, EOK, dev->pfun->handle);
     293       
     294        fibril_rwlock_read_unlock(&device_tree.rwlock);
     295}
     296
    271297static void devman_dev_get_functions(ipc_callid_t iid, ipc_call_t *icall)
    272298{
     
    425451       
    426452        if (!async_data_read_receive(&callid, &size)) {
    427                 async_answer_0(callid, EREFUSED);
    428453                async_answer_0(iid, EREFUSED);
    429454                return;
     
    449474        async_answer_1(iid, retval, act_size);
    450475}
     476
     477static void devman_driver_get_devices(ipc_callid_t iid, ipc_call_t *icall)
     478{
     479        ipc_callid_t callid;
     480        size_t size;
     481        size_t act_size;
     482        int rc;
     483       
     484        if (!async_data_read_receive(&callid, &size)) {
     485                async_answer_0(iid, EREFUSED);
     486                return;
     487        }
     488       
     489        driver_t *drv = driver_find(&drivers_list, IPC_GET_ARG1(*icall));
     490        if (drv == NULL) {
     491                async_answer_0(callid, ENOENT);
     492                async_answer_0(iid, ENOENT);
     493                return;
     494        }
     495       
     496        devman_handle_t *hdl_buf = (devman_handle_t *) malloc(size);
     497        if (hdl_buf == NULL) {
     498                async_answer_0(callid, ENOMEM);
     499                async_answer_0(iid, ENOMEM);
     500                return;
     501        }
     502       
     503        rc = driver_get_devices(drv, hdl_buf, size, &act_size);
     504        if (rc != EOK) {
     505                fibril_rwlock_read_unlock(&device_tree.rwlock);
     506                async_answer_0(callid, rc);
     507                async_answer_0(iid, rc);
     508                return;
     509        }
     510       
     511        sysarg_t retval = async_data_read_finalize(callid, hdl_buf, size);
     512        free(hdl_buf);
     513       
     514        async_answer_1(iid, retval, act_size);
     515}
     516
    451517
    452518/** Find driver by name. */
     
    563629                        devman_function_get_handle(callid, &call);
    564630                        break;
     631                case DEVMAN_DEV_GET_PARENT:
     632                        devman_dev_get_parent(callid, &call);
     633                        break;
    565634                case DEVMAN_DEV_GET_FUNCTIONS:
    566635                        devman_dev_get_functions(callid, &call);
     
    589658                case DEVMAN_GET_DRIVERS:
    590659                        devman_get_drivers(callid, &call);
     660                        break;
     661                case DEVMAN_DRIVER_GET_DEVICES:
     662                        devman_driver_get_devices(callid, &call);
    591663                        break;
    592664                case DEVMAN_DRIVER_GET_HANDLE:
  • uspace/srv/devman/driver.c

    rcd3b380 r1db5669  
    729729}
    730730
     731/** Get list of device functions. */
     732int driver_get_devices(driver_t *driver, devman_handle_t *hdl_buf,
     733    size_t buf_size, size_t *act_size)
     734{
     735        size_t act_cnt;
     736        size_t buf_cnt;
     737
     738        fibril_mutex_lock(&driver->driver_mutex);
     739
     740        buf_cnt = buf_size / sizeof(devman_handle_t);
     741
     742        act_cnt = list_count(&driver->devices);
     743        *act_size = act_cnt * sizeof(devman_handle_t);
     744
     745        if (buf_size % sizeof(devman_handle_t) != 0) {
     746                fibril_mutex_unlock(&driver->driver_mutex);
     747                return EINVAL;
     748        }
     749
     750        size_t pos = 0;
     751        list_foreach(driver->devices, driver_devices, dev_node_t, dev) {
     752                if (pos < buf_cnt) {
     753                        hdl_buf[pos] = dev->handle;
     754                }
     755
     756                pos++;
     757        }
     758
     759        fibril_mutex_unlock(&driver->driver_mutex);
     760        return EOK;
     761}
     762
    731763/** @}
    732764 */
  • uspace/srv/devman/driver.h

    rcd3b380 r1db5669  
    6464extern void delete_driver(driver_t *);
    6565extern int driver_get_list(driver_list_t *, devman_handle_t *, size_t, size_t *);
     66extern int driver_get_devices(driver_t *, devman_handle_t *, size_t, size_t *);
    6667
    6768#endif
Note: See TracChangeset for help on using the changeset viewer.