Changeset 8ff0bd2 in mainline for uspace/lib/c/include


Ignore:
Timestamp:
2011-09-04T11:30:58Z (14 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
03bc76a
Parents:
d2c67e7 (diff), deac215e (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/include
Files:
5 added
43 edited
4 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/include/adt/hash_table.h

    rd2c67e7 r8ff0bd2  
    7575/** Hash table structure. */
    7676typedef struct {
    77         link_t *entry;
     77        list_t *entry;
    7878        hash_count_t entries;
    7979        hash_count_t max_keys;

  • uspace/lib/c/include/adt/list.h

    rd2c67e7 r8ff0bd2  
    11/*
    22 * Copyright (c) 2001-2004 Jakub Jermar
     3 * Copyright (c) 2011 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    3637#define LIBC_LIST_H_
    3738
     39#include <assert.h>
    3840#include <unistd.h>
    3941
    40 /** Doubly linked list head and link type. */
     42/** Doubly linked list link. */
    4143typedef struct link {
    4244        struct link *prev;  /**< Pointer to the previous item in the list. */
    … …  
    4446} link_t;
    4547
     48/** Doubly linked list. */
     49typedef struct list {
     50        link_t head;  /**< List head. Does not have any data. */
     51} list_t;
     52
    4653/** Declare and initialize statically allocated list.
    4754 *
    … …  
    5057 */
    5158#define LIST_INITIALIZE(name) \
    52         link_t name = { \
    53                 .prev = &name, \
    54                 .next = &name \
     59        list_t name = { \
     60                .head = { \
     61                        .prev = &(name).head, \
     62                        .next = &(name).head \
     63                } \
    5564        }
    5665
    … …  
    5968
    6069#define list_foreach(list, iterator) \
    61         for (link_t *iterator = (list).next; \
    62             iterator != &(list); iterator = iterator->next)
     70        for (link_t *iterator = (list).head.next; \
     71            iterator != &(list).head; iterator = iterator->next)
     72
     73#define assert_link_not_used(link) \
     74        assert((link)->prev == NULL && (link)->next == NULL)
    6375
    6476/** Initialize doubly-linked circular list link
    … …  
    7991 * Initialize doubly-linked circular list.
    8092 *
    81  * @param list Pointer to link_t structure representing the list.
    82  *
    83  */
    84 static inline void list_initialize(link_t *list)
    85 {
    86         list->prev = list;
    87         list->next = list;
     93 * @param list Pointer to list_t structure.
     94 *
     95 */
     96static inline void list_initialize(list_t *list)
     97{
     98        list->head.prev = &list->head;
     99        list->head.next = &list->head;
     100}
     101
     102/** Insert item before another item in doubly-linked circular list.
     103 *
     104 */
     105static inline void list_insert_before(link_t *lnew, link_t *lold)
     106{
     107        lnew->next = lold;
     108        lnew->prev = lold->prev;
     109        lold->prev->next = lnew;
     110        lold->prev = lnew;
     111}
     112
     113/** Insert item after another item in doubly-linked circular list.
     114 *
     115 */
     116static inline void list_insert_after(link_t *lnew, link_t *lold)
     117{
     118        lnew->prev = lold;
     119        lnew->next = lold->next;
     120        lold->next->prev = lnew;
     121        lold->next = lnew;
    88122}
    89123
    … …  
    93127 *
    94128 * @param link Pointer to link_t structure to be added.
    95  * @param list Pointer to link_t structure representing the list.
    96  *
    97  */
    98 static inline void list_prepend(link_t *link, link_t *list)
    99 {
    100         link->next = list->next;
    101         link->prev = list;
    102         list->next->prev = link;
    103         list->next = link;
     129 * @param list Pointer to list_t structure.
     130 *
     131 */
     132static inline void list_prepend(link_t *link, list_t *list)
     133{
     134        list_insert_after(link, &list->head);
    104135}
    105136
    … …  
    109140 *
    110141 * @param link Pointer to link_t structure to be added.
    111  * @param list Pointer to link_t structure representing the list.
    112  *
    113  */
    114 static inline void list_append(link_t *link, link_t *list)
    115 {
    116         link->prev = list->prev;
    117         link->next = list;
    118         list->prev->next = link;
    119         list->prev = link;
    120 }
    121 
    122 /** Insert item before another item in doubly-linked circular list.
    123  *
    124  */
    125 static inline void list_insert_before(link_t *link, link_t *list)
    126 {
    127         list_append(link, list);
    128 }
    129 
    130 /** Insert item after another item in doubly-linked circular list.
    131  *
    132  */
    133 static inline void list_insert_after(link_t *link, link_t *list)
    134 {
    135         list_prepend(list, link);
     142 * @param list Pointer to list_t structure.
     143 *
     144 */
     145static inline void list_append(link_t *link, list_t *list)
     146{
     147        list_insert_before(link, &list->head);
    136148}
    137149
    … …  
    155167 * Query emptiness of doubly-linked circular list.
    156168 *
    157  * @param list Pointer to link_t structure representing the list.
    158  *
    159  */
    160 static inline int list_empty(link_t *list)
    161 {
    162         return (list->next == list);
    163 }
    164 
    165 /** Get head item of a list.
    166  *
    167  * @param list Pointer to link_t structure representing the list.
     169 * @param list Pointer to lins_t structure.
     170 *
     171 */
     172static inline int list_empty(list_t *list)
     173{
     174        return (list->head.next == &list->head);
     175}
     176
     177/** Get first item in list.
     178 *
     179 * @param list Pointer to list_t structure.
    168180 *
    169181 * @return Head item of the list.
    … …  
    171183 *
    172184 */
    173 static inline link_t *list_head(link_t *list)
    174 {
    175         return ((list->next == list) ? NULL : list->next);
     185static inline link_t *list_first(list_t *list)
     186{
     187        return ((list->head.next == &list->head) ? NULL : list->head.next);
     188}
     189
     190/** Get last item in list.
     191 *
     192 * @param list Pointer to list_t structure.
     193 *
     194 * @return Head item of the list.
     195 * @return NULL if the list is empty.
     196 *
     197 */
     198static inline link_t *list_last(list_t *list)
     199{
     200        return ((list->head.prev == &list->head) ? NULL : list->head.prev);
    176201}
    177202
    … …  
    230255}
    231256
    232 /** Get n-th item of a list.
     257/** Get n-th item in a list.
    233258 *
    234259 * @param list Pointer to link_t structure representing the list.
    … …  
    239264 *
    240265 */
    241 static inline link_t *list_nth(link_t *list, unsigned int n)
     266static inline link_t *list_nth(list_t *list, unsigned int n)
    242267{
    243268        unsigned int cnt = 0;
    … …  
    253278}
    254279
    255 extern int list_member(const link_t *, const link_t *);
    256 extern void list_concat(link_t *, link_t *);
    257 extern unsigned int list_count(const link_t *);
     280extern int list_member(const link_t *, const list_t *);
     281extern void list_concat(list_t *, list_t *);
     282extern unsigned int list_count(const list_t *);
    258283
    259284#endif

  • uspace/lib/c/include/adt/measured_strings.h

    rd2c67e7 r8ff0bd2  
    4141
    4242#include <sys/types.h>
     43#include <async.h>
    4344
    4445/** Type definition of the character string with measured length.
    … …  
    6465extern int measured_strings_receive(measured_string_t **, uint8_t **, size_t);
    6566extern int measured_strings_reply(const measured_string_t *, size_t);
    66 extern int measured_strings_return(int, measured_string_t **, uint8_t **, size_t);
    67 extern int measured_strings_send(int, const measured_string_t *, size_t);
     67
     68extern int measured_strings_return(async_exch_t *, measured_string_t **,
     69    uint8_t **, size_t);
     70extern int measured_strings_send(async_exch_t *, const measured_string_t *,
     71    size_t);
    6872
    6973#endif

  • uspace/lib/c/include/adt/prodcons.h

    rd2c67e7 r8ff0bd2  
    4242        fibril_mutex_t mtx;
    4343        fibril_condvar_t cv;
    44         link_t list;
     44        list_t list;
    4545} prodcons_t;
    4646

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

    rd2c67e7 r8ff0bd2  
    3737
    3838#include <sys/types.h>
     39#include <abi/mm/as.h>
    3940#include <task.h>
    40 #include <kernel/mm/as.h>
    4141#include <libarch/config.h>
    4242

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

    rd2c67e7 r8ff0bd2  
    4242#include <ipc/common.h>
    4343#include <fibril.h>
    44 #include <fibril_synch.h>
    4544#include <sys/time.h>
    4645#include <atomic.h>
    … …  
    5352typedef void (*async_client_data_dtor_t)(void *);
    5453
    55 typedef void (*async_client_conn_t)(ipc_callid_t, ipc_call_t *);
     54/** Client connection handler
     55 *
     56 * @param callid ID of incoming call or 0 if connection initiated from
     57 *               inside using async_connect_to_me()
     58 * @param call   Incoming call or 0 if connection initiated from inside
     59 * @param arg    Local argument passed from async_new_connection() or
     60 *               async_connect_to_me()
     61 */
     62typedef void (*async_client_conn_t)(ipc_callid_t, ipc_call_t *, void *);
     63
     64/** Interrupt handler */
     65typedef void (*async_interrupt_handler_t)(ipc_callid_t, ipc_call_t *);
    5666
    5767/** Exchange management style
    … …  
    8595} exch_mgmt_t;
    8696
    87 /** Session data */
    88 typedef struct {
    89         /** List of inactive exchanges */
    90         link_t exch_list;
    91        
    92         /** Exchange management style */
    93         exch_mgmt_t mgmt;
    94        
    95         /** Session identification */
    96         int phone;
    97        
    98         /** First clone connection argument */
    99         sysarg_t arg1;
    100        
    101         /** Second clone connection argument */
    102         sysarg_t arg2;
    103        
    104         /** Third clone connection argument */
    105         sysarg_t arg3;
    106        
    107         /** Exchange mutex */
    108         fibril_mutex_t mutex;
    109        
    110         /** Number of opened exchanges */
    111         atomic_t refcnt;
    112 } async_sess_t;
    113 
    114 /** Exchange data */
    115 typedef struct {
    116         /** Link into list of inactive exchanges */
    117         link_t sess_link;
    118        
    119         /** Link into global list of inactive exchanges */
    120         link_t global_link;
    121        
    122         /** Session pointer */
    123         async_sess_t *sess;
    124        
    125         /** Exchange identification */
    126         int phone;
    127 } async_exch_t;
     97/** Forward declarations */
     98struct _async_exch;
     99struct _async_sess;
     100
     101typedef struct _async_sess async_sess_t;
     102typedef struct _async_exch async_exch_t;
    128103
    129104extern atomic_t threads_in_ipc_wait;
    … …  
    165140extern int async_wait_timeout(aid_t, sysarg_t *, suseconds_t);
    166141
    167 extern fid_t async_new_connection(sysarg_t, sysarg_t, ipc_callid_t,
    168     ipc_call_t *, async_client_conn_t);
     142extern fid_t async_new_connection(task_id_t, sysarg_t, ipc_callid_t,
     143    ipc_call_t *, async_client_conn_t, void *);
    169144
    170145extern void async_usleep(suseconds_t);
    … …  
    175150extern void async_set_client_data_destructor(async_client_data_dtor_t);
    176151extern void *async_get_client_data(void);
     152extern void *async_get_client_data_by_id(task_id_t);
     153extern void async_put_client_data_by_id(task_id_t);
    177154
    178155extern void async_set_client_connection(async_client_conn_t);
    179 extern void async_set_interrupt_received(async_client_conn_t);
     156extern void async_set_interrupt_received(async_interrupt_handler_t);
    180157
    181158/*
    … …  
    351328
    352329extern int async_connect_to_me(async_exch_t *, sysarg_t, sysarg_t, sysarg_t,
    353     async_client_conn_t);
     330    async_client_conn_t, void *);
    354331
    355332extern int async_hangup(async_sess_t *);
    … …  
    358335extern async_exch_t *async_exchange_begin(async_sess_t *);
    359336extern void async_exchange_end(async_exch_t *);
     337
     338/*
     339 * FIXME These functions just work around problems with parallel exchange
     340 * management. Proper solution needs to be implemented.
     341 */
     342void async_sess_args_set(async_sess_t *sess, sysarg_t, sysarg_t, sysarg_t);
    360343
    361344/*
    … …  
    466449extern async_sess_t *async_callback_receive_start(exch_mgmt_t, ipc_call_t *);
    467450
     451extern int async_state_change_start(async_exch_t *, sysarg_t, sysarg_t,
     452    sysarg_t, async_exch_t *);
     453extern bool async_state_change_receive(ipc_callid_t *, sysarg_t *, sysarg_t *,
     454    sysarg_t *);
     455extern int async_state_change_finalize(ipc_callid_t, async_exch_t *);
     456
     457extern void *async_remote_state_acquire(async_sess_t *);
     458extern void async_remote_state_update(async_sess_t *, void *);
     459extern void async_remote_state_release(async_sess_t *);
     460extern void async_remote_state_release_exchange(async_exch_t *);
     461
    468462#endif
    469463

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

    rd2c67e7 r8ff0bd2  
    4040#define LIBC_ASYNC_OBSOLETE_H_
    4141
    42 extern void async_obsolete_serialize_start(void);
    43 extern void async_obsolete_serialize_end(void);
    44 
    4542#define async_obsolete_send_0(phoneid, method, dataptr) \
    4643        async_obsolete_send_fast((phoneid), (method), 0, 0, 0, 0, (dataptr))
    … …  
    198195
    199196extern int async_obsolete_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t,
    200     async_client_conn_t);
     197    async_client_conn_t, void *);
    201198extern int async_obsolete_connect_me_to(int, sysarg_t, sysarg_t, sysarg_t);
    202199extern int async_obsolete_connect_me_to_blocking(int, sysarg_t, sysarg_t, sysarg_t);

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

    rd2c67e7 r8ff0bd2  
    3838#include <sys/types.h>
    3939
     40/** Mask with bit @a n set. */
     41#define BIT_V(type, n) \
     42    ((type)1 << ((n) - 1))
     43
     44/** Mask with rightmost @a n bits set. */
     45#define BIT_RRANGE(type, n) \
     46    (BIT_V(type, (n) + 1) - 1)
     47
     48/** Mask with bits @a hi .. @a lo set. @a hi >= @a lo. */
     49#define BIT_RANGE(type, hi, lo) \
     50    (BIT_RRANGE(type, (hi) - (lo) + 1) << (lo))
     51
     52/** Extract range of bits @a hi .. @a lo from @a value. */
     53#define BIT_RANGE_EXTRACT(type, hi, lo, value) \
     54    (((value) >> (lo)) & BIT_RRANGE(type, (hi) - (lo) + 1))
    4055
    4156/** Return position of first non-zero bit from left (i.e. [log_2(arg)]).

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

    rd2c67e7 r8ff0bd2  
    3737
    3838#include <libarch/types.h>
     39#include <abi/bool.h>
    3940
    4041#define false  0
    4142#define true   1
    42 
    43 typedef uint8_t bool;
    4443
    4544#endif

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

    rd2c67e7 r8ff0bd2  
    3737
    3838#include <sys/types.h>
    39 #include <kernel/ddi/irq.h>
     39#include <abi/ddi/irq.h>
    4040#include <task.h>
    4141

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

    rd2c67e7 r8ff0bd2  
    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);
     52extern int devman_drv_fun_online(devman_handle_t);
     53extern int devman_drv_fun_offline(devman_handle_t);
    5054
    5155extern async_sess_t *devman_device_connect(exch_mgmt_t, devman_handle_t,
    … …  
    5458    unsigned int);
    5559
    56 extern int devman_device_get_handle(const char *, devman_handle_t *,
     60extern int devman_fun_get_handle(const char *, devman_handle_t *,
    5761    unsigned int);
    58 extern int devman_device_get_handle_by_class(const char *, const char *,
    59     devman_handle_t *, unsigned int);
    60 extern int devman_get_device_path(devman_handle_t, char *, size_t);
     62extern int devman_fun_get_child(devman_handle_t, devman_handle_t *);
     63extern int devman_dev_get_functions(devman_handle_t, devman_handle_t **,
     64    size_t *);
     65extern int devman_fun_get_name(devman_handle_t, char *, size_t);
     66extern int devman_fun_get_path(devman_handle_t, char *, size_t);
     67extern int devman_fun_online(devman_handle_t);
     68extern int devman_fun_offline(devman_handle_t);
    6169
    62 extern int devman_add_device_to_class(devman_handle_t, const char *);
     70extern int devman_add_device_to_category(devman_handle_t, const char *);
     71extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *);
    6372
    6473#endif

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

    rd2c67e7 r8ff0bd2  
    11/*
    2  * Copyright (c) 2010 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup mouse
    30  * @brief
     29/** @addtogroup generic
    3130 * @{
    3231 */
    … …  
    3433 */
    3534
    36 #ifndef ADBDEV_H_
    37 #define ADBDEV_H_
     35#ifndef LIBC_ELF_H_
     36#define LIBC_ELF_H_
    3837
    3938#include <sys/types.h>
    40 
    41 extern int adb_dev_init(void);
     39#include <abi/elf.h>
     40#include <libarch/elf.h>
    4241
    4342#endif
    4443
    45 /**
    46  * @}
    47  */
    48 
     44/** @}
     45 */

  • uspace/lib/c/include/elf/elf_load.h

    rd2c67e7 r8ff0bd2  
    11/*
     2 * Copyright (c) 2006 Sergey Bondari
    23 * Copyright (c) 2008 Jiri Svoboda
    34 * All rights reserved.
    … …  
    3738#define ELF_LOAD_H_
    3839
    39 #include <arch/elf.h>
     40#include <elf/elf.h>
    4041#include <sys/types.h>
    4142#include <loader/pcb.h>
    4243
    43 #include "elf.h"
     44/**
     45 * ELF error return codes
     46 */
     47#define EE_OK                   0       /* No error */
     48#define EE_INVALID              1       /* Invalid ELF image */
     49#define EE_MEMORY               2       /* Cannot allocate address space */
     50#define EE_INCOMPATIBLE         3       /* ELF image is not compatible with current architecture */
     51#define EE_UNSUPPORTED          4       /* Non-supported ELF (e.g. dynamic ELFs) */
     52#define EE_LOADER               5       /* The image is actually a program loader. */
     53#define EE_IRRECOVERABLE        6
    4454
    4555typedef enum {
    … …  
    8292} elf_ld_t;
    8393
    84 int elf_load_file(const char *file_name, size_t so_bias, eld_flags_t flags,
    85     elf_info_t *info);
    86 void elf_create_pcb(elf_info_t *info, pcb_t *pcb);
     94extern const char *elf_error(unsigned int);
     95extern int elf_load_file(const char *, size_t, eld_flags_t, elf_info_t *);
     96extern void elf_create_pcb(elf_info_t *, pcb_t *);
    8797
    8898#endif

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

    rd2c67e7 r8ff0bd2  
    3636#define LIBC_ERRNO_H_
    3737
    38 #include <kernel/errno.h>
     38#include <abi/errno.h>
    3939#include <fibril.h>
    4040
    … …  
    5555#define EIO           (-265)
    5656#define EMLINK        (-266)
     57#define ENXIO         (-267)
    5758
    5859/** Bad checksum. */

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

    rd2c67e7 r8ff0bd2  
    3636#define LIBC_EVENT_H_
    3737
    38 #include <kernel/ipc/event_types.h>
     38#include <abi/ipc/event.h>
     39#include <libarch/types.h>
    3940
    4041extern int event_subscribe(event_type_t, sysarg_t);
     42extern int event_task_subscribe(event_task_type_t, sysarg_t);
    4143extern int event_unmask(event_type_t);
     44extern int event_task_unmask(event_task_type_t);
    4245
    4346#endif

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

    rd2c67e7 r8ff0bd2  
    4545        fibril_owner_info_t oi;  /**< Keep this the first thing. */
    4646        int counter;
    47         link_t waiters;
     47        list_t waiters;
    4848} fibril_mutex_t;
    4949
    … …  
    5555                .counter = 1, \
    5656                .waiters = { \
    57                         .prev = &name.waiters, \
    58                         .next = &name.waiters, \
     57                        .head = { \
     58                                .prev = &(name).waiters.head, \
     59                                .next = &(name).waiters.head, \
     60                        } \
    5961                } \
    6062        }
    … …  
    6769        unsigned writers;
    6870        unsigned readers;
    69         link_t waiters;
     71        list_t waiters;
    7072} fibril_rwlock_t;
    7173
    … …  
    7880                .writers = 0, \
    7981                .waiters = { \
    80                         .prev = &name.waiters, \
    81                         .next = &name.waiters, \
     82                        .head = { \
     83                                .prev = &(name).waiters.head, \
     84                                .next = &(name).waiters.head, \
     85                        } \
    8286                } \
    8387        }
    … …  
    8791
    8892typedef struct {
    89         link_t waiters;
     93        list_t waiters;
    9094} fibril_condvar_t;
    9195
    … …  
    9397        { \
    9498                .waiters = { \
    95                         .next = &name.waiters, \
    96                         .prev = &name.waiters, \
     99                        .head = { \
     100                                .next = &(name).waiters.head, \
     101                                .prev = &(name).waiters.head, \
     102                        } \
    97103                } \
    98104        }

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

    rd2c67e7 r8ff0bd2  
    4242        BD_GET_NUM_BLOCKS,
    4343        BD_READ_BLOCKS,
    44         BD_WRITE_BLOCKS
     44        BD_WRITE_BLOCKS,
     45        BD_READ_TOC
    4546} bd_request_t;
    4647

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

    rd2c67e7 r8ff0bd2  
    3636#define LIBC_IPC_CLIPBOARD_H_
    3737
     38#include <ipc/common.h>
     39
    3840typedef enum {
    3941        CLIPBOARD_PUT_DATA = IPC_FIRST_USER_METHOD,

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

    rd2c67e7 r8ff0bd2  
    3737
    3838#include <sys/types.h>
     39#include <abi/ipc/ipc.h>
    3940#include <atomic.h>
    40 #include <kernel/ipc/ipc.h>
     41#include <task.h>
    4142
    4243#define IPC_FLAG_BLOCKING  0x01
    … …  
    4445typedef struct {
    4546        sysarg_t args[IPC_CALL_LEN];
    46         sysarg_t in_task_hash;
     47        task_id_t in_task_id;
    4748        sysarg_t in_phone_hash;
    4849} ipc_call_t;

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

    rd2c67e7 r8ff0bd2  
    4848        CONSOLE_SET_COLOR,
    4949        CONSOLE_SET_RGB_COLOR,
    50         CONSOLE_CURSOR_VISIBILITY,
    51         CONSOLE_KCON_ENABLE
     50        CONSOLE_CURSOR_VISIBILITY
    5251} console_request_t;
    5352

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

    rd2c67e7 r8ff0bd2  
    7272 */
    7373typedef struct match_id_list {
    74         link_t ids;
     74        list_t ids;
    7575} match_id_list_t;
    7676
    … …  
    9595{
    9696        match_id_t *mid = NULL;
    97         link_t *link = ids->ids.next;
     97        link_t *link = ids->ids.head.next;
    9898       
    99         while (link != &ids->ids) {
     99        while (link != &ids->ids.head) {
    100100                mid = list_get_instance(link, match_id_t,link);
    101101                if (mid->score < id->score) {
    102102                        break;
    103                 }       
     103                }
    104104                link = link->next;
    105105        }
    … …  
    118118        match_id_t *id;
    119119       
    120         while(!list_empty(&ids->ids)) {
    121                 link = ids->ids.next;
    122                 list_remove(link);             
     120        while (!list_empty(&ids->ids)) {
     121                link = list_first(&ids->ids);
     122                list_remove(link);
    123123                id = list_get_instance(link, match_id_t, link);
    124                 delete_match_id(id);           
    125         }       
     124                delete_match_id(id);
     125        }
    126126}
    127127
    … …  
    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_DRV_FUN_ONLINE,
     142        DEVMAN_DRV_FUN_OFFLINE,
     143        DEVMAN_REMOVE_FUNCTION
    142144} driver_to_devman_t;
    143145
    144146typedef enum {
    145         DRIVER_ADD_DEVICE = IPC_FIRST_USER_METHOD
     147        DRIVER_DEV_ADD = IPC_FIRST_USER_METHOD,
     148        DRIVER_DEV_REMOVE,
     149        DRIVER_FUN_ONLINE,
     150        DRIVER_FUN_OFFLINE,
    146151
    147152} devman_to_driver_t;
    … …  
    149154typedef enum {
    150155        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
    151         DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
    152         DEVMAN_DEVICE_GET_DEVICE_PATH
     156        DEVMAN_DEV_GET_FUNCTIONS,
     157        DEVMAN_FUN_GET_CHILD,
     158        DEVMAN_FUN_GET_NAME,
     159        DEVMAN_FUN_ONLINE,
     160        DEVMAN_FUN_OFFLINE,
     161        DEVMAN_FUN_GET_PATH,
     162        DEVMAN_FUN_SID_TO_HANDLE
    153163} client_to_devman_t;
    154164

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

    rd2c67e7 r8ff0bd2  
    5555        FB_DRAW_TEXT_DATA,
    5656        FB_FLUSH,
    57         FB_DRAW_PPM,
     57        FB_DRAW_IMGMAP,
    5858        FB_PREPARE_SHM,
    5959        FB_DROP_SHM,
    60         FB_SHM2PIXMAP,
    61         FB_VP_DRAW_PIXMAP,
    62         FB_VP2PIXMAP,
    63         FB_DROP_PIXMAP,
     60        FB_SHM2IMGMAP,
     61        FB_VP_DRAW_IMGMAP,
     62        FB_VP2IMGMAP,
     63        FB_DROP_IMGMAP,
    6464        FB_ANIM_CREATE,
    6565        FB_ANIM_DROP,
    66         FB_ANIM_ADDPIXMAP,
     66        FB_ANIM_ADDIMGMAP,
    6767        FB_ANIM_CHGVP,
    6868        FB_ANIM_START,

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

    rd2c67e7 r8ff0bd2  
    4242#include <sys/types.h>
    4343#include <ipc/common.h>
    44 #include <kernel/ipc/ipc_methods.h>
    45 #include <kernel/synch/synch.h>
     44#include <abi/ipc/methods.h>
     45#include <abi/synch.h>
    4646#include <task.h>
    4747
    … …  
    254254    sysarg_t, sysarg_t, void *, ipc_async_callback_t, bool);
    255255
    256 extern int ipc_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, sysarg_t *,
     256extern int ipc_connect_to_me(int, sysarg_t, sysarg_t, sysarg_t, task_id_t *,
    257257    sysarg_t *);
    258258extern int ipc_connect_me(int);

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

    rd2c67e7 r8ff0bd2  
    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/mouseev.h

    rd2c67e7 r8ff0bd2  
    2727 */
    2828
    29 /** @addtogroup kbdgen generic
    30  * @brief HelenOS generic uspace keyboard handler.
    31  * @ingroup kbd
     29/** @addtogroup mouse
     30 * @brief
    3231 * @{
    3332 */
    … …  
    3534 */
    3635
    37 #ifndef LIBC_IPC_KBD_H_
    38 #define LIBC_IPC_KBD_H_
     36#ifndef LIBC_IPC_MOUSEEV_H_
     37#define LIBC_IPC_MOUSEEV_H_
    3938
    4039#include <ipc/common.h>
    … …  
    4241
    4342typedef enum {
    44         KBD_YIELD = DEV_FIRST_CUSTOM_METHOD,
    45         KBD_RECLAIM
    46 } kbd_request_t;
     43        MOUSEEV_YIELD = DEV_FIRST_CUSTOM_METHOD,
     44        MOUSEEV_RECLAIM
     45} mouseev_request_t;
    4746
    4847typedef enum {
    49         KBD_EVENT = IPC_FIRST_USER_METHOD
    50 } kbd_notif_t;
     48        MOUSEEV_MOVE_EVENT = IPC_FIRST_USER_METHOD,
     49        MOUSEEV_BUTTON_EVENT
     50} mouseev_notif_t;
    5151
    5252#endif

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

    rd2c67e7 r8ff0bd2  
    335335#define IPC_GET_ERROR(call)  ((services_t) IPC_GET_ARG4(call))
    336336
    337 /** Return the phone message argument.
    338  *
    339  * @param[in] call Message call structure.
    340  *
    341  */
    342 #define IPC_GET_PHONE(call)  ((int) IPC_GET_ARG5(call))
    343 
    344337/** Set the device identifier in the message answer.
    345338 *

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

    rd2c67e7 r8ff0bd2  
    3838#define LIBC_SERVICES_H_
    3939
     40#include <fourcc.h>
     41
    4042typedef enum {
    41         SERVICE_NONE = 0,
    42         SERVICE_LOAD,
    43         SERVICE_PCI,
    44         SERVICE_VIDEO,
    45         SERVICE_CONSOLE,
    46         SERVICE_VFS,
    47         SERVICE_DEVMAP,
    48         SERVICE_DEVMAN,
    49         SERVICE_IRC,
    50         SERVICE_CLIPBOARD,
    51         SERVICE_NETWORKING,
    52         SERVICE_LO,
    53         SERVICE_NE2000,
    54         SERVICE_ETHERNET,
    55         SERVICE_NILDUMMY,
    56         SERVICE_IP,
    57         SERVICE_ARP,
    58         SERVICE_RARP,
    59         SERVICE_ICMP,
    60         SERVICE_UDP,
    61         SERVICE_TCP,
    62         SERVICE_SOCKET
     43        SERVICE_NONE       = 0,
     44        SERVICE_LOAD       = FOURCC('l', 'o', 'a', 'd'),
     45        SERVICE_VIDEO      = FOURCC('v', 'i', 'd', ' '),
     46        SERVICE_VFS        = FOURCC('v', 'f', 's', ' '),
     47        SERVICE_LOC        = FOURCC('l', 'o', 'c', ' '),
     48        SERVICE_DEVMAN     = FOURCC('d', 'e', 'v', 'n'),
     49        SERVICE_IRC        = FOURCC('i', 'r', 'c', ' '),
     50        SERVICE_CLIPBOARD  = FOURCC('c', 'l', 'i', 'p'),
     51        SERVICE_NETWORKING = FOURCC('n', 'e', 't', ' '),
     52        SERVICE_LO         = FOURCC('l', 'o', ' ', ' '),
     53        SERVICE_NE2000     = FOURCC('n', 'e', '2', 'k'),
     54        SERVICE_ETHERNET   = FOURCC('e', 't', 'h', ' '),
     55        SERVICE_NILDUMMY   = FOURCC('n', 'i', 'l', 'd'),
     56        SERVICE_IP         = FOURCC('i', 'p', 'v', '4'),
     57        SERVICE_ARP        = FOURCC('a', 'r', 'p', ' '),
     58        SERVICE_ICMP       = FOURCC('i', 'c', 'm', 'p'),
     59        SERVICE_UDP        = FOURCC('u', 'd', 'p', ' '),
     60        SERVICE_TCP        = FOURCC('t', 'c', 'p', ' ')
    6361} services_t;
    6462

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

    rd2c67e7 r8ff0bd2  
    6262typedef enum {
    6363        VFS_IN_OPEN = IPC_FIRST_USER_METHOD,
    64         VFS_IN_OPEN_NODE,
    6564        VFS_IN_READ,
    6665        VFS_IN_WRITE,
    … …  
    7877        VFS_IN_RENAME,
    7978        VFS_IN_STAT,
    80         VFS_IN_DUP
     79        VFS_IN_DUP,
     80        VFS_IN_WAIT_HANDLE,
    8181} vfs_in_request_t;
    8282

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

    rd2c67e7 r8ff0bd2  
    3737
    3838#include <sys/types.h>
    39 #include <kernel/syscall/syscall.h>
     39#include <abi/syscall.h>
    4040#include <libarch/syscall.h>
    4141

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

    rd2c67e7 r8ff0bd2  
    3838
    3939#include <task.h>
    40 #include <vfs/vfs.h>
    4140
    4241/** Forward declararion */
    … …  
    5049extern int loader_set_pathname(loader_t *, const char *);
    5150extern int loader_set_args(loader_t *, const char *const[]);
    52 extern int loader_set_files(loader_t *, fdi_node_t *const[]);
     51extern int loader_set_files(loader_t *, int *const[]);
    5352extern int loader_load_program(loader_t *);
    5453extern int loader_run(loader_t *);

  • uspace/lib/c/include/loader/pcb.h

    rd2c67e7 r8ff0bd2  
    3838
    3939#include <sys/types.h>
    40 #include <vfs/vfs.h>
    4140
    4241typedef void (*entry_point_t)(void);
    … …  
    6261       
    6362        /** Number of preset files. */
    64         int filc;
    65         /** Preset files. */
    66         fdi_node_t **filv;
     63        unsigned int filc;
    6764       
    6865        /*

  • uspace/lib/c/include/net/icmp_api.h

    rd2c67e7 r8ff0bd2  
    4242#include <sys/types.h>
    4343#include <sys/time.h>
    44 
    4544#include <adt/measured_strings.h>
    4645#include <net/ip_codes.h>
    4746#include <net/icmp_codes.h>
    4847#include <net/icmp_common.h>
     48#include <async.h>
    4949
    5050/** @name ICMP module application interface
    … …  
    5353/*@{*/
    5454
    55 extern int icmp_echo_msg(int, size_t, mseconds_t, ip_ttl_t, ip_tos_t, int,
    56     const struct sockaddr *, socklen_t);
     55extern int icmp_echo_msg(async_sess_t *, size_t, mseconds_t, ip_ttl_t, ip_tos_t,
     56    int, const struct sockaddr *, socklen_t);
    5757
    5858/*@}*/

  • uspace/lib/c/include/net/icmp_common.h

    rd2c67e7 r8ff0bd2  
    4040#include <ipc/services.h>
    4141#include <sys/time.h>
     42#include <async.h>
    4243
    43 /** Default timeout for incoming connections in microseconds (1 sec). */
    44 #define ICMP_CONNECT_TIMEOUT  1000000
    45 
    46 extern int icmp_connect_module(suseconds_t);
     44extern async_sess_t *icmp_connect_module(void);
    4745
    4846#endif

  • uspace/lib/c/include/net/modules.h

    rd2c67e7 r8ff0bd2  
    4646#include <sys/time.h>
    4747
    48 /** Connect to the needed module function type definition.
     48/** Connect to module function type definition.
    4949 *
    50  * @param[in] need The needed module service.
    51  *
    52  * @return The phone of the needed service.
     50 * @return Session to the service.
    5351 *
    5452 */
    55 typedef int connect_module_t(services_t need);
     53typedef async_sess_t *connect_module_t(services_t);
    5654
    5755extern void answer_call(ipc_callid_t, int, ipc_call_t *, size_t);
    58 extern int bind_service(services_t, sysarg_t, sysarg_t, sysarg_t,
     56extern async_sess_t *bind_service(services_t, sysarg_t, sysarg_t, sysarg_t,
    5957    async_client_conn_t);
    60 extern int bind_service_timeout(services_t, sysarg_t, sysarg_t, sysarg_t,
    61     async_client_conn_t, suseconds_t);
    62 extern int connect_to_service(services_t);
    63 extern int connect_to_service_timeout(services_t, suseconds_t);
     58extern async_sess_t *connect_to_service(services_t);
    6459extern int data_reply(void *, size_t);
    6560extern void refresh_answer(ipc_call_t *, size_t *);

  • uspace/lib/c/include/rtld/elf_dyn.h

    rd2c67e7 r8ff0bd2  
    3636#define LIBC_RTLD_ELF_DYN_H_
    3737
    38 #include <arch/elf.h>
    3938#include <sys/types.h>
    40 
    41 #include <elf.h>
     39#include <elf/elf.h>
    4240#include <libarch/rtld/elf_dyn.h>
    4341

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

    rd2c67e7 r8ff0bd2  
    4949
    5050        /** List of all loaded modules including rtld and the program */
    51         link_t modules_head;
     51        list_t modules;
    5252
    5353        /** Temporary hack to place each module at different address. */

  • uspace/lib/c/include/rtld/symbol.h

    rd2c67e7 r8ff0bd2  
    3636#define LIBC_RTLD_SYMBOL_H_
    3737
     38#include <elf/elf.h>
    3839#include <rtld/rtld.h>
    39 #include <elf.h>
    4040
    4141elf_symbol_t *symbol_bfs_find(const char *name, module_t *start, module_t **mod);

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

    rd2c67e7 r8ff0bd2  
    4040#include <stdint.h>
    4141#include <bool.h>
    42 #include <kernel/sysinfo/abi.h>
     42#include <sys/types.h>
     43#include <abi/sysinfo.h>
    4344
    4445extern stats_cpu_t *stats_get_cpus(size_t *);

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

    rd2c67e7 r8ff0bd2  
    11/*
    22 * Copyright (c) 2005 Martin Decky
     3 * Copyright (c) 2011 Oleg Romanenko
    34 * All rights reserved.
    45 *
    … …  
    4849#define STR_BOUNDS(length)  ((length) << 2)
    4950
     51/**
     52 * Maximum size of a buffer needed to a string converted from space-padded
     53 * ASCII of size @a spa_size using spascii_to_str().
     54 */
     55#define SPASCII_STR_BUFSIZE(spa_size) ((spa_size) + 1)
     56
    5057extern wchar_t str_decode(const char *str, size_t *offset, size_t sz);
    5158extern int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t sz);
    … …  
    7380extern void str_append(char *dest, size_t size, const char *src);
    7481
     82extern int spascii_to_str(char *dest, size_t size, const uint8_t *src, size_t n);
    7583extern void wstr_to_str(char *dest, size_t size, const wchar_t *src);
    7684extern char *wstr_to_astr(const wchar_t *src);
    7785extern void str_to_wstr(wchar_t *dest, size_t dlen, const char *src);
     86extern wchar_t *str_to_awstr(const char *src);
     87extern int utf16_to_str(char *dest, size_t size, const uint16_t *src);
     88extern int str_to_utf16(uint16_t *dest, size_t size, const char *src);
    7889
    7990extern char *str_chr(const char *str, wchar_t ch);

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

    rd2c67e7 r8ff0bd2  
    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/syscall.h

    rd2c67e7 r8ff0bd2  
    4545
    4646#include <sys/types.h>
    47 #include <kernel/syscall/syscall.h>
     47#include <abi/syscall.h>
    4848
    4949#define __syscall0  __syscall

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

    rd2c67e7 r8ff0bd2  
    3636#define LIBC_SYSINFO_H_
    3737
    38 #include <libc.h>
     38#include <sys/types.h>
     39#include <bool.h>
     40#include <abi/sysinfo.h>
    3941
    40 /** Sysinfo value types
    41  *
    42  */
    43 typedef enum {
    44         SYSINFO_VAL_UNDEFINED = 0,
    45         SYSINFO_VAL_VAL = 1,
    46         SYSINFO_VAL_DATA = 2
    47 } sysinfo_item_tag_t;
    48 
    49 extern sysinfo_item_tag_t sysinfo_get_tag(const char *);
     42extern sysinfo_item_val_type_t sysinfo_get_val_type(const char *);
    5043extern int sysinfo_get_value(const char *, sysarg_t *);
    5144extern void *sysinfo_get_data(const char *, size_t *);

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

    rd2c67e7 r8ff0bd2  
    3737
    3838#include <sys/types.h>
    39 
    40 typedef uint64_t task_id_t;
     39#include <abi/proc/task.h>
    4140
    4241typedef enum {
    … …  
    5150extern task_id_t task_spawn(const char *, const char *const[], int *);
    5251extern int task_spawnv(task_id_t *, const char *path, const char *const []);
     52extern int task_spawnvf(task_id_t *, const char *path, const char *const [],
     53    int *const []);
    5354extern int task_spawnl(task_id_t *, const char *path, ...);
    5455

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

    rd2c67e7 r8ff0bd2  
    3838#include <libarch/thread.h>
    3939#include <sys/types.h>
    40 
    41 typedef uint64_t thread_id_t;
     40#include <abi/proc/thread.h>
    4241
    4342extern int thread_create(void (*)(void *), void *, const char *, thread_id_t *);

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

    rd2c67e7 r8ff0bd2  
    3636#define LIBC_UDEBUG_H_
    3737
    38 #include <kernel/udebug/udebug.h>
     38#include <abi/udebug.h>
    3939#include <sys/types.h>
    4040#include <async.h>

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

    rd2c67e7 r8ff0bd2  
    6363extern ssize_t read(int, void *, size_t);
    6464
     65extern ssize_t read_all(int, void *, size_t);
     66extern ssize_t write_all(int, const void *, size_t);
     67
    6568extern off64_t lseek(int, off64_t, int);
    6669extern int ftruncate(int, aoff64_t);

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

    rd2c67e7 r8ff0bd2  
    3838#include <sys/types.h>
    3939#include <ipc/vfs.h>
    40 #include <ipc/devmap.h>
     40#include <ipc/loc.h>
    4141#include <stdio.h>
     42#include <async.h>
    4243
    43 /** Libc version of the VFS triplet.
    44  *
    45  * Unique identification of a file system node
    46  * within a file system instance.
    47  *
    48  */
    49 typedef struct {
    50         fs_handle_t fs_handle;
    51         devmap_handle_t devmap_handle;
    52         fs_index_t index;
    53 } fdi_node_t;
     44enum vfs_change_state_type {
     45        VFS_PASS_HANDLE
     46};
    5447
    5548extern char *absolutize(const char *, size_t *);
    … …  
    5952extern int unmount(const char *);
    6053
    61 extern int open_node(fdi_node_t *, int);
    62 extern int fd_node(int, fdi_node_t *);
     54extern int fhandle(FILE *, int *);
    6355
    64 extern FILE *fopen_node(fdi_node_t *, const char *);
    65 extern int fnode(FILE *, fdi_node_t *);
     56extern int fd_wait(void);
     57
     58extern async_exch_t *vfs_exchange_begin(void);
     59extern void vfs_exchange_end(async_exch_t *);
    6660
    6761#endif
Note: See TracChangeset for help on using the changeset viewer.