Changeset 42a619b in mainline for uspace/lib/c


Ignore:
Timestamp:
2011-08-19T08:58:50Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7dcb7981, 903bac0a, c2cf033
Parents:
ef7052ec (diff), d894fbd (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 from lp:~jakub/helenos/camp2011.

Location:
uspace/lib/c
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/async.c

    ref7052ec r42a619b  
    201201{
    202202        async_client_data_destroy = dtor;
    203 }
    204 
    205 void *async_get_client_data(void)
    206 {
    207         assert(fibril_connection);
    208         return fibril_connection->client->data;
    209203}
    210204
    … …  
    580574}
    581575
     576static client_t *async_client_get(sysarg_t client_hash, bool create)
     577{
     578        unsigned long key = client_hash;
     579        client_t *client = NULL;
     580
     581        futex_down(&async_futex);
     582        link_t *lnk = hash_table_find(&client_hash_table, &key);
     583        if (lnk) {
     584                client = hash_table_get_instance(lnk, client_t, link);
     585                atomic_inc(&client->refcnt);
     586        } else if (create) {
     587                client = malloc(sizeof(client_t));
     588                if (client) {
     589                        client->in_task_hash = client_hash;
     590                        client->data = async_client_data_create();
     591               
     592                        atomic_set(&client->refcnt, 1);
     593                        hash_table_insert(&client_hash_table, &key, &client->link);
     594                }
     595        }
     596
     597        futex_up(&async_futex);
     598        return client;
     599}
     600
     601static void async_client_put(client_t *client)
     602{
     603        bool destroy;
     604        unsigned long key = client->in_task_hash;
     605       
     606        futex_down(&async_futex);
     607       
     608        if (atomic_predec(&client->refcnt) == 0) {
     609                hash_table_remove(&client_hash_table, &key, 1);
     610                destroy = true;
     611        } else
     612                destroy = false;
     613       
     614        futex_up(&async_futex);
     615       
     616        if (destroy) {
     617                if (client->data)
     618                        async_client_data_destroy(client->data);
     619               
     620                free(client);
     621        }
     622}
     623
     624void *async_get_client_data(void)
     625{
     626        assert(fibril_connection);
     627        return fibril_connection->client->data;
     628}
     629
     630void *async_get_client_data_by_hash(sysarg_t client_hash)
     631{
     632        client_t *client = async_client_get(client_hash, false);
     633        if (!client)
     634                return NULL;
     635        if (!client->data) {
     636                async_client_put(client);
     637                return NULL;
     638        }
     639
     640        return client->data;
     641}
     642
     643void async_put_client_data_by_hash(sysarg_t client_hash)
     644{
     645        client_t *client = async_client_get(client_hash, false);
     646
     647        assert(client);
     648        assert(client->data);
     649
     650        /* Drop the reference we got in async_get_client_data_by_hash(). */
     651        async_client_put(client);
     652
     653        /* Drop our own reference we got at the beginning of this function. */
     654        async_client_put(client);
     655}
     656
    582657/** Wrapper for client connection fibril.
    583658 *
    … …  
    598673         */
    599674        fibril_connection = (connection_t *) arg;
    600        
    601         futex_down(&async_futex);
    602675       
    603676        /*
    … …  
    606679         * hash in a new tracking structure.
    607680         */
    608        
    609         unsigned long key = fibril_connection->in_task_hash;
    610         link_t *lnk = hash_table_find(&client_hash_table, &key);
    611        
    612         client_t *client;
    613        
    614         if (lnk) {
    615                 client = hash_table_get_instance(lnk, client_t, link);
    616                 atomic_inc(&client->refcnt);
    617         } else {
    618                 client = malloc(sizeof(client_t));
    619                 if (!client) {
    620                         ipc_answer_0(fibril_connection->callid, ENOMEM);
    621                         futex_up(&async_futex);
    622                         return 0;
    623                 }
    624                
    625                 client->in_task_hash = fibril_connection->in_task_hash;
    626                 client->data = async_client_data_create();
    627                
    628                 atomic_set(&client->refcnt, 1);
    629                 hash_table_insert(&client_hash_table, &key, &client->link);
    630         }
    631        
    632         futex_up(&async_futex);
    633        
     681
     682        client_t *client = async_client_get(fibril_connection->in_task_hash, true);
     683        if (!client) {
     684                ipc_answer_0(fibril_connection->callid, ENOMEM);
     685                return 0;
     686        }
     687
    634688        fibril_connection->client = client;
    635689       
    … …  
    643697         * Remove the reference for this client task connection.
    644698         */
    645         bool destroy;
    646        
    647         futex_down(&async_futex);
    648        
    649         if (atomic_predec(&client->refcnt) == 0) {
    650                 hash_table_remove(&client_hash_table, &key, 1);
    651                 destroy = true;
    652         } else
    653                 destroy = false;
    654        
    655         futex_up(&async_futex);
    656        
    657         if (destroy) {
    658                 if (client->data)
    659                         async_client_data_destroy(client->data);
    660                
    661                 free(client);
    662         }
     699        async_client_put(client);
    663700       
    664701        /*
    … …  
    666703         */
    667704        futex_down(&async_futex);
    668         key = fibril_connection->in_phone_hash;
     705        unsigned long key = fibril_connection->in_phone_hash;
    669706        hash_table_remove(&conn_hash_table, &key, 1);
    670707        futex_up(&async_futex);
    … …  
    24292466}
    24302467
     2468int async_state_change_start(async_exch_t *exch, sysarg_t arg1, sysarg_t arg2,
     2469    sysarg_t arg3, async_exch_t *other_exch)
     2470{
     2471        return async_req_5_0(exch, IPC_M_STATE_CHANGE_AUTHORIZE,
     2472            arg1, arg2, arg3, 0, other_exch->phone);
     2473}
     2474
     2475bool async_state_change_receive(ipc_callid_t *callid, sysarg_t *arg1,
     2476    sysarg_t *arg2, sysarg_t *arg3)
     2477{
     2478        assert(callid);
     2479
     2480        ipc_call_t call;
     2481        *callid = async_get_call(&call);
     2482
     2483        if (IPC_GET_IMETHOD(call) != IPC_M_STATE_CHANGE_AUTHORIZE)
     2484                return false;
     2485       
     2486        if (arg1)
     2487                *arg1 = IPC_GET_ARG1(call);
     2488        if (arg2)
     2489                *arg2 = IPC_GET_ARG2(call);
     2490        if (arg3)
     2491                *arg3 = IPC_GET_ARG3(call);
     2492
     2493        return true;
     2494}
     2495
     2496int async_state_change_finalize(ipc_callid_t callid, async_exch_t *other_exch)
     2497{
     2498        return ipc_answer_1(callid, EOK, other_exch->phone);
     2499}
     2500
    24312501/** @}
    24322502 */

  • uspace/lib/c/generic/event.c

    ref7052ec r42a619b  
    5454}
    5555
     56int event_task_subscribe(event_task_type_t evno, sysarg_t imethod)
     57{
     58        return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) evno,
     59            (sysarg_t) imethod);
     60}
     61
    5662/** Unmask event notifications.
    5763 *
    … …  
    6672}
    6773
     74int event_task_unmask(event_task_type_t evno)
     75{
     76        return __SYSCALL1(SYS_EVENT_UNMASK, (sysarg_t) evno);
     77}
     78
    6879/** @}
    6980 */

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

    ref7052ec r42a619b  
    101101static LIST_INITIALIZE(files);
    102102
    103 void __stdio_init(int filc, fdi_node_t *filv[])
     103void __stdio_init(int filc)
    104104{
    105105        if (filc > 0) {
    106                 stdin = fopen_node(filv[0], "r");
     106                stdin = fdopen(0, "r");
    107107        } else {
    108108                stdin = &stdin_null;
    … …  
    111111       
    112112        if (filc > 1) {
    113                 stdout = fopen_node(filv[1], "w");
     113                stdout = fdopen(1, "w");
    114114        } else {
    115115                stdout = &stdout_klog;
    … …  
    118118       
    119119        if (filc > 2) {
    120                 stderr = fopen_node(filv[2], "w");
     120                stderr = fdopen(2, "w");
    121121        } else {
    122122                stderr = &stderr_klog;
    … …  
    285285}
    286286
    287 FILE *fopen_node(fdi_node_t *node, const char *mode)
    288 {
    289         int flags;
    290         if (!parse_mode(mode, &flags))
    291                 return NULL;
    292        
    293         /* Open file. */
    294         FILE *stream = malloc(sizeof(FILE));
    295         if (stream == NULL) {
    296                 errno = ENOMEM;
    297                 return NULL;
    298         }
    299        
    300         stream->fd = open_node(node, flags);
    301         if (stream->fd < 0) {
    302                 /* errno was set by open_node() */
    303                 free(stream);
    304                 return NULL;
    305         }
    306        
    307         stream->error = false;
    308         stream->eof = false;
    309         stream->klog = false;
    310         stream->sess = NULL;
    311         stream->need_sync = false;
    312         _setvbuf(stream);
    313        
    314         list_append(&stream->link, &files);
    315        
    316         return stream;
    317 }
    318 
    319287int fclose(FILE *stream)
    320288{
    … …  
    780748}
    781749
    782 int fnode(FILE *stream, fdi_node_t *node)
    783 {
    784         if (stream->fd >= 0)
    785                 return fd_node(stream->fd, node);
     750int fhandle(FILE *stream, int *handle)
     751{
     752        if (stream->fd >= 0) {
     753                *handle = stream->fd;
     754                return EOK;
     755        }
    786756       
    787757        return ENOENT;

  • uspace/lib/c/generic/libc.c

    ref7052ec r42a619b  
    9191                argc = 0;
    9292                argv = NULL;
    93                 __stdio_init(0, NULL);
     93                __stdio_init(0);
    9494        } else {
    9595                argc = __pcb->argc;
    9696                argv = __pcb->argv;
    97                 __stdio_init(__pcb->filc, __pcb->filv);
     97                __stdio_init(__pcb->filc);
    9898                (void) chdir(__pcb->cwd);
    9999        }

  • uspace/lib/c/generic/loader.c

    ref7052ec r42a619b  
    256256 *
    257257 */
    258 int loader_set_files(loader_t *ldr, fdi_node_t *const files[])
    259 {
    260         /*
    261          * Serialize the arguments into a single array. First
    262          * compute size of the buffer needed.
    263          */
    264         fdi_node_t *const *ap = files;
    265         size_t count = 0;
    266         while (*ap != NULL) {
    267                 count++;
    268                 ap++;
    269         }
    270        
    271         fdi_node_t *files_buf;
    272         files_buf = (fdi_node_t *) malloc(count * sizeof(fdi_node_t));
    273         if (files_buf == NULL)
    274                 return ENOMEM;
    275        
    276         /* Fill the buffer */
    277         size_t i;
    278         for (i = 0; i < count; i++)
    279                 files_buf[i] = *files[i];
    280        
     258int loader_set_files(loader_t *ldr, int * const files[])
     259{
    281260        /* Send serialized files to the loader */
    282261        async_exch_t *exch = async_exchange_begin(ldr->sess);
    283        
    284         ipc_call_t answer;
    285         aid_t req = async_send_0(exch, LOADER_SET_FILES, &answer);
    286         sysarg_t rc = async_data_write_start(exch, (void *) files_buf,
    287             count * sizeof(fdi_node_t));
    288        
    289         async_exchange_end(exch);
    290         free(files_buf);
    291        
     262        async_exch_t *vfs_exch = vfs_exchange_begin();
     263       
     264        int i;
     265        for (i = 0; files[i]; i++)
     266                ;
     267
     268        ipc_call_t answer;
     269        aid_t req = async_send_1(exch, LOADER_SET_FILES, i, &answer);
     270
     271        sysarg_t rc = EOK;
     272       
     273        for (i = 0; files[i]; i++) {
     274                rc = async_state_change_start(exch, VFS_PASS_HANDLE, *files[i],
     275                    0, vfs_exch);
     276                if (rc != EOK)
     277                        break;
     278        }
     279       
     280        vfs_exchange_end(vfs_exch);
     281        async_exchange_end(exch);
     282
    292283        if (rc != EOK) {
    293284                async_wait_for(req, NULL);

  • uspace/lib/c/generic/private/async.h

    ref7052ec r42a619b  
    3636#define LIBC_PRIVATE_ASYNC_H_
    3737
     38#include <ipc/common.h>
    3839#include <adt/list.h>
    3940#include <fibril.h>

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

    ref7052ec r42a619b  
    3636#define LIBC_PRIVATE_IO_H_
    3737
    38 #include <vfs/vfs.h>
    39 
    40 extern void __stdio_init(int filc, fdi_node_t *filv[]);
     38extern void __stdio_init(int);
    4139extern void __stdio_done(void);
    4240

  • uspace/lib/c/generic/task.c

    ref7052ec r42a619b  
    4646#include <libc.h>
    4747#include "private/ns.h"
     48#include <vfs/vfs.h>
    4849
    4950task_id_t task_get_id(void)
    … …  
    102103{
    103104        /* Send default files */
    104         fdi_node_t *files[4];
    105         fdi_node_t stdin_node;
    106         fdi_node_t stdout_node;
    107         fdi_node_t stderr_node;
    108        
    109         if ((stdin != NULL) && (fnode(stdin, &stdin_node) == EOK))
    110                 files[0] = &stdin_node;
     105        int *files[4];
     106        int fd_stdin;
     107        int fd_stdout;
     108        int fd_stderr;
     109       
     110        if ((stdin != NULL) && (fhandle(stdin, &fd_stdin) == EOK))
     111                files[0] = &fd_stdin;
    111112        else
    112113                files[0] = NULL;
    113114       
    114         if ((stdout != NULL) && (fnode(stdout, &stdout_node) == EOK))
    115                 files[1] = &stdout_node;
     115        if ((stdout != NULL) && (fhandle(stdout, &fd_stdout) == EOK))
     116                files[1] = &fd_stdout;
    116117        else
    117118                files[1] = NULL;
    118119       
    119         if ((stderr != NULL) && (fnode(stderr, &stderr_node) == EOK))
    120                 files[2] = &stderr_node;
     120        if ((stderr != NULL) && (fhandle(stderr, &fd_stderr) == EOK))
     121                files[2] = &fd_stderr;
    121122        else
    122123                files[2] = NULL;
    … …  
    142143 */
    143144int task_spawnvf(task_id_t *id, const char *path, const char *const args[],
    144     fdi_node_t *const files[])
     145    int *const files[])
    145146{
    146147        /* Connect to a program loader. */

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

    ref7052ec r42a619b  
    6969 *
    7070 */
    71 static async_exch_t *vfs_exchange_begin(void)
     71async_exch_t *vfs_exchange_begin(void)
    7272{
    7373        fibril_mutex_lock(&vfs_mutex);
    … …  
    8787 *
    8888 */
    89 static void vfs_exchange_end(async_exch_t *exch)
     89void vfs_exchange_end(async_exch_t *exch)
    9090{
    9191        async_exchange_end(exch);
    … …  
    329329}
    330330
    331 int open_node(fdi_node_t *node, int oflag)
    332 {
    333         async_exch_t *exch = vfs_exchange_begin();
    334        
    335         ipc_call_t answer;
    336         aid_t req = async_send_4(exch, VFS_IN_OPEN_NODE, node->fs_handle,
    337             node->service_id, node->index, oflag, &answer);
    338        
    339         vfs_exchange_end(exch);
    340 
    341         sysarg_t rc;
    342         async_wait_for(req, &rc);
    343        
    344         if (rc != EOK)
    345                 return (int) rc;
    346        
    347         return (int) IPC_GET_ARG1(answer);
    348 }
    349 
    350331int close(int fildes)
    351332{
    … …  
    819800}
    820801
    821 int fd_node(int fildes, fdi_node_t *node)
    822 {
    823         struct stat stat;
    824         int rc = fstat(fildes, &stat);
    825        
    826         if (rc == EOK) {
    827                 node->fs_handle = stat.fs_handle;
    828                 node->service_id = stat.service_id;
    829                 node->index = stat.index;
    830         }
    831        
    832         return rc;
    833 }
    834 
    835802int dup2(int oldfd, int newfd)
    836803{
    … …  
    848815}
    849816
     817int fd_wait(void)
     818{
     819        async_exch_t *exch = vfs_exchange_begin();
     820       
     821        sysarg_t ret;
     822        sysarg_t rc = async_req_0_1(exch, VFS_IN_WAIT_HANDLE, &ret);
     823       
     824        vfs_exchange_end(exch);
     825       
     826        if (rc == EOK)
     827                return (int) ret;
     828       
     829        return (int) rc;
     830}
     831
    850832/** @}
    851833 */

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

    ref7052ec r42a619b  
    186186extern void async_set_client_data_destructor(async_client_data_dtor_t);
    187187extern void *async_get_client_data(void);
     188extern void *async_get_client_data_by_hash(sysarg_t);
     189extern void async_put_client_data_by_hash(sysarg_t);
    188190
    189191extern void async_set_client_connection(async_client_conn_t);
    … …  
    477479extern async_sess_t *async_callback_receive_start(exch_mgmt_t, ipc_call_t *);
    478480
     481extern int async_state_change_start(async_exch_t *, sysarg_t, sysarg_t,
     482    sysarg_t, async_exch_t *);
     483extern bool async_state_change_receive(ipc_callid_t *, sysarg_t *, sysarg_t *,
     484    sysarg_t *);
     485extern int async_state_change_finalize(ipc_callid_t, async_exch_t *);
     486
    479487#endif
    480488

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

    ref7052ec r42a619b  
    3737
    3838#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/ipc/vfs.h

    ref7052ec r42a619b  
    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/loader/loader.h

    ref7052ec r42a619b  
    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

    ref7052ec r42a619b  
    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/task.h

    ref7052ec r42a619b  
    3737
    3838#include <sys/types.h>
    39 #include <vfs/vfs.h>
    4039
    4140typedef uint64_t task_id_t;
    … …  
    5352extern int task_spawnv(task_id_t *, const char *path, const char *const []);
    5453extern int task_spawnvf(task_id_t *, const char *path, const char *const [],
    55     fdi_node_t *const []);
     54    int *const []);
    5655extern int task_spawnl(task_id_t *, const char *path, ...);
    5756

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

    ref7052ec r42a619b  
    4040#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         service_id_t service_id;
    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.