Changeset 903bac0a in mainline for uspace/lib/c


Ignore:
Timestamp:
2011-08-19T09:00:38Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e2ab36f1
Parents:
d894fbd (diff), 42a619b (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 mainline changes.

Location:
uspace/lib/c
Files:
1 added
1 deleted
9 edited
2 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    rd894fbd r903bac0a  
    6464        generic/cap.c \
    6565        generic/clipboard.c \
    66         generic/devmap.c \
    6766        generic/devman.c \
    6867        generic/device/hw_res.c \
    … …  
    7170        generic/event.c \
    7271        generic/errno.c \
     72        generic/loc.c \
    7373        generic/mem.c \
    7474        generic/str.c \

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

    rd894fbd r903bac0a  
    271271}
    272272
    273 int devman_add_device_to_class(devman_handle_t devman_handle,
    274     const char *class_name)
     273int devman_add_device_to_category(devman_handle_t devman_handle,
     274    const char *cat_name)
    275275{
    276276        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
    277277       
    278278        ipc_call_t answer;
    279         aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CLASS,
     279        aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CATEGORY,
    280280            devman_handle, &answer);
    281         sysarg_t retval = async_data_write_start(exch, class_name,
    282             str_size(class_name));
     281        sysarg_t retval = async_data_write_start(exch, cat_name,
     282            str_size(cat_name));
    283283       
    284284        devman_exchange_end(exch);
    … …  
    308308}
    309309
     310/** Remove function from device.
     311 *
     312 * Request devman to remove function owned by this driver task.
     313 * @param funh      Devman handle of the function
     314 *
     315 * @return EOK on success or negative error code.
     316 */
     317int devman_remove_function(devman_handle_t funh)
     318{
     319        async_exch_t *exch;
     320        sysarg_t retval;
     321       
     322        exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
     323        retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
     324        devman_exchange_end(exch);
     325       
     326        return (int) retval;
     327}
     328
    310329async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt,
    311330    devman_handle_t handle, unsigned int flags)
    … …  
    333352                exch = devman_exchange_begin(DEVMAN_CLIENT);
    334353                if (exch == NULL)
    335                         return errno;
     354                        return ENOMEM;
    336355        }
    337356       
    … …  
    364383}
    365384
    366 int devman_device_get_handle_by_class(const char *classname,
    367     const char *devname, devman_handle_t *handle, unsigned int flags)
    368 {
    369         async_exch_t *exch;
    370        
    371         if (flags & IPC_FLAG_BLOCKING)
    372                 exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
    373         else {
    374                 exch = devman_exchange_begin(DEVMAN_CLIENT);
    375                 if (exch == NULL)
    376                         return errno;
    377         }
    378        
    379         ipc_call_t answer;
    380         aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
    381             flags, &answer);
    382         sysarg_t retval = async_data_write_start(exch, classname,
    383             str_size(classname));
    384        
    385         if (retval != EOK) {
    386                 devman_exchange_end(exch);
    387                 async_wait_for(req, NULL);
    388                 return retval;
    389         }
    390        
    391         retval = async_data_write_start(exch, devname,
    392             str_size(devname));
    393        
    394         devman_exchange_end(exch);
    395        
    396         if (retval != EOK) {
    397                 async_wait_for(req, NULL);
    398                 return retval;
    399         }
    400        
    401         async_wait_for(req, &retval);
    402        
    403         if (retval != EOK) {
    404                 if (handle != NULL)
    405                         *handle = (devman_handle_t) -1;
    406                
    407                 return retval;
    408         }
    409        
    410         if (handle != NULL)
    411                 *handle = (devman_handle_t) IPC_GET_ARG1(answer);
    412        
    413         return retval;
    414 }
    415 
    416385int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size)
    417386{
    418387        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
    419388        if (exch == NULL)
    420                 return errno;
     389                return ENOMEM;
    421390       
    422391        ipc_call_t answer;
    … …  
    463432}
    464433
     434int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
     435{
     436        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
     437        if (exch == NULL)
     438                return ENOMEM;
     439       
     440        sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE,
     441            sid, handle);
     442       
     443        devman_exchange_end(exch);
     444        return (int) retval;
     445}
     446
    465447/** @}
    466448 */

  • uspace/lib/c/generic/io/io.c

    rd894fbd r903bac0a  
    4545#include <vfs/vfs.h>
    4646#include <vfs/vfs_sess.h>
    47 #include <ipc/devmap.h>
     47#include <ipc/loc.h>
    4848#include <adt/list.h>
    4949#include "../private/io.h"

  • uspace/lib/c/generic/vfs/vfs.c

    rd894fbd r903bac0a  
    5151#include <assert.h>
    5252#include <str.h>
    53 #include <devmap.h>
     53#include <loc.h>
    5454#include <ipc/vfs.h>
    55 #include <ipc/devmap.h>
     55#include <ipc/loc.h>
    5656
    5757static FIBRIL_MUTEX_INITIALIZE(vfs_mutex);
    … …  
    142142}
    143143
    144 int mount(const char *fs_name, const char *mp, const char *fqdn,
     144int mount(const char *fs_name, const char *mp, const char *fqsn,
    145145    const char *opts, unsigned int flags)
    146146{
    147147        int null_id = -1;
    148         char null[DEVMAP_NAME_MAXLEN];
    149        
    150         if (str_cmp(fqdn, "") == 0) {
     148        char null[LOC_NAME_MAXLEN];
     149       
     150        if (str_cmp(fqsn, "") == 0) {
    151151                /* No device specified, create a fresh
    152152                   null/%d device instead */
    153                 null_id = devmap_null_create();
     153                null_id = loc_null_create();
    154154               
    155155                if (null_id == -1)
    156156                        return ENOMEM;
    157157               
    158                 snprintf(null, DEVMAP_NAME_MAXLEN, "null/%d", null_id);
    159                 fqdn = null;
    160         }
    161        
    162         devmap_handle_t devmap_handle;
    163         int res = devmap_device_get_handle(fqdn, &devmap_handle, flags);
     158                snprintf(null, LOC_NAME_MAXLEN, "null/%d", null_id);
     159                fqsn = null;
     160        }
     161       
     162        service_id_t service_id;
     163        int res = loc_service_get_id(fqsn, &service_id, flags);
    164164        if (res != EOK) {
    165165                if (null_id != -1)
    166                         devmap_null_destroy(null_id);
     166                        loc_null_destroy(null_id);
    167167               
    168168                return res;
    … …  
    173173        if (!mpa) {
    174174                if (null_id != -1)
    175                         devmap_null_destroy(null_id);
     175                        loc_null_destroy(null_id);
    176176               
    177177                return ENOMEM;
    … …  
    181181
    182182        sysarg_t rc_orig;
    183         aid_t req = async_send_2(exch, VFS_IN_MOUNT, devmap_handle, flags, NULL);
     183        aid_t req = async_send_2(exch, VFS_IN_MOUNT, service_id, flags, NULL);
    184184        sysarg_t rc = async_data_write_start(exch, (void *) mpa, mpa_size);
    185185        if (rc != EOK) {
    … …  
    189189               
    190190                if (null_id != -1)
    191                         devmap_null_destroy(null_id);
     191                        loc_null_destroy(null_id);
    192192               
    193193                if (rc_orig == EOK)
    … …  
    204204               
    205205                if (null_id != -1)
    206                         devmap_null_destroy(null_id);
     206                        loc_null_destroy(null_id);
    207207               
    208208                if (rc_orig == EOK)
    … …  
    219219               
    220220                if (null_id != -1)
    221                         devmap_null_destroy(null_id);
     221                        loc_null_destroy(null_id);
    222222               
    223223                if (rc_orig == EOK)
    … …  
    235235               
    236236                if (null_id != -1)
    237                         devmap_null_destroy(null_id);
     237                        loc_null_destroy(null_id);
    238238               
    239239                if (rc_orig == EOK)
    … …  
    248248       
    249249        if ((rc != EOK) && (null_id != -1))
    250                 devmap_null_destroy(null_id);
     250                loc_null_destroy(null_id);
    251251       
    252252        return (int) rc;
    … …  
    792792        }
    793793       
    794         if (!stat.device) {
     794        if (!stat.service) {
    795795                errno = ENOENT;
    796796                return NULL;
    797797        }
    798798       
    799         return devmap_device_connect(mgmt, stat.device, 0);
     799        return loc_service_connect(mgmt, stat.service, 0);
    800800}
    801801

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

    rd894fbd r903bac0a  
    3838
    3939#include <ipc/devman.h>
     40#include <ipc/loc.h>
    4041#include <async.h>
    4142#include <bool.h>
    … …  
    4849extern int devman_add_function(const char *, fun_type_t, match_id_list_t *,
    4950    devman_handle_t, devman_handle_t *);
     51extern int devman_remove_function(devman_handle_t);
    5052
    5153extern async_sess_t *devman_device_connect(exch_mgmt_t, devman_handle_t,
    … …  
    5658extern int devman_device_get_handle(const char *, devman_handle_t *,
    5759    unsigned int);
    58 extern int devman_device_get_handle_by_class(const char *, const char *,
    59     devman_handle_t *, unsigned int);
    6060extern int devman_get_device_path(devman_handle_t, char *, size_t);
    6161
    62 extern int devman_add_device_to_class(devman_handle_t, const char *);
     62extern int devman_add_device_to_category(devman_handle_t, const char *);
     63extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *);
    6364
    6465#endif

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

    rd894fbd r903bac0a  
    130130        DEVMAN_CLIENT,
    131131        DEVMAN_CONNECT_TO_DEVICE,
    132         DEVMAN_CONNECT_FROM_DEVMAP,
     132        DEVMAN_CONNECT_FROM_LOC,
    133133        DEVMAN_CONNECT_TO_PARENTS_DEVICE
    134134} devman_interface_t;
    … …  
    138138        DEVMAN_ADD_FUNCTION,
    139139        DEVMAN_ADD_MATCH_ID,
    140         DEVMAN_ADD_DEVICE_TO_CLASS
    141 
     140        DEVMAN_ADD_DEVICE_TO_CATEGORY,
     141        DEVMAN_REMOVE_FUNCTION
    142142} driver_to_devman_t;
    143143
    … …  
    149149typedef enum {
    150150        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
    151         DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
    152         DEVMAN_DEVICE_GET_DEVICE_PATH
     151        DEVMAN_DEVICE_GET_DEVICE_PATH,
     152        DEVMAN_FUN_SID_TO_HANDLE
    153153} client_to_devman_t;
    154154

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

    rd894fbd r903bac0a  
    11/*
    22 * Copyright (c) 2007 Josef Cejka
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    2728 */
    2829
    29 /** @addtogroup devmap
     30/** @addtogroup loc
    3031 * @{
    3132 */
    3233
    33 #ifndef LIBC_IPC_DEVMAP_H_
    34 #define LIBC_IPC_DEVMAP_H_
     34#ifndef LIBC_IPC_LOC_H_
     35#define LIBC_IPC_LOC_H_
    3536
    3637#include <ipc/common.h>
    3738
    38 #define DEVMAP_NAME_MAXLEN  255
     39#define LOC_NAME_MAXLEN  255
    3940
    40 typedef sysarg_t devmap_handle_t;
     41typedef sysarg_t service_id_t;
     42typedef sysarg_t category_id_t;
    4143
    4244typedef enum {
    43         DEV_HANDLE_NONE,
    44         DEV_HANDLE_NAMESPACE,
    45         DEV_HANDLE_DEVICE
    46 } devmap_handle_type_t;
     45        LOC_OBJECT_NONE,
     46        LOC_OBJECT_NAMESPACE,
     47        LOC_OBJECT_SERVICE
     48} loc_object_type_t;
    4749
    4850typedef enum {
    49         DEVMAP_DRIVER_REGISTER = IPC_FIRST_USER_METHOD,
    50         DEVMAP_DRIVER_UNREGISTER,
    51         DEVMAP_DEVICE_REGISTER,
    52         DEVMAP_DEVICE_UNREGISTER,
    53         DEVMAP_DEVICE_GET_HANDLE,
    54         DEVMAP_NAMESPACE_GET_HANDLE,
    55         DEVMAP_HANDLE_PROBE,
    56         DEVMAP_NULL_CREATE,
    57         DEVMAP_NULL_DESTROY,
    58         DEVMAP_GET_NAMESPACE_COUNT,
    59         DEVMAP_GET_DEVICE_COUNT,
    60         DEVMAP_GET_NAMESPACES,
    61         DEVMAP_GET_DEVICES
    62 } devmap_request_t;
     51        LOC_SERVER_REGISTER = IPC_FIRST_USER_METHOD,
     52        LOC_SERVER_UNREGISTER,
     53        LOC_SERVICE_ADD_TO_CAT,
     54        LOC_SERVICE_REGISTER,
     55        LOC_SERVICE_UNREGISTER,
     56        LOC_SERVICE_GET_ID,
     57        LOC_SERVICE_GET_NAME,
     58        LOC_NAMESPACE_GET_ID,
     59        LOC_CALLBACK_CREATE,
     60        LOC_CATEGORY_GET_ID,
     61        LOC_CATEGORY_GET_NAME,
     62        LOC_CATEGORY_GET_SVCS,
     63        LOC_ID_PROBE,
     64        LOC_NULL_CREATE,
     65        LOC_NULL_DESTROY,
     66        LOC_GET_NAMESPACE_COUNT,
     67        LOC_GET_SERVICE_COUNT,
     68        LOC_GET_CATEGORIES,
     69        LOC_GET_NAMESPACES,
     70        LOC_GET_SERVICES
     71} loc_request_t;
    6372
    64 /** Interface provided by devmap.
     73typedef enum {
     74        LOC_EVENT_CAT_CHANGE = IPC_FIRST_USER_METHOD
     75} loc_event_t;
     76
     77/** Ports provided by location service.
    6578 *
    66  * Every process that connects to devmap must ask one of following
    67  * interfaces otherwise connection will be refused.
     79 * Every process that connects to loc must ask one of following
     80 * ports, otherwise connection will be refused.
    6881 *
    6982 */
    7083typedef enum {
    71         /** Connect as device driver */
    72         DEVMAP_DRIVER = 1,
    73         /** Connect as client */
    74         DEVMAP_CLIENT,
     84        /** Service supplier (server) port */
     85        LOC_PORT_SUPPLIER = 1,
     86        /** Service consumer (client) port */
     87        LOC_PORT_CONSUMER,
    7588        /** Create new connection to instance of device that
    7689            is specified by second argument of call. */
    77         DEVMAP_CONNECT_TO_DEVICE
    78 } devmap_interface_t;
     90        LOC_CONNECT_TO_SERVICE
     91} loc_interface_t;
    7992
    8093typedef struct {
    81         devmap_handle_t handle;
    82         char name[DEVMAP_NAME_MAXLEN + 1];
    83 } dev_desc_t;
     94        service_id_t id;
     95        char name[LOC_NAME_MAXLEN + 1];
     96} loc_sdesc_t;
    8497
    8598#endif

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

    rd894fbd r903bac0a  
    4545        SERVICE_VIDEO      = FOURCC('v', 'i', 'd', ' '),
    4646        SERVICE_VFS        = FOURCC('v', 'f', 's', ' '),
    47         SERVICE_DEVMAP     = FOURCC('d', 'e', 'v', 'p'),
     47        SERVICE_LOC        = FOURCC('l', 'o', 'c', ' '),
    4848        SERVICE_DEVMAN     = FOURCC('d', 'e', 'v', 'n'),
    4949        SERVICE_IRC        = FOURCC('i', 'r', 'c', ' '),

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

    rd894fbd r903bac0a  
    3333 */
    3434
    35 #ifndef LIBC_DEVMAP_H_
    36 #define LIBC_DEVMAP_H_
     35#ifndef LIBC_LOC_H_
     36#define LIBC_LOC_H_
    3737
    38 #include <ipc/devmap.h>
     38#include <ipc/loc.h>
    3939#include <async.h>
    4040#include <bool.h>
    4141
    42 extern async_exch_t *devmap_exchange_begin_blocking(devmap_interface_t);
    43 extern async_exch_t *devmap_exchange_begin(devmap_interface_t);
    44 extern void devmap_exchange_end(async_exch_t *);
     42typedef void (*loc_cat_change_cb_t)(void);
    4543
    46 extern int devmap_driver_register(const char *, async_client_conn_t);
    47 extern int devmap_device_register(const char *, devmap_handle_t *);
    48 extern int devmap_device_register_with_iface(const char *, devmap_handle_t *,
     44extern async_exch_t *loc_exchange_begin_blocking(loc_interface_t);
     45extern async_exch_t *loc_exchange_begin(loc_interface_t);
     46extern void loc_exchange_end(async_exch_t *);
     47
     48extern int loc_server_register(const char *, async_client_conn_t);
     49extern int loc_service_register(const char *, service_id_t *);
     50extern int loc_service_register_with_iface(const char *, service_id_t *,
    4951    sysarg_t);
     52extern int loc_service_unregister(service_id_t);
     53extern int loc_service_add_to_cat(service_id_t, category_id_t);
    5054
    51 extern int devmap_device_get_handle(const char *, devmap_handle_t *,
     55extern int loc_service_get_id(const char *, service_id_t *,
    5256    unsigned int);
    53 extern int devmap_namespace_get_handle(const char *, devmap_handle_t *,
     57extern int loc_service_get_name(service_id_t, char **);
     58extern int loc_namespace_get_id(const char *, service_id_t *,
    5459    unsigned int);
    55 extern devmap_handle_type_t devmap_handle_probe(devmap_handle_t);
     60extern int loc_category_get_id(const char *, category_id_t *,
     61    unsigned int);
     62extern int loc_category_get_name(category_id_t, char **);
     63extern int loc_category_get_svcs(category_id_t, category_id_t **, size_t *);
     64extern loc_object_type_t loc_id_probe(service_id_t);
    5665
    57 extern async_sess_t *devmap_device_connect(exch_mgmt_t, devmap_handle_t,
     66extern async_sess_t *loc_service_connect(exch_mgmt_t, service_id_t,
    5867    unsigned int);
    5968
    60 extern int devmap_null_create(void);
    61 extern void devmap_null_destroy(int);
     69extern int loc_null_create(void);
     70extern void loc_null_destroy(int);
    6271
    63 extern size_t devmap_count_namespaces(void);
    64 extern size_t devmap_count_devices(devmap_handle_t);
     72extern size_t loc_count_namespaces(void);
     73extern size_t loc_count_services(service_id_t);
    6574
    66 extern size_t devmap_get_namespaces(dev_desc_t **);
    67 extern size_t devmap_get_devices(devmap_handle_t, dev_desc_t **);
     75extern size_t loc_get_namespaces(loc_sdesc_t **);
     76extern size_t loc_get_services(service_id_t, loc_sdesc_t **);
     77extern int loc_get_categories(category_id_t **, size_t *);
     78extern int loc_register_cat_change_cb(loc_cat_change_cb_t);
     79
    6880
    6981#endif

  • uspace/lib/c/include/sys/stat.h

    rd894fbd r903bac0a  
    3939#include <bool.h>
    4040#include <ipc/vfs.h>
    41 #include <ipc/devmap.h>
     41#include <ipc/loc.h>
    4242
    4343struct stat {
    4444        fs_handle_t fs_handle;
    45         devmap_handle_t devmap_handle;
     45        service_id_t service_id;
    4646        fs_index_t index;
    4747        unsigned int lnkcnt;
    … …  
    4949        bool is_directory;
    5050        aoff64_t size;
    51         devmap_handle_t device;
     51        service_id_t service;
    5252};
    5353

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

    rd894fbd r903bac0a  
    3838#include <sys/types.h>
    3939#include <ipc/vfs.h>
    40 #include <ipc/devmap.h>
     40#include <ipc/loc.h>
    4141#include <stdio.h>
    4242#include <async.h>
Note: See TracChangeset for help on using the changeset viewer.