Changeset 6610565b in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2011-01-10T16:20:56Z (15 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1ffa73b, 8048c648, 8426912a, 977fcea, f401312
Parents:
a97ea0f (diff), 4a5c6c1 (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/generic
Files:
10 edited
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/adt/char_map.c

    ra97ea0f r6610565b  
    6565 */
    6666static int
    67 char_map_add_item(char_map_t *map, const char *identifier, size_t length,
     67char_map_add_item(char_map_t *map, const uint8_t *identifier, size_t length,
    6868    const int value)
    6969{
    … …  
    139139 */
    140140int
    141 char_map_add(char_map_t *map, const char *identifier, size_t length,
     141char_map_add(char_map_t *map, const uint8_t *identifier, size_t length,
    142142    const int value)
    143143{
    … …  
    200200 */
    201201static char_map_t *
    202 char_map_find_node(const char_map_t *map, const char *identifier,
     202char_map_find_node(const char_map_t *map, const uint8_t *identifier,
    203203    size_t length)
    204204{
    … …  
    241241 * @return              CHAR_MAP_NULL if the key is not assigned a value.
    242242 */
    243 int char_map_exclude(char_map_t *map, const char *identifier, size_t length)
     243int char_map_exclude(char_map_t *map, const uint8_t *identifier, size_t length)
    244244{
    245245        char_map_t *node;
    … …  
    269269 *  @return             CHAR_MAP_NULL if the key is not assigned a value.
    270270 */
    271 int char_map_find(const char_map_t *map, const char *identifier, size_t length)
     271int char_map_find(const char_map_t *map, const uint8_t *identifier, size_t length)
    272272{
    273273        char_map_t *node;
    … …  
    329329 */
    330330int
    331 char_map_update(char_map_t *map, const char *identifier, const size_t length,
     331char_map_update(char_map_t *map, const uint8_t *identifier, const size_t length,
    332332    const int value)
    333333{

  • uspace/lib/c/generic/adt/measured_strings.c

    ra97ea0f r6610565b  
    5959 */
    6060measured_string_t *
    61 measured_string_create_bulk(const char *string, size_t length)
     61measured_string_create_bulk(const uint8_t *string, size_t length)
    6262{
    6363        measured_string_t *new;
    … …  
    6868        }
    6969        new = (measured_string_t *) malloc(sizeof(measured_string_t) +
    70             (sizeof(char) * (length + 1)));
     70            (sizeof(uint8_t) * (length + 1)));
    7171        if (!new)
    7272                return NULL;
    7373
    7474        new->length = length;
    75         new->value = ((char *) new) + sizeof(measured_string_t);
     75        new->value = ((uint8_t *) new) + sizeof(measured_string_t);
    7676        // append terminating zero explicitly - to be safe
    7777        memcpy(new->value, string, new->length);
    … …  
    9797        new = (measured_string_t *) malloc(sizeof(measured_string_t));
    9898        if (new) {
    99                 new->value = (char *) malloc(source->length + 1);
     99                new->value = (uint8_t *) malloc(source->length + 1);
    100100                if (new->value) {
    101101                        new->length = source->length;
    … …  
    131131 */
    132132int
    133 measured_strings_receive(measured_string_t **strings, char **data,
     133measured_strings_receive(measured_string_t **strings, uint8_t **data,
    134134    size_t count)
    135135{
    … …  
    137137        size_t index;
    138138        size_t length;
    139         char *next;
     139        uint8_t *next;
    140140        ipc_callid_t callid;
    141141        int rc;
    … …  
    311311 */
    312312int
    313 measured_strings_return(int phone, measured_string_t **strings, char **data,
     313measured_strings_return(int phone, measured_string_t **strings, uint8_t **data,
    314314    size_t count)
    315315{
    316316        size_t *lengths;
    317317        size_t index;
    318         char *next;
     318        uint8_t *next;
    319319        int rc;
    320320

  • uspace/lib/c/generic/async_sess.c

    ra97ea0f r6610565b  
    110110typedef struct {
    111111        link_t sess_link;       /**< Link for the session list of inactive connections. */
    112         link_t global_link;     /**< Link for the global list of inactive connectinos. */
     112        link_t global_link;     /**< Link for the global list of inactive connections. */
    113113        int data_phone;         /**< Connected data phone. */
    114114} conn_node_t;
    115115
    116116/**
    117  * Mutex protecting the inactive_conn_head list and the session list.
     117 * Mutex protecting the inactive_conn_head list, the session list and the
     118 * avail_phone condition variable.
    118119 */
    119120static fibril_mutex_t async_sess_mutex;
    … …  
    128129 */
    129130static LIST_INITIALIZE(session_list_head);
     131
     132/**
     133 * Condition variable used to wait for a phone to become available.
     134 */
     135static FIBRIL_CONDVAR_INITIALIZE(avail_phone_cv);
    130136
    131137/** Initialize the async_sess subsystem.
    … …  
    150156 * @param sess  Session structure provided by caller, will be filled in.
    151157 * @param phone Phone connected to the desired server task.
    152  */
    153 void async_session_create(async_sess_t *sess, int phone)
     158 * @param arg1  Value to pass as first argument upon creating a new
     159 *              connection. Typical use is to identify a resource within
     160 *              the server that the caller wants to access (port ID,
     161 *              interface ID, device ID, etc.).
     162 */
     163void async_session_create(async_sess_t *sess, int phone, sysarg_t arg1)
    154164{
    155165        sess->sess_phone = phone;
     166        sess->connect_arg1 = arg1;
    156167        list_initialize(&sess->conn_head);
    157168       
    … …  
    192203                free(conn);
    193204        }
     205       
     206        fibril_condvar_broadcast(&avail_phone_cv);
    194207}
    195208
    … …  
    231244                 */
    232245retry:
    233                 data_phone = async_connect_me_to(sess->sess_phone, 0, 0, 0);
     246                data_phone = async_connect_me_to(sess->sess_phone,
     247                    sess->connect_arg1, 0, 0);
    234248                if (data_phone >= 0) {
    235249                        /* success, do nothing */
    … …  
    250264                } else {
    251265                        /*
    252                          * This is unfortunate. We failed both to find a cached
    253                          * connection or to create a new one even after cleaning up
    254                          * the cache. This is most likely due to too many
    255                          * open sessions (connected session phones).
     266                         * Wait for a phone to become available.
    256267                         */
    257                         data_phone = ELIMIT;
     268                        fibril_condvar_wait(&avail_phone_cv, &async_sess_mutex);
     269                        goto retry;
    258270                }
    259271        }
    … …  
    273285
    274286        fibril_mutex_lock(&async_sess_mutex);
     287        fibril_condvar_signal(&avail_phone_cv);
    275288        conn = (conn_node_t *) malloc(sizeof(conn_node_t));
    276289        if (!conn) {
    … …  
    279292                 * means that we simply hang up.
    280293                 */
     294                ipc_hangup(data_phone);
    281295                fibril_mutex_unlock(&async_sess_mutex);
    282                 ipc_hangup(data_phone);
    283296                return;
    284297        }

  • uspace/lib/c/generic/device/char_dev.c

    ra97ea0f r6610565b  
    3434
    3535#include <ipc/dev_iface.h>
    36 #include <device/char.h>
     36#include <device/char_dev.h>
    3737#include <errno.h>
    3838#include <async.h>
    … …  
    4545 * using its character interface.
    4646 *
    47  * @param dev_phone Phone to the device.
    48  * @param buf       Buffer for the data read
    49  *                  from or written to the device.
    50  * @param len       Maximum length of the data to be
    51  *                  read or written.
    52  * @param read      Read from the device if true,
    53  *                  write to it otherwise.
     47 * @param dev_phone     Phone to the device.
     48 * @param buf           Buffer for the data read from or written to the device.
     49 * @param size          Maximum size of data (in bytes) to be read or written.
     50 * @param read          Read from the device if true, write to it otherwise.
    5451 *
    55  * @return Non-negative number of bytes actually read
    56  *         from or written to the device on success,
    57  *         negative error number otherwise.
    58  *
     52 * @return              Non-negative number of bytes actually read from or
     53 *                      written to the device on success, negative error number
     54 *                      otherwise.
    5955 */
    60 static ssize_t rw_dev(int dev_phone, void *buf, size_t len, bool read)
     56static ssize_t char_dev_rw(int dev_phone, void *buf, size_t size, bool read)
    6157{
    6258        async_serialize_start();
    … …  
    6864        if (read) {
    6965                req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE),
    70                     CHAR_READ_DEV, &answer);
    71                 ret = async_data_read_start(dev_phone, buf, len);
     66                    CHAR_DEV_READ, &answer);
     67                ret = async_data_read_start(dev_phone, buf, size);
    7268        } else {
    7369                req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE),
    74                     CHAR_WRITE_DEV, &answer);
    75                 ret = async_data_write_start(dev_phone, buf, len);
     70                    CHAR_DEV_WRITE, &answer);
     71                ret = async_data_write_start(dev_phone, buf, size);
    7672        }
    7773       
    … …  
    8278                if (rc == EOK)
    8379                        return (ssize_t) ret;
    84                        
     80               
    8581                return (ssize_t) rc;
    8682        }
    … …  
    9692}
    9793
    98 /** Read from device using its character interface.
     94/** Read from character device.
    9995 *
    100  * @param dev_phone Phone to the device.
    101  * @param buf       Output buffer for the data
    102  *                  read from the device.
    103  * @param len       Maximum length of the data to be read.
     96 * @param dev_phone     Phone to the device.
     97 * @param buf           Output buffer for the data read from the device.
     98 * @param size          Maximum size (in bytes) of the data to be read.
    10499 *
    105  * @return Non-negative number of bytes actually read
    106  *         from the device on success, negative error
    107  *         number otherwise.
    108  *
     100 * @return              Non-negative number of bytes actually read from the
     101 *                      device on success, negative error number otherwise.
    109102 */
    110 ssize_t read_dev(int dev_phone, void *buf, size_t len)
     103ssize_t char_dev_read(int dev_phone, void *buf, size_t size)
    111104{
    112         return rw_dev(dev_phone, buf, len, true);
     105        return char_dev_rw(dev_phone, buf, size, true);
    113106}
    114107
    115 /** Write to device using its character interface.
     108/** Write to character device.
    116109 *
    117  * @param dev_phone Phone to the device.
    118  * @param buf       Input buffer containg the data
    119  *                  to be written to the device.
    120  * @param len       Maximum length of the data to be written.
     110 * @param dev_phone     Phone to the device.
     111 * @param buf           Input buffer containg the data to be written to the
     112 *                      device.
     113 * @param size          Maximum size (in bytes) of the data to be written.
    121114 *
    122  * @return Non-negative number of bytes actually written
    123  *         to the device on success, negative error number
    124  *         otherwise.
    125  *
     115 * @return              Non-negative number of bytes actually written to the
     116 *                      device on success, negative error number otherwise.
    126117 */
    127 ssize_t write_dev(int dev_phone, void *buf, size_t len)
     118ssize_t char_dev_write(int dev_phone, void *buf, size_t size)
    128119{
    129         return rw_dev(dev_phone, buf, len, false);
     120        return char_dev_rw(dev_phone, buf, size, false);
    130121}
    131122

  • uspace/lib/c/generic/device/hw_res.c

    ra97ea0f r6610565b  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28  
     28
    2929 /** @addtogroup libc
    3030 * @{
    … …  
    3232/** @file
    3333 */
    34  
     34
    3535#include <device/hw_res.h>
    3636#include <errno.h>
    … …  
    3838#include <malloc.h>
    3939
    40 int get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources)
     40int hw_res_get_resource_list(int dev_phone, hw_resource_list_t *hw_resources)
    4141{
    4242        sysarg_t count = 0;
    43         int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), GET_RESOURCE_LIST, &count);
     43
     44        int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     45            HW_RES_GET_RESOURCE_LIST, &count);
     46
    4447        hw_resources->count = count;
    4548        if (rc != EOK)
    … …  
    5760                return rc;
    5861        }
    59                  
     62       
    6063        return EOK;
    6164}
    6265
    63 bool enable_interrupt(int dev_phone)
     66bool hw_res_enable_interrupt(int dev_phone)
    6467{
    65         int rc = async_req_1_0(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), ENABLE_INTERRUPT);
     68        int rc = async_req_1_0(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     69            HW_RES_ENABLE_INTERRUPT);
     70
    6671        return rc == EOK;
    6772}
    68  
    69  
    70  
    71  /** @}
     73
     74/** @}
    7275 */

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

    ra97ea0f r6610565b  
    4242#include <devman.h>
    4343#include <async.h>
     44#include <fibril_synch.h>
    4445#include <errno.h>
    4546#include <malloc.h>
    … …  
    5051static int devman_phone_client = -1;
    5152
     53static FIBRIL_MUTEX_INITIALIZE(devman_phone_mutex);
     54
    5255int devman_get_phone(devman_interface_t iface, unsigned int flags)
    5356{
    5457        switch (iface) {
    5558        case DEVMAN_DRIVER:
    56                 if (devman_phone_driver >= 0)
     59                fibril_mutex_lock(&devman_phone_mutex);
     60                if (devman_phone_driver >= 0) {
     61                        fibril_mutex_unlock(&devman_phone_mutex);
    5762                        return devman_phone_driver;
     63                }
    5864               
    5965                if (flags & IPC_FLAG_BLOCKING)
    60                         devman_phone_driver = ipc_connect_me_to_blocking(PHONE_NS,
     66                        devman_phone_driver = async_connect_me_to_blocking(
     67                            PHONE_NS, SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
     68                else
     69                        devman_phone_driver = async_connect_me_to(PHONE_NS,
    6170                            SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
    62                 else
    63                         devman_phone_driver = ipc_connect_me_to(PHONE_NS,
    64                             SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
    65                
     71               
     72                fibril_mutex_unlock(&devman_phone_mutex);
    6673                return devman_phone_driver;
    6774        case DEVMAN_CLIENT:
    68                 if (devman_phone_client >= 0)
     75                fibril_mutex_lock(&devman_phone_mutex);
     76                if (devman_phone_client >= 0) {
     77                        fibril_mutex_unlock(&devman_phone_mutex);
    6978                        return devman_phone_client;
     79                }
    7080               
    7181                if (flags & IPC_FLAG_BLOCKING)
    72                         devman_phone_client = ipc_connect_me_to_blocking(PHONE_NS,
     82                        devman_phone_client = async_connect_me_to_blocking(
     83                            PHONE_NS, SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
     84                else
     85                        devman_phone_client = async_connect_me_to(PHONE_NS,
    7386                            SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
    74                 else
    75                         devman_phone_client = ipc_connect_me_to(PHONE_NS,
    76                             SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
    77                
     87               
     88                fibril_mutex_unlock(&devman_phone_mutex);
    7889                return devman_phone_client;
    7990        default:
    … …  
    245256       
    246257        if (flags & IPC_FLAG_BLOCKING) {
    247                 phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
     258                phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
    248259                    DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
    249260        } else {
    250                 phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
     261                phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
    251262                    DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
    252263        }

  • uspace/lib/c/generic/fibril.c

    ra97ea0f r6610565b  
    361361}
    362362
     363int fibril_get_sercount(void)
     364{
     365        return serialization_count;
     366}
     367
    363368/** @}
    364369 */

  • uspace/lib/c/generic/fibril_synch.c

    ra97ea0f r6610565b  
    104104        fibril_t *f = (fibril_t *) fibril_get_id();
    105105
     106        if (fibril_get_sercount() != 0)
     107                core();
     108
    106109        futex_down(&async_futex);
    107110        if (fm->counter-- <= 0) {
    … …  
    194197        fibril_t *f = (fibril_t *) fibril_get_id();
    195198       
     199        if (fibril_get_sercount() != 0)
     200                core();
     201
    196202        futex_down(&async_futex);
    197203        if (frw->writers) {
    … …  
    219225        fibril_t *f = (fibril_t *) fibril_get_id();
    220226       
     227        if (fibril_get_sercount() != 0)
     228                core();
     229
    221230        futex_down(&async_futex);
    222231        if (frw->writers || frw->readers) {

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

    ra97ea0f r6610565b  
    3737#include <unistd.h>
    3838#include <io/printf_core.h>
    39 #include <futex.h>
     39#include <fibril_synch.h>
    4040#include <async.h>
    4141#include <str.h>
    4242
    43 static atomic_t printf_futex = FUTEX_INITIALIZER;
     43static FIBRIL_MUTEX_INITIALIZE(printf_mutex);
    4444
    4545static int vprintf_str_write(const char *str, size_t size, void *stream)
    … …  
    8585         * Prevent other threads to execute printf_core()
    8686         */
    87         futex_down(&printf_futex);
    88        
    89         /*
    90          * Prevent other fibrils of the same thread
    91          * to execute printf_core()
    92          */
    93         async_serialize_start();
     87        fibril_mutex_lock(&printf_mutex);
    9488       
    9589        int ret = printf_core(fmt, &ps, ap);
    9690       
    97         async_serialize_end();
    98         futex_up(&printf_futex);
     91        fibril_mutex_unlock(&printf_mutex);
    9992       
    10093        return ret;

  • uspace/lib/c/generic/mem.c

    ra97ea0f r6610565b  
    222222/** Compare two memory areas.
    223223 *
    224  * @param s1            Pointer to the first area to compare.
    225  * @param s2            Pointer to the second area to compare.
    226  * @param len           Size of the first area in bytes. Both areas must have
    227  *                      the same length.
    228  * @return              If len is 0, return zero. If the areas match, return
    229  *                      zero. Otherwise return non-zero.
    230  */
    231 int bcmp(const char *s1, const char *s2, size_t len)
    232 {
    233         for (; len && *s1++ == *s2++; len--)
    234                 ;
     224 * @param s1  Pointer to the first area to compare.
     225 * @param s2  Pointer to the second area to compare.
     226 * @param len Size of the first area in bytes. Both areas must have
     227 *            the same length.
     228 *
     229 * @return If len is 0, return zero. If the areas match, return
     230 *         zero. Otherwise return non-zero.
     231 *
     232 */
     233int bcmp(const void *s1, const void *s2, size_t len)
     234{
     235        uint8_t *u1 = (uint8_t *) s1;
     236        uint8_t *u2 = (uint8_t *) s2;
     237       
     238        for (; (len != 0) && (*u1++ == *u2++); len--);
     239       
    235240        return len;
    236241}

  • uspace/lib/c/generic/net/modules.c

    ra97ea0f r6610565b  
    3232
    3333/** @file
    34  * Generic module functions implementation. 
     34 * Generic module functions implementation.
    3535 *
    3636 * @todo MAKE IT POSSIBLE TO REMOVE THIS FILE VIA EITHER REPLACING PART OF ITS
    … …  
    5252#define MODULE_WAIT_TIME        (10 * 1000)
    5353
    54 /** Answers the call.
    55  *
    56  * @param[in] callid    The call identifier.
    57  * @param[in] result    The message processing result.
    58  * @param[in] answer    The message processing answer.
    59  * @param[in] answer_count The number of answer parameters.
    60  */
    61 void
    62 answer_call(ipc_callid_t callid, int result, ipc_call_t *answer,
    63     int answer_count)
    64 {
    65         /* Choose the most efficient answer function */
    66         if (answer || (!answer_count)) {
    67                 switch (answer_count) {
     54/** Answer a call.
     55 *
     56 * @param[in] callid Call identifier.
     57 * @param[in] result Message processing result.
     58 * @param[in] answer Message processing answer.
     59 * @param[in] count  Number of answer parameters.
     60 *
     61 */
     62void answer_call(ipc_callid_t callid, int result, ipc_call_t *answer,
     63    size_t count)
     64{
     65        /* Choose the most efficient function */
     66        if ((answer != NULL) || (count == 0)) {
     67                switch (count) {
    6868                case 0:
    6969                        ipc_answer_0(callid, (sysarg_t) result);
    … …  
    228228}
    229229
    230 /** Refreshes answer structure and parameters count.
    231  *
    232  * Erases all attributes.
    233  *
    234  * @param[in,out] answer The message processing answer structure.
    235  * @param[in,out] answer_count The number of answer parameters.
    236  */
    237 void refresh_answer(ipc_call_t *answer, int *answer_count)
    238 {
    239         if (answer_count)
    240                 *answer_count = 0;
    241 
    242         if (answer) {
     230/** Refresh answer structure and argument count.
     231 *
     232 * Erase all arguments.
     233 *
     234 * @param[in,out] answer Message processing answer structure.
     235 * @param[in,out] count  Number of answer arguments.
     236 *
     237 */
     238void refresh_answer(ipc_call_t *answer, size_t *count)
     239{
     240        if (count != NULL)
     241                *count = 0;
     242       
     243        if (answer != NULL) {
    243244                IPC_SET_RETVAL(*answer, 0);
    244                 /* Just to be precise */
    245245                IPC_SET_IMETHOD(*answer, 0);
    246246                IPC_SET_ARG1(*answer, 0);
Note: See TracChangeset for help on using the changeset viewer.