Changeset 86ffa27f in mainline for uspace/srv


Ignore:
Timestamp:
2011-08-07T11:21:44Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
cc574511
Parents:
15f3c3f (diff), e8067c0 (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/srv
Files:
5 deleted
35 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/bd/ata_bd/ata_bd.c

    r15f3c3f r86ffa27f  
    8080 */
    8181static const size_t identify_data_size = 512;
    82 
    83 /** Size of the communication area. */
    84 static size_t comm_size;
    8582
    8683/** I/O base address of the command registers. */
    … …  
    281278        sysarg_t method;
    282279        service_id_t dsid;
     280        size_t comm_size;       /**< Size of the communication area. */
    283281        unsigned int flags;
    284282        int retval;

  • uspace/srv/devman/devman.c

    r15f3c3f r86ffa27f  
    270270        }
    271271       
    272         ssize_t read_bytes = safe_read(fd, buf, len);
     272        ssize_t read_bytes = read_all(fd, buf, len);
    273273        if (read_bytes <= 0) {
    274                 log_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
     274                log_msg(LVL_ERROR, "Unable to read file '%s' (%zd).", conf_path,
     275                    read_bytes);
    275276                goto cleanup;
    276277        }
    … …  
    421422        }
    422423       
    423         insert_fun_node(tree, fun, clone_string(""), NULL);
     424        insert_fun_node(tree, fun, str_dup(""), NULL);
    424425        match_id_t *id = create_match_id();
    425         id->id = clone_string("root");
     426        id->id = str_dup("root");
    426427        id->score = 100;
    427428        add_match_id(&fun->match_ids, id);

  • uspace/srv/devman/util.c

    r15f3c3f r86ffa27f  
    9191}
    9292
    93 char *clone_string(const char *s)
    94 {
    95         size_t size = str_size(s) + 1;
    96         char *str;
    97        
    98         str = (char *) malloc(size);
    99         if (str != NULL)
    100                 str_cpy(str, size, s);
    101         return str;
    102 }
    103 
    10493void replace_char(char *str, char orig, char repl)
    10594{
    … …  
    111100}
    112101
    113 ssize_t safe_read(int fd, void *buffer, size_t size)
    114 {
    115         if (size == 0) {
    116                 return 0;
    117         }
    118 
    119         uint8_t *buf_ptr = (uint8_t *) buffer;
    120 
    121         size_t total_read = 0;
    122         while (total_read < size) {
    123                 ssize_t bytes_read = read(fd, buf_ptr, size - total_read);
    124                 if (bytes_read < 0) {
    125                         /* Error. */
    126                         return bytes_read;
    127                 } else if (bytes_read == 0) {
    128                         /* Possibly end of file. */
    129                         break;
    130                 } else {
    131                         /* Read at least something. */
    132                         buf_ptr += bytes_read;
    133                         total_read += bytes_read;
    134                 }
    135         }
    136 
    137         return (ssize_t) total_read;
    138 }
    139 
    140102/** @}
    141103 */

  • uspace/srv/devman/util.h

    r15f3c3f r86ffa27f  
    4444extern size_t get_nonspace_len(const char *);
    4545extern void free_not_null(const void *);
    46 extern char *clone_string(const char *);
    4746extern void replace_char(char *, char, char);
    48 
    49 extern ssize_t safe_read(int, void *, size_t);
    5047
    5148#endif

  • uspace/srv/fs/ext2fs/ext2fs.c

    r15f3c3f r86ffa27f  
    11/*
    22 * Copyright (c) 2006 Martin Decky
    3  * Copyright (c) 2008 Jakub Jermar
    43 * Copyright (c) 2011 Martin Sucha
    54 * All rights reserved.
    … …  
    5554};
    5655
    57 fs_reg_t ext2fs_reg;
    58 
    59 /**
    60  * This connection fibril processes VFS requests from VFS.
    61  *
    62  * In order to support simultaneous VFS requests, our design is as follows.
    63  * The connection fibril accepts VFS requests from VFS. If there is only one
    64  * instance of the fibril, VFS will need to serialize all VFS requests it sends
    65  * to EXT2FS. To overcome this bottleneck, VFS can send EXT2FS the IPC_M_CONNECT_ME_TO
    66  * call. In that case, a new connection fibril will be created, which in turn
    67  * will accept the call. Thus, a new phone will be opened for VFS.
    68  *
    69  * There are few issues with this arrangement. First, VFS can run out of
    70  * available phones. In that case, VFS can close some other phones or use one
    71  * phone for more serialized requests. Similarily, EXT2FS can refuse to duplicate
    72  * the connection. VFS should then just make use of already existing phones and
    73  * route its requests through them. To avoid paying the fibril creation price
    74  * upon each request, EXT2FS might want to keep the connections open after the
    75  * request has been completed.
    76  */
    77 static void ext2fs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    78 {
    79         if (iid) {
    80                 /*
    81                  * This only happens for connections opened by
    82                  * IPC_M_CONNECT_ME_TO calls as opposed to callback connections
    83                  * created by IPC_M_CONNECT_TO_ME.
    84                  */
    85                 async_answer_0(iid, EOK);
    86         }
    87        
    88         dprintf(NAME ": connection opened\n");
    89         while (true) {
    90                 ipc_call_t call;
    91                 ipc_callid_t callid = async_get_call(&call);
    92                
    93                 if (!IPC_GET_IMETHOD(call))
    94                         return;
    95                
    96                 switch (IPC_GET_IMETHOD(call)) {
    97                 case VFS_OUT_MOUNTED:
    98                         ext2fs_mounted(callid, &call);
    99                         break;
    100                 case VFS_OUT_MOUNT:
    101                         ext2fs_mount(callid, &call);
    102                         break;
    103                 case VFS_OUT_UNMOUNTED:
    104                         ext2fs_unmounted(callid, &call);
    105                         break;
    106                 case VFS_OUT_UNMOUNT:
    107                         ext2fs_unmount(callid, &call);
    108                         break;
    109                 case VFS_OUT_LOOKUP:
    110                         ext2fs_lookup(callid, &call);
    111                         break;
    112                 case VFS_OUT_READ:
    113                         ext2fs_read(callid, &call);
    114                         break;
    115                 case VFS_OUT_WRITE:
    116                         ext2fs_write(callid, &call);
    117                         break;
    118                 case VFS_OUT_TRUNCATE:
    119                         ext2fs_truncate(callid, &call);
    120                         break;
    121                 case VFS_OUT_STAT:
    122                         ext2fs_stat(callid, &call);
    123                         break;
    124                 case VFS_OUT_CLOSE:
    125                         ext2fs_close(callid, &call);
    126                         break;
    127                 case VFS_OUT_DESTROY:
    128                         ext2fs_destroy(callid, &call);
    129                         break;
    130                 case VFS_OUT_OPEN_NODE:
    131                         ext2fs_open_node(callid, &call);
    132                         break;
    133                 case VFS_OUT_SYNC:
    134                         ext2fs_sync(callid, &call);
    135                         break;
    136                 default:
    137                         async_answer_0(callid, ENOTSUP);
    138                         break;
    139                 }
    140         }
    141 }
    142 
    14356int main(int argc, char **argv)
    14457{
    … …  
    15871        }       
    15972               
    160         rc = fs_register(vfs_sess, &ext2fs_reg, &ext2fs_vfs_info, ext2fs_connection);
     73        rc = fs_register(vfs_sess, &ext2fs_vfs_info, &ext2fs_ops,
     74            &ext2fs_libfs_ops);
    16175        if (rc != EOK) {
    16276                fprintf(stdout, NAME ": Failed to register fs (%d)\n", rc);

  • uspace/srv/fs/ext2fs/ext2fs.h

    r15f3c3f r86ffa27f  
    11/*
    2  * Copyright (c) 2008 Jakub Jermar
    32 * Copyright (c) 2011 Martin Sucha
    43 * All rights reserved.
    … …  
    3635
    3736#include <libext2.h>
    38 #include <fibril_synch.h>
    3937#include <libfs.h>
    40 #include <atomic.h>
    4138#include <sys/types.h>
    42 #include <bool.h>
    43 #include "../../vfs/vfs.h"
    44 
    45 #ifndef dprintf
    46 #define dprintf(...)    printf(__VA_ARGS__)
    47 #endif
    4839
    4940#define min(a, b)               ((a) < (b) ? (a) : (b))
    5041
    51 extern fs_reg_t ext2fs_reg;
     42extern vfs_out_ops_t ext2fs_ops;
     43extern libfs_ops_t ext2fs_libfs_ops;
    5244
    5345extern int ext2fs_global_init(void);
    5446extern int ext2fs_global_fini(void);
    55 extern void ext2fs_mounted(ipc_callid_t, ipc_call_t *);
    56 extern void ext2fs_mount(ipc_callid_t, ipc_call_t *);
    57 extern void ext2fs_unmounted(ipc_callid_t, ipc_call_t *);
    58 extern void ext2fs_unmount(ipc_callid_t, ipc_call_t *);
    59 extern void ext2fs_lookup(ipc_callid_t, ipc_call_t *);
    60 extern void ext2fs_read(ipc_callid_t, ipc_call_t *);
    61 extern void ext2fs_write(ipc_callid_t, ipc_call_t *);
    62 extern void ext2fs_truncate(ipc_callid_t, ipc_call_t *);
    63 extern void ext2fs_stat(ipc_callid_t, ipc_call_t *);
    64 extern void ext2fs_close(ipc_callid_t, ipc_call_t *);
    65 extern void ext2fs_destroy(ipc_callid_t, ipc_call_t *);
    66 extern void ext2fs_open_node(ipc_callid_t, ipc_call_t *);
    67 extern void ext2fs_stat(ipc_callid_t, ipc_call_t *);
    68 extern void ext2fs_sync(ipc_callid_t, ipc_call_t *);
    6947
    7048#endif

  • uspace/srv/fs/ext2fs/ext2fs_ops.c

    r15f3c3f r86ffa27f  
    11/*
    2  * Copyright (c) 2008 Jakub Jermar
    32 * Copyright (c) 2011 Martin Sucha
    43 * All rights reserved.
    … …  
    8786 */
    8887static int ext2fs_instance_get(service_id_t, ext2fs_instance_t **);
    89 static void ext2fs_read_directory(ipc_callid_t, ipc_callid_t, aoff64_t,
    90         size_t, ext2fs_instance_t *, ext2_inode_ref_t *);
    91 static void ext2fs_read_file(ipc_callid_t, ipc_callid_t, aoff64_t,
    92         size_t, ext2fs_instance_t *, ext2_inode_ref_t *);
     88static int ext2fs_read_directory(ipc_callid_t, aoff64_t, size_t,
     89    ext2fs_instance_t *, ext2_inode_ref_t *, size_t *);
     90static int ext2fs_read_file(ipc_callid_t, aoff64_t, size_t, ext2fs_instance_t *,
     91    ext2_inode_ref_t *, size_t *);
    9392static bool ext2fs_is_dots(const uint8_t *, size_t);
    9493static int ext2fs_node_get_core(fs_node_t **, ext2fs_instance_t *, fs_index_t);
    … …  
    111110static aoff64_t ext2fs_size_get(fs_node_t *);
    112111static unsigned ext2fs_lnkcnt_get(fs_node_t *);
    113 static char ext2fs_plb_get_char(unsigned);
    114112static bool ext2fs_is_directory(fs_node_t *);
    115113static bool ext2fs_is_file(fs_node_t *node);
    … …  
    240238        }
    241239       
    242         rc = ext2_directory_iterator_init(&it, fs, eparent->inode_ref);
     240        rc = ext2_directory_iterator_init(&it, fs, eparent->inode_ref, 0);
    243241        if (rc != EOK) {
    244242                return rc;
    … …  
    478476        }
    479477       
    480         rc = ext2_directory_iterator_init(&it, fs, enode->inode_ref);
     478        rc = ext2_directory_iterator_init(&it, fs, enode->inode_ref, 0);
    481479        if (rc != EOK) {
    482480                EXT2FS_DBG("error %u", rc);
    … …  
    538536        EXT2FS_DBG("%u", count);
    539537        return count;
    540 }
    541 
    542 char ext2fs_plb_get_char(unsigned pos)
    543 {
    544         return ext2fs_reg.plb_ro[pos % PLB_SIZE];
    545538}
    546539
    … …  
    586579        .size_get = ext2fs_size_get,
    587580        .lnkcnt_get = ext2fs_lnkcnt_get,
    588         .plb_get_char = ext2fs_plb_get_char,
    589581        .is_directory = ext2fs_is_directory,
    590582        .is_file = ext2fs_is_file,
    … …  
    596588 */
    597589
    598 void ext2fs_mounted(ipc_callid_t rid, ipc_call_t *request)
    599 {
    600         EXT2FS_DBG("");
    601         int rc;
    602         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
     590static int ext2fs_mounted(service_id_t service_id, const char *opts,
     591   fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
     592{
     593        EXT2FS_DBG("");
     594        int rc;
    603595        ext2_filesystem_t *fs;
    604596        ext2fs_instance_t *inst;
    605597        bool read_only;
    606598       
    607         /* Accept the mount options */
    608         char *opts;
    609         rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    610        
    611         if (rc != EOK) {
    612                 async_answer_0(rid, rc);
    613                 return;
    614         }
    615 
    616         free(opts);
    617        
    618599        /* Allocate libext2 filesystem structure */
    619600        fs = (ext2_filesystem_t *) malloc(sizeof(ext2_filesystem_t));
    620         if (fs == NULL) {
    621                 async_answer_0(rid, ENOMEM);
    622                 return;
    623         }
     601        if (fs == NULL)
     602                return ENOMEM;
    624603       
    625604        /* Allocate instance structure */
    … …  
    627606        if (inst == NULL) {
    628607                free(fs);
    629                 async_answer_0(rid, ENOMEM);
    630                 return;
     608                return ENOMEM;
    631609        }
    632610       
    … …  
    636614                free(fs);
    637615                free(inst);
    638                 async_answer_0(rid, rc);
    639                 return;
     616                return rc;
    640617        }
    641618       
    … …  
    646623                free(fs);
    647624                free(inst);
    648                 async_answer_0(rid, rc);
    649                 return;
     625                return rc;
    650626        }
    651627       
    … …  
    656632                free(fs);
    657633                free(inst);
    658                 async_answer_0(rid, rc);
    659                 return;
     634                return rc;
    660635        }
    661636       
    … …  
    673648                free(fs);
    674649                free(inst);
    675                 async_answer_0(rid, rc);
    676                 return;
     650                return rc;
    677651        }
    678652        ext2fs_node_t *enode = EXT2FS_NODE(root_node);
    … …  
    683657        fibril_mutex_unlock(&instance_list_mutex);
    684658       
    685         async_answer_3(rid, EOK,
    686             EXT2_INODE_ROOT_INDEX,
    687             0,
    688             ext2_inode_get_usage_count(enode->inode_ref->inode));
     659        *index = EXT2_INODE_ROOT_INDEX;
     660        *size = 0;
     661        *lnkcnt = ext2_inode_get_usage_count(enode->inode_ref->inode);
    689662       
    690663        ext2fs_node_put(root_node);
    691 }
    692 
    693 void ext2fs_mount(ipc_callid_t rid, ipc_call_t *request)
    694 {
    695         EXT2FS_DBG("");
    696         libfs_mount(&ext2fs_libfs_ops, ext2fs_reg.fs_handle, rid, request);
    697 }
    698 
    699 void ext2fs_unmounted(ipc_callid_t rid, ipc_call_t *request)
    700 {
    701         EXT2FS_DBG("");
    702         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
     664
     665        return EOK;
     666}
     667
     668static int ext2fs_unmounted(service_id_t service_id)
     669{
     670        EXT2FS_DBG("");
    703671        ext2fs_instance_t *inst;
    704672        int rc;
    … …  
    706674        rc = ext2fs_instance_get(service_id, &inst);
    707675       
    708         if (rc != EOK) {
    709                 async_answer_0(rid, rc);
    710                 return;
    711         }
     676        if (rc != EOK)
     677                return rc;
    712678       
    713679        fibril_mutex_lock(&open_nodes_lock);
    … …  
    716682        if (inst->open_nodes_count != 0) {
    717683                fibril_mutex_unlock(&open_nodes_lock);
    718                 async_answer_0(rid, EBUSY);
    719                 return;
     684                return EBUSY;
    720685        }
    721686       
    … …  
    729694        ext2_filesystem_fini(inst->filesystem);
    730695       
    731         async_answer_0(rid, EOK);
    732 }
    733 
    734 void ext2fs_unmount(ipc_callid_t rid, ipc_call_t *request)
    735 {
    736         EXT2FS_DBG("");
    737         libfs_unmount(&ext2fs_libfs_ops, rid, request);
    738 }
    739 
    740 void ext2fs_lookup(ipc_callid_t rid, ipc_call_t *request)
    741 {
    742         EXT2FS_DBG("");
    743         libfs_lookup(&ext2fs_libfs_ops, ext2fs_reg.fs_handle, rid, request);
    744 }
    745 
    746 void ext2fs_read(ipc_callid_t rid, ipc_call_t *request)
    747 {
    748         EXT2FS_DBG("");
    749         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    750         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    751         aoff64_t pos =
    752             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     696        return EOK;
     697}
     698
     699static int
     700ext2fs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     701    size_t *rbytes)
     702{
     703        EXT2FS_DBG("");
    753704       
    754705        ext2fs_instance_t *inst;
    … …  
    763714        if (!async_data_read_receive(&callid, &size)) {
    764715                async_answer_0(callid, EINVAL);
    765                 async_answer_0(rid, EINVAL);
    766                 return;
     716                return EINVAL;
    767717        }
    768718       
    … …  
    770720        if (rc != EOK) {
    771721                async_answer_0(callid, rc);
    772                 async_answer_0(rid, rc);
    773                 return;
     722                return rc;
    774723        }
    775724       
    … …  
    777726        if (rc != EOK) {
    778727                async_answer_0(callid, rc);
    779                 async_answer_0(rid, rc);
    780                 return;
     728                return rc;
    781729        }
    782730       
    783731        if (ext2_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
    784                     EXT2_INODE_MODE_FILE)) {
    785                 ext2fs_read_file(rid, callid, pos, size, inst, inode_ref);
    786         }
    787         else if (ext2_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
    788                     EXT2_INODE_MODE_DIRECTORY)) {
    789                 ext2fs_read_directory(rid, callid, pos, size, inst, inode_ref);
    790         }
    791         else {
     732            EXT2_INODE_MODE_FILE)) {
     733                rc = ext2fs_read_file(callid, pos, size, inst, inode_ref,
     734                    rbytes);
     735        } else if (ext2_inode_is_type(inst->filesystem->superblock,
     736            inode_ref->inode, EXT2_INODE_MODE_DIRECTORY)) {
     737                rc = ext2fs_read_directory(callid, pos, size, inst, inode_ref,
     738                    rbytes);
     739        } else {
    792740                /* Other inode types not supported */
    793741                async_answer_0(callid, ENOTSUP);
    794                 async_answer_0(rid, ENOTSUP);
     742                rc = ENOTSUP;
    795743        }
    796744       
    797745        ext2_filesystem_put_inode_ref(inode_ref);
    798746       
     747        return rc;
    799748}
    800749
    … …  
    814763}
    815764
    816 void ext2fs_read_directory(ipc_callid_t rid, ipc_callid_t callid, aoff64_t pos,
    817         size_t size, ext2fs_instance_t *inst, ext2_inode_ref_t *inode_ref)
     765int ext2fs_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size,
     766    ext2fs_instance_t *inst, ext2_inode_ref_t *inode_ref, size_t *rbytes)
    818767{
    819768        ext2_directory_iterator_t it;
    820         aoff64_t cur;
     769        aoff64_t next;
    821770        uint8_t *buf;
    822771        size_t name_size;
    … …  
    824773        bool found = false;
    825774       
    826         rc = ext2_directory_iterator_init(&it, inst->filesystem, inode_ref);
     775        rc = ext2_directory_iterator_init(&it, inst->filesystem, inode_ref, pos);
    827776        if (rc != EOK) {
    828777                async_answer_0(callid, rc);
    829                 async_answer_0(rid, rc);
    830                 return;
    831         }
    832        
    833         /* Find the index we want to read
    834          * Note that we need to iterate and count as
    835          * the underlying structure is a linked list
    836          * Moreover, we want to skip . and .. entries
     778                return rc;
     779        }
     780       
     781        /* Find next interesting directory entry.
     782         * We want to skip . and .. entries
    837783         * as these are not used in HelenOS
    838784         */
    839         cur = 0;
    840785        while (it.current != NULL) {
    841786                if (it.current->inode == 0) {
    … …  
    844789               
    845790                name_size = ext2_directory_entry_ll_get_name_length(
    846                         inst->filesystem->superblock, it.current);
     791                    inst->filesystem->superblock, it.current);
    847792               
    848793                /* skip . and .. */
    … …  
    851796                }
    852797               
    853                 /* Is this the dir entry we want to read? */
    854                 if (cur == pos) {
    855                         /* The on-disk entry does not contain \0 at the end
    856                          * end of entry name, so we copy it to new buffer
    857                          * and add the \0 at the end
    858                          */
    859                         buf = malloc(name_size+1);
    860                         if (buf == NULL) {
    861                                 ext2_directory_iterator_fini(&it);
    862                                 async_answer_0(callid, ENOMEM);
    863                                 async_answer_0(rid, ENOMEM);
    864                                 return;
    865                         }
    866                         memcpy(buf, &it.current->name, name_size);
    867                         *(buf+name_size) = 0;
    868                         found = true;
    869                         (void) async_data_read_finalize(callid, buf, name_size+1);
    870                         free(buf);
    871                         break;
    872                 }
    873                 cur++;
     798                /* The on-disk entry does not contain \0 at the end
     799                 * end of entry name, so we copy it to new buffer
     800                 * and add the \0 at the end
     801                 */
     802                buf = malloc(name_size+1);
     803                if (buf == NULL) {
     804                        ext2_directory_iterator_fini(&it);
     805                        async_answer_0(callid, ENOMEM);
     806                        return ENOMEM;
     807                }
     808                memcpy(buf, &it.current->name, name_size);
     809                *(buf + name_size) = 0;
     810                found = true;
     811                (void) async_data_read_finalize(callid, buf, name_size + 1);
     812                free(buf);
     813                break;
    874814               
    875815skip:
    … …  
    878818                        ext2_directory_iterator_fini(&it);
    879819                        async_answer_0(callid, rc);
    880                         async_answer_0(rid, rc);
    881                         return;
    882                 }
     820                        return rc;
     821                }
     822        }
     823       
     824        if (found) {
     825                rc = ext2_directory_iterator_next(&it);
     826                if (rc != EOK)
     827                        return rc;
     828                next = it.current_offset;
    883829        }
    884830       
    885831        rc = ext2_directory_iterator_fini(&it);
    886         if (rc != EOK) {
    887                 async_answer_0(rid, rc);
    888                 return;
    889         }
     832        if (rc != EOK)
     833                return rc;
    890834       
    891835        if (found) {
    892                 async_answer_1(rid, EOK, 1);
    893         }
    894         else {
     836                *rbytes = next - pos;
     837                return EOK;
     838        } else {
    895839                async_answer_0(callid, ENOENT);
    896                 async_answer_0(rid, ENOENT);
    897         }
    898 }
    899 
    900 void ext2fs_read_file(ipc_callid_t rid, ipc_callid_t callid, aoff64_t pos,
    901         size_t size, ext2fs_instance_t *inst, ext2_inode_ref_t *inode_ref)
     840                return ENOENT;
     841        }
     842}
     843
     844int ext2fs_read_file(ipc_callid_t callid, aoff64_t pos, size_t size,
     845    ext2fs_instance_t *inst, ext2_inode_ref_t *inode_ref, size_t *rbytes)
    902846{
    903847        int rc;
    … …  
    917861                /* Read 0 bytes successfully */
    918862                async_data_read_finalize(callid, NULL, 0);
    919                 async_answer_1(rid, EOK, 0);
    920                 return;
     863                *rbytes = 0;
     864                return EOK;
    921865        }
    922866       
    … …  
    937881        if (rc != EOK) {
    938882                async_answer_0(callid, rc);
    939                 async_answer_0(rid, rc);
    940                 return;
     883                return rc;
    941884        }
    942885       
    … …  
    950893                if (buffer == NULL) {
    951894                        async_answer_0(callid, ENOMEM);
    952                         async_answer_0(rid, ENOMEM);
    953                         return;
     895                        return ENOMEM;
    954896                }
    955897               
    … …  
    957899               
    958900                async_data_read_finalize(callid, buffer, bytes);
    959                 async_answer_1(rid, EOK, bytes);
     901                *rbytes = bytes;
    960902               
    961903                free(buffer);
    962904               
    963                 return;
     905                return EOK;
    964906        }
    965907       
    … …  
    968910        if (rc != EOK) {
    969911                async_answer_0(callid, rc);
    970                 async_answer_0(rid, rc);
    971                 return;
     912                return rc;
    972913        }
    973914       
    … …  
    976917       
    977918        rc = block_put(block);
    978         if (rc != EOK) {
    979                 async_answer_0(rid, rc);
    980                 return;
    981         }
    982                
    983         async_answer_1(rid, EOK, bytes);
    984 }
    985 
    986 void ext2fs_write(ipc_callid_t rid, ipc_call_t *request)
    987 {
    988         EXT2FS_DBG("");
    989 //      service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    990 //      fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    991 //      aoff64_t pos =
    992 //          (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
    993        
    994         // TODO
    995         async_answer_0(rid, ENOTSUP);
    996 }
    997 
    998 void ext2fs_truncate(ipc_callid_t rid, ipc_call_t *request)
    999 {
    1000         EXT2FS_DBG("");
    1001 //      service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    1002 //      fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1003 //      aoff64_t size =
    1004 //          (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
    1005        
    1006         // TODO
    1007         async_answer_0(rid, ENOTSUP);
    1008 }
    1009 
    1010 void ext2fs_close(ipc_callid_t rid, ipc_call_t *request)
    1011 {
    1012         EXT2FS_DBG("");
    1013         async_answer_0(rid, EOK);
    1014 }
    1015 
    1016 void ext2fs_destroy(ipc_callid_t rid, ipc_call_t *request)
    1017 {
    1018         EXT2FS_DBG("");
    1019 //      service_id_t service_id = (service_id_t)IPC_GET_ARG1(*request);
    1020 //      fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    1021        
    1022         // TODO
    1023         async_answer_0(rid, ENOTSUP);
    1024 }
    1025 
    1026 void ext2fs_open_node(ipc_callid_t rid, ipc_call_t *request)
    1027 {
    1028         EXT2FS_DBG("");
    1029         libfs_open_node(&ext2fs_libfs_ops, ext2fs_reg.fs_handle, rid, request);
    1030 }
    1031 
    1032 void ext2fs_stat(ipc_callid_t rid, ipc_call_t *request)
    1033 {
    1034         EXT2FS_DBG("");
    1035         libfs_stat(&ext2fs_libfs_ops, ext2fs_reg.fs_handle, rid, request);
    1036 }
    1037 
    1038 void ext2fs_sync(ipc_callid_t rid, ipc_call_t *request)
    1039 {
    1040         EXT2FS_DBG("");
    1041 //      service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    1042 //      fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1043        
    1044         // TODO
    1045         async_answer_0(rid, ENOTSUP);
    1046 }
     919        if (rc != EOK)
     920                return rc;
     921       
     922        *rbytes = bytes;
     923        return EOK;
     924}
     925
     926static int
     927ext2fs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     928    size_t *wbytes, aoff64_t *nsize)
     929{
     930        EXT2FS_DBG("");
     931        return ENOTSUP;
     932}
     933
     934static int
     935ext2fs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
     936{
     937        EXT2FS_DBG("");
     938        return ENOTSUP;
     939}
     940
     941static int ext2fs_close(service_id_t service_id, fs_index_t index)
     942{
     943        EXT2FS_DBG("");
     944        return EOK;
     945}
     946
     947static int ext2fs_destroy(service_id_t service_id, fs_index_t index)
     948{
     949        EXT2FS_DBG("");
     950        return ENOTSUP;
     951}
     952
     953static int ext2fs_sync(service_id_t service_id, fs_index_t index)
     954{
     955        EXT2FS_DBG("");
     956        return ENOTSUP;
     957}
     958
     959vfs_out_ops_t ext2fs_ops = {
     960        .mounted = ext2fs_mounted,
     961        .unmounted = ext2fs_unmounted,
     962        .read = ext2fs_read,
     963        .write = ext2fs_write,
     964        .truncate = ext2fs_truncate,
     965        .close = ext2fs_close,
     966        .destroy = ext2fs_destroy,
     967        .sync = ext2fs_sync,
     968};
    1047969
    1048970/**
    1049971 * @}
    1050972 */
     973

  • uspace/srv/fs/fat/fat.c

    r15f3c3f r86ffa27f  
    5656};
    5757
    58 fs_reg_t fat_reg;
    59 
    60 /**
    61  * This connection fibril processes VFS requests from VFS.
    62  *
    63  * In order to support simultaneous VFS requests, our design is as follows.
    64  * The connection fibril accepts VFS requests from VFS. If there is only one
    65  * instance of the fibril, VFS will need to serialize all VFS requests it sends
    66  * to FAT. To overcome this bottleneck, VFS can send FAT the IPC_M_CONNECT_ME_TO
    67  * call. In that case, a new connection fibril will be created, which in turn
    68  * will accept the call. Thus, a new phone will be opened for VFS.
    69  *
    70  * There are few issues with this arrangement. First, VFS can run out of
    71  * available phones. In that case, VFS can close some other phones or use one
    72  * phone for more serialized requests. Similarily, FAT can refuse to duplicate
    73  * the connection. VFS should then just make use of already existing phones and
    74  * route its requests through them. To avoid paying the fibril creation price
    75  * upon each request, FAT might want to keep the connections open after the
    76  * request has been completed.
    77  */
    78 static void fat_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    79 {
    80         if (iid) {
    81                 /*
    82                  * This only happens for connections opened by
    83                  * IPC_M_CONNECT_ME_TO calls as opposed to callback connections
    84                  * created by IPC_M_CONNECT_TO_ME.
    85                  */
    86                 async_answer_0(iid, EOK);
    87         }
    88        
    89         dprintf(NAME ": connection opened\n");
    90        
    91         while (true) {
    92                 ipc_call_t call;
    93                 ipc_callid_t callid = async_get_call(&call);
    94                
    95                 if (!IPC_GET_IMETHOD(call))
    96                         return;
    97                
    98                 switch (IPC_GET_IMETHOD(call)) {
    99                 case VFS_OUT_MOUNTED:
    100                         fat_mounted(callid, &call);
    101                         break;
    102                 case VFS_OUT_MOUNT:
    103                         fat_mount(callid, &call);
    104                         break;
    105                 case VFS_OUT_UNMOUNTED:
    106                         fat_unmounted(callid, &call);
    107                         break;
    108                 case VFS_OUT_UNMOUNT:
    109                         fat_unmount(callid, &call);
    110                         break;
    111                 case VFS_OUT_LOOKUP:
    112                         fat_lookup(callid, &call);
    113                         break;
    114                 case VFS_OUT_READ:
    115                         fat_read(callid, &call);
    116                         break;
    117                 case VFS_OUT_WRITE:
    118                         fat_write(callid, &call);
    119                         break;
    120                 case VFS_OUT_TRUNCATE:
    121                         fat_truncate(callid, &call);
    122                         break;
    123                 case VFS_OUT_STAT:
    124                         fat_stat(callid, &call);
    125                         break;
    126                 case VFS_OUT_CLOSE:
    127                         fat_close(callid, &call);
    128                         break;
    129                 case VFS_OUT_DESTROY:
    130                         fat_destroy(callid, &call);
    131                         break;
    132                 case VFS_OUT_OPEN_NODE:
    133                         fat_open_node(callid, &call);
    134                         break;
    135                 case VFS_OUT_SYNC:
    136                         fat_sync(callid, &call);
    137                         break;
    138                 default:
    139                         async_answer_0(callid, ENOTSUP);
    140                         break;
    141                 }
    142         }
    143 }
    144 
    14558int main(int argc, char **argv)
    14659{
    … …  
    15871        }
    15972       
    160         rc = fs_register(vfs_sess, &fat_reg, &fat_vfs_info, fat_connection);
     73        rc = fs_register(vfs_sess, &fat_vfs_info, &fat_ops, &fat_libfs_ops);
    16174        if (rc != EOK) {
    16275                fat_idx_fini();

  • uspace/srv/fs/fat/fat.h

    r15f3c3f r86ffa27f  
    224224} fat_node_t;
    225225
    226 extern fs_reg_t fat_reg;
    227 
    228 extern void fat_mounted(ipc_callid_t, ipc_call_t *);
    229 extern void fat_mount(ipc_callid_t, ipc_call_t *);
    230 extern void fat_unmounted(ipc_callid_t, ipc_call_t *);
    231 extern void fat_unmount(ipc_callid_t, ipc_call_t *);
    232 extern void fat_lookup(ipc_callid_t, ipc_call_t *);
    233 extern void fat_read(ipc_callid_t, ipc_call_t *);
    234 extern void fat_write(ipc_callid_t, ipc_call_t *);
    235 extern void fat_truncate(ipc_callid_t, ipc_call_t *);
    236 extern void fat_stat(ipc_callid_t, ipc_call_t *);
    237 extern void fat_close(ipc_callid_t, ipc_call_t *);
    238 extern void fat_destroy(ipc_callid_t, ipc_call_t *);
    239 extern void fat_open_node(ipc_callid_t, ipc_call_t *);
    240 extern void fat_stat(ipc_callid_t, ipc_call_t *);
    241 extern void fat_sync(ipc_callid_t, ipc_call_t *);
     226extern vfs_out_ops_t fat_ops;
     227extern libfs_ops_t fat_libfs_ops;
    242228
    243229extern int fat_idx_get_new(fat_idx_t **, service_id_t);

  • uspace/srv/fs/fat/fat_ops.c

    r15f3c3f r86ffa27f  
    8585static aoff64_t fat_size_get(fs_node_t *);
    8686static unsigned fat_lnkcnt_get(fs_node_t *);
    87 static char fat_plb_get_char(unsigned);
    8887static bool fat_is_directory(fs_node_t *);
    8988static bool fat_is_file(fs_node_t *node);
    … …  
    901900}
    902901
    903 char fat_plb_get_char(unsigned pos)
    904 {
    905         return fat_reg.plb_ro[pos % PLB_SIZE];
    906 }
    907 
    908902bool fat_is_directory(fs_node_t *fn)
    909903{
    … …  
    936930        .size_get = fat_size_get,
    937931        .lnkcnt_get = fat_lnkcnt_get,
    938         .plb_get_char = fat_plb_get_char,
    939932        .is_directory = fat_is_directory,
    940933        .is_file = fat_is_file,
    … …  
    943936
    944937/*
    945  * VFS operations.
     938 * FAT VFS_OUT operations.
    946939 */
    947940
    948 void fat_mounted(ipc_callid_t rid, ipc_call_t *request)
    949 {
    950         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
     941static int
     942fat_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
     943    aoff64_t *size, unsigned *linkcnt)
     944{
    951945        enum cache_mode cmode;
    952946        fat_bs_t *bs;
    953        
    954         /* Accept the mount options */
    955         char *opts;
    956         int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    957        
    958         if (rc != EOK) {
    959                 async_answer_0(rid, rc);
    960                 return;
    961         }
    962 
     947        int rc;
     948       
    963949        /* Check for option enabling write through. */
    964950        if (str_cmp(opts, "wtcache") == 0)
    … …  
    967953                cmode = CACHE_MODE_WB;
    968954
    969         free(opts);
    970 
    971955        /* initialize libblock */
    972956        rc = block_init(EXCHANGE_SERIALIZE, service_id, BS_SIZE);
    973         if (rc != EOK) {
    974                 async_answer_0(rid, rc);
    975                 return;
    976         }
     957        if (rc != EOK)
     958                return rc;
    977959
    978960        /* prepare the boot block */
    … …  
    980962        if (rc != EOK) {
    981963                block_fini(service_id);
    982                 async_answer_0(rid, rc);
    983                 return;
     964                return rc;
    984965        }
    985966
    … …  
    989970        if (BPS(bs) != BS_SIZE) {
    990971                block_fini(service_id);
    991                 async_answer_0(rid, ENOTSUP);
    992                 return;
     972                return ENOTSUP;
    993973        }
    994974
    … …  
    997977        if (rc != EOK) {
    998978                block_fini(service_id);
    999                 async_answer_0(rid, rc);
    1000                 return;
     979                return rc;
    1001980        }
    1002981
    … …  
    1006985                (void) block_cache_fini(service_id);
    1007986                block_fini(service_id);
    1008                 async_answer_0(rid, rc);
    1009                 return;
     987                return rc;
    1010988        }
    1011989
    … …  
    1014992                (void) block_cache_fini(service_id);
    1015993                block_fini(service_id);
    1016                 async_answer_0(rid, rc);
    1017                 return;
     994                return rc;
    1018995        }
    1019996
    … …  
    10241001                block_fini(service_id);
    10251002                fat_idx_fini_by_service_id(service_id);
    1026                 async_answer_0(rid, ENOMEM);
    1027                 return;
     1003                return ENOMEM;
    10281004        }
    10291005        fs_node_initialize(rfn);
    … …  
    10341010                block_fini(service_id);
    10351011                fat_idx_fini_by_service_id(service_id);
    1036                 async_answer_0(rid, ENOMEM);
    1037                 return;
     1012                return ENOMEM;
    10381013        }
    10391014        fat_node_initialize(rootp);
    … …  
    10461021                block_fini(service_id);
    10471022                fat_idx_fini_by_service_id(service_id);
    1048                 async_answer_0(rid, ENOMEM);
    1049                 return;
     1023                return ENOMEM;
    10501024        }
    10511025        assert(ridxp->index == 0);
    … …  
    10641038        fibril_mutex_unlock(&ridxp->lock);
    10651039
    1066         async_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
    1067 }
    1068 
    1069 void fat_mount(ipc_callid_t rid, ipc_call_t *request)
    1070 {
    1071         libfs_mount(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1072 }
    1073 
    1074 void fat_unmounted(ipc_callid_t rid, ipc_call_t *request)
    1075 {
    1076         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
     1040        *index = ridxp->index;
     1041        *size = rootp->size;
     1042        *linkcnt = rootp->lnkcnt;
     1043
     1044        return EOK;
     1045}
     1046
     1047static int fat_unmounted(service_id_t service_id)
     1048{
    10771049        fs_node_t *fn;
    10781050        fat_node_t *nodep;
    … …  
    10801052
    10811053        rc = fat_root_get(&fn, service_id);
    1082         if (rc != EOK) {
    1083                 async_answer_0(rid, rc);
    1084                 return;
    1085         }
     1054        if (rc != EOK)
     1055                return rc;
    10861056        nodep = FAT_NODE(fn);
    10871057
    … …  
    10921062        if (nodep->refcnt != 2) {
    10931063                (void) fat_node_put(fn);
    1094                 async_answer_0(rid, EBUSY);
    1095                 return;
     1064                return EBUSY;
    10961065        }
    10971066       
    … …  
    11121081        block_fini(service_id);
    11131082
    1114         async_answer_0(rid, EOK);
    1115 }
    1116 
    1117 void fat_unmount(ipc_callid_t rid, ipc_call_t *request)
    1118 {
    1119         libfs_unmount(&fat_libfs_ops, rid, request);
    1120 }
    1121 
    1122 void fat_lookup(ipc_callid_t rid, ipc_call_t *request)
    1123 {
    1124         libfs_lookup(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1125 }
    1126 
    1127 void fat_read(ipc_callid_t rid, ipc_call_t *request)
    1128 {
    1129         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    1130         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1131         aoff64_t pos =
    1132             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1083        return EOK;
     1084}
     1085
     1086static int
     1087fat_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1088    size_t *rbytes)
     1089{
    11331090        fs_node_t *fn;
    11341091        fat_node_t *nodep;
    … …  
    11391096
    11401097        rc = fat_node_get(&fn, service_id, index);
    1141         if (rc != EOK) {
    1142                 async_answer_0(rid, rc);
    1143                 return;
    1144         }
    1145         if (!fn) {
    1146                 async_answer_0(rid, ENOENT);
    1147                 return;
    1148         }
     1098        if (rc != EOK)
     1099                return rc;
     1100        if (!fn)
     1101                return ENOENT;
    11491102        nodep = FAT_NODE(fn);
    11501103
    … …  
    11541107                fat_node_put(fn);
    11551108                async_answer_0(callid, EINVAL);
    1156                 async_answer_0(rid, EINVAL);
    1157                 return;
     1109                return EINVAL;
    11581110        }
    11591111
    … …  
    11781130                                fat_node_put(fn);
    11791131                                async_answer_0(callid, rc);
    1180                                 async_answer_0(rid, rc);
    1181                                 return;
     1132                                return rc;
    11821133                        }
    11831134                        (void) async_data_read_finalize(callid,
    … …  
    11861137                        if (rc != EOK) {
    11871138                                fat_node_put(fn);
    1188                                 async_answer_0(rid, rc);
    1189                                 return;
     1139                                return rc;
    11901140                        }
    11911141                }
    … …  
    12441194                rc = fat_node_put(fn);
    12451195                async_answer_0(callid, rc != EOK ? rc : ENOENT);
    1246                 async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    1247                 return;
     1196                *rbytes = 0;
     1197                return rc != EOK ? rc : ENOENT;
    12481198
    12491199err:
    12501200                (void) fat_node_put(fn);
    12511201                async_answer_0(callid, rc);
    1252                 async_answer_0(rid, rc);
    1253                 return;
     1202                return rc;
    12541203
    12551204hit:
    … …  
    12591208
    12601209        rc = fat_node_put(fn);
    1261         async_answer_1(rid, rc, (sysarg_t)bytes);
    1262 }
    1263 
    1264 void fat_write(ipc_callid_t rid, ipc_call_t *request)
    1265 {
    1266         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    1267         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1268         aoff64_t pos =
    1269             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1210        *rbytes = bytes;
     1211        return rc;
     1212}
     1213
     1214static int
     1215fat_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1216    size_t *wbytes, aoff64_t *nsize)
     1217{
    12701218        fs_node_t *fn;
    12711219        fat_node_t *nodep;
    12721220        fat_bs_t *bs;
    1273         size_t bytes, size;
     1221        size_t bytes;
    12741222        block_t *b;
    12751223        aoff64_t boundary;
    … …  
    12781226       
    12791227        rc = fat_node_get(&fn, service_id, index);
    1280         if (rc != EOK) {
    1281                 async_answer_0(rid, rc);
    1282                 return;
    1283         }
    1284         if (!fn) {
    1285                 async_answer_0(rid, ENOENT);
    1286                 return;
    1287         }
     1228        if (rc != EOK)
     1229                return rc;
     1230        if (!fn)
     1231                return ENOENT;
    12881232        nodep = FAT_NODE(fn);
    12891233       
    … …  
    12931237                (void) fat_node_put(fn);
    12941238                async_answer_0(callid, EINVAL);
    1295                 async_answer_0(rid, EINVAL);
    1296                 return;
     1239                return EINVAL;
    12971240        }
    12981241
    … …  
    13221265                        (void) fat_node_put(fn);
    13231266                        async_answer_0(callid, rc);
    1324                         async_answer_0(rid, rc);
    1325                         return;
     1267                        return rc;
    13261268                }
    13271269                rc = fat_block_get(&b, bs, nodep, pos / BPS(bs), flags);
    … …  
    13291271                        (void) fat_node_put(fn);
    13301272                        async_answer_0(callid, rc);
    1331                         async_answer_0(rid, rc);
    1332                         return;
     1273                        return rc;
    13331274                }
    13341275                (void) async_data_write_finalize(callid,
    … …  
    13381279                if (rc != EOK) {
    13391280                        (void) fat_node_put(fn);
    1340                         async_answer_0(rid, rc);
    1341                         return;
     1281                        return rc;
    13421282                }
    13431283                if (pos + bytes > nodep->size) {
    … …  
    13451285                        nodep->dirty = true;    /* need to sync node */
    13461286                }
    1347                 size = nodep->size;
     1287                *wbytes = bytes;
     1288                *nsize = nodep->size;
    13481289                rc = fat_node_put(fn);
    1349                 async_answer_2(rid, rc, bytes, nodep->size);
    1350                 return;
     1290                return rc;
    13511291        } else {
    13521292                /*
    … …  
    13641304                        (void) fat_node_put(fn);
    13651305                        async_answer_0(callid, rc);
    1366                         async_answer_0(rid, rc);
    1367                         return;
     1306                        return rc;
    13681307                }
    13691308                /* zero fill any gaps */
    … …  
    13731312                        (void) fat_node_put(fn);
    13741313                        async_answer_0(callid, rc);
    1375                         async_answer_0(rid, rc);
    1376                         return;
     1314                        return rc;
    13771315                }
    13781316                rc = _fat_block_get(&b, bs, service_id, lcl, NULL,
    … …  
    13821320                        (void) fat_node_put(fn);
    13831321                        async_answer_0(callid, rc);
    1384                         async_answer_0(rid, rc);
    1385                         return;
     1322                        return rc;
    13861323                }
    13871324                (void) async_data_write_finalize(callid,
    … …  
    13921329                        (void) fat_free_clusters(bs, service_id, mcl);
    13931330                        (void) fat_node_put(fn);
    1394                         async_answer_0(rid, rc);
    1395                         return;
     1331                        return rc;
    13961332                }
    13971333                /*
    … …  
    14031339                        (void) fat_free_clusters(bs, service_id, mcl);
    14041340                        (void) fat_node_put(fn);
    1405                         async_answer_0(rid, rc);
    1406                         return;
    1407                 }
    1408                 nodep->size = size = pos + bytes;
     1341                        return rc;
     1342                }
     1343                *nsize = nodep->size = pos + bytes;
     1344                rc = fat_node_put(fn);
    14091345                nodep->dirty = true;            /* need to sync node */
    1410                 rc = fat_node_put(fn);
    1411                 async_answer_2(rid, rc, bytes, size);
    1412                 return;
    1413         }
    1414 }
    1415 
    1416 void fat_truncate(ipc_callid_t rid, ipc_call_t *request)
    1417 {
    1418         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    1419         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1420         aoff64_t size =
    1421             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     1346                *wbytes = bytes;
     1347                return rc;
     1348        }
     1349}
     1350
     1351static int
     1352fat_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
     1353{
    14221354        fs_node_t *fn;
    14231355        fat_node_t *nodep;
    … …  
    14261358
    14271359        rc = fat_node_get(&fn, service_id, index);
    1428         if (rc != EOK) {
    1429                 async_answer_0(rid, rc);
    1430                 return;
    1431         }
    1432         if (!fn) {
    1433                 async_answer_0(rid, ENOENT);
    1434                 return;
    1435         }
     1360        if (rc != EOK)
     1361                return rc;
     1362        if (!fn)
     1363                return ENOENT;
    14361364        nodep = FAT_NODE(fn);
    14371365
    … …  
    14771405out:
    14781406        fat_node_put(fn);
    1479         async_answer_0(rid, rc);
    1480         return;
    1481 }
    1482 
    1483 void fat_close(ipc_callid_t rid, ipc_call_t *request)
    1484 {
    1485         async_answer_0(rid, EOK);
    1486 }
    1487 
    1488 void fat_destroy(ipc_callid_t rid, ipc_call_t *request)
    1489 {
    1490         service_id_t service_id = (service_id_t)IPC_GET_ARG1(*request);
    1491         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
     1407        return rc;
     1408}
     1409
     1410static int fat_close(service_id_t service_id, fs_index_t index)
     1411{
     1412        return EOK;
     1413}
     1414
     1415static int fat_destroy(service_id_t service_id, fs_index_t index)
     1416{
    14921417        fs_node_t *fn;
    14931418        fat_node_t *nodep;
    … …  
    14951420
    14961421        rc = fat_node_get(&fn, service_id, index);
    1497         if (rc != EOK) {
    1498                 async_answer_0(rid, rc);
    1499                 return;
    1500         }
    1501         if (!fn) {
    1502                 async_answer_0(rid, ENOENT);
    1503                 return;
    1504         }
     1422        if (rc != EOK)
     1423                return rc;
     1424        if (!fn)
     1425                return ENOENT;
    15051426
    15061427        nodep = FAT_NODE(fn);
    … …  
    15121433
    15131434        rc = fat_destroy_node(fn);
    1514         async_answer_0(rid, rc);
    1515 }
    1516 
    1517 void fat_open_node(ipc_callid_t rid, ipc_call_t *request)
    1518 {
    1519         libfs_open_node(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1520 }
    1521 
    1522 void fat_stat(ipc_callid_t rid, ipc_call_t *request)
    1523 {
    1524         libfs_stat(&fat_libfs_ops, fat_reg.fs_handle, rid, request);
    1525 }
    1526 
    1527 void fat_sync(ipc_callid_t rid, ipc_call_t *request)
    1528 {
    1529         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    1530         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1531        
     1435        return rc;
     1436}
     1437
     1438static int fat_sync(service_id_t service_id, fs_index_t index)
     1439{
    15321440        fs_node_t *fn;
    15331441        int rc = fat_node_get(&fn, service_id, index);
    1534         if (rc != EOK) {
    1535                 async_answer_0(rid, rc);
    1536                 return;
    1537         }
    1538         if (!fn) {
    1539                 async_answer_0(rid, ENOENT);
    1540                 return;
    1541         }
     1442        if (rc != EOK)
     1443                return rc;
     1444        if (!fn)
     1445                return ENOENT;
    15421446       
    15431447        fat_node_t *nodep = FAT_NODE(fn);
    … …  
    15471451       
    15481452        fat_node_put(fn);
    1549         async_answer_0(rid, rc);
    1550 }
     1453        return rc;
     1454}
     1455
     1456vfs_out_ops_t fat_ops = {
     1457        .mounted = fat_mounted,
     1458        .unmounted = fat_unmounted,
     1459        .read = fat_read,
     1460        .write = fat_write,
     1461        .truncate = fat_truncate,
     1462        .close = fat_close,
     1463        .destroy = fat_destroy,
     1464        .sync = fat_sync,
     1465};
    15511466
    15521467/**

  • uspace/srv/fs/locfs/locfs.c

    r15f3c3f r86ffa27f  
    5757};
    5858
    59 fs_reg_t locfs_reg;
    60 
    61 static void locfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    62 {
    63         if (iid)
    64                 async_answer_0(iid, EOK);
    65        
    66         while (true) {
    67                 ipc_call_t call;
    68                 ipc_callid_t callid = async_get_call(&call);
    69                
    70                 if (!IPC_GET_IMETHOD(call))
    71                         return;
    72                
    73                 switch (IPC_GET_IMETHOD(call)) {
    74                 case VFS_OUT_MOUNTED:
    75                         locfs_mounted(callid, &call);
    76                         break;
    77                 case VFS_OUT_MOUNT:
    78                         locfs_mount(callid, &call);
    79                         break;
    80                 case VFS_OUT_UNMOUNTED:
    81                         locfs_unmounted(callid, &call);
    82                         break;
    83                 case VFS_OUT_UNMOUNT:
    84                         locfs_unmount(callid, &call);
    85                         break;
    86                 case VFS_OUT_LOOKUP:
    87                         locfs_lookup(callid, &call);
    88                         break;
    89                 case VFS_OUT_OPEN_NODE:
    90                         locfs_open_node(callid, &call);
    91                         break;
    92                 case VFS_OUT_STAT:
    93                         locfs_stat(callid, &call);
    94                         break;
    95                 case VFS_OUT_READ:
    96                         locfs_read(callid, &call);
    97                         break;
    98                 case VFS_OUT_WRITE:
    99                         locfs_write(callid, &call);
    100                         break;
    101                 case VFS_OUT_TRUNCATE:
    102                         locfs_truncate(callid, &call);
    103                         break;
    104                 case VFS_OUT_CLOSE:
    105                         locfs_close(callid, &call);
    106                         break;
    107                 case VFS_OUT_SYNC:
    108                         locfs_sync(callid, &call);
    109                         break;
    110                 case VFS_OUT_DESTROY:
    111                         locfs_destroy(callid, &call);
    112                         break;
    113                 default:
    114                         async_answer_0(callid, ENOTSUP);
    115                         break;
    116                 }
    117         }
    118 }
    119 
    12059int main(int argc, char *argv[])
    12160{
    … …  
    13473        }
    13574       
    136         int rc = fs_register(vfs_sess, &locfs_reg, &locfs_vfs_info,
    137             locfs_connection);
     75        int rc = fs_register(vfs_sess, &locfs_vfs_info, &locfs_ops,
     76            &locfs_libfs_ops);
    13877        if (rc != EOK) {
    13978                printf("%s: Failed to register file system (%d)\n", NAME, rc);
    … …  
    15291 * @}
    15392 */
     93

  • uspace/srv/fs/locfs/locfs.h

    r15f3c3f r86ffa27f  
    3636#include <libfs.h>
    3737
    38 extern fs_reg_t locfs_reg;
     38extern vfs_out_ops_t locfs_ops;
     39extern libfs_ops_t locfs_libfs_ops;
    3940
    4041#endif

  • uspace/srv/fs/locfs/locfs_ops.c

    r15f3c3f r86ffa27f  
    404404}
    405405
    406 static char locfs_plb_get_char(unsigned pos)
    407 {
    408         return locfs_reg.plb_ro[pos % PLB_SIZE];
    409 }
    410 
    411406static bool locfs_is_directory(fs_node_t *fn)
    412407{
    … …  
    448443        .size_get = locfs_size_get,
    449444        .lnkcnt_get = locfs_lnkcnt_get,
    450         .plb_get_char = locfs_plb_get_char,
    451445        .is_directory = locfs_is_directory,
    452446        .is_file = locfs_is_file,
    … …  
    463457}
    464458
    465 void locfs_mounted(ipc_callid_t rid, ipc_call_t *request)
    466 {
    467         char *opts;
    468        
    469         /* Accept the mount options */
    470         sysarg_t retval = async_data_write_accept((void **) &opts, true, 0, 0,
    471             0, NULL);
    472         if (retval != EOK) {
    473                 async_answer_0(rid, retval);
    474                 return;
    475         }
    476        
    477         free(opts);
    478         async_answer_3(rid, EOK, 0, 0, 0);
    479 }
    480 
    481 void locfs_mount(ipc_callid_t rid, ipc_call_t *request)
    482 {
    483         libfs_mount(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request);
    484 }
    485 
    486 void locfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
    487 {
    488         async_answer_0(rid, ENOTSUP);
    489 }
    490 
    491 void locfs_unmount(ipc_callid_t rid, ipc_call_t *request)
    492 {
    493         libfs_unmount(&locfs_libfs_ops, rid, request);
    494 }
    495 
    496 void locfs_lookup(ipc_callid_t rid, ipc_call_t *request)
    497 {
    498         libfs_lookup(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request);
    499 }
    500 
    501 void locfs_open_node(ipc_callid_t rid, ipc_call_t *request)
    502 {
    503         libfs_open_node(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request);
    504 }
    505 
    506 void locfs_stat(ipc_callid_t rid, ipc_call_t *request)
    507 {
    508         libfs_stat(&locfs_libfs_ops, locfs_reg.fs_handle, rid, request);
    509 }
    510 
    511 void locfs_read(ipc_callid_t rid, ipc_call_t *request)
    512 {
    513         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    514         aoff64_t pos =
    515             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
    516        
     459static int locfs_mounted(service_id_t service_id, const char *opts,
     460    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
     461{
     462        *index = 0;
     463        *size = 0;
     464        *lnkcnt = 0;
     465        return EOK;
     466}
     467
     468static int locfs_unmounted(service_id_t service_id)
     469{
     470        return ENOTSUP;
     471}
     472
     473static int
     474locfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     475    size_t *rbytes)
     476{
    517477        if (index == 0) {
    518478                ipc_callid_t callid;
    … …  
    520480                if (!async_data_read_receive(&callid, &size)) {
    521481                        async_answer_0(callid, EINVAL);
    522                         async_answer_0(rid, EINVAL);
    523                         return;
     482                        return EINVAL;
    524483                }
    525484               
    … …  
    541500                        async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    542501                        free(desc);
    543                         async_answer_1(rid, EOK, 1);
    544                         return;
     502                        *rbytes = 1;
     503                        return EOK;
    545504                }
    546505               
    … …  
    556515                                async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    557516                                free(desc);
    558                                 async_answer_1(rid, EOK, 1);
    559                                 return;
     517                                *rbytes = 1;
     518                                return EOK;
    560519                        }
    561520                       
    … …  
    564523               
    565524                async_answer_0(callid, ENOENT);
    566                 async_answer_1(rid, ENOENT, 0);
    567                 return;
     525                return ENOENT;
    568526        }
    569527       
    … …  
    576534                if (!async_data_read_receive(&callid, &size)) {
    577535                        async_answer_0(callid, EINVAL);
    578                         async_answer_0(rid, EINVAL);
    579                         return;
     536                        return EINVAL;
    580537                }
    581538               
    … …  
    586543                        async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
    587544                        free(desc);
    588                         async_answer_1(rid, EOK, 1);
    589                         return;
     545                        *rbytes = 1;
     546                        return EOK;
    590547                }
    591548               
    592549                free(desc);
    593550                async_answer_0(callid, ENOENT);
    594                 async_answer_1(rid, ENOENT, 0);
    595                 return;
     551                return ENOENT;
    596552        }
    597553       
    … …  
    607563                if (lnk == NULL) {
    608564                        fibril_mutex_unlock(&services_mutex);
    609                         async_answer_0(rid, ENOENT);
    610                         return;
     565                        return ENOENT;
    611566                }
    612567               
    … …  
    618573                        fibril_mutex_unlock(&services_mutex);
    619574                        async_answer_0(callid, EINVAL);
    620                         async_answer_0(rid, EINVAL);
    621                         return;
     575                        return EINVAL;
    622576                }
    623577               
    … …  
    626580               
    627581                ipc_call_t answer;
    628                 aid_t msg = async_send_3(exch, IPC_GET_IMETHOD(*request),
    629                     IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
    630                     IPC_GET_ARG3(*request), &answer);
     582                aid_t msg = async_send_4(exch, VFS_OUT_READ, service_id,
     583                    index, LOWER32(pos), UPPER32(pos), &answer);
    631584               
    632585                /* Forward the IPC_M_DATA_READ request to the driver */
    … …  
    640593                sysarg_t rc;
    641594                async_wait_for(msg, &rc);
    642                 size_t bytes = IPC_GET_ARG1(answer);
    643                
    644                 /* Driver reply is the final result of the whole operation */
    645                 async_answer_1(rid, rc, bytes);
    646                 return;
    647         }
    648        
    649         async_answer_0(rid, ENOENT);
    650 }
    651 
    652 void locfs_write(ipc_callid_t rid, ipc_call_t *request)
    653 {
    654         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    655         if (index == 0) {
    656                 async_answer_0(rid, ENOTSUP);
    657                 return;
    658         }
     595               
     596                *rbytes = IPC_GET_ARG1(answer);
     597                return rc;
     598        }
     599       
     600        return ENOENT;
     601}
     602
     603static int
     604locfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     605    size_t *wbytes, aoff64_t *nsize)
     606{
     607        if (index == 0)
     608                return ENOTSUP;
    659609       
    660610        loc_object_type_t type = loc_id_probe(index);
    … …  
    662612        if (type == LOC_OBJECT_NAMESPACE) {
    663613                /* Namespace directory */
    664                 async_answer_0(rid, ENOTSUP);
    665                 return;
     614                return ENOTSUP;
    666615        }
    667616       
    … …  
    676625                if (lnk == NULL) {
    677626                        fibril_mutex_unlock(&services_mutex);
    678                         async_answer_0(rid, ENOENT);
    679                         return;
     627                        return ENOENT;
    680628                }
    681629               
    … …  
    687635                        fibril_mutex_unlock(&services_mutex);
    688636                        async_answer_0(callid, EINVAL);
    689                         async_answer_0(rid, EINVAL);
    690                         return;
     637                        return EINVAL;
    691638                }
    692639               
    … …  
    695642               
    696643                ipc_call_t answer;
    697                 aid_t msg = async_send_3(exch, IPC_GET_IMETHOD(*request),
    698                     IPC_GET_ARG1(*request), IPC_GET_ARG2(*request),
    699                     IPC_GET_ARG3(*request), &answer);
     644                aid_t msg = async_send_4(exch, VFS_OUT_WRITE, service_id,
     645                    index, LOWER32(pos), UPPER32(pos), &answer);
    700646               
    701647                /* Forward the IPC_M_DATA_WRITE request to the driver */
    … …  
    709655                sysarg_t rc;
    710656                async_wait_for(msg, &rc);
    711                 size_t bytes = IPC_GET_ARG1(answer);
    712                
    713                 /* Driver reply is the final result of the whole operation */
    714                 async_answer_1(rid, rc, bytes);
    715                 return;
    716         }
    717        
    718         async_answer_0(rid, ENOENT);
    719 }
    720 
    721 void locfs_truncate(ipc_callid_t rid, ipc_call_t *request)
    722 {
    723         async_answer_0(rid, ENOTSUP);
    724 }
    725 
    726 void locfs_close(ipc_callid_t rid, ipc_call_t *request)
    727 {
    728         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    729        
    730         if (index == 0) {
    731                 async_answer_0(rid, EOK);
    732                 return;
    733         }
     657               
     658                *wbytes = IPC_GET_ARG1(answer);
     659                *nsize = 0;
     660                return rc;
     661        }
     662       
     663        return ENOENT;
     664}
     665
     666static int
     667locfs_truncate(service_id_t service_id, fs_index_t index, aoff64_t size)
     668{
     669        return ENOTSUP;
     670}
     671
     672static int locfs_close(service_id_t service_id, fs_index_t index)
     673{
     674        if (index == 0)
     675                return EOK;
    734676       
    735677        loc_object_type_t type = loc_id_probe(index);
    … …  
    737679        if (type == LOC_OBJECT_NAMESPACE) {
    738680                /* Namespace directory */
    739                 async_answer_0(rid, EOK);
    740                 return;
     681                return EOK;
    741682        }
    742683       
    … …  
    750691                if (lnk == NULL) {
    751692                        fibril_mutex_unlock(&services_mutex);
    752                         async_answer_0(rid, ENOENT);
    753                         return;
     693                        return ENOENT;
    754694                }
    755695               
    … …  
    765705                fibril_mutex_unlock(&services_mutex);
    766706               
    767                 async_answer_0(rid, EOK);
    768                 return;
    769         }
    770        
    771         async_answer_0(rid, ENOENT);
    772 }
    773 
    774 void locfs_sync(ipc_callid_t rid, ipc_call_t *request)
    775 {
    776         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    777        
    778         if (index == 0) {
    779                 async_answer_0(rid, EOK);
    780                 return;
    781         }
     707                return EOK;
     708        }
     709       
     710        return ENOENT;
     711}
     712
     713static int locfs_sync(service_id_t service_id, fs_index_t index)
     714{
     715        if (index == 0)
     716                return EOK;
    782717       
    783718        loc_object_type_t type = loc_id_probe(index);
    … …  
    785720        if (type == LOC_OBJECT_NAMESPACE) {
    786721                /* Namespace directory */
    787                 async_answer_0(rid, EOK);
    788                 return;
     722                return EOK;
    789723        }
    790724       
    … …  
    798732                if (lnk == NULL) {
    799733                        fibril_mutex_unlock(&services_mutex);
    800                         async_answer_0(rid, ENOENT);
    801                         return;
     734                        return ENOENT;
    802735                }
    803736               
    … …  
    809742               
    810743                ipc_call_t answer;
    811                 aid_t msg = async_send_2(exch, IPC_GET_IMETHOD(*request),
    812                     IPC_GET_ARG1(*request), IPC_GET_ARG2(*request), &answer);
     744                aid_t msg = async_send_2(exch, VFS_OUT_SYNC, service_id,
     745                    index, &answer);
    813746               
    814747                async_exchange_end(exch);
    … …  
    820753                async_wait_for(msg, &rc);
    821754               
    822                 /* Driver reply is the final result of the whole operation */
    823                 async_answer_0(rid, rc);
    824                 return;
    825         }
    826        
    827         async_answer_0(rid, ENOENT);
    828 }
    829 
    830 void locfs_destroy(ipc_callid_t rid, ipc_call_t *request)
    831 {
    832         async_answer_0(rid, ENOTSUP);
    833 }
     755                return rc;
     756        }
     757       
     758        return  ENOENT;
     759}
     760
     761static int locfs_destroy(service_id_t service_id, fs_index_t index)
     762{
     763        return ENOTSUP;
     764}
     765
     766vfs_out_ops_t locfs_ops = {
     767        .mounted = locfs_mounted,
     768        .unmounted = locfs_unmounted,
     769        .read = locfs_read,
     770        .write = locfs_write,
     771        .truncate = locfs_truncate,
     772        .close = locfs_close,
     773        .destroy = locfs_destroy,
     774        .sync = locfs_sync,
     775};
    834776
    835777/**

  • uspace/srv/fs/locfs/locfs_ops.h

    r15f3c3f r86ffa27f  
    3434#define LOCFS_LOCFS_OPS_H_
    3535
    36 #include <ipc/common.h>
    3736#include <bool.h>
    3837
    3938extern bool locfs_init(void);
    40 
    41 extern void locfs_mounted(ipc_callid_t, ipc_call_t *);
    42 extern void locfs_mount(ipc_callid_t, ipc_call_t *);
    43 extern void locfs_unmounted(ipc_callid_t, ipc_call_t *);
    44 extern void locfs_unmount(ipc_callid_t, ipc_call_t *);
    45 extern void locfs_lookup(ipc_callid_t, ipc_call_t *);
    46 extern void locfs_open_node(ipc_callid_t, ipc_call_t *);
    47 extern void locfs_stat(ipc_callid_t, ipc_call_t *);
    48 extern void locfs_sync(ipc_callid_t, ipc_call_t *);
    49 extern void locfs_read(ipc_callid_t, ipc_call_t *);
    50 extern void locfs_write(ipc_callid_t, ipc_call_t *);
    51 extern void locfs_truncate(ipc_callid_t, ipc_call_t *);
    52 extern void locfs_close(ipc_callid_t, ipc_call_t *);
    53 extern void locfs_destroy(ipc_callid_t, ipc_call_t *);
    5439
    5540#endif

  • uspace/srv/fs/tmpfs/tmpfs.c

    r15f3c3f r86ffa27f  
    6161};
    6262
    63 fs_reg_t tmpfs_reg;
    64 
    65 /**
    66  * This connection fibril processes VFS requests from VFS.
    67  *
    68  * In order to support simultaneous VFS requests, our design is as follows.
    69  * The connection fibril accepts VFS requests from VFS. If there is only one
    70  * instance of the fibril, VFS will need to serialize all VFS requests it sends
    71  * to FAT. To overcome this bottleneck, VFS can send TMPFS the
    72  * IPC_M_CONNECT_ME_TO call. In that case, a new connection fibril will be
    73  * created, which in turn will accept the call. Thus, a new phone will be
    74  * opened for VFS.
    75  *
    76  * There are few issues with this arrangement. First, VFS can run out of
    77  * available phones. In that case, VFS can close some other phones or use one
    78  * phone for more serialized requests. Similarily, TMPFS can refuse to duplicate
    79  * the connection. VFS should then just make use of already existing phones and
    80  * route its requests through them. To avoid paying the fibril creation price
    81  * upon each request, TMPFS might want to keep the connections open after the
    82  * request has been completed.
    83  */
    84 static void tmpfs_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    85 {
    86         if (iid) {
    87                 /*
    88                  * This only happens for connections opened by
    89                  * IPC_M_CONNECT_ME_TO calls as opposed to callback connections
    90                  * created by IPC_M_CONNECT_TO_ME.
    91                  */
    92                 async_answer_0(iid, EOK);
    93         }
    94        
    95         dprintf(NAME ": connection opened\n");
    96        
    97         while (true) {
    98                 ipc_call_t call;
    99                 ipc_callid_t callid = async_get_call(&call);
    100                
    101                 if (!IPC_GET_IMETHOD(call))
    102                         return;
    103                
    104                 switch (IPC_GET_IMETHOD(call)) {
    105                 case VFS_OUT_MOUNTED:
    106                         tmpfs_mounted(callid, &call);
    107                         break;
    108                 case VFS_OUT_MOUNT:
    109                         tmpfs_mount(callid, &call);
    110                         break;
    111                 case VFS_OUT_UNMOUNTED:
    112                         tmpfs_unmounted(callid, &call);
    113                         break;
    114                 case VFS_OUT_UNMOUNT:
    115                         tmpfs_unmount(callid, &call);
    116                         break;
    117                 case VFS_OUT_LOOKUP:
    118                         tmpfs_lookup(callid, &call);
    119                         break;
    120                 case VFS_OUT_READ:
    121                         tmpfs_read(callid, &call);
    122                         break;
    123                 case VFS_OUT_WRITE:
    124                         tmpfs_write(callid, &call);
    125                         break;
    126                 case VFS_OUT_TRUNCATE:
    127                         tmpfs_truncate(callid, &call);
    128                         break;
    129                 case VFS_OUT_CLOSE:
    130                         tmpfs_close(callid, &call);
    131                         break;
    132                 case VFS_OUT_DESTROY:
    133                         tmpfs_destroy(callid, &call);
    134                         break;
    135                 case VFS_OUT_OPEN_NODE:
    136                         tmpfs_open_node(callid, &call);
    137                         break;
    138                 case VFS_OUT_STAT:
    139                         tmpfs_stat(callid, &call);
    140                         break;
    141                 case VFS_OUT_SYNC:
    142                         tmpfs_sync(callid, &call);
    143                         break;
    144                 default:
    145                         async_answer_0(callid, ENOTSUP);
    146                         break;
    147                 }
    148         }
    149 }
    150 
    15163int main(int argc, char **argv)
    15264{
    … …  
    16577        }
    16678       
    167         int rc = fs_register(vfs_sess, &tmpfs_reg, &tmpfs_vfs_info,
    168             tmpfs_connection);
     79        int rc = fs_register(vfs_sess, &tmpfs_vfs_info, &tmpfs_ops,
     80            &tmpfs_libfs_ops);
    16981        if (rc != EOK) {
    17082                printf(NAME ": Failed to register file system (%d)\n", rc);

  • uspace/srv/fs/tmpfs/tmpfs.h

    r15f3c3f r86ffa27f  
    7070} tmpfs_node_t;
    7171
    72 extern fs_reg_t tmpfs_reg;
    73 
     72extern vfs_out_ops_t tmpfs_ops;
    7473extern libfs_ops_t tmpfs_libfs_ops;
    7574
    7675extern bool tmpfs_init(void);
    77 
    78 extern void tmpfs_mounted(ipc_callid_t, ipc_call_t *);
    79 extern void tmpfs_mount(ipc_callid_t, ipc_call_t *);
    80 extern void tmpfs_unmounted(ipc_callid_t, ipc_call_t *);
    81 extern void tmpfs_unmount(ipc_callid_t, ipc_call_t *);
    82 extern void tmpfs_lookup(ipc_callid_t, ipc_call_t *);
    83 extern void tmpfs_read(ipc_callid_t, ipc_call_t *);
    84 extern void tmpfs_write(ipc_callid_t, ipc_call_t *);
    85 extern void tmpfs_truncate(ipc_callid_t, ipc_call_t *);
    86 extern void tmpfs_stat(ipc_callid_t, ipc_call_t *);
    87 extern void tmpfs_close(ipc_callid_t, ipc_call_t *);
    88 extern void tmpfs_destroy(ipc_callid_t, ipc_call_t *);
    89 extern void tmpfs_open_node(ipc_callid_t, ipc_call_t *);
    90 extern void tmpfs_sync(ipc_callid_t, ipc_call_t *);
    91 
    9276extern bool tmpfs_restore(service_id_t);
    9377

  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r15f3c3f r86ffa27f  
    104104}
    105105
    106 static char tmpfs_plb_get_char(unsigned pos)
    107 {
    108         return tmpfs_reg.plb_ro[pos % PLB_SIZE];
    109 }
    110 
    111106static bool tmpfs_is_directory(fs_node_t *fn)
    112107{
    … …  
    139134        .size_get = tmpfs_size_get,
    140135        .lnkcnt_get = tmpfs_lnkcnt_get,
    141         .plb_get_char = tmpfs_plb_get_char,
    142136        .is_directory = tmpfs_is_directory,
    143137        .is_file = tmpfs_is_file,
    … …  
    433427}
    434428
    435 void tmpfs_mounted(ipc_callid_t rid, ipc_call_t *request)
    436 {
    437         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
     429/*
     430 * Implementation of the VFS_OUT interface.
     431 */
     432
     433static int
     434tmpfs_mounted(service_id_t service_id, const char *opts,
     435    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
     436{
    438437        fs_node_t *rootfn;
    439438        int rc;
    440439       
    441         /* Accept the mount options. */
    442         char *opts;
    443         rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    444         if (rc != EOK) {
    445                 async_answer_0(rid, rc);
    446                 return;
    447         }
    448 
    449440        /* Check if this device is not already mounted. */
    450441        rc = tmpfs_root_get(&rootfn, service_id);
    451442        if ((rc == EOK) && (rootfn)) {
    452443                (void) tmpfs_node_put(rootfn);
    453                 free(opts);
    454                 async_answer_0(rid, EEXIST);
    455                 return;
     444                return EEXIST;
    456445        }
    457446
    458447        /* Initialize TMPFS instance. */
    459         if (!tmpfs_instance_init(service_id)) {
    460                 free(opts);
    461                 async_answer_0(rid, ENOMEM);
    462                 return;
    463         }
     448        if (!tmpfs_instance_init(service_id))
     449                return ENOMEM;
    464450
    465451        rc = tmpfs_root_get(&rootfn, service_id);
    … …  
    467453        tmpfs_node_t *rootp = TMPFS_NODE(rootfn);
    468454        if (str_cmp(opts, "restore") == 0) {
    469                 if (tmpfs_restore(service_id))
    470                         async_answer_3(rid, EOK, rootp->index, rootp->size,
    471                             rootp->lnkcnt);
    472                 else
    473                         async_answer_0(rid, ELIMIT);
    474         } else {
    475                 async_answer_3(rid, EOK, rootp->index, rootp->size,
    476                     rootp->lnkcnt);
    477         }
    478         free(opts);
    479 }
    480 
    481 void tmpfs_mount(ipc_callid_t rid, ipc_call_t *request)
    482 {
    483         libfs_mount(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
    484 }
    485 
    486 void tmpfs_unmounted(ipc_callid_t rid, ipc_call_t *request)
    487 {
    488         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    489 
     455                if (!tmpfs_restore(service_id))
     456                        return ELIMIT;
     457        }
     458
     459        *index = rootp->index;
     460        *size = rootp->size;
     461        *lnkcnt = rootp->lnkcnt;
     462
     463        return EOK;
     464}
     465
     466static int tmpfs_unmounted(service_id_t service_id)
     467{
    490468        tmpfs_instance_done(service_id);
    491         async_answer_0(rid, EOK);
    492 }
    493 
    494 void tmpfs_unmount(ipc_callid_t rid, ipc_call_t *request)
    495 {
    496         libfs_unmount(&tmpfs_libfs_ops, rid, request);
    497 }
    498 
    499 void tmpfs_lookup(ipc_callid_t rid, ipc_call_t *request)
    500 {
    501         libfs_lookup(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
    502 }
    503 
    504 void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
    505 {
    506         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    507         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    508         aoff64_t pos =
    509             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
    510        
     469        return EOK;
     470}
     471
     472static int tmpfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     473    size_t *rbytes)
     474{
    511475        /*
    512476         * Lookup the respective TMPFS node.
    … …  
    518482        };
    519483        hlp = hash_table_find(&nodes, key);
    520         if (!hlp) {
    521                 async_answer_0(rid, ENOENT);
    522                 return;
    523         }
     484        if (!hlp)
     485                return ENOENT;
    524486        tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
    525487            nh_link);
    … …  
    532494        if (!async_data_read_receive(&callid, &size)) {
    533495                async_answer_0(callid, EINVAL);
    534                 async_answer_0(rid, EINVAL);
    535                 return;
     496                return EINVAL;
    536497        }
    537498
    … …  
    556517                if (lnk == NULL) {
    557518                        async_answer_0(callid, ENOENT);
    558                         async_answer_1(rid, ENOENT, 0);
    559                         return;
     519                        return ENOENT;
    560520                }
    561521
    … …  
    567527        }
    568528
    569         /*
    570          * Answer the VFS_READ call.
    571          */
    572         async_answer_1(rid, EOK, bytes);
    573 }
    574 
    575 void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
    576 {
    577         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    578         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    579         aoff64_t pos =
    580             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
    581        
     529        *rbytes = bytes;
     530        return EOK;
     531}
     532
     533static int
     534tmpfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     535    size_t *wbytes, aoff64_t *nsize)
     536{
    582537        /*
    583538         * Lookup the respective TMPFS node.
    … …  
    589544        };
    590545        hlp = hash_table_find(&nodes, key);
    591         if (!hlp) {
    592                 async_answer_0(rid, ENOENT);
    593                 return;
    594         }
     546        if (!hlp)
     547                return ENOENT;
    595548        tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
    596549            nh_link);
    … …  
    603556        if (!async_data_write_receive(&callid, &size)) {
    604557                async_answer_0(callid, EINVAL);
    605                 async_answer_0(rid, EINVAL);
    606                 return;
     558                return EINVAL;
    607559        }
    608560
    … …  
    612564        if (pos + size <= nodep->size) {
    613565                /* The file size is not changing. */
    614                 (void) async_data_write_finalize(callid, nodep->data + pos, size);
    615                 async_answer_2(rid, EOK, size, nodep->size);
    616                 return;
     566                (void) async_data_write_finalize(callid, nodep->data + pos,
     567                    size);
     568                goto out;
    617569        }
    618570        size_t delta = (pos + size) - nodep->size;
    … …  
    627579        if (!newdata) {
    628580                async_answer_0(callid, ENOMEM);
    629                 async_answer_2(rid, EOK, 0, nodep->size);
    630                 return;
     581                size = 0;
     582                goto out;
    631583        }
    632584        /* Clear any newly allocated memory in order to emulate gaps. */
    … …  
    635587        nodep->data = newdata;
    636588        (void) async_data_write_finalize(callid, nodep->data + pos, size);
    637         async_answer_2(rid, EOK, size, nodep->size);
    638 }
    639 
    640 void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
    641 {
    642         service_id_t service_id = (service_id_t) IPC_GET_ARG1(*request);
    643         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    644         aoff64_t size =
    645             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
    646        
     589
     590out:
     591        *wbytes = size;
     592        *nsize = nodep->size;
     593        return EOK;
     594}
     595
     596static int tmpfs_truncate(service_id_t service_id, fs_index_t index,
     597    aoff64_t size)
     598{
    647599        /*
    648600         * Lookup the respective TMPFS node.
    … …  
    653605        };
    654606        link_t *hlp = hash_table_find(&nodes, key);
    655         if (!hlp) {
    656                 async_answer_0(rid, ENOENT);
    657                 return;
    658         }
    659         tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
    660             nh_link);
    661        
    662         if (size == nodep->size) {
    663                 async_answer_0(rid, EOK);
    664                 return;
    665         }
    666        
    667         if (size > SIZE_MAX) {
    668                 async_answer_0(rid, ENOMEM);
    669                 return;
    670         }
     607        if (!hlp)
     608                return ENOENT;
     609        tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t, nh_link);
     610       
     611        if (size == nodep->size)
     612                return EOK;
     613       
     614        if (size > SIZE_MAX)
     615                return ENOMEM;
    671616       
    672617        void *newdata = realloc(nodep->data, size);
    673         if (!newdata) {
    674                 async_answer_0(rid, ENOMEM);
    675                 return;
    676         }
     618        if (!newdata)
     619                return ENOMEM;
    677620       
    678621        if (size > nodep->size) {
    … …  
    683626        nodep->size = size;
    684627        nodep->data = newdata;
    685         async_answer_0(rid, EOK);
    686 }
    687 
    688 void tmpfs_close(ipc_callid_t rid, ipc_call_t *request)
    689 {
    690         async_answer_0(rid, EOK);
    691 }
    692 
    693 void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
    694 {
    695         service_id_t service_id = (service_id_t)IPC_GET_ARG1(*request);
    696         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    697         int rc;
    698 
     628        return EOK;
     629}
     630
     631static int tmpfs_close(service_id_t service_id, fs_index_t index)
     632{
     633        return EOK;
     634}
     635
     636static int tmpfs_destroy(service_id_t service_id, fs_index_t index)
     637{
    699638        link_t *hlp;
    700639        unsigned long key[] = {
    … …  
    703642        };
    704643        hlp = hash_table_find(&nodes, key);
    705         if (!hlp) {
    706                 async_answer_0(rid, ENOENT);
    707                 return;
    708         }
     644        if (!hlp)
     645                return ENOENT;
    709646        tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
    710647            nh_link);
    711         rc = tmpfs_destroy_node(FS_NODE(nodep));
    712         async_answer_0(rid, rc);
    713 }
    714 
    715 void tmpfs_open_node(ipc_callid_t rid, ipc_call_t *request)
    716 {
    717         libfs_open_node(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
    718 }
    719 
    720 void tmpfs_stat(ipc_callid_t rid, ipc_call_t *request)
    721 {
    722         libfs_stat(&tmpfs_libfs_ops, tmpfs_reg.fs_handle, rid, request);
    723 }
    724 
    725 void tmpfs_sync(ipc_callid_t rid, ipc_call_t *request)
     648        return tmpfs_destroy_node(FS_NODE(nodep));
     649}
     650
     651static int tmpfs_sync(service_id_t service_id, fs_index_t index)
    726652{
    727653        /*
    … …  
    729655         * thus the sync operation is a no-op.
    730656         */
    731         async_answer_0(rid, EOK);
    732 }
     657        return EOK;
     658}
     659
     660vfs_out_ops_t tmpfs_ops = {
     661        .mounted = tmpfs_mounted,
     662        .unmounted = tmpfs_unmounted,
     663        .read = tmpfs_read,
     664        .write = tmpfs_write,
     665        .truncate = tmpfs_truncate,
     666        .close = tmpfs_close,
     667        .destroy = tmpfs_destroy,
     668        .sync = tmpfs_sync,
     669};
    733670
    734671/**
    735672 * @}
    736673 */
     674

  • uspace/srv/hid/console/console.c

    r15f3c3f r86ffa27f  
    357357                console_serialize_end();
    358358               
    359                 if (__SYSCALL0(SYS_DEBUG_ENABLE_CONSOLE)) {
     359                if (console_kcon()) {
    360360                        prev_console = active_console;
    361361                        active_console = kernel_console;
    … …  
    711711                        console_serialize_start();
    712712                        continue;
    713                 case CONSOLE_KCON_ENABLE:
    714                         change_console(kernel_console);
    715                         break;
    716713                }
    717714                async_answer_3(callid, EOK, arg1, arg2, arg3);
    … …  
    833830        }
    834831       
    835         /* Disable kernel output to the console */
    836         __SYSCALL0(SYS_DEBUG_DISABLE_CONSOLE);
    837        
    838832        /* Initialize the screen */
    839833        console_serialize_start();

  • uspace/srv/hid/fb/Makefile

    r15f3c3f r86ffa27f  
    8484                EXTRA_CFLAGS += -DNIAGARA_ENABLED
    8585        endif
    86        
    87         ifeq ($(MACHINE),serengeti)
    88                 SOURCES += \
    89                         sgcn.c \
    90                         serial_console.c
    91                 EXTRA_CFLAGS += -DSGCN_ENABLED
    92         endif
    9386endif
    9487

  • uspace/srv/hid/fb/main.c

    r15f3c3f r86ffa27f  
    4040#include "msim.h"
    4141#include "ski.h"
    42 #include "sgcn.h"
    4342#include "niagara.h"
    4443#include "main.h"
    … …  
    9291        }
    9392#endif
    94 #ifdef SGCN_ENABLED
    95         if ((!initialized) && (fb_kind == 4)) {
    96                 if (sgcn_init() == 0)
    97                         initialized = true;
    98         }
    99 #endif
    10093#ifdef NIAGARA_ENABLED
    10194        if ((!initialized) && (fb_kind == 5)) {

  • uspace/srv/hid/fb/niagara.c

    r15f3c3f r86ffa27f  
    2929 */
    3030
    31 /** @defgroup niagarafb SGCN
     31/** @defgroup niagarafb
    3232 * @brief       userland driver of the Niagara console output
    3333 * @{

  • uspace/srv/hid/fb/niagara.h

    r15f3c3f r86ffa27f  
    2727 */
    2828
    29 /** @defgroup sgcnfb SGCN
    30  * @brief       userland driver of the Serengeti console output
     29/** @defgroup niagarafb
     30 * @brief       userland driver of the Niagara console output
    3131 * @{
    3232 */

  • uspace/srv/hid/input/Makefile

    r15f3c3f r86ffa27f  
    4949        port/ns16550.c \
    5050        port/pl050.c \
    51         port/sgcn.c \
    5251        port/ski.c \
    53         port/z8530.c \
    5452        proto/adb.c \
    5553        proto/mousedev.c \

  • uspace/srv/hid/input/ctl/stty.c

    r15f3c3f r86ffa27f  
    3434 * @file
    3535 * @brief Serial TTY-like keyboard controller driver.
     36 *
     37 * Keyboard emulation on a serial terminal.
    3638 */
    3739
    … …  
    6365#include <stdio.h>
    6466
     67/**
     68 * Sequnece definitions are primarily for Xterm. Additionally we define
     69 * sequences that are unique to Gnome terminal -- most are the same but
     70 * some differ.
     71 */
    6572static int seq_defs[] = {
    6673        /* Not shifted */
    … …  
    8188        0,      KC_MINUS,       0x2d, GSP_END,
    8289        0,      KC_EQUALS,      0x3d, GSP_END,
     90
    8391        0,      KC_BACKSPACE,   0x08, GSP_END,
    8492
    … …  
    216224        0,      KC_RIGHT,       0x1b, 0x5b, 0x43, GSP_END,
    217225
     226        /*
     227         * Sequences specific to Gnome terminal
     228         */
     229        0,      KC_BACKSPACE,   0x7f, GSP_END, /* ASCII DEL */
     230        0,      KC_HOME,        0x1b, 0x4f, 0x48, GSP_END,
     231        0,      KC_END,         0x1b, 0x4f, 0x46, GSP_END,
     232
    218233        0,      0
    219234};

  • uspace/srv/hid/input/generic/gsp.c

    r15f3c3f r86ffa27f  
    104104                if (key == 0) break;
    105105
    106                 /* Insert one sequence. */             
     106                /* Insert one sequence. */
    107107                rc = gsp_insert_seq(p, dp, mods, key);
    108108                if (rc != 0)
    … …  
    197197
    198198        if (t == NULL) {
    199                 printf("gsp_step: not found\n");
     199                printf("gsp_step: not found, state=%d, input=0x%x\n",
     200                    state, input);
    200201                *mods = 0;
    201202                *key = 0;
    … …  
    205206        *mods = t->out_mods;
    206207        *key = t->out_key;
     208
    207209        return t->new_state;
    208210}

  • uspace/srv/hid/input/generic/input.c

    r15f3c3f r86ffa27f  
    410410#endif
    411411#if defined(MACHINE_msim)
    412         kbd_add_dev(&msim_port, &pc_ctl);
     412        kbd_add_dev(&msim_port, &stty_ctl);
    413413#endif
    414414#if (defined(MACHINE_lgxemul) || defined(MACHINE_bgxemul)) && defined(CONFIG_FB)
    … …  
    424424        kbd_add_dev(&niagara_port, &stty_ctl);
    425425#endif
    426 #if defined(UARCH_sparc64) && defined(MACHINE_serengeti)
    427         kbd_add_dev(&sgcn_port, &stty_ctl);
    428 #endif
    429426#if defined(UARCH_sparc64) && defined(MACHINE_generic)
    430         kbd_add_dev(&z8530_port, &sun_ctl);
    431427        kbd_add_dev(&ns16550_port, &sun_ctl);
    432428#endif
    … …  
    556552        printf("%s: HelenOS input service\n", NAME);
    557553       
    558         sysarg_t fhc;
    559554        sysarg_t obio;
    560555       
    … …  
    562557        list_initialize(&mouse_devs);
    563558       
    564         if (((sysinfo_get_value("kbd.cir.fhc", &fhc) == EOK) && (fhc))
    565             || ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio)))
     559        if ((sysinfo_get_value("kbd.cir.obio", &obio) == EOK) && (obio))
    566560                irc_service = true;
    567561       

  • uspace/srv/hid/input/include/kbd_port.h

    r15f3c3f r86ffa27f  
    5656extern kbd_port_ops_t ns16550_port;
    5757extern kbd_port_ops_t pl050_port;
    58 extern kbd_port_ops_t sgcn_port;
    5958extern kbd_port_ops_t ski_port;
    60 extern kbd_port_ops_t z8530_port;
    6159
    6260#endif

  • uspace/srv/hid/input/port/niagara.c

    r15f3c3f r86ffa27f  
    154154
    155155/**
    156  * Thread to poll SGCN for keypresses.
     156 * Thread to poll Niagara console for keypresses.
    157157 */
    158158static void niagara_thread_impl(void *arg)

  • uspace/srv/hw/irc/apic/apic.c

    r15f3c3f r86ffa27f  
    4242#include <as.h>
    4343#include <ddi.h>
    44 #include <libarch/ddi.h>
    45 #include <align.h>
    4644#include <bool.h>
    4745#include <errno.h>
    4846#include <async.h>
    49 #include <align.h>
    50 #include <async.h>
    51 #include <stdio.h>
    52 #include <ipc/loc.h>
    5347
    5448#define NAME  "apic"
    5549
     50#define APIC_MAX_IRQ    15
     51
     52#define IOREGSEL  (0x00U / sizeof(uint32_t))
     53#define IOWIN     (0x10U / sizeof(uint32_t))
     54
     55#define IOREDTBL   0x10U
     56
     57/** I/O Register Select Register. */
     58typedef union {
     59        uint32_t value;
     60        struct {
     61                uint8_t reg_addr;       /**< APIC Register Address. */
     62                unsigned int : 24;      /**< Reserved. */
     63        } __attribute__ ((packed));
     64} io_regsel_t;
     65
     66/** I/O Redirection Register. */
     67typedef struct io_redirection_reg {
     68        union {
     69                uint32_t lo;
     70                struct {
     71                        uint8_t intvec;                 /**< Interrupt Vector. */
     72                        unsigned int delmod : 3;        /**< Delivery Mode. */
     73                        unsigned int destmod : 1;       /**< Destination mode. */
     74                        unsigned int delivs : 1;        /**< Delivery status (RO). */
     75                        unsigned int intpol : 1;        /**< Interrupt Input Pin Polarity. */
     76                        unsigned int irr : 1;           /**< Remote IRR (RO). */
     77                        unsigned int trigger_mode : 1;  /**< Trigger Mode. */
     78                        unsigned int masked : 1;        /**< Interrupt Mask. */
     79                        unsigned int : 15;              /**< Reserved. */
     80                } __attribute__ ((packed));
     81        };
     82        union {
     83                uint32_t hi;
     84                struct {
     85                        unsigned int : 24;      /**< Reserved. */
     86                        uint8_t dest : 8;       /**< Destination Field. */
     87                } __attribute__ ((packed));
     88        };
     89} __attribute__ ((packed)) io_redirection_reg_t;
     90
     91// FIXME: get the address from the kernel
     92#define IO_APIC_BASE    0xfec00000UL
     93#define IO_APIC_SIZE    20
     94
     95ioport32_t *io_apic = NULL;
     96
     97/** Read from IO APIC register.
     98 *
     99 * @param address IO APIC register address.
     100 *
     101 * @return Content of the addressed IO APIC register.
     102 *
     103 */
     104static uint32_t io_apic_read(uint8_t address)
     105{
     106        io_regsel_t regsel;
     107
     108        regsel.value = io_apic[IOREGSEL];
     109        regsel.reg_addr = address;
     110        io_apic[IOREGSEL] = regsel.value;
     111        return io_apic[IOWIN];
     112}
     113
     114/** Write to IO APIC register.
     115 *
     116 * @param address IO APIC register address.
     117 * @param val     Content to be written to the addressed IO APIC register.
     118 *
     119 */
     120static void io_apic_write(uint8_t address, uint32_t val)
     121{
     122        io_regsel_t regsel;
     123
     124        regsel.value = io_apic[IOREGSEL];
     125        regsel.reg_addr = address;
     126        io_apic[IOREGSEL] = regsel.value;
     127        io_apic[IOWIN] = val;
     128}
     129
     130static int irq_to_pin(int irq)
     131{
     132        // FIXME: get the map from the kernel, even though this may work
     133        //        for simple cases
     134        return irq;
     135}
     136
    56137static int apic_enable_irq(sysarg_t irq)
    57138{
    58         // FIXME: TODO
    59         return ENOTSUP;
     139        io_redirection_reg_t reg;
     140
     141        if (irq > APIC_MAX_IRQ)
     142                return ELIMIT;
     143
     144        int pin = irq_to_pin(irq);
     145        if (pin == -1)
     146                return ENOENT;
     147
     148        reg.lo = io_apic_read((uint8_t) (IOREDTBL + pin * 2));
     149        reg.masked = false;
     150        io_apic_write((uint8_t) (IOREDTBL + pin * 2), reg.lo);
     151
     152        return EOK;
    60153}
    61154
    … …  
    111204                return false;
    112205        }
     206
     207        if (pio_enable((void *) IO_APIC_BASE, IO_APIC_SIZE,
     208            (void **) &io_apic) != EOK)
     209                return false;   
    113210       
    114211        async_set_client_connection(apic_connection);

  • uspace/srv/hw/netif/ne2000/ne2000.c

    r15f3c3f r86ffa27f  
    404404{
    405405        /* Start the module */
    406         return netif_module_start(SERVICE_ETHERNET);
     406        return netif_module_start();
    407407}
    408408

  • uspace/srv/loader/Makefile

    r15f3c3f r86ffa27f  
    3939LINKER_SCRIPT = $(LIBC_PREFIX)/arch/$(UARCH)/_link-loader.ld
    4040
    41 EXTRA_CFLAGS = -Iinclude
    42 
    4341BINARY = loader
    4442STATIC_ONLY = y
    … …  
    4644GENERIC_SOURCES = \
    4745        main.c \
    48         elf_load.c \
    4946        interp.s
    5047

  • uspace/srv/loader/main.c

    r15f3c3f r86ffa27f  
    5959#include <str.h>
    6060#include <as.h>
    61 #include <elf.h>
    62 #include <elf_load.h>
     61#include <elf/elf.h>
     62#include <elf/elf_load.h>
    6363
    6464#ifdef CONFIG_RTLD
    … …  
    348348
    349349        /* Initialize list of loaded modules */
    350         list_initialize(&runtime_env->modules_head);
    351         list_append(&prog_mod.modules_link, &runtime_env->modules_head);
     350        list_initialize(&runtime_env->modules);
     351        list_append(&prog_mod.modules_link, &runtime_env->modules);
    352352
    353353        /* Pointer to program module. Used as root of the module graph. */

  • uspace/srv/net/net/net.c

    r15f3c3f r86ffa27f  
    479479       
    480480        /* Network interface layer startup */
     481        services_t internet_service;
    481482        if (netif->nil) {
    482483                setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_MTU, 0);
    … …  
    486487               
    487488                int mtu = setting ? strtol((char *) setting->value, NULL, 10) : 0;
    488                
    489                 rc = nil_device_req(netif->nil->sess, netif->id, mtu);
     489                rc = nil_device_req(netif->nil->sess, netif->id, mtu,
     490                    netif->driver->service);
    490491                if (rc != EOK)
    491492                        return rc;
    492         }
     493               
     494                internet_service = netif->nil->service;
     495        } else
     496                internet_service = netif->driver->service;
    493497       
    494498        /* Inter-network layer startup */
    495         rc = ip_device_req(netif->il->sess, netif->id);
     499        rc = ip_device_req(netif->il->sess, netif->id, internet_service);
    496500        if (rc != EOK)
    497501                return rc;

  • uspace/srv/net/netif/lo/lo.c

    r15f3c3f r86ffa27f  
    225225{
    226226        /* Start the module */
    227         return netif_module_start(SERVICE_NILDUMMY);
     227        return netif_module_start();
    228228}
    229229

  • uspace/srv/vfs/vfs_ops.c

    r15f3c3f r86ffa27f  
    7676        vfs_node_t *mr_node;
    7777        fs_index_t rindex;
    78         size_t rsize;
     78        aoff64_t rsize;
    7979        unsigned rlnkcnt;
    8080        async_exch_t *exch;
    … …  
    146146
    147147                        rindex = (fs_index_t) IPC_GET_ARG1(answer);
    148                         rsize = (size_t) IPC_GET_ARG2(answer);
    149                         rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
     148                        rsize = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
     149                        rlnkcnt = (unsigned) IPC_GET_ARG4(answer);
    150150                       
    151151                        mr_res.triplet.fs_handle = fs_handle;
    … …  
    229229        if (rc == EOK) {
    230230                rindex = (fs_index_t) IPC_GET_ARG1(answer);
    231                 rsize = (size_t) IPC_GET_ARG2(answer);
    232                 rlnkcnt = (unsigned) IPC_GET_ARG3(answer);
     231                rsize = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(answer),
     232                    IPC_GET_ARG3(answer));
     233                rlnkcnt = (unsigned) IPC_GET_ARG4(answer);
    233234               
    234235                mr_res.triplet.fs_handle = fs_handle;
    … …  
    795796        ipc_call_t answer;
    796797        if (read) {
    797                 rc = async_data_read_forward_3_1(fs_exch, VFS_OUT_READ,
    798                     file->node->service_id, file->node->index, file->pos,
    799                     &answer);
     798                rc = async_data_read_forward_4_1(fs_exch, VFS_OUT_READ,
     799                    file->node->service_id, file->node->index,
     800                    LOWER32(file->pos), UPPER32(file->pos), &answer);
    800801        } else {
    801802                if (file->append)
    802803                        file->pos = file->node->size;
    803804               
    804                 rc = async_data_write_forward_3_1(fs_exch, VFS_OUT_WRITE,
    805                     file->node->service_id, file->node->index, file->pos,
    806                     &answer);
     805                rc = async_data_write_forward_4_1(fs_exch, VFS_OUT_WRITE,
     806                    file->node->service_id, file->node->index,
     807                    LOWER32(file->pos), UPPER32(file->pos), &answer);
    807808        }
    808809       
    … …  
    821822                /* Update the cached version of node's size. */
    822823                if (rc == EOK)
    823                         file->node->size = IPC_GET_ARG2(answer);
     824                        file->node->size = MERGE_LOUP32(IPC_GET_ARG2(answer),
     825                            IPC_GET_ARG3(answer));
    824826                fibril_rwlock_write_unlock(&file->node->contents_rwlock);
    825827        }
Note: See TracChangeset for help on using the changeset viewer.