Changeset 49ff5f3 in mainline for uspace/srv


Ignore:
Timestamp:
2012-04-18T20:55:21Z (14 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7769ec9
Parents:
e895352 (diff), 63920b0 (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:
72 added
24 deleted
42 edited
13 moved

Legend:

Unmodified
Added
Removed

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

    re895352 r49ff5f3  
    245245        void *vaddr;
    246246        int rc;
    247 
    248         rc = loc_server_register(NAME, ata_bd_connection);
     247       
     248        async_set_client_connection(ata_bd_connection);
     249        rc = loc_server_register(NAME);
    249250        if (rc < 0) {
    250251                printf(NAME ": Unable to register driver.\n");
    … …  
    309310        }
    310311
    311         fs_va = as_get_mappable_page(comm_size);
    312         if (fs_va == NULL) {
     312        (void) async_share_out_finalize(callid, &fs_va);
     313        if (fs_va == (void *) -1) {
    313314                async_answer_0(callid, EHANGUP);
    314315                return;
    315316        }
    316 
    317         (void) async_share_out_finalize(callid, fs_va);
    318317
    319318        while (true) {

  • uspace/srv/bd/file_bd/file_bd.c

    re895352 r49ff5f3  
    141141        int rc;
    142142        long img_size;
    143 
    144         rc = loc_server_register(NAME, file_bd_connection);
     143       
     144        async_set_client_connection(file_bd_connection);
     145        rc = loc_server_register(NAME);
    145146        if (rc < 0) {
    146147                printf(NAME ": Unable to register driver.\n");
    … …  
    190191        }
    191192
    192         fs_va = as_get_mappable_page(comm_size);
    193         if (fs_va == NULL) {
     193        (void) async_share_out_finalize(callid, &fs_va);
     194        if (fs_va == (void *) -1) {
    194195                async_answer_0(callid, EHANGUP);
    195196                return;
    196197        }
    197 
    198         (void) async_share_out_finalize(callid, fs_va);
    199198
    200199        while (true) {

  • uspace/srv/bd/gxe_bd/gxe_bd.c

    re895352 r49ff5f3  
    125125        int rc, i;
    126126        char name[16];
    127 
    128         rc = loc_server_register(NAME, gxe_bd_connection);
     127       
     128        async_set_client_connection(gxe_bd_connection);
     129        rc = loc_server_register(NAME);
    129130        if (rc < 0) {
    130131                printf(NAME ": Unable to register driver.\n");
    … …  
    193194        }
    194195
    195         fs_va = as_get_mappable_page(comm_size);
    196         if (fs_va == NULL) {
     196        (void) async_share_out_finalize(callid, &fs_va);
     197        if (fs_va == (void *) -1) {
    197198                async_answer_0(callid, EHANGUP);
    198199                return;
    199200        }
    200 
    201         (void) async_share_out_finalize(callid, fs_va);
    202201
    203202        while (true) {

  • uspace/srv/bd/part/guid_part/guid_part.c

    re895352 r49ff5f3  
    164164
    165165        /* Register server with location service. */
    166         rc = loc_server_register(NAME, gpt_connection);
     166        async_set_client_connection(gpt_connection);
     167        rc = loc_server_register(NAME);
    167168        if (rc != EOK) {
    168169                printf(NAME ": Unable to register server.\n");
    … …  
    348349        }
    349350
    350         fs_va = as_get_mappable_page(comm_size);
    351         if (fs_va == NULL) {
     351        (void) async_share_out_finalize(callid, &fs_va);
     352        if (fs_va == (void *) -1) {
    352353                async_answer_0(callid, EHANGUP);
    353354                return;
    354355        }
    355 
    356         (void) async_share_out_finalize(callid, fs_va);
    357356
    358357        while (true) {

  • uspace/srv/bd/part/mbr_part/mbr_part.c

    re895352 r49ff5f3  
    214214
    215215        /* Register server with location service. */
    216         rc = loc_server_register(NAME, mbr_connection);
     216        async_set_client_connection(mbr_connection);
     217        rc = loc_server_register(NAME);
    217218        if (rc != EOK) {
    218219                printf(NAME ": Unable to register server.\n");
    … …  
    425426        }
    426427
    427         fs_va = as_get_mappable_page(comm_size);
    428         if (fs_va == NULL) {
     428        (void) async_share_out_finalize(callid, &fs_va);
     429        if (fs_va == (void *) -1) {
    429430                async_answer_0(callid, EHANGUP);
    430431                return;
    431432        }
    432 
    433         (void) async_share_out_finalize(callid, fs_va);
    434433
    435434        while (1) {

  • uspace/srv/bd/rd/rd.c

    re895352 r49ff5f3  
    5555#include <ipc/bd.h>
    5656#include <macros.h>
    57 
    58 #define NAME "rd"
     57#include <inttypes.h>
     58
     59#define NAME  "rd"
    5960
    6061/** Pointer to the ramdisk's image */
    … …  
    104105        unsigned int flags;
    105106        if (async_share_out_receive(&callid, &comm_size, &flags)) {
    106                 fs_va = as_get_mappable_page(comm_size);
    107                 if (fs_va) {
    108                         (void) async_share_out_finalize(callid, fs_va);
    109                 } else {
     107                (void) async_share_out_finalize(callid, &fs_va);
     108                if (fs_va == (void *) -1) {
    110109                        async_answer_0(callid, EHANGUP);
    111110                        return;
    … …  
    208207static bool rd_init(void)
    209208{
    210         int ret = sysinfo_get_value("rd.size", &rd_size);
    211         if ((ret != EOK) || (rd_size == 0)) {
     209        sysarg_t size;
     210        int ret = sysinfo_get_value("rd.size", &size);
     211        if ((ret != EOK) || (size == 0)) {
    212212                printf("%s: No RAM disk found\n", NAME);
    213213                return false;
    214214        }
    215215       
    216         sysarg_t rd_ph_addr;
    217         ret = sysinfo_get_value("rd.address.physical", &rd_ph_addr);
    218         if ((ret != EOK) || (rd_ph_addr == 0)) {
     216        sysarg_t addr_phys;
     217        ret = sysinfo_get_value("rd.address.physical", &addr_phys);
     218        if ((ret != EOK) || (addr_phys == 0)) {
    219219                printf("%s: Invalid RAM disk physical address\n", NAME);
    220220                return false;
    221221        }
    222222       
    223         rd_addr = as_get_mappable_page(rd_size);
    224        
    225         int flags = AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
    226         int retval = physmem_map((void *) rd_ph_addr, rd_addr,
    227             ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags);
    228        
    229         if (retval < 0) {
     223        rd_size = ALIGN_UP(size, block_size);
     224        unsigned int flags =
     225            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE;
     226       
     227        ret = physmem_map((void *) addr_phys,
     228            ALIGN_UP(rd_size, PAGE_SIZE) >> PAGE_WIDTH, flags, &rd_addr);
     229        if (ret != EOK) {
    230230                printf("%s: Error mapping RAM disk\n", NAME);
    231231                return false;
    232232        }
    233233       
    234         printf("%s: Found RAM disk at %p, %zu bytes\n", NAME,
    235             (void *) rd_ph_addr, rd_size);
    236        
    237         int rc = loc_server_register(NAME, rd_connection);
    238         if (rc < 0) {
    239                 printf("%s: Unable to register driver (%d)\n", NAME, rc);
     234        printf("%s: Found RAM disk at %p, %" PRIun " bytes\n", NAME,
     235            (void *) addr_phys, size);
     236       
     237        async_set_client_connection(rd_connection);
     238        ret = loc_server_register(NAME);
     239        if (ret < 0) {
     240                printf("%s: Unable to register driver (%d)\n", NAME, ret);
    240241                return false;
    241242        }
    242243       
    243244        service_id_t service_id;
    244         if (loc_service_register("bd/initrd", &service_id) != EOK) {
     245        ret = loc_service_register("bd/initrd", &service_id);
     246        if (ret != EOK) {
    245247                printf("%s: Unable to register device service\n", NAME);
    246248                return false;

  • uspace/srv/devman/devman.c

    re895352 r49ff5f3  
    794794        case EOK:
    795795                dev->state = DEVICE_USABLE;
    796                 exch = async_exchange_begin(drv->sess);
    797                 async_msg_1(exch, DRIVER_DEV_ADDED, dev->handle);
    798                 async_exchange_end(exch);
    799796                break;
    800797        case ENOENT:
    … …  
    803800        default:
    804801                dev->state = DEVICE_INVALID;
     802                break;
    805803        }
    806804       

  • uspace/srv/devman/main.c

    re895352 r49ff5f3  
    13091309
    13101310        /*
    1311          * !!! devman_connection ... as the device manager is not a real loc
    1312          * driver (it uses a completely different ipc protocol than an ordinary
    1313          * loc driver) forwarding a connection from client to the devman by
    1314          * location service would not work.
     1311         * Caution: As the device manager is not a real loc
     1312         * driver (it uses a completely different IPC protocol
     1313         * than an ordinary loc driver), forwarding a connection
     1314         * from client to the devman by location service will
     1315         * not work.
    13151316         */
    1316         loc_server_register(NAME, devman_connection);
     1317        loc_server_register(NAME);
    13171318       
    13181319        return true;
    … …  
    13251326        if (log_init(NAME, LVL_WARN) != EOK) {
    13261327                printf(NAME ": Error initializing logging subsystem.\n");
    1327                 return -1;
    1328         }
    1329 
    1330         if (!devman_init()) {
    1331                 log_msg(LVL_ERROR, "Error while initializing service.");
    13321328                return -1;
    13331329        }
    … …  
    13381334        async_set_client_connection(devman_connection);
    13391335
     1336        if (!devman_init()) {
     1337                log_msg(LVL_ERROR, "Error while initializing service.");
     1338                return -1;
     1339        }
     1340
    13401341        /* Register device manager at naming service. */
    13411342        if (service_register(SERVICE_DEVMAN) != EOK) {

  • uspace/srv/fs/exfat/exfat_bitmap.c

    re895352 r49ff5f3  
    4545#include <assert.h>
    4646#include <fibril_synch.h>
    47 #include <malloc.h>
    4847#include <mem.h>
    4948
    5049
    51 int bitmap_is_free(exfat_bs_t *bs, service_id_t service_id,
     50int exfat_bitmap_is_free(exfat_bs_t *bs, service_id_t service_id,
    5251    exfat_cluster_t clst)
    5352{
    … …  
    9089}
    9190
    92 int bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id,
     91int exfat_bitmap_set_cluster(exfat_bs_t *bs, service_id_t service_id,
    9392    exfat_cluster_t clst)
    9493{
    … …  
    125124}
    126125
    127 int bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id,
     126int exfat_bitmap_clear_cluster(exfat_bs_t *bs, service_id_t service_id,
    128127    exfat_cluster_t clst)
    129128{
    … …  
    161160}
    162161
    163 int bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id,
     162int exfat_bitmap_set_clusters(exfat_bs_t *bs, service_id_t service_id,
    164163    exfat_cluster_t firstc, exfat_cluster_t count)
    165164{
    … …  
    169168
    170169        while (clst < firstc + count ) {
    171                 rc = bitmap_set_cluster(bs, service_id, clst);
     170                rc = exfat_bitmap_set_cluster(bs, service_id, clst);
    172171                if (rc != EOK) {
    173172                        if (clst - firstc > 0)
    174                                 (void) bitmap_clear_clusters(bs, service_id,
     173                                (void) exfat_bitmap_clear_clusters(bs, service_id,
    175174                                    firstc, clst - firstc);
    176175                        return rc;
    … …  
    181180}
    182181
    183 int bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id,
     182int exfat_bitmap_clear_clusters(exfat_bs_t *bs, service_id_t service_id,
    184183    exfat_cluster_t firstc, exfat_cluster_t count)
    185184{
    … …  
    189188
    190189        while (clst < firstc + count) {
    191                 rc = bitmap_clear_cluster(bs, service_id, clst);
     190                rc = exfat_bitmap_clear_cluster(bs, service_id, clst);
    192191                if (rc != EOK)
    193192                        return rc;
    … …  
    197196}
    198197
    199 int bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id,
     198int exfat_bitmap_alloc_clusters(exfat_bs_t *bs, service_id_t service_id,
    200199    exfat_cluster_t *firstc, exfat_cluster_t count)
    201200{
    … …  
    205204        while (startc < DATA_CNT(bs) + 2) {
    206205                endc = startc;
    207                 while (bitmap_is_free(bs, service_id, endc) == EOK) {
     206                while (exfat_bitmap_is_free(bs, service_id, endc) == EOK) {
    208207                        if ((endc - startc) + 1 == count) {
    209208                                *firstc = startc;
    210                                 return bitmap_set_clusters(bs, service_id, startc, count);
     209                                return exfat_bitmap_set_clusters(bs, service_id, startc, count);
    211210                        } else
    212211                                endc++;
    … …  
    218217
    219218
    220 int bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
     219int exfat_bitmap_append_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
    221220    exfat_cluster_t count)
    222221{
    223222        if (nodep->firstc == 0) {
    224                 return bitmap_alloc_clusters(bs, nodep->idx->service_id,
     223                return exfat_bitmap_alloc_clusters(bs, nodep->idx->service_id,
    225224                    &nodep->firstc, count);
    226225        } else {
    … …  
    229228
    230229                clst = lastc + 1;
    231                 while (bitmap_is_free(bs, nodep->idx->service_id, clst) == EOK) {
     230                while (exfat_bitmap_is_free(bs, nodep->idx->service_id, clst) == EOK) {
    232231                        if (clst - lastc == count){
    233                                 return bitmap_set_clusters(bs, nodep->idx->service_id,
     232                                return exfat_bitmap_set_clusters(bs, nodep->idx->service_id,
    234233                                    lastc + 1, count);
    235234                        } else
    … …  
    241240
    242241
    243 int bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
     242int exfat_bitmap_free_clusters(exfat_bs_t *bs, exfat_node_t *nodep,
    244243    exfat_cluster_t count)
    245244{
    … …  
    248247        lastc -= count;
    249248
    250         return bitmap_clear_clusters(bs, nodep->idx->service_id, lastc + 1, count);
    251 }
    252 
    253 
    254 int bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
     249        return exfat_bitmap_clear_clusters(bs, nodep->idx->service_id, lastc + 1, count);
     250}
     251
     252
     253int exfat_bitmap_replicate_clusters(exfat_bs_t *bs, exfat_node_t *nodep)
    255254{
    256255        int rc;

  • uspace/srv/fs/exfat/exfat_bitmap.h

    re895352 r49ff5f3  
    4242struct exfat_bs;
    4343
    44 extern int bitmap_alloc_clusters(struct exfat_bs *, service_id_t,
     44extern int exfat_bitmap_alloc_clusters(struct exfat_bs *, service_id_t,
    4545    exfat_cluster_t *, exfat_cluster_t);
    46 extern int bitmap_append_clusters(struct exfat_bs *, struct exfat_node *,
     46extern int exfat_bitmap_append_clusters(struct exfat_bs *, struct exfat_node *,
    4747    exfat_cluster_t);
    48 extern int bitmap_free_clusters(struct exfat_bs *, struct exfat_node *,
     48extern int exfat_bitmap_free_clusters(struct exfat_bs *, struct exfat_node *,
    4949    exfat_cluster_t);
    50 extern int bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *);
     50extern int exfat_bitmap_replicate_clusters(struct exfat_bs *, struct exfat_node *);
    5151
    52 extern int bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
    53 extern int bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
    54 extern int bitmap_clear_cluster(struct exfat_bs *, service_id_t,
     52extern int exfat_bitmap_is_free(struct exfat_bs *, service_id_t, exfat_cluster_t);
     53extern int exfat_bitmap_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t);
     54extern int exfat_bitmap_clear_cluster(struct exfat_bs *, service_id_t,
    5555    exfat_cluster_t);
    5656
    57 extern int bitmap_set_clusters(struct exfat_bs *, service_id_t,
     57extern int exfat_bitmap_set_clusters(struct exfat_bs *, service_id_t,
    5858    exfat_cluster_t, exfat_cluster_t);
    59 extern int bitmap_clear_clusters(struct exfat_bs *, service_id_t,
     59extern int exfat_bitmap_clear_clusters(struct exfat_bs *, service_id_t,
    6060    exfat_cluster_t, exfat_cluster_t);
    6161

  • uspace/srv/fs/exfat/exfat_dentry.c

    re895352 r49ff5f3  
    101101bool exfat_valid_char(wchar_t ch)
    102102{
    103         /* TODO */
    104         return true;
     103        switch (ch) {
     104        case 0x01 ... 0x1F:
     105        case '/':
     106        case '\\':
     107        case '?':
     108        case '|':
     109        case '>':
     110        case '<':
     111        case '"':
     112        case '*':
     113        case ':':
     114                return false;
     115        default:
     116                return true;
     117        }
    105118}
    106119
    107120bool exfat_valid_name(const char *name)
    108121{
    109         /* TODO */
     122        size_t off = 0;
     123        wchar_t ch;
     124
     125        while ((ch = str_decode(name, &off, STR_NO_LIMIT)) != 0) {
     126                if (!exfat_valid_char(ch))
     127                        return false;
     128        }
    110129        return true;
    111130}
    112131
    113 size_t utf16_length(const uint16_t *wstr)
     132size_t exfat_utf16_length(const uint16_t *wstr)
    114133{
    115134        size_t len = 0;

  • uspace/srv/fs/exfat/exfat_dentry.h

    re895352 r49ff5f3  
    160160extern bool exfat_valid_name(const char *);
    161161
    162 extern size_t utf16_length(const uint16_t *);
     162extern size_t exfat_utf16_length(const uint16_t *);
    163163
    164164

  • uspace/srv/fs/exfat/exfat_directory.c

    re895352 r49ff5f3  
    9292        int rc = EOK;
    9393       
    94         if (di->b)
     94        if (di->b) {
    9595                rc = block_put(di->b);
     96                di->b = NULL;
     97        }
    9698       
    9799        return rc;
    … …  
    101103{
    102104        uint32_t i;
    103         int rc;
     105        int rc = EOK;
    104106
    105107        i = (di->pos * sizeof(exfat_dentry_t)) / BPS(di->bs);
    … …  
    108110
    109111        if (di->b && di->bnum != i) {
    110                 block_put(di->b);
     112                rc = block_put(di->b);
    111113                di->b = NULL;
     114                if (rc != EOK)
     115                        return rc;
    112116        }
    113117        if (!di->b) {
    … …  
    126130                di->bnum = i;
    127131        }
    128         return EOK;
     132        return rc;
    129133}
    130134
    … …  
    264268                if (idx == 2 || idx == 3)
    265269                        continue;
    266                 checksum = ((checksum << 15) | (checksum >> 1)) + (uint16_t)bytes[idx];
     270                checksum = ((checksum << 15) | (checksum >> 1)) +
     271                    (uint16_t)bytes[idx];
    267272        }
    268273        return checksum;
    … …  
    285290        for (i = 0; i < count; i++) {
    286291                rc = exfat_directory_get(di, &de);
    287                 if (rc != EOK)
    288                         return rc;
     292                if (rc != EOK) {
     293                        free(array);
     294                        return rc;
     295                }
    289296                array[i] = *de;
    290297                rc = exfat_directory_next(di);
    … …  
    306313        array[1].stream.valid_data_size = host2uint64_t_le(ds->valid_data_size);
    307314        array[1].stream.data_size = host2uint64_t_le(ds->data_size);
    308         array[0].file.checksum = host2uint16_t_le(exfat_directory_set_checksum((uint8_t *)array,
     315        array[0].file.checksum =
     316            host2uint16_t_le(exfat_directory_set_checksum((uint8_t *)array,
    309317            count * sizeof(exfat_dentry_t)));
    310318
    … …  
    312320        for (i = 0; i < count; i++) {
    313321                rc = exfat_directory_get(di, &de);
    314                 if (rc != EOK)
    315                         return rc;
     322                if (rc != EOK) {
     323                        free(array);
     324                        return rc;
     325                }
    316326                *de = array[i];
    317327                di->b->dirty = true;
    … …  
    346356        uctablep = EXFAT_NODE(fn);
    347357
    348         uctable_chars = ALIGN_DOWN(uctablep->size, sizeof(uint16_t)) / sizeof(uint16_t);
     358        uctable_chars = ALIGN_DOWN(uctablep->size,
     359            sizeof(uint16_t)) / sizeof(uint16_t);
    349360        uctable = (uint16_t *) malloc(uctable_chars * sizeof(uint16_t));
    350361        rc = exfat_read_uctable(di->bs, uctablep, (uint8_t *)uctable);
    … …  
    360371        ds.stream.valid_data_size = 0;
    361372        ds.stream.data_size = 0;
    362         ds.stream.name_size = utf16_length(wname);
     373        ds.stream.name_size = exfat_utf16_length(wname);
    363374        ds.stream.hash = host2uint16_t_le(exfat_name_hash(wname, uctable,
    364375            uctable_chars));
    … …  
    411422                        return rc;
    412423
    413                 if (i == df.file.count - 2)
    414                         chars = ds.stream.name_size - EXFAT_NAME_PART_LEN*(df.file.count - 2);
     424                if (i == df.file.count - 2) {
     425                        chars = ds.stream.name_size -
     426                            EXFAT_NAME_PART_LEN*(df.file.count - 2);
     427                }
     428
    415429                rc = exfat_directory_get(di, &de);
    416430                if (rc != EOK)
    … …  
    424438
    425439                di->b->dirty = true;
    426                 sname += chars;
    427440        }
    428441       
    … …  
    434447        int rc, count;
    435448        exfat_dentry_t *de;
     449
     450        di->pos = pos;
    436451
    437452        rc = exfat_directory_get(di, &de);

  • uspace/srv/fs/exfat/exfat_fat.c

    re895352 r49ff5f3  
    5050#include <malloc.h>
    5151#include <mem.h>
     52#include <str.h>
    5253
    5354
    … …  
    126127{
    127128        exfat_cluster_t firstc = nodep->firstc;
    128         exfat_cluster_t currc;
     129        exfat_cluster_t currc = 0;
    129130        aoff64_t relbn = bn;
    130131        int rc;
    … …  
    313314            clst++) {
    314315                /* Need to rewrite because of multiple exfat_bitmap_get calls */
    315                 if (bitmap_is_free(bs, service_id, clst) == EOK) {
     316                if (exfat_bitmap_is_free(bs, service_id, clst) == EOK) {
    316317                        /*
    317318                         * The cluster is free. Put it into our stack
    … …  
    322323                            (found == 0) ?  EXFAT_CLST_EOF : lifo[found - 1]);
    323324                        if (rc != EOK)
    324                                 break;
     325                                goto exit_error;
    325326                        found++;
    326                         rc = bitmap_set_cluster(bs, service_id, clst);
     327                        rc = exfat_bitmap_set_cluster(bs, service_id, clst);
    327328                        if (rc != EOK)
    328                                 break;
     329                                goto exit_error;
    329330
    330331                }
    … …  
    339340        }
    340341
     342        rc = ENOSPC;
     343
     344exit_error:
     345
    341346        /* If something wrong - free the clusters */
    342347        while (found--) {
    343                 (void) bitmap_clear_cluster(bs, service_id, lifo[found]);
     348                (void) exfat_bitmap_clear_cluster(bs, service_id, lifo[found]);
    344349                (void) exfat_set_cluster(bs, service_id, lifo[found], 0);
    345350        }
    … …  
    347352        free(lifo);
    348353        fibril_mutex_unlock(&exfat_alloc_lock);
    349         return ENOSPC;
     354        return rc;
    350355}
    351356
    … …  
    373378                if (rc != EOK)
    374379                        return rc;
    375                 rc = bitmap_clear_cluster(bs, service_id, firstc);
     380                rc = exfat_bitmap_clear_cluster(bs, service_id, firstc);
    376381                if (rc != EOK)
    377382                        return rc;
    … …  
    537542int exfat_sanity_check(exfat_bs_t *bs, service_id_t service_id)
    538543{
    539         /* TODO */
     544        if (str_cmp((char const *)bs->oem_name, "EXFAT   "))
     545                return ENOTSUP;
     546        else if (uint16_t_le2host(bs->signature) != 0xAA55)
     547                return ENOTSUP;
     548        else if (uint32_t_le2host(bs->fat_sector_count) == 0)
     549                return ENOTSUP;
     550        else if (uint32_t_le2host(bs->data_clusters) == 0)
     551                return ENOTSUP;
     552        else if (bs->fat_count != 1)
     553                return ENOTSUP;
     554        else if ((bs->bytes_per_sector + bs->sec_per_cluster) > 25) {
     555                /* exFAT does not support cluster size > 32 Mb */
     556                return ENOTSUP;
     557        }
    540558        return EOK;
    541559}

  • uspace/srv/fs/exfat/exfat_ops.c

    re895352 r49ff5f3  
    405405
    406406        if (!nodep->fragmented) {
    407                 rc = bitmap_append_clusters(bs, nodep, clusters);
     407                rc = exfat_bitmap_append_clusters(bs, nodep, clusters);
    408408                if (rc != ENOSPC)
    409409                        return rc;
    … …  
    411411                        nodep->fragmented = true;
    412412                        nodep->dirty = true;            /* need to sync node */
    413                         rc = bitmap_replicate_clusters(bs, nodep);
     413                        rc = exfat_bitmap_replicate_clusters(bs, nodep);
    414414                        if (rc != EOK)
    415415                                return rc;
    … …  
    457457
    458458                clsts = prev_clsts - new_clsts;
    459                 rc = bitmap_free_clusters(bs, nodep, clsts);
     459                rc = exfat_bitmap_free_clusters(bs, nodep, clsts);
    460460                if (rc != EOK)
    461461                        return rc;
    … …  
    657657                        return rc;
    658658                }
     659
     660                rc = exfat_zero_cluster(bs, service_id, nodep->firstc);
     661                if (rc != EOK) {
     662                        (void) exfat_node_put(FS_NODE(nodep));
     663                        return rc;
     664                }
     665
    659666                nodep->size = BPC(bs);
    660667        } else {
    … …  
    697704                                nodep->firstc);
    698705                else
    699                         rc = bitmap_free_clusters(bs, nodep,
     706                        rc = exfat_bitmap_free_clusters(bs, nodep,
    700707                            ROUND_UP(nodep->size, BPC(bs)) / BPC(bs));
    701708        }
    … …  
    739746         */
    740747        rc = exfat_directory_write_file(&di, name);
    741         if (rc != EOK)
    742                 return rc;
     748        if (rc != EOK) {
     749                (void) exfat_directory_close(&di);
     750                fibril_mutex_unlock(&parentp->idx->lock);
     751                return rc;
     752        }
    743753        rc = exfat_directory_close(&di);
    744         if (rc != EOK)
    745                 return rc;
     754        if (rc != EOK) {
     755                fibril_mutex_unlock(&parentp->idx->lock);
     756                return rc;
     757        }
    746758
    747759        fibril_mutex_unlock(&parentp->idx->lock);
    748         if (rc != EOK)
    749                 return rc;
    750 
    751760        fibril_mutex_lock(&childp->idx->lock);
    752 
    753761
    754762        childp->idx->pfc = parentp->firstc;
    … …  
    12581266                exfat_directory_t di;
    12591267                rc = exfat_directory_open(nodep, &di);
    1260                 if (rc != EOK) goto err;
     1268                if (rc != EOK)
     1269                        goto err;
     1270
    12611271                rc = exfat_directory_seek(&di, pos);
    12621272                if (rc != EOK) {
    … …  
    12681278                    &df, &ds);
    12691279                if (rc == EOK)
    1270                     goto hit;
    1271                 if (rc == ENOENT)
    1272                     goto miss;
     1280                        goto hit;
     1281                else if (rc == ENOENT)
     1282                        goto miss;
     1283
     1284                (void) exfat_directory_close(&di);
    12731285
    12741286err:
    … …  
    12791291miss:
    12801292                rc = exfat_directory_close(&di);
    1281                 if (rc!=EOK)
     1293                if (rc != EOK)
    12821294                        goto err;
    12831295                rc = exfat_node_put(fn);
    … …  
    13971409
    13981410        (void) async_data_write_finalize(callid,
    1399                 b->data + pos % BPS(bs), bytes);
     1411            b->data + pos % BPS(bs), bytes);
    14001412        b->dirty = true;                /* need to sync block */
    14011413        rc = block_put(b);
    … …  
    14471459        }
    14481460
    1449         (void) exfat_node_put(fn);
     1461        int rc2 = exfat_node_put(fn);
     1462        if (rc == EOK && rc2 != EOK)
     1463                rc = rc2;
     1464
    14501465        return rc;
    14511466}

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

    re895352 r49ff5f3  
    334334        while (i < count) {
    335335                if ((ch = str_decode(src, &off, STR_NO_LIMIT)) != 0) {
    336                         if (ascii_check(ch) & IS_D_CHAR(ch))
     336                        if (ascii_check(ch) && IS_D_CHAR(ch))
    337337                                *dst = toupper(ch);
    338338                        else

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

    re895352 r49ff5f3  
    162162        int rc;
    163163
     164        void *data;
     165        fat_instance_t *instance;
     166
     167        rc = fs_instance_get(di->nodep->idx->service_id, &data);
     168        assert(rc == EOK);
     169        instance = (fat_instance_t *) data;
     170       
    164171        do {
    165172                rc = fat_directory_get(di, &d);
    … …  
    177184                                long_entry_count--;
    178185                                if ((FAT_LFN_ORDER(d) == long_entry_count) &&
    179                                         (checksum == FAT_LFN_CHKSUM(d))) {
     186                                    (checksum == FAT_LFN_CHKSUM(d))) {
    180187                                        /* Right order! */
    181188                                        fat_lfn_get_entry(d, wname,
    … …  
    189196                                        long_entry = false;
    190197                                }
    191                         } else if (FAT_IS_LFN(d)) {
     198                        } else if (FAT_IS_LFN(d) && instance->lfn_enabled) {
    192199                                /* We found Last long entry! */
    193200                                if (FAT_LFN_COUNT(d) <= FAT_LFN_MAX_COUNT) {
    … …  
    308315                checksum = fat_dentry_chksum(de->name);
    309316
    310                 rc = fat_directory_seek(di, start_pos+long_entry_count);
     317                rc = fat_directory_seek(di, start_pos + long_entry_count);
    311318                if (rc != EOK)
    312319                        return rc;

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

    re895352 r49ff5f3  
    481481                                event->c = c;
    482482                               
    483                                 /* Kernel console does not read events
     483                                /*
     484                                 * Kernel console does not read events
    484485                                 * from us, so we will redirect them
    485486                                 * to the (last) active userspace console
    … …  
    487488                                 */
    488489                                console_t *target_console = cons_get_active_uspace();
    489 
     490                               
    490491                                prodcons_produce(&target_console->input_pc,
    491492                                    &event->link);
    … …  
    824825       
    825826        /* Register server */
    826         int rc = loc_server_register(NAME, client_connection);
     827        async_set_client_connection(client_connection);
     828        int rc = loc_server_register(NAME);
    827829        if (rc < 0) {
    828830                printf("%s: Unable to register server (%s)\n", NAME,

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

    re895352 r49ff5f3  
    304304        }
    305305       
    306         frontbuf->data = as_get_mappable_page(frontbuf->size);
    307         int rc = async_answer_1(callid, EOK, (sysarg_t) frontbuf->data);
    308         if (rc != EOK) {
     306        int rc = async_share_out_finalize(callid, &frontbuf->data);
     307        if ((rc != EOK) || (frontbuf->data == (void *) -1)) {
    309308                free(frontbuf);
    310309                async_answer_0(iid, ENOMEM);
    … …  
    348347        }
    349348       
    350         imagemap->data = as_get_mappable_page(imagemap->size);
    351         int rc = async_answer_1(callid, EOK, (sysarg_t) imagemap->data);
    352         if (rc != EOK) {
     349        int rc = async_share_out_finalize(callid, &imagemap->data);
     350        if ((rc != EOK) || (imagemap->data == (void *) -1)) {
    353351                free(imagemap);
    354352                async_answer_0(iid, ENOMEM);
    … …  
    989987       
    990988        /* Register server */
    991         int rc = loc_server_register(NAME, client_connection);
     989        async_set_client_connection(client_connection);
     990        int rc = loc_server_register(NAME);
    992991        if (rc != EOK) {
    993992                printf("%s: Unable to register driver (%d)\n", NAME, rc);

  • uspace/srv/hid/fb/port/ega.c

    re895352 r49ff5f3  
    117117        uint8_t glyph;
    118118       
    119         if ((field->ch >= 0) && (field->ch < 128))
     119        if (ascii_check(field->ch))
    120120                glyph = field->ch;
    121121        else
    … …  
    280280       
    281281        ega.size = (width * height) << 1;
    282         ega.addr = as_get_mappable_page(ega.size);
    283         if (ega.addr == NULL)
    284                 return ENOMEM;
    285        
    286         rc = physmem_map((void *) paddr, ega.addr,
    287             ALIGN_UP(ega.size, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
     282       
     283        rc = physmem_map((void *) paddr,
     284            ALIGN_UP(ega.size, PAGE_SIZE) >> PAGE_WIDTH,
     285            AS_AREA_READ | AS_AREA_WRITE, (void *) &ega.addr);
    288286        if (rc != EOK)
    289287                return rc;

  • uspace/srv/hid/fb/port/kchar.c

    re895352 r49ff5f3  
    4848static void kchar_putchar(wchar_t ch)
    4949{
    50         if ((ch >= 0) && (ch < 128))
     50        if (ascii_check(ch))
    5151                *kchar.addr = ch;
    5252        else
    … …  
    8383                return rc;
    8484       
    85         kchar.addr = as_get_mappable_page(1);
    86         if (kchar.addr == NULL)
    87                 return ENOMEM;
    88        
    89         rc = physmem_map((void *) paddr, kchar.addr,
    90             ALIGN_UP(1, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
     85        rc = physmem_map((void *) paddr,
     86            ALIGN_UP(1, PAGE_SIZE) >> PAGE_WIDTH,
     87            AS_AREA_READ | AS_AREA_WRITE, (void *) &kchar.addr);
    9188        if (rc != EOK)
    9289                return rc;

  • uspace/srv/hid/fb/port/kfb.c

    re895352 r49ff5f3  
    409409        charfield_t *field = screenbuffer_field_at(vp->backbuf, col, row);
    410410       
    411         pixel_t bgcolor;
    412         pixel_t fgcolor;
     411        pixel_t bgcolor = 0;
     412        pixel_t fgcolor = 0;
    413413        attrs_rgb(field->attrs, &bgcolor, &fgcolor);
    414414       
    … …  
    525525        }
    526526       
    527         pixel_t bgcolor;
    528         pixel_t fgcolor;
     527        pixel_t bgcolor = 0;
     528        pixel_t fgcolor = 0;
    529529        attrs_rgb(vp->attrs, &bgcolor, &fgcolor);
    530530       
    … …  
    756756       
    757757        kfb.size = scanline * height;
    758         kfb.addr = as_get_mappable_page(kfb.size);
    759         if (kfb.addr == NULL) {
    760                 free(kfb.glyphs);
    761                 return ENOMEM;
    762         }
    763        
    764         rc = physmem_map((void *) paddr + offset, kfb.addr,
    765             ALIGN_UP(kfb.size, PAGE_SIZE) >> PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
     758       
     759        rc = physmem_map((void *) paddr + offset,
     760            ALIGN_UP(kfb.size, PAGE_SIZE) >> PAGE_WIDTH,
     761            AS_AREA_READ | AS_AREA_WRITE, (void *) &kfb.addr);
    766762        if (rc != EOK) {
    767763                free(kfb.glyphs);

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

    re895352 r49ff5f3  
    6868static void niagara_putchar(wchar_t ch)
    6969{
    70         if ((ch >= 0) && (ch < 128))
     70        if (ascii_check(ch))
    7171                niagara_putc(ch);
    7272        else
    … …  
    103103                return rc;
    104104       
    105         niagara.fifo =
    106             (output_fifo_t *) as_get_mappable_page(sizeof(output_fifo_t));
    107         if (niagara.fifo == NULL)
    108                 return ENOMEM;
    109        
    110         rc = physmem_map((void *) paddr, (void *) niagara.fifo, 1,
    111             AS_AREA_READ | AS_AREA_WRITE);
     105        rc = physmem_map((void *) paddr, 1,
     106            AS_AREA_READ | AS_AREA_WRITE, (void *) &niagara.fifo);
    112107        if (rc != EOK)
    113108                return rc;

  • uspace/srv/hid/input/Makefile

    re895352 r49ff5f3  
    4343        port/adb_mouse.c \
    4444        port/chardev.c \
    45         port/chardev_mouse.c \
    4645        port/gxemul.c \
    4746        port/msim.c \
    … …  
    5251        proto/adb.c \
    5352        proto/mousedev.c \
    54         proto/ps2.c \
    5553        ctl/apple.c \
    5654        ctl/gxe_fb.c \

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

    re895352 r49ff5f3  
    3939#include <adt/list.h>
    4040#include <bool.h>
     41#include <fibril_synch.h>
    4142#include <ipc/services.h>
    4243#include <ipc/input.h>
    … …  
    8384async_sess_t *irc_sess = NULL;
    8485
     86static FIBRIL_MUTEX_INITIALIZE(discovery_lock);
     87
    8588void kbd_push_data(kbd_dev_t *kdev, sysarg_t data)
    8689{
    … …  
    172175
    173176/** Mouse pointer has moved. */
    174 void mouse_push_event_move(mouse_dev_t *mdev, int dx, int dy)
     177void mouse_push_event_move(mouse_dev_t *mdev, int dx, int dy, int dz)
    175178{
    176179        async_exch_t *exch = async_exchange_begin(client_sess);
    177         async_msg_2(exch, INPUT_EVENT_MOVE, dx, dy);
     180        if (dx || dy)
     181                async_msg_2(exch, INPUT_EVENT_MOVE, dx, dy);
     182        if (dz) {
     183                // TODO: Implement proper wheel support
     184                keycode_t code = dz > 0 ? KC_UP : KC_DOWN;
     185                for (int i = 0; i < 3; ++i) {
     186                        async_msg_4(exch, INPUT_EVENT_KEY, KEY_PRESS, code, 0, 0);
     187                }
     188                async_msg_4(exch, INPUT_EVENT_KEY, KEY_RELEASE, code, 0, 0);
     189        }
    178190        async_exchange_end(exch);
    179191}
    … …  
    397409         * them automatically.
    398410         */
    399 #if defined(UARCH_amd64)
    400         kbd_add_dev(&chardev_port, &pc_ctl);
    401 #endif
    402411#if defined(UARCH_arm32) && defined(MACHINE_gta02)
    403412        kbd_add_dev(&chardev_port, &stty_ctl);
    … …  
    411420#if defined(UARCH_arm32) && defined(MACHINE_integratorcp)
    412421        kbd_add_dev(&pl050_port, &pc_ctl);
    413 #endif
    414 #if defined(UARCH_ia32)
    415         kbd_add_dev(&chardev_port, &pc_ctl);
    416 #endif
    417 #if defined(MACHINE_i460GX)
    418         kbd_add_dev(&chardev_port, &pc_ctl);
    419422#endif
    420423#if defined(MACHINE_ski)
    … …  
    450453         * them automatically.
    451454         */
    452 #if defined(UARCH_amd64)
    453         mouse_add_dev(&chardev_mouse_port, &ps2_proto);
    454 #endif
    455 #if defined(UARCH_ia32)
    456         mouse_add_dev(&chardev_mouse_port, &ps2_proto);
    457 #endif
    458 #if defined(MACHINE_i460GX)
    459         mouse_add_dev(&chardev_mouse_port, &ps2_proto);
    460 #endif
    461455#if defined(UARCH_ppc32)
    462456        mouse_add_dev(&adb_mouse_port, &adb_proto);
    … …  
    602596        int rc;
    603597       
     598        fibril_mutex_lock(&discovery_lock);
     599       
    604600        rc = dev_check_new_kbdevs();
    605         if (rc != EOK)
     601        if (rc != EOK) {
     602                fibril_mutex_unlock(&discovery_lock);
    606603                return rc;
     604        }
    607605       
    608606        rc = dev_check_new_mousedevs();
    609         if (rc != EOK)
     607        if (rc != EOK) {
     608                fibril_mutex_unlock(&discovery_lock);
    610609                return rc;
    611 
     610        }
     611       
     612        fibril_mutex_unlock(&discovery_lock);
     613       
    612614        return EOK;
    613615}
    … …  
    658660       
    659661        /* Register driver */
    660         int rc = loc_server_register(NAME, client_connection);
     662        async_set_client_connection(client_connection);
     663        int rc = loc_server_register(NAME);
    661664        if (rc < 0) {
    662665                printf("%s: Unable to register server (%d)\n", NAME, rc);

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

    re895352 r49ff5f3  
    6262
    6363extern void mouse_push_data(mouse_dev_t *, sysarg_t);
    64 extern void mouse_push_event_move(mouse_dev_t *, int, int);
     64extern void mouse_push_event_move(mouse_dev_t *, int, int, int);
    6565extern void mouse_push_event_button(mouse_dev_t *, int, int);
    6666

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

    re895352 r49ff5f3  
    4848
    4949extern mouse_proto_ops_t adb_proto;
    50 extern mouse_proto_ops_t ps2_proto;
    5150extern mouse_proto_ops_t mousedev_proto;
    5251

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

    re895352 r49ff5f3  
    6363/** List of devices to try connecting to. */
    6464static const char *in_devs[] = {
    65         "char/ps2a",
    6665        "char/s3c24ser"
    6766};

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

    re895352 r49ff5f3  
    5757static kbd_dev_t *kbd_dev;
    5858
     59static irq_pio_range_t gxemul_ranges[] = {
     60        {
     61                .base = 0,
     62                .size = 1
     63        }
     64};
     65
    5966static irq_cmd_t gxemul_cmds[] = {
    6067        {
    … …  
    6976
    7077static irq_code_t gxemul_kbd = {
     78        sizeof(gxemul_ranges) / sizeof(irq_pio_range_t),
     79        gxemul_ranges,
    7180        sizeof(gxemul_cmds) / sizeof(irq_cmd_t),
    7281        gxemul_cmds
    … …  
    8190       
    8291        sysarg_t addr;
    83         if (sysinfo_get_value("kbd.address.virtual", &addr) != EOK)
     92        if (sysinfo_get_value("kbd.address.physical", &addr) != EOK)
    8493                return -1;
    8594       
    … …  
    8998       
    9099        async_set_interrupt_received(gxemul_irq_handler);
     100        gxemul_ranges[0].base = addr;
    91101        gxemul_cmds[0].addr = (void *) addr;
    92         register_irq(inr, device_assign_devno(), 0, &gxemul_kbd);
     102        irq_register(inr, device_assign_devno(), 0, &gxemul_kbd);
    93103        return 0;
    94104}

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

    re895352 r49ff5f3  
    5757static kbd_dev_t *kbd_dev;
    5858
     59static irq_pio_range_t msim_ranges[] = {
     60        {
     61                .base = 0,
     62                .size = 1
     63        }
     64};
     65
    5966static irq_cmd_t msim_cmds[] = {
    6067        {
    … …  
    6976
    7077static irq_code_t msim_kbd = {
     78        sizeof(msim_ranges) / sizeof(irq_pio_range_t),
     79        msim_ranges,
    7180        sizeof(msim_cmds) / sizeof(irq_cmd_t),
    7281        msim_cmds
    … …  
    7988        kbd_dev = kdev;
    8089
    81         sysarg_t vaddr;
    82         if (sysinfo_get_value("kbd.address.virtual", &vaddr) != EOK)
     90        sysarg_t paddr;
     91        if (sysinfo_get_value("kbd.address.physical", &paddr) != EOK)
    8392                return -1;
    8493       
    … …  
    8796                return -1;
    8897       
    89         msim_cmds[0].addr = (void *) vaddr;
     98        msim_ranges[0].base = paddr;
     99        msim_cmds[0].addr = (void *) paddr;
    90100        async_set_interrupt_received(msim_irq_handler);
    91         register_irq(inr, device_assign_devno(), 0, &msim_kbd);
     101        irq_register(inr, device_assign_devno(), 0, &msim_kbd);
    92102       
    93103        return 0;

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

    re895352 r49ff5f3  
    6363#define POLL_INTERVAL  10000
    6464
    65 /**
    66  * Virtual address mapped to the buffer shared with the kernel counterpart.
    67  */
    68 static uintptr_t input_buffer_addr;
    69 
    7065/*
    7166 * Kernel counterpart of the driver pushes characters (it has read) here.
    … …  
    10297                return -1;
    10398       
    104         input_buffer_addr = (uintptr_t) as_get_mappable_page(PAGE_SIZE);
    105         int rc = physmem_map((void *) paddr, (void *) input_buffer_addr,
    106             1, AS_AREA_READ | AS_AREA_WRITE);
    107        
     99        int rc = physmem_map((void *) paddr, 1,
     100            AS_AREA_READ | AS_AREA_WRITE, (void *) &input_buffer);
    108101        if (rc != 0) {
    109102                printf("Niagara: uspace driver couldn't map physical memory: %d\n",
    … …  
    111104                return rc;
    112105        }
    113        
    114         input_buffer = (input_buffer_t) input_buffer_addr;
    115106       
    116107        thread_id_t tid;

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

    re895352 r49ff5f3  
    7070#define LSR_DATA_READY  0x01
    7171
     72static irq_pio_range_t ns16550_ranges[] = {
     73        {
     74                .base = 0,
     75                .size = 8
     76        }
     77};
     78
    7279static irq_cmd_t ns16550_cmds[] = {
    7380        {
    … …  
    98105
    99106irq_code_t ns16550_kbd = {
     107        sizeof(ns16550_ranges) / sizeof(irq_pio_range_t),
     108        ns16550_ranges,
    100109        sizeof(ns16550_cmds) / sizeof(irq_cmd_t),
    101110        ns16550_cmds
    … …  
    105114
    106115static uintptr_t ns16550_physical;
    107 static uintptr_t ns16550_kernel;
    108116
    109117static kbd_dev_t *kbd_dev;
    … …  
    124132                return -1;
    125133       
    126         if (sysinfo_get_value("kbd.address.kernel", &ns16550_kernel) != EOK)
    127                 return -1;
    128        
    129134        sysarg_t inr;
    130135        if (sysinfo_get_value("kbd.inr", &inr) != EOK)
    131136                return -1;
    132137       
    133         ns16550_kbd.cmds[0].addr = (void *) (ns16550_kernel + LSR_REG);
    134         ns16550_kbd.cmds[3].addr = (void *) (ns16550_kernel + RBR_REG);
     138        ns16550_kbd.ranges[0].base = ns16550_physical;
     139        ns16550_kbd.cmds[0].addr = (void *) (ns16550_physical + LSR_REG);
     140        ns16550_kbd.cmds[3].addr = (void *) (ns16550_physical + RBR_REG);
    135141       
    136142        async_set_interrupt_received(ns16550_irq_handler);
    137         register_irq(inr, device_assign_devno(), inr, &ns16550_kbd);
     143        irq_register(inr, device_assign_devno(), inr, &ns16550_kbd);
    138144       
    139145        return pio_enable((void *) ns16550_physical, 8, &vaddr);

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

    re895352 r49ff5f3  
    6161static kbd_dev_t *kbd_dev;
    6262
     63#define PL050_STAT      4
     64#define PL050_DATA      8
     65
    6366#define PL050_STAT_RXFULL  (1 << 4)
     67
     68static irq_pio_range_t pl050_ranges[] = {
     69        {
     70                .base = 0,
     71                .size = 9,
     72        }
     73};
    6474
    6575static irq_cmd_t pl050_cmds[] = {
    … …  
    91101
    92102static irq_code_t pl050_kbd = {
     103        sizeof(pl050_ranges) / sizeof(irq_pio_range_t),
     104        pl050_ranges,
    93105        sizeof(pl050_cmds) / sizeof(irq_cmd_t),
    94106        pl050_cmds
    … …  
    102114       
    103115        sysarg_t addr;
    104         if (sysinfo_get_value("kbd.address.status", &addr) != EOK)
     116        if (sysinfo_get_value("kbd.address.physical", &addr) != EOK)
    105117                return -1;
    106118       
    107         pl050_kbd.cmds[0].addr = (void *) addr;
    108        
    109         if (sysinfo_get_value("kbd.address.data", &addr) != EOK)
    110                 return -1;
    111        
    112         pl050_kbd.cmds[3].addr = (void *) addr;
     119        pl050_kbd.ranges[0].base = addr;
     120        pl050_kbd.cmds[0].addr = (void *) addr + PL050_STAT;
     121        pl050_kbd.cmds[3].addr = (void *) addr + PL050_DATA;
    113122       
    114123        sysarg_t inr;
    … …  
    117126       
    118127        async_set_interrupt_received(pl050_irq_handler);
    119         register_irq(inr, device_assign_devno(), 0, &pl050_kbd);
     128        irq_register(inr, device_assign_devno(), 0, &pl050_kbd);
    120129       
    121130        return 0;

  • uspace/srv/hid/input/proto/adb.c

    re895352 r49ff5f3  
    8282       
    8383        if (dx != 0 || dy != 0)
    84                 mouse_push_event_move(mouse_dev, dx, dy);
     84                mouse_push_event_move(mouse_dev, dx, dy, 0);
    8585}
    8686

  • uspace/srv/hid/input/proto/mousedev.c

    re895352 r49ff5f3  
    9191                switch (IPC_GET_IMETHOD(call)) {
    9292                case MOUSEEV_MOVE_EVENT:
    93                         mouse_push_event_move(mousedev->mouse_dev, IPC_GET_ARG1(call),
    94                             IPC_GET_ARG2(call));
     93                        mouse_push_event_move(mousedev->mouse_dev,
     94                            IPC_GET_ARG1(call), IPC_GET_ARG2(call),
     95                            IPC_GET_ARG3(call));
    9596                        retval = EOK;
    9697                        break;
    9798                case MOUSEEV_BUTTON_EVENT:
    98                         mouse_push_event_button(mousedev->mouse_dev, IPC_GET_ARG1(call),
    99                             IPC_GET_ARG2(call));
     99                        mouse_push_event_button(mousedev->mouse_dev,
     100                            IPC_GET_ARG1(call), IPC_GET_ARG2(call));
    100101                        retval = EOK;
    101102                        break;

  • uspace/srv/hid/remcons/telnet.h

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2011 Vojtech Horky
     2 * Copyright (c) 2012 Vojtech Horky
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libusbdev
     29/** @addtogroup remcons
    3030 * @{
    3131 */
    3232/** @file
    33  * Library internal functions on USB pipes.
    3433 */
    35 #ifndef LIBUSBDEV_PIPEPRIV_H_
    36 #define LIBUSBDEV_PIPEPRIV_H_
    3734
    38 #include <usb/dev/pipes.h>
    39 #include <bool.h>
     35#ifndef TELNET_H_
     36#define TELNET_H_
    4037
    41 void pipe_acquire(usb_pipe_t *);
    42 void pipe_release(usb_pipe_t *);
     38#include <inttypes.h>
    4339
    44 void pipe_start_transaction(usb_pipe_t *);
    45 void pipe_end_transaction(usb_pipe_t *);
     40typedef uint8_t telnet_cmd_t;
    4641
    47 int pipe_add_ref(usb_pipe_t *, bool);
    48 void pipe_drop_ref(usb_pipe_t *);
     42/*
     43 * Telnet commands.
     44 */
     45
     46#define TELNET_IAC 255
     47
     48#define TELNET_WILL 251
     49#define TELNET_WONT 252
     50#define TELNET_DO 253
     51#define TELNET_DONT 254
     52
     53#define TELNET_IS_OPTION_CODE(code) (((code) >= 251) && ((code) <= 254))
     54
     55#define TELNET_ECHO 1
     56#define TELNET_SUPPRESS_GO_AHEAD 3
     57#define TELNET_LINEMODE 34
    4958
    5059
    5160#endif
     61
    5262/**
    5363 * @}

  • uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c

    re895352 r49ff5f3  
    6262
    6363static irq_code_t ts_irq_code = {
     64        0,
     65        NULL,
    6466        sizeof(ts_irq_cmds) / sizeof(irq_cmd_t),
    6567        ts_irq_cmds
    … …  
    8587
    8688        printf(NAME ": S3C24xx touchscreen driver\n");
    87 
    88         rc = loc_server_register(NAME, s3c24xx_ts_connection);
     89       
     90        async_set_client_connection(s3c24xx_ts_connection);
     91        rc = loc_server_register(NAME);
    8992        if (rc < 0) {
    9093                printf(NAME ": Unable to register driver.\n");
    … …  
    139142
    140143        async_set_interrupt_received(s3c24xx_ts_irq_handler);
    141         register_irq(inr, device_assign_devno(), 0, &ts_irq_code);
     144        irq_register(inr, device_assign_devno(), 0, &ts_irq_code);
    142145
    143146        s3c24xx_ts_wait_for_int_mode(ts, updn_down);

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    re895352 r49ff5f3  
    104104enum {
    105105        ADB_MAX_ADDR    = 16
     106};
     107
     108static irq_pio_range_t cuda_ranges[] = {
     109        {
     110                .base = 0,
     111                .size = sizeof(cuda_t)
     112        }
    106113};
    107114
    … …  
    130137
    131138static irq_code_t cuda_irq_code = {
     139        sizeof(cuda_ranges) / sizeof(irq_pio_range_t),
     140        cuda_ranges,
    132141        sizeof(cuda_cmds) / sizeof(irq_cmd_t),
    133142        cuda_cmds
    … …  
    154163        }
    155164
    156         rc = loc_server_register(NAME, cuda_connection);
     165        async_set_client_connection(cuda_connection);
     166        rc = loc_server_register(NAME);
    157167        if (rc < 0) {
    158168                printf(NAME ": Unable to register server.\n");
    … …  
    254264                return -1;
    255265       
    256         if (sysinfo_get_value("cuda.address.kernel", &(instance->cuda_kernel)) != EOK)
    257                 return -1;
    258        
    259266        void *vaddr;
    260267        if (pio_enable((void *) instance->cuda_physical, sizeof(cuda_t), &vaddr) != 0)
    … …  
    273280        pio_write_8(&dev->ier, IER_CLR | ALL_INT);
    274281
    275         cuda_irq_code.cmds[0].addr = (void *) &((cuda_t *) instance->cuda_kernel)->ifr;
     282        cuda_irq_code.ranges[0].base = (uintptr_t) instance->cuda_physical;
     283        cuda_irq_code.cmds[0].addr = (void *) &((cuda_t *) instance->cuda_physical)->ifr;
    276284        async_set_interrupt_received(cuda_irq_handler);
    277         register_irq(10, device_assign_devno(), 0, &cuda_irq_code);
     285        irq_register(10, device_assign_devno(), 0, &cuda_irq_code);
    278286
    279287        /* Enable SR interrupt. */

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.h

    re895352 r49ff5f3  
    111111        cuda_t *cuda;
    112112        uintptr_t cuda_physical;
    113         uintptr_t cuda_kernel;
    114113
    115114        uint8_t rcv_buf[CUDA_RCV_BUF_SIZE];

  • uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c

    re895352 r49ff5f3  
    6060
    6161static irq_code_t uart_irq_code = {
     62        0,
     63        NULL,
    6264        sizeof(uart_irq_cmds) / sizeof(irq_cmd_t),
    6365        uart_irq_cmds
    … …  
    7981        printf(NAME ": S3C24xx on-chip UART driver\n");
    8082
    81         rc = loc_server_register(NAME, s3c24xx_uart_connection);
     83        async_set_client_connection(s3c24xx_uart_connection);
     84        rc = loc_server_register(NAME);
    8285        if (rc < 0) {
    8386                printf(NAME ": Unable to register server.\n");
    … …  
    194197        async_set_interrupt_received(s3c24xx_uart_irq_handler);
    195198
    196         register_irq(inr, device_assign_devno(), 0, &uart_irq_code);
     199        irq_register(inr, device_assign_devno(), 0, &uart_irq_code);
    197200
    198201        /* Enable FIFO, Tx trigger level: empty, Rx trigger level: 1 byte. */

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

    re895352 r49ff5f3  
    124124       
    125125        base_phys = (void *) paddr;
    126         base_virt = as_get_mappable_page(OBIO_SIZE);
    127126       
    128127        int flags = AS_AREA_READ | AS_AREA_WRITE;
    129         int retval = physmem_map(base_phys, (void *) base_virt,
    130             ALIGN_UP(OBIO_SIZE, PAGE_SIZE) >> PAGE_WIDTH, flags);
     128        int retval = physmem_map(base_phys,
     129            ALIGN_UP(OBIO_SIZE, PAGE_SIZE) >> PAGE_WIDTH, flags,
     130            (void *) &base_virt);
    131131       
    132132        if (retval < 0) {

  • uspace/srv/loc/loc.c

    re895352 r49ff5f3  
    5656#define NULL_SERVICES  256
    5757
     58/** Callback session */
     59typedef struct {
     60        link_t cb_sess_list;
     61        async_sess_t *sess;
     62} cb_sess_t;
     63
    5864LIST_INITIALIZE(services_list);
    5965LIST_INITIALIZE(namespaces_list);
    … …  
    8692
    8793static FIBRIL_MUTEX_INITIALIZE(callback_sess_mutex);
    88 static async_sess_t *callback_sess = NULL;
     94static LIST_INITIALIZE(callback_sess_list);
    8995
    9096service_id_t loc_create_id(void)
    … …  
    608614        size_t act_size;
    609615        loc_service_t *svc;
     616        char *fqn;
    610617       
    611618        if (!async_data_read_receive(&callid, &size)) {
    … …  
    625632        }
    626633       
    627         act_size = str_size(svc->name);
     634        if (asprintf(&fqn, "%s/%s", svc->namespace->name, svc->name) < 0) {
     635                fibril_mutex_unlock(&services_list_mutex);
     636                async_answer_0(callid, ENOMEM);
     637                async_answer_0(iid, ENOMEM);
     638                return;
     639        }
     640       
     641        act_size = str_size(fqn);
    628642        if (act_size > size) {
     643                free(fqn);
    629644                fibril_mutex_unlock(&services_list_mutex);
    630645                async_answer_0(callid, EOVERFLOW);
    … …  
    633648        }
    634649       
    635         sysarg_t retval = async_data_read_finalize(callid, svc->name,
     650        sysarg_t retval = async_data_read_finalize(callid, fqn,
    636651            min(size, act_size));
     652        free(fqn);
    637653       
    638654        fibril_mutex_unlock(&services_list_mutex);
    … …  
    790806}
    791807
    792 /** Find ID for category specified by name.
    793  *
    794  * On success, answer will contain EOK int retval and service ID in arg1.
     808/** Create callback connection.
     809 *
     810 * Create callback connection which will be used to send category change
     811 * events.
     812 *
     813 * On success, answer will contain EOK int retval.
    795814 * On failure, error code will be sent in retval.
    796815 *
    … …  
    798817static void loc_callback_create(ipc_callid_t iid, ipc_call_t *icall)
    799818{
    800         async_sess_t *cb_sess = async_callback_receive(EXCHANGE_SERIALIZE);
     819        cb_sess_t *cb_sess = calloc(1, sizeof(cb_sess_t));
    801820        if (cb_sess == NULL) {
    802821                async_answer_0(iid, ENOMEM);
    … …  
    804823        }
    805824       
     825        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
     826        if (sess == NULL) {
     827                free(cb_sess);
     828                async_answer_0(iid, ENOMEM);
     829                return;
     830        }
     831       
     832        cb_sess->sess = sess;
     833        link_initialize(&cb_sess->cb_sess_list);
     834       
    806835        fibril_mutex_lock(&callback_sess_mutex);
    807         if (callback_sess != NULL) {
    808                 fibril_mutex_unlock(&callback_sess_mutex);
    809                 async_answer_0(iid, EEXIST);
    810                 return;
    811         }
    812        
    813         callback_sess = cb_sess;
     836        list_append(&cb_sess->cb_sess_list, &callback_sess_list);
    814837        fibril_mutex_unlock(&callback_sess_mutex);
    815838       
    … …  
    820843{
    821844        fibril_mutex_lock(&callback_sess_mutex);
    822 
    823         if (callback_sess != NULL) {
    824                 async_exch_t *exch = async_exchange_begin(callback_sess);
     845       
     846        list_foreach(callback_sess_list, link) {
     847                cb_sess_t *cb_sess;
     848               
     849                cb_sess = list_get_instance(link, cb_sess_t, cb_sess_list);
     850               
     851                async_exch_t *exch = async_exchange_begin(cb_sess->sess);
    825852                async_msg_0(exch, LOC_EVENT_CAT_CHANGE);
    826853                async_exchange_end(exch);
    827854        }
    828 
     855       
    829856        fibril_mutex_unlock(&callback_sess_mutex);
    830857}
    … …  
    12671294
    12681295        cat = category_new("bd");
     1296        categ_dir_add_cat(&cdir, cat);
     1297
     1298        cat = category_new("iplink");
    12691299        categ_dir_add_cat(&cdir, cat);
    12701300

  • uspace/srv/net/ethip/atrans.h

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup inet
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * ICMP client interface.
     32/**
     33 * @file
     34 * @brief
    3535 */
    3636
    37 #ifndef LIBNET_ICMP_CLIENT_H_
    38 #define LIBNET_ICMP_CLIENT_H_
     37#ifndef ATRANS_H_
     38#define ATRANS_H_
    3939
    40 #include <net/icmp_codes.h>
    41 #include <net/packet.h>
     40#include <inet/iplink_srv.h>
     41#include "ethip.h"
    4242
    43 extern int icmp_client_process_packet(packet_t *, icmp_type_t *, icmp_code_t *,
    44     icmp_param_t *, icmp_param_t *);
    45 extern size_t icmp_client_header_length(packet_t *);
     43extern int atrans_add(iplink_srv_addr_t *, mac48_addr_t *);
     44extern int atrans_remove(iplink_srv_addr_t *);
     45extern int atrans_lookup(iplink_srv_addr_t *, mac48_addr_t *);
     46extern int atrans_wait_timeout(suseconds_t);
    4647
    4748#endif

  • uspace/srv/net/inet/icmp_std.h

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libc
     29/** @addtogroup inet
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * ICMP module application interface.
     32/**
     33 * @file ICMP standard definitions
     34 *
    3535 */
    3636
    37 #ifndef LIBC_ICMP_API_H_
    38 #define LIBC_ICMP_API_H_
     37#ifndef ICMP_STD_H_
     38#define ICMP_STD_H_
    3939
    40 #include <net/socket_codes.h>
    41 #include <net/inet.h>
    4240#include <sys/types.h>
    43 #include <sys/time.h>
    44 #include <adt/measured_strings.h>
    45 #include <net/ip_codes.h>
    46 #include <net/icmp_codes.h>
    47 #include <net/icmp_common.h>
    48 #include <async.h>
    4941
    50 /** @name ICMP module application interface
    51  * This interface is used by other application modules.
    52  */
    53 /*@{*/
     42#define IP_PROTO_ICMP 1
    5443
    55 extern int icmp_echo_msg(async_sess_t *, size_t, mseconds_t, ip_ttl_t, ip_tos_t,
    56     int, const struct sockaddr *, socklen_t);
     44/** Type of service used for ICMP */
     45#define ICMP_TOS        0
    5746
    58 /*@}*/
     47/** ICMP message type */
     48enum icmp_type {
     49        ICMP_ECHO_REPLY   = 0,
     50        ICMP_ECHO_REQUEST = 8
     51};
     52
     53/** ICMP Echo Request or Reply message header */
     54typedef struct {
     55        /** ICMP message type */
     56        uint8_t type;
     57        /** Code (0) */
     58        uint8_t code;
     59        /** Internet checksum of the ICMP message */
     60        uint16_t checksum;
     61        /** Indentifier */
     62        uint16_t ident;
     63        /** Sequence number */
     64        uint16_t seq_no;
     65} icmp_echo_t;
    5966
    6067#endif

  • uspace/srv/net/tcp/Makefile

    re895352 r49ff5f3  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2011 Jiri Svoboda
    43# All rights reserved.
    54#
    … …  
    2827#
    2928
    30 USPACE_PREFIX = ../../../..
     29USPACE_PREFIX = ../../..
    3130LIBS = $(LIBNET_PREFIX)/libnet.a
    3231EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    … …  
    3433
    3534SOURCES = \
    36         tcp.c
     35        conn.c \
     36        iqueue.c \
     37        ncsim.c \
     38        pdu.c \
     39        rqueue.c \
     40        segment.c \
     41        seq_no.c \
     42        sock.c \
     43        tcp.c \
     44        test.c \
     45        tqueue.c \
     46        ucall.c
    3747
    3848include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/net/tcp/segment.h

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup tcp
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * Ethernet protocol numbers according to the on-line IANA - Ethernet numbers
    35  * http://www.iana.org/assignments/ethernet-numbers
    36  * cited January 17 2009.
     32/** @file Segment processing
    3733 */
    3834
    39 #ifndef LIBNET_ETHERNET_PROTOCOLS_H_
    40 #define LIBNET_ETHERNET_PROTOCOLS_H_
     35#ifndef SEGMENT_H
     36#define SEGMENT_H
    4137
    4238#include <sys/types.h>
     39#include "tcp_type.h"
    4340
    44 /** Ethernet protocol type definition. */
    45 typedef uint16_t eth_type_t;
     41extern tcp_segment_t *tcp_segment_new(void);
     42extern void tcp_segment_delete(tcp_segment_t *);
     43extern tcp_segment_t *tcp_segment_dup(tcp_segment_t *);
     44extern tcp_segment_t *tcp_segment_make_ctrl(tcp_control_t);
     45extern tcp_segment_t *tcp_segment_make_rst(tcp_segment_t *);
     46extern tcp_segment_t *tcp_segment_make_data(tcp_control_t, void *, size_t);
     47extern void tcp_segment_trim(tcp_segment_t *, uint32_t, uint32_t);
     48extern void tcp_segment_text_copy(tcp_segment_t *, void *, size_t);
     49extern size_t tcp_segment_text_size(tcp_segment_t *);
     50extern void tcp_segment_dump(tcp_segment_t *);
    4651
    47 /** @name Ethernet protocols definitions */
    48 /*@{*/
    4952
    50 /** Ethernet minimal protocol number.
    51  * According to the IEEE 802.3 specification.
    52  */
    53 #define ETH_MIN_PROTO           0x0600 /* 1536 */
    54 
    55 /** Internet IP (IPv4) ethernet protocol type. */
    56 #define ETH_P_IP                0x0800
    57 
    58 /** ARP ethernet protocol type. */
    59 #define ETH_P_ARP               0x0806
    60 
    61 /*@}*/
    6253
    6354#endif

  • uspace/srv/net/tcp/seq_no.h

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup tcp
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * Internetwork layer module interface for the underlying network interface
    35  * layer. This interface is always called by the remote modules.
     32/** @file Sequence number computations
    3633 */
    3734
    38 #ifndef LIBNET_IL_REMOTE_H_
    39 #define LIBNET_IL_REMOTE_H_
     35#ifndef SEQ_NO_H
     36#define SEQ_NO_H
    4037
    41 #include <ipc/services.h>
    4238#include <sys/types.h>
    43 #include <net/device.h>
    44 #include <net/packet.h>
    45 #include <async.h>
     39#include "tcp_type.h"
    4640
    47 /** @name Internetwork layer module interface
    48  * This interface is used by other modules.
    49  */
    50 /*@{*/
     41extern bool seq_no_ack_acceptable(tcp_conn_t *, uint32_t);
     42extern bool seq_no_ack_duplicate(tcp_conn_t *, uint32_t);
     43extern bool seq_no_in_rcv_wnd(tcp_conn_t *, uint32_t);
     44extern bool seq_no_new_wnd_update(tcp_conn_t *, tcp_segment_t *);
     45extern bool seq_no_segment_acked(tcp_conn_t *, tcp_segment_t *, uint32_t);
     46extern bool seq_no_syn_acked(tcp_conn_t *);
     47extern bool seq_no_segment_ready(tcp_conn_t *, tcp_segment_t *);
     48extern bool seq_no_segment_acceptable(tcp_conn_t *, tcp_segment_t *);
     49extern void seq_no_seg_trim_calc(tcp_conn_t *, tcp_segment_t *, uint32_t *,
     50    uint32_t *);
     51extern int seq_no_seg_cmp(tcp_conn_t *, tcp_segment_t *, tcp_segment_t *);
    5152
    52 extern int il_device_state_msg(async_sess_t *, nic_device_id_t,
    53     nic_device_state_t, services_t);
    54 extern int il_received_msg(async_sess_t *, nic_device_id_t, packet_t *,
    55     services_t);
    56 extern int il_mtu_changed_msg(async_sess_t *, nic_device_id_t, size_t,
    57     services_t);
    58 extern int il_addr_changed_msg(async_sess_t *, nic_device_id_t, size_t,
    59     const uint8_t *);
    60 
    61 /*@}*/
     53extern uint32_t seq_no_control_len(tcp_control_t);
    6254
    6355#endif

  • uspace/srv/net/tcp/sock.h

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2006 Jakub Vana
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup ia32
     29/** @addtogroup tcp
    3030 * @{
    3131 */
    32 /** @file
     32/** @file Socket provider
    3333 */
    3434
    35 #ifndef KERN_ia32_VESA_H_
    36 #define KERN_ia32_VESA_H_
     35#ifndef SOCK_H
     36#define SOCK_H
    3737
    38 #include <typedefs.h>
     38#include <async.h>
    3939
    40 extern bool vesa_init(void);
     40extern int tcp_sock_init(void);
    4141
    4242#endif

  • uspace/srv/net/tcp/std.h

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup tcp
    3030 * @{
    3131 */
    32 /** @file
    33  * General CRC and checksum computation.
     32/** @file TCP header definitions
     33 *
     34 * Based on IETF RFC 793
    3435 */
    3536
    36 #ifndef LIBNET_CHECKSUM_H_
    37 #define LIBNET_CHECKSUM_H_
     37#ifndef STD_H
     38#define STD_H
    3839
    39 #include <byteorder.h>
    4040#include <sys/types.h>
    4141
    42 /** IP checksum value for computed zero checksum.
    43  *
    44  * Zero is returned as 0xFFFF (not flipped)
    45  *
    46  */
    47 #define IP_CHECKSUM_ZERO  0xffffU
     42/** TCP Header (fixed part) */
     43typedef struct {
     44        /** Source port */
     45        uint16_t src_port;
     46        /** Destination port */
     47        uint16_t dest_port;
     48        /** Sequence number */
     49        uint32_t seq;
     50        /** Acknowledgement number */
     51        uint32_t ack;
     52        /** Data Offset, Reserved, Flags */
     53        uint16_t doff_flags;
     54        /** Window */
     55        uint16_t window;
     56        /* Checksum */
     57        uint16_t checksum;
     58        /** Urgent pointer */
     59        uint16_t urg_ptr;
     60} tcp_header_t;
    4861
    49 #ifdef __BE__
     62/** Bits in tcp_header_t.doff_flags */
     63enum doff_flags_bits {
     64        DF_DATA_OFFSET_h        = 15,
     65        DF_DATA_OFFSET_l        = 12,
     66        DF_URG                  = 5,
     67        DF_ACK                  = 4,
     68        DF_PSH                  = 3,
     69        DF_RST                  = 2,
     70        DF_SYN                  = 1,
     71        DF_FIN                  = 0
     72};
    5073
    51 #define compute_crc32(seed, data, length) \
    52         compute_crc32_be(seed, (uint8_t *) data, length)
     74/** TCP pseudo header */
     75typedef struct {
     76        /** Source address */
     77        uint32_t src_addr;
     78        /** Destination address */
     79        uint32_t dest_addr;
     80        /** Zero */
     81        uint8_t zero;
     82        /** Protocol */
     83        uint8_t protocol;
     84        /** TCP length */
     85        uint16_t tcp_length;
     86} tcp_phdr_t;
    5387
    54 #endif
    55 
    56 #ifdef __LE__
    57 
    58 #define compute_crc32(seed, data, length) \
    59         compute_crc32_le(seed, (uint8_t *) data, length)
    60 
    61 #endif
    62 
    63 extern uint32_t compute_crc32_le(uint32_t, uint8_t *, size_t);
    64 extern uint32_t compute_crc32_be(uint32_t, uint8_t *, size_t);
    65 extern uint32_t compute_checksum(uint32_t, uint8_t *, size_t);
    66 extern uint16_t compact_checksum(uint32_t);
    67 extern uint16_t flip_checksum(uint16_t);
    68 extern uint16_t ip_checksum(uint8_t *, size_t);
    69 extern uint64_t multicast_hash(const uint8_t addr[6]);
     88/** Option kind */
     89enum opt_kind {
     90        /** End of option list */
     91        OPT_END_LIST            = 0,
     92        /** No-operation */
     93        OPT_NOP                 = 1,
     94        /** Maximum segment size */
     95        OPT_MAX_SEG_SIZE        = 2
     96};
    7097
    7198#endif

  • uspace/srv/net/tcp/tcp.h

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libc
    30  *  @{
     29/** @addtogroup tcp
     30 * @{
     31 */
     32/** @file TCP (Transmission Control Protocol) network module
    3133 */
    3234
    33 /** @file
    34  * ICMP module common interface.
    35  */
     35#ifndef TCP_H
     36#define TCP_H
    3637
    37 #ifndef LIBC_ICMP_COMMON_H_
    38 #define LIBC_ICMP_COMMON_H_
     38#include <async.h>
     39#include "tcp_type.h"
    3940
    40 #include <ipc/services.h>
    41 #include <sys/time.h>
    42 #include <async.h>
    43 
    44 extern async_sess_t *icmp_connect_module(void);
     41extern void tcp_transmit_pdu(tcp_pdu_t *);
    4542
    4643#endif

  • uspace/srv/net/udp/Makefile

    re895352 r49ff5f3  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2012 Jiri Svoboda
    43# All rights reserved.
    54#
    … …  
    2827#
    2928
    30 USPACE_PREFIX = ../../../..
     29USPACE_PREFIX = ../../..
    3130LIBS = $(LIBNET_PREFIX)/libnet.a
    3231EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    … …  
    3433
    3534SOURCES = \
    36         udp.c
     35        assoc.c \
     36        msg.c \
     37        sock.c \
     38        pdu.c \
     39        ucall.c \
     40        udp.c \
     41        udp_inet.c
    3742
    3843include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/net/udp/assoc.h

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup udp
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * Link service access point identifiers.
     32/** @file UDP associations
    3533 */
    3634
    37 #ifndef LIBNET_ETHERNET_LSAP_H_
    38 #define LIBNET_ETHERNET_LSAP_H_
     35#ifndef ASSOC_H
     36#define ASSOC_H
    3937
    4038#include <sys/types.h>
     39#include "udp_type.h"
    4140
    42 /** Ethernet LSAP type definition. */
    43 typedef uint8_t eth_lsap_t;
     41extern udp_assoc_t *udp_assoc_new(udp_sock_t *, udp_sock_t *);
     42extern void udp_assoc_delete(udp_assoc_t *);
     43extern void udp_assoc_add(udp_assoc_t *);
     44extern void udp_assoc_remove(udp_assoc_t *);
     45extern void udp_assoc_addref(udp_assoc_t *);
     46extern void udp_assoc_delref(udp_assoc_t *);
     47extern void udp_assoc_set_foreign(udp_assoc_t *, udp_sock_t *);
     48extern void udp_assoc_set_local(udp_assoc_t *, udp_sock_t *);
     49extern int udp_assoc_send(udp_assoc_t *, udp_sock_t *, udp_msg_t *);
     50extern int udp_assoc_recv(udp_assoc_t *, udp_msg_t **, udp_sock_t *);
     51extern void udp_assoc_received(udp_sockpair_t *, udp_msg_t *);
    4452
    45 /** @name Ethernet LSAP values definitions */
    46 /*@{*/
    47 
    48 /** Null LSAP LSAP identifier. */
    49 #define ETH_LSAP_NULL   0x00
    50 /** ARPANET Internet Protocol (IP) LSAP identifier. */
    51 #define ETH_LSAP_IP     0x06
    52 /** ARPANET Address Resolution Protocol (ARP) LSAP identifier. */
    53 #define ETH_LSAP_ARP    0x98
    54 /** SubNetwork Access Protocol (SNAP) LSAP identifier. */
    55 #define ETH_LSAP_SNAP   0xAA
    56 /** Global LSAP LSAP identifier. */
    57 #define ETH_LSAP_GLSAP  0xFF
    58 
    59 /*@}*/
    6053
    6154#endif

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

    re895352 r49ff5f3  
    11/*
    2  * Copyright (c) 2008 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3131 */
    3232
    33 /** @file
    34  * UDP module.
     33/**
     34 * @file UDP (User Datagram Protocol) service
    3535 */
    3636
    37 #ifndef NET_UDP_H_
    38 #define NET_UDP_H_
     37#include <async.h>
     38#include <errno.h>
     39#include <io/log.h>
     40#include <stdio.h>
     41#include <task.h>
    3942
    40 #include <async.h>
    41 #include <fibril_synch.h>
    42 #include <socket_core.h>
    43 #include <tl_common.h>
     43#include "udp_inet.h"
     44#include "sock.h"
    4445
    45 /** Type definition of the UDP global data.
    46  * @see udp_globals
     46#define NAME       "udp"
     47
     48static int udp_init(void)
     49{
     50        int rc;
     51
     52        log_msg(LVL_DEBUG, "udp_init()");
     53
     54        rc = udp_inet_init();
     55        if (rc != EOK) {
     56                log_msg(LVL_ERROR, "Failed connecting to internet service.");
     57                return ENOENT;
     58        }
     59
     60        rc = udp_sock_init();
     61        if (rc != EOK) {
     62                log_msg(LVL_ERROR, "Failed initializing socket service.");
     63                return ENOENT;
     64        }
     65
     66        return EOK;
     67}
     68
     69int main(int argc, char **argv)
     70{
     71        int rc;
     72
     73        printf(NAME ": UDP (User Datagram Protocol) service\n");
     74
     75        rc = log_init(NAME, LVL_WARN);
     76        if (rc != EOK) {
     77                printf(NAME ": Failed to initialize log.\n");
     78                return 1;
     79        }
     80
     81        rc = udp_init();
     82        if (rc != EOK)
     83                return 1;
     84
     85        printf(NAME ": Accepting connections.\n");
     86        task_retval(0);
     87        async_manager();
     88
     89        /* Not reached */
     90        return 0;
     91}
     92
     93/**
     94 * @}
    4795 */
    48 typedef struct udp_globals udp_globals_t;
    49 
    50 /** UDP global data. */
    51 struct udp_globals {
    52         /** Networking module session. */
    53         async_sess_t *net_sess;
    54         /** IP module session. */
    55         async_sess_t *ip_sess;
    56         /** ICMP module session. */
    57         async_sess_t *icmp_sess;
    58         /** Packet dimension. */
    59         packet_dimension_t packet_dimension;
    60         /** Indicates whether UDP checksum computing is enabled. */
    61         int checksum_computing;
    62         /** Indicates whether UDP autobnding on send is enabled. */
    63         int autobinding;
    64         /** Last used free port. */
    65         int last_used_port;
    66         /** Active sockets. */
    67         socket_ports_t sockets;
    68         /** Device packet dimensions. */
    69         packet_dimensions_t dimensions;
    70         /** Safety lock. */
    71         fibril_rwlock_t lock;
    72 };
    73 
    74 #endif
    75 
    76 /** @}
    77  */

  • uspace/srv/vfs/vfs.c

    re895352 r49ff5f3  
    172172         * Allocate and initialize the Path Lookup Buffer.
    173173         */
    174         plb = as_get_mappable_page(PLB_SIZE);
    175         if (!plb) {
    176                 printf(NAME ": Cannot allocate a mappable piece of address space\n");
    177                 return ENOMEM;
    178         }
    179        
    180         if (as_area_create(plb, PLB_SIZE, AS_AREA_READ | AS_AREA_WRITE |
    181             AS_AREA_CACHEABLE) != plb) {
     174        plb = as_area_create((void *) -1, PLB_SIZE,
     175            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
     176        if (plb == (void *) -1) {
    182177                printf(NAME ": Cannot create address space area\n");
    183178                return ENOMEM;
Note: See TracChangeset for help on using the changeset viewer.