Changes in / [a8b8086:eb083ad] in mainline


Ignore:
Files:
37 added
34 deleted
34 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    ra8b8086 reb083ad  
    556556
    557557% Include development files (headers, libraries)
    558 ! [RDFMT=tmpfs|RDFMT=ext2fs] CONFIG_DEVEL_FILES (n/y)
     558! CONFIG_DEVEL_FILES (n/y)
    559559
    560560% Strip binaries
    … …  
    578578# USB settings
    579579
    580 % USB release build (less logging)
    581 ! CONFIG_USB_RELEASE_BUILD (y/n)
     580% USB verbose messages
     581! CONFIG_USB_VERBOSE (n/y)
    582582
    583583% Start virtual USB host controller

  • boot/Makefile.common

    ra8b8086 reb083ad  
    7272        $(USPACE_PATH)/srv/loader/loader \
    7373        $(USPACE_PATH)/app/init/init \
    74         $(USPACE_PATH)/srv/loc/loc \
     74        $(USPACE_PATH)/srv/locsrv/locsrv \
    7575        $(USPACE_PATH)/srv/bd/rd/rd \
    7676        $(USPACE_PATH)/srv/vfs/vfs
    … …  
    107107        $(USPACE_PATH)/srv/hid/remcons/remcons \
    108108        $(USPACE_PATH)/srv/net/ethip/ethip \
    109         $(USPACE_PATH)/srv/net/inet/inet \
     109        $(USPACE_PATH)/srv/net/inetsrv/inetsrv \
    110110        $(USPACE_PATH)/srv/net/loopip/loopip \
    111111        $(USPACE_PATH)/srv/net/tcp/tcp \
    … …  
    157157        $(USPACE_PATH)/app/edit/edit \
    158158        $(USPACE_PATH)/app/ext2info/ext2info \
    159         $(USPACE_PATH)/app/inetcfg/inetcfg \
     159        $(USPACE_PATH)/app/inet/inet \
    160160        $(USPACE_PATH)/app/kill/kill \
    161161        $(USPACE_PATH)/app/killall/killall \
    162         $(USPACE_PATH)/app/locinfo/locinfo \
     162        $(USPACE_PATH)/app/loc/loc \
    163163        $(USPACE_PATH)/app/mkfat/mkfat \
    164164        $(USPACE_PATH)/app/mkexfat/mkexfat \
    … …  
    177177        $(USPACE_PATH)/app/nettest3/nettest3 \
    178178        $(USPACE_PATH)/app/netecho/netecho \
     179        $(USPACE_PATH)/app/nterm/nterm \
    179180        $(USPACE_PATH)/app/ping/ping \
    180181        $(USPACE_PATH)/app/stats/stats \

  • kernel/arch/amd64/include/mm/page.h

    ra8b8086 reb083ad  
    3333 */
    3434
    35 /** Paging on AMD64
    36  *
    37  * The space is divided in positive numbers (uspace) and
    38  * negative numbers (kernel). The 'negative' space starting
    39  * with 0xffff800000000000 and ending with 0xffffffffffffffff
    40  * is identically mapped physical memory.
    41  *
    42  */
    43 
    4435#ifndef KERN_amd64_PAGE_H_
    4536#define KERN_amd64_PAGE_H_

  • kernel/genarch/src/fb/fb.c

    ra8b8086 reb083ad  
    390390                            instance->position / instance->cols, false);
    391391                        instance->position++;
    392                 } while ((instance->position % 8)
    393                     && (instance->position < instance->cols * instance->rows));
     392                } while (((instance->position % instance->cols) % 8 != 0) &&
     393                    (instance->position < instance->cols * instance->rows));
    394394                break;
    395395        default:

  • kernel/genarch/src/mm/page_pt.c

    ra8b8086 reb083ad  
    4848#include <align.h>
    4949#include <macros.h>
     50#include <bitops.h>
    5051
    5152static void pt_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    … …  
    292293}
    293294
     295/** Return the size of the region mapped by a single PTL0 entry.
     296 *
     297 * @return Size of the region mapped by a single PTL0 entry.
     298 */
     299static uintptr_t ptl0_step_get(void)
     300{
     301        size_t va_bits;
     302
     303        va_bits = fnzb(PTL0_ENTRIES) + fnzb(PTL1_ENTRIES) + fnzb(PTL2_ENTRIES) +
     304            fnzb(PTL3_ENTRIES) + PAGE_WIDTH;
     305
     306        return 1UL << (va_bits - fnzb(PTL0_ENTRIES));
     307}
     308
    294309/** Make the mappings in the given range global accross all address spaces.
    295310 *
    … …  
    309324{
    310325        uintptr_t ptl0 = PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
    311         uintptr_t ptl0step = (((uintptr_t) -1) / PTL0_ENTRIES) + 1;
     326        uintptr_t ptl0_step = ptl0_step_get();
    312327        size_t order;
    313328        uintptr_t addr;
    … …  
    321336#endif
    322337
    323         ASSERT(ispwr2(ptl0step));
    324338        ASSERT(size > 0);
    325339
    326         for (addr = ALIGN_DOWN(base, ptl0step); addr - 1 < base + size - 1;
    327             addr += ptl0step) {
     340        for (addr = ALIGN_DOWN(base, ptl0_step); addr - 1 < base + size - 1;
     341            addr += ptl0_step) {
    328342                uintptr_t l1;
    329343

  • kernel/generic/include/lib/ra.h

    ra8b8086 reb083ad  
    4242
    4343typedef struct {
    44         SPINLOCK_DECLARE(lock);
     44        IRQ_SPINLOCK_DECLARE(lock);
    4545        list_t spans;           /**< List of arena's spans. */
    4646} ra_arena_t;

  • kernel/generic/include/mm/slab.h

    ra8b8086 reb083ad  
    8181        slab_magazine_t *current;
    8282        slab_magazine_t *last;
    83         SPINLOCK_DECLARE(lock);
     83        IRQ_SPINLOCK_DECLARE(lock);
    8484} slab_mag_cache_t;
    8585
    … …  
    113113        list_t full_slabs;     /**< List of full slabs */
    114114        list_t partial_slabs;  /**< List of partial slabs */
    115         SPINLOCK_DECLARE(slablock);
     115        IRQ_SPINLOCK_DECLARE(slablock);
    116116        /* Magazines */
    117117        list_t magazines;  /**< List o full magazines */
    118         SPINLOCK_DECLARE(maglock);
     118        IRQ_SPINLOCK_DECLARE(maglock);
    119119       
    120120        /** CPU cache */

  • kernel/generic/src/lib/ra.c

    ra8b8086 reb083ad  
    185185                return NULL;
    186186
    187         spinlock_initialize(&arena->lock, "arena_lock");
     187        irq_spinlock_initialize(&arena->lock, "arena_lock");
    188188        list_initialize(&arena->spans);
    189189
    … …  
    209209
    210210        /* TODO: check for overlaps */
    211         spinlock_lock(&arena->lock);
     211        irq_spinlock_lock(&arena->lock, true);
    212212        list_append(&span->span_link, &arena->spans);
    213         spinlock_unlock(&arena->lock);
     213        irq_spinlock_unlock(&arena->lock, true);
    214214        return true;
    215215}
    … …  
    390390        ASSERT(ispwr2(alignment));
    391391
    392         spinlock_lock(&arena->lock);
     392        irq_spinlock_lock(&arena->lock, true);
    393393        list_foreach(arena->spans, cur) {
    394394                ra_span_t *span = list_get_instance(cur, ra_span_t, span_link);
    … …  
    398398                        break;
    399399        }
    400         spinlock_unlock(&arena->lock);
     400        irq_spinlock_unlock(&arena->lock, true);
    401401
    402402        return base;
    … …  
    406406void ra_free(ra_arena_t *arena, uintptr_t base, size_t size)
    407407{
    408         spinlock_lock(&arena->lock);
     408        irq_spinlock_lock(&arena->lock, true);
    409409        list_foreach(arena->spans, cur) {
    410410                ra_span_t *span = list_get_instance(cur, ra_span_t, span_link);
    … …  
    412412                if (iswithin(span->base, span->size, base, size)) {
    413413                        ra_span_free(span, base, size);
    414                         spinlock_unlock(&arena->lock);
     414                        irq_spinlock_unlock(&arena->lock, true);
    415415                        return;
    416416                }
    417417        }
    418         spinlock_unlock(&arena->lock);
     418        irq_spinlock_unlock(&arena->lock, true);
    419419
    420420        panic("Freeing to wrong arena (base=%" PRIxn ", size=%" PRIdn ").",

  • kernel/generic/src/mm/frame.c

    ra8b8086 reb083ad  
    10861086#endif
    10871087               
     1088                /*
     1089                 * Since the mem_avail_mtx is an active mutex, we need to disable interrupts
     1090                 * to prevent deadlock with TLB shootdown.
     1091                 */
     1092                ipl_t ipl = interrupts_disable();
    10881093                mutex_lock(&mem_avail_mtx);
    10891094               
    … …  
    10981103               
    10991104                mutex_unlock(&mem_avail_mtx);
     1105                interrupts_restore(ipl);
    11001106               
    11011107#ifdef CONFIG_DEBUG
    … …  
    11611167         * Signal that some memory has been freed.
    11621168         */
     1169
     1170       
     1171        /*
     1172         * Since the mem_avail_mtx is an active mutex, we need to disable interrupts
     1173         * to prevent deadlock with TLB shootdown.
     1174         */
     1175        ipl_t ipl = interrupts_disable();
    11631176        mutex_lock(&mem_avail_mtx);
    11641177        if (mem_avail_req > 0)
    … …  
    11701183        }
    11711184        mutex_unlock(&mem_avail_mtx);
     1185        interrupts_restore(ipl);
    11721186       
    11731187        if (!(flags & FRAME_NO_RESERVE))

  • kernel/generic/src/mm/slab.c

    ra8b8086 reb083ad  
    264264                freed = cache->destructor(obj);
    265265       
    266         spinlock_lock(&cache->slablock);
     266        irq_spinlock_lock(&cache->slablock, true);
    267267        ASSERT(slab->available < cache->objects);
    268268       
    … …  
    275275                /* Free associated memory */
    276276                list_remove(&slab->link);
    277                 spinlock_unlock(&cache->slablock);
     277                irq_spinlock_unlock(&cache->slablock, true);
    278278               
    279279                return freed + slab_space_free(cache, slab);
    … …  
    284284        }
    285285       
    286         spinlock_unlock(&cache->slablock);
     286        irq_spinlock_unlock(&cache->slablock, true);
    287287        return freed;
    288288}
    … …  
    295295NO_TRACE static void *slab_obj_create(slab_cache_t *cache, unsigned int flags)
    296296{
    297         spinlock_lock(&cache->slablock);
     297        irq_spinlock_lock(&cache->slablock, true);
    298298       
    299299        slab_t *slab;
    … …  
    308308                 *
    309309                 */
    310                 spinlock_unlock(&cache->slablock);
     310                irq_spinlock_unlock(&cache->slablock, true);
    311311                slab = slab_space_alloc(cache, flags);
    312312                if (!slab)
    313313                        return NULL;
    314314               
    315                 spinlock_lock(&cache->slablock);
     315                irq_spinlock_lock(&cache->slablock, true);
    316316        } else {
    317317                slab = list_get_instance(list_first(&cache->partial_slabs),
    … …  
    329329                list_prepend(&slab->link, &cache->partial_slabs);
    330330       
    331         spinlock_unlock(&cache->slablock);
     331        irq_spinlock_unlock(&cache->slablock, true);
    332332       
    333333        if ((cache->constructor) && (cache->constructor(obj, flags))) {
    … …  
    355355        link_t *cur;
    356356       
    357         spinlock_lock(&cache->maglock);
     357        irq_spinlock_lock(&cache->maglock, true);
    358358        if (!list_empty(&cache->magazines)) {
    359359                if (first)
    … …  
    366366                atomic_dec(&cache->magazine_counter);
    367367        }
    368        
    369         spinlock_unlock(&cache->maglock);
     368        irq_spinlock_unlock(&cache->maglock, true);
     369
    370370        return mag;
    371371}
    … …  
    377377    slab_magazine_t *mag)
    378378{
    379         spinlock_lock(&cache->maglock);
     379        irq_spinlock_lock(&cache->maglock, true);
    380380       
    381381        list_prepend(&mag->link, &cache->magazines);
    382382        atomic_inc(&cache->magazine_counter);
    383383       
    384         spinlock_unlock(&cache->maglock);
     384        irq_spinlock_unlock(&cache->maglock, true);
    385385}
    386386
    … …  
    414414        slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
    415415       
    416         ASSERT(spinlock_locked(&cache->mag_cache[CPU->id].lock));
     416        ASSERT(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
    417417       
    418418        if (cmag) { /* First try local CPU magazines */
    … …  
    451451                return NULL;
    452452       
    453         spinlock_lock(&cache->mag_cache[CPU->id].lock);
     453        irq_spinlock_lock(&cache->mag_cache[CPU->id].lock, true);
    454454       
    455455        slab_magazine_t *mag = get_full_current_mag(cache);
    456456        if (!mag) {
    457                 spinlock_unlock(&cache->mag_cache[CPU->id].lock);
     457                irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
    458458                return NULL;
    459459        }
    460460       
    461461        void *obj = mag->objs[--mag->busy];
    462         spinlock_unlock(&cache->mag_cache[CPU->id].lock);
     462        irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
    463463       
    464464        atomic_dec(&cache->cached_objs);
    … …  
    481481        slab_magazine_t *lastmag = cache->mag_cache[CPU->id].last;
    482482       
    483         ASSERT(spinlock_locked(&cache->mag_cache[CPU->id].lock));
     483        ASSERT(irq_spinlock_locked(&cache->mag_cache[CPU->id].lock));
    484484       
    485485        if (cmag) {
    … …  
    531531                return -1;
    532532       
    533         spinlock_lock(&cache->mag_cache[CPU->id].lock);
     533        irq_spinlock_lock(&cache->mag_cache[CPU->id].lock, true);
    534534       
    535535        slab_magazine_t *mag = make_empty_current_mag(cache);
    536536        if (!mag) {
    537                 spinlock_unlock(&cache->mag_cache[CPU->id].lock);
     537                irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
    538538                return -1;
    539539        }
    … …  
    541541        mag->objs[mag->busy++] = obj;
    542542       
    543         spinlock_unlock(&cache->mag_cache[CPU->id].lock);
     543        irq_spinlock_unlock(&cache->mag_cache[CPU->id].lock, true);
    544544       
    545545        atomic_inc(&cache->cached_objs);
    … …  
    593593        for (i = 0; i < config.cpu_count; i++) {
    594594                memsetb(&cache->mag_cache[i], sizeof(cache->mag_cache[i]), 0);
    595                 spinlock_initialize(&cache->mag_cache[i].lock,
     595                irq_spinlock_initialize(&cache->mag_cache[i].lock,
    596596                    "slab.cache.mag_cache[].lock");
    597597        }
    … …  
    624624        list_initialize(&cache->magazines);
    625625       
    626         spinlock_initialize(&cache->slablock, "slab.cache.slablock");
    627         spinlock_initialize(&cache->maglock, "slab.cache.maglock");
     626        irq_spinlock_initialize(&cache->slablock, "slab.cache.slablock");
     627        irq_spinlock_initialize(&cache->maglock, "slab.cache.maglock");
    628628       
    629629        if (!(cache->flags & SLAB_CACHE_NOMAGAZINE))
    … …  
    704704                size_t i;
    705705                for (i = 0; i < config.cpu_count; i++) {
    706                         spinlock_lock(&cache->mag_cache[i].lock);
     706                        irq_spinlock_lock(&cache->mag_cache[i].lock, true);
    707707                       
    708708                        mag = cache->mag_cache[i].current;
    … …  
    716716                        cache->mag_cache[i].last = NULL;
    717717                       
    718                         spinlock_unlock(&cache->mag_cache[i].lock);
     718                        irq_spinlock_unlock(&cache->mag_cache[i].lock, true);
    719719                }
    720720        }

  • kernel/generic/src/synch/mutex.c

    ra8b8086 reb083ad  
    4040#include <debug.h>
    4141#include <arch.h>
     42#include <stacktrace.h>
    4243
    4344/** Initialize mutex.
    … …  
    6162        return semaphore_count_get(&mtx->sem) <= 0;
    6263}
     64
     65#define MUTEX_DEADLOCK_THRESHOLD        100000000
    6366
    6467/** Acquire mutex.
    … …  
    8790                ASSERT(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
    8891               
     92                unsigned int cnt = 0;
     93                bool deadlock_reported = false;
    8994                do {
     95                        if (cnt++ > MUTEX_DEADLOCK_THRESHOLD) {
     96                                printf("cpu%u: looping on active mutex %p\n",
     97                                    CPU->id, mtx);
     98                                stack_trace();
     99                                cnt = 0;
     100                                deadlock_reported = true;
     101                        }
    90102                        rc = semaphore_trydown(&mtx->sem);
    91103                } while (SYNCH_FAILED(rc) &&
    92104                    !(flags & SYNCH_FLAGS_NON_BLOCKING));
     105                if (deadlock_reported)
     106                        printf("cpu%u: not deadlocked\n", CPU->id);
    93107        }
    94108

  • kernel/generic/src/synch/spinlock.c

    ra8b8086 reb083ad  
    4444#include <debug.h>
    4545#include <symtab.h>
     46#include <stacktrace.h>
    4647
    4748#ifdef CONFIG_SMP
    … …  
    104105                            "caller=%p (%s)\n", CPU->id, lock, lock->name,
    105106                            (void *) CALLER, symtab_fmt_name_lookup(CALLER));
     107                        stack_trace();
    106108                       
    107109                        i = 0;
    … …  
    260262        int rc = spinlock_trylock(&(lock->lock));
    261263       
    262         ASSERT_IRQ_SPINLOCK(!lock->guard, lock);
     264        ASSERT_IRQ_SPINLOCK(!rc || !lock->guard, lock);
    263265        return rc;
    264266}

  • uspace/Makefile

    ra8b8086 reb083ad  
    4242        app/getterm \
    4343        app/init \
    44         app/inetcfg \
     44        app/inet \
    4545        app/kill \
    4646        app/killall \
    4747        app/klog \
    48         app/locinfo \
     48        app/loc \
    4949        app/lsusb \
    5050        app/mkfat \
    5151        app/mkexfat \
    5252        app/mkmfs \
     53        app/nterm \
    5354        app/redir \
    5455        app/sbi \
    … …  
    6869        app/nettest3 \
    6970        app/ping \
    70         app/websrv \
    7171        app/sysinfo \
    7272        app/mkbd \
    7373        app/date \
     74        app/websrv \
    7475        srv/clipboard \
    75         srv/loc \
     76        srv/locsrv \
    7677        srv/devman \
    7778        srv/loader \
    7879        srv/net/ethip \
    79         srv/net/inet \
     80        srv/net/inetsrv \
    8081        srv/net/loopip \
    8182        srv/net/tcp \

  • uspace/app/init/init.c

    ra8b8086 reb083ad  
    307307        spawn("/srv/loopip");
    308308        spawn("/srv/ethip");
    309         spawn("/srv/inet");
     309        spawn("/srv/inetsrv");
    310310        spawn("/srv/tcp");
    311311        spawn("/srv/udp");

  • uspace/app/sbi/src/stype.c

    ra8b8086 reb083ad  
    652652        assert(iface_ti->tic == tic_tobject);
    653653        iface = iface_ti->u.tobject->csi;
    654         assert(iface->cc = csi_interface);
     654        assert(iface->cc == csi_interface);
    655655
    656656#ifdef DEBUG_TYPE_TRACE

  • uspace/app/websrv/websrv.c

    ra8b8086 reb083ad  
    11/*
    2  * Copyright (c) 2011 Jiri Svoboda
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4141#include <stdlib.h>
    4242#include <fcntl.h>
     43#include <task.h>
    4344
    4445#include <net/in.h>
    … …  
    7172
    7273static char fbuf[BUFFER_SIZE];
     74
     75static bool verbose = false;
    7376
    7477/** Responses to send to client. */
    … …  
    187190        size_t response_size = str_size(msg);
    188191       
    189         fprintf(stderr, "Sending response\n");
     192        if (verbose)
     193            fprintf(stderr, "Sending response\n");
     194       
    190195        ssize_t rc = send(conn_sd, (void *) msg, response_size, 0);
    191196        if (rc < 0) {
    … …  
    251256        }
    252257       
    253         fprintf(stderr, "Request: %s", lbuf);
     258        if (verbose)
     259                fprintf(stderr, "Request: %s", lbuf);
    254260       
    255261        if (str_lcmp(lbuf, "GET ", 4) != 0) {
    … …  
    266272       
    267273        *end_uri = '\0';
    268         fprintf(stderr, "Requested URI: %s\n", uri);
     274        if (verbose)
     275                fprintf(stderr, "Requested URI: %s\n", uri);
    269276       
    270277        if (!uri_is_valid(uri)) {
    … …  
    287294            "\n"
    288295            "-h | --help\n"
    289             "\tShow this application help.\n");
     296            "\tShow this application help.\n"
     297            "-v | --verbose\n"
     298            "\tVerbose mode\n");
    290299}
    291300
    … …  
    306315               
    307316                port = (uint16_t) value;
     317                break;
     318        case 'v':
     319                verbose = true;
    308320                break;
    309321        /* Long options with double dash */
    … …  
    318330                       
    319331                        port = (uint16_t) value;
     332                } else if (str_cmp(argv[*index] +2, "verbose") == 0) {
     333                        verbose = true;
    320334                } else {
    321335                        usage();
    … …  
    358372        }
    359373       
    360         fprintf(stderr, "Creating socket\n");
     374        printf("%s: HelenOS web server\n", NAME);
     375
     376        if (verbose)
     377                fprintf(stderr, "Creating socket\n");
    361378       
    362379        int listen_sd = socket(PF_INET, SOCK_STREAM, 0);
    … …  
    380397        }
    381398       
    382         fprintf(stderr, "Listening for connections at port %" PRIu16 "\n",
    383             port);
     399        fprintf(stderr, "%s: Listening for connections at port %" PRIu16 "\n",
     400            NAME, port);
     401
     402        task_retval(0);
     403
    384404        while (true) {
    385405                struct sockaddr_in raddr;
    … …  
    393413                }
    394414               
    395                 fprintf(stderr, "Connection accepted (sd=%d), "
    396                     "waiting for request\n", conn_sd);
     415                if (verbose) {
     416                        fprintf(stderr, "Connection accepted (sd=%d), "
     417                            "waiting for request\n", conn_sd);
     418                }
    397419               
    398420                rbuf_out = 0;
    … …  
    412434                }
    413435               
    414                 fprintf(stderr, "Connection closed\n");
     436                if (verbose)
     437                        fprintf(stderr, "Connection closed\n");
    415438        }
    416439       

  • uspace/lib/c/Makefile

    ra8b8086 reb083ad  
    123123        generic/vfs/canonify.c \
    124124        generic/net/inet.c \
    125         generic/net/modules.c \
    126125        generic/net/socket_client.c \
    127126        generic/net/socket_parse.c \

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

    ra8b8086 reb083ad  
    4444#include <errno.h>
    4545#include <task.h>
     46#include <ns.h>
    4647#include <ipc/services.h>
    4748#include <ipc/socket.h>
    48 #include <net/modules.h>
    4949#include <net/in.h>
    5050#include <net/socket.h>
    … …  
    284284{
    285285        if (socket_globals.tcp_sess == NULL) {
    286                 socket_globals.tcp_sess = bind_service(SERVICE_TCP,
     286                socket_globals.tcp_sess = service_bind(SERVICE_TCP,
    287287                    0, 0, SERVICE_TCP, socket_connection);
    288288        }
    … …  
    301301{
    302302        if (socket_globals.udp_sess == NULL) {
    303                 socket_globals.udp_sess = bind_service(SERVICE_UDP,
     303                socket_globals.udp_sess = service_bind(SERVICE_UDP,
    304304                    0, 0, SERVICE_UDP, socket_connection);
    305305        }
    … …  
    378378 * @return              Other error codes as defined for the NET_SOCKET message.
    379379 * @return              Other error codes as defined for the
    380  *                      bind_service() function.
     380 *                      service_bind() function.
    381381 */
    382382int socket(int domain, int type, int protocol)

  • uspace/lib/c/generic/ns.c

    ra8b8086 reb083ad  
    3737#include <async.h>
    3838#include <macros.h>
     39#include <errno.h>
    3940#include "private/ns.h"
    4041
    … …  
    4849}
    4950
    50 async_sess_t *service_connect(exch_mgmt_t mgmt, sysarg_t service, sysarg_t arg2,
     51async_sess_t *service_connect(exch_mgmt_t mgmt, services_t service, sysarg_t arg2,
    5152    sysarg_t arg3)
    5253{
    … …  
    7273}
    7374
    74 async_sess_t *service_connect_blocking(exch_mgmt_t mgmt, sysarg_t service,
     75async_sess_t *service_connect_blocking(exch_mgmt_t mgmt, services_t service,
    7576    sysarg_t arg2, sysarg_t arg3)
    7677{
    … …  
    8182            async_connect_me_to_blocking(mgmt, exch, service, arg2, arg3);
    8283        async_exchange_end(exch);
    83 
     84       
    8485        if (!sess)
    8586                return NULL;
    … …  
    9192         */
    9293        async_sess_args_set(sess, arg2, arg3, 0);
     94       
     95        return sess;
     96}
     97
     98/** Create bidirectional connection with a service
     99 *
     100 * @param[in] service         Service.
     101 * @param[in] arg1            First parameter.
     102 * @param[in] arg2            Second parameter.
     103 * @param[in] arg3            Third parameter.
     104 * @param[in] client_receiver Message receiver.
     105 *
     106 * @return Session to the service.
     107 * @return Other error codes as defined by async_connect_to_me().
     108 *
     109 */
     110async_sess_t *service_bind(services_t service, sysarg_t arg1, sysarg_t arg2,
     111    sysarg_t arg3, async_client_conn_t client_receiver)
     112{
     113        /* Connect to the needed service */
     114        async_sess_t *sess =
     115            service_connect_blocking(EXCHANGE_SERIALIZE, service, 0, 0);
     116        if (sess != NULL) {
     117                /* Request callback connection */
     118                async_exch_t *exch = async_exchange_begin(sess);
     119                int rc = async_connect_to_me(exch, arg1, arg2, arg3,
     120                    client_receiver, NULL);
     121                async_exchange_end(exch);
     122               
     123                if (rc != EOK) {
     124                        async_hangup(sess);
     125                        errno = rc;
     126                        return NULL;
     127                }
     128        }
    93129       
    94130        return sess;

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

    ra8b8086 reb083ad  
    3737
    3838#include <sys/types.h>
     39#include <ipc/services.h>
    3940#include <task.h>
    4041#include <async.h>
    4142
    4243extern int service_register(sysarg_t);
    43 extern async_sess_t *service_connect(exch_mgmt_t, sysarg_t, sysarg_t, sysarg_t);
    44 extern async_sess_t *service_connect_blocking(exch_mgmt_t, sysarg_t, sysarg_t,
     44extern async_sess_t *service_connect(exch_mgmt_t, services_t, sysarg_t, sysarg_t);
     45extern async_sess_t *service_connect_blocking(exch_mgmt_t, services_t, sysarg_t,
    4546    sysarg_t);
     47extern async_sess_t *service_bind(services_t, sysarg_t, sysarg_t, sysarg_t,
     48    async_client_conn_t);
    4649
    4750extern int ns_ping(void);

  • uspace/lib/net/tl/socket_core.c

    ra8b8086 reb083ad  
    3939#include <net/in.h>
    4040#include <net/inet.h>
    41 #include <net/modules.h>
    4241#include <stdint.h>
    4342#include <stdlib.h>

  • uspace/lib/usb/include/usb/debug.h

    ra8b8086 reb083ad  
    8181
    8282/** Default log level. */
    83 #ifdef CONFIG_USB_RELEASE_BUILD
     83#ifdef CONFIG_USB_VERBOSE
     84#  define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_DEBUG
     85#else
    8486#  define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_INFO
    85 #else
    86 #  define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_DEBUG
    8787#endif
    8888

  • uspace/lib/usb/src/hc.c

    ra8b8086 reb083ad  
    6666        if (connection->ref_count == 0) {
    6767                /* Closing already closed connection... */
    68                 assert(connection->hc_sess = NULL);
     68                assert(connection->hc_sess == NULL);
    6969                fibril_mutex_unlock(&connection->guard);
    7070                return EOK;

  • uspace/srv/net/tcp/conn.c

    ra8b8086 reb083ad  
    184184void tcp_conn_addref(tcp_conn_t *conn)
    185185{
    186         log_msg(LVL_DEBUG, "%s: tcp_conn_addref(%p)", conn->name, conn);
     186        log_msg(LVL_DEBUG2, "%s: tcp_conn_addref(%p)", conn->name, conn);
    187187        atomic_inc(&conn->refcnt);
    188188}
    … …  
    196196void tcp_conn_delref(tcp_conn_t *conn)
    197197{
    198         log_msg(LVL_DEBUG, "%s: tcp_conn_delref(%p)", conn->name, conn);
     198        log_msg(LVL_DEBUG2, "%s: tcp_conn_delref(%p)", conn->name, conn);
    199199
    200200        if (atomic_predec(&conn->refcnt) == 0)
    … …  
    312312static bool tcp_socket_match(tcp_sock_t *sock, tcp_sock_t *patt)
    313313{
    314         log_msg(LVL_DEBUG, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))",
     314        log_msg(LVL_DEBUG2, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))",
    315315            sock->addr.ipv4, sock->port, patt->addr.ipv4, patt->port);
    316316
    … …  
    323323                return false;
    324324
    325         log_msg(LVL_DEBUG, " -> match");
     325        log_msg(LVL_DEBUG2, " -> match");
    326326
    327327        return true;
    … …  
    331331static bool tcp_sockpair_match(tcp_sockpair_t *sp, tcp_sockpair_t *pattern)
    332332{
    333         log_msg(LVL_DEBUG, "tcp_sockpair_match(%p, %p)", sp, pattern);
     333        log_msg(LVL_DEBUG2, "tcp_sockpair_match(%p, %p)", sp, pattern);
    334334
    335335        if (!tcp_socket_match(&sp->local, &pattern->local))
    … …  
    360360                tcp_conn_t *conn = list_get_instance(link, tcp_conn_t, link);
    361361                tcp_sockpair_t *csp = &conn->ident;
    362                 log_msg(LVL_DEBUG, "compare with conn (f:(%x,%u), l:(%x,%u))",
     362                log_msg(LVL_DEBUG2, "compare with conn (f:(%x,%u), l:(%x,%u))",
    363363                    csp->foreign.addr.ipv4, csp->foreign.port,
    364364                    csp->local.addr.ipv4, csp->local.port);

  • uspace/srv/net/tcp/ncsim.c

    ra8b8086 reb083ad  
    4444#include <io/log.h>
    4545#include <stdlib.h>
    46 #include <thread.h>
     46#include <fibril.h>
    4747#include "conn.h"
    4848#include "ncsim.h"
    … …  
    119119}
    120120
    121 /** Network condition simulator handler thread. */
    122 static void tcp_ncsim_thread(void *arg)
     121/** Network condition simulator handler fibril. */
     122static int tcp_ncsim_fibril(void *arg)
    123123{
    124124        link_t *link;
    … …  
    126126        int rc;
    127127
    128         log_msg(LVL_DEBUG, "tcp_ncsim_thread()");
     128        log_msg(LVL_DEBUG, "tcp_ncsim_fibril()");
    129129
    130130
    … …  
    151151                free(sqe);
    152152        }
     153
     154        /* Not reached */
     155        return 0;
    153156}
    154157
    155 /** Start simulator handler thread. */
    156 void tcp_ncsim_thread_start(void)
     158/** Start simulator handler fibril. */
     159void tcp_ncsim_fibril_start(void)
    157160{
    158         thread_id_t tid;
    159         int rc;
     161        fid_t fid;
    160162
    161         log_msg(LVL_DEBUG, "tcp_ncsim_thread_start()");
     163        log_msg(LVL_DEBUG, "tcp_ncsim_fibril_start()");
    162164
    163         rc = thread_create(tcp_ncsim_thread, NULL, "ncsim", &tid);
    164         if (rc != EOK) {
    165                 log_msg(LVL_ERROR, "Failed creating ncsim thread.");
     165        fid = fibril_create(tcp_ncsim_fibril, NULL);
     166        if (fid == 0) {
     167                log_msg(LVL_ERROR, "Failed creating ncsim fibril.");
    166168                return;
    167169        }
     170
     171        fibril_add_ready(fid);
    168172}
    169173

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

    ra8b8086 reb083ad  
    4040extern void tcp_ncsim_init(void);
    4141extern void tcp_ncsim_bounce_seg(tcp_sockpair_t *, tcp_segment_t *);
    42 extern void tcp_ncsim_thread_start(void);
    43 
     42extern void tcp_ncsim_fibril_start(void);
    4443
    4544#endif

  • uspace/srv/net/tcp/rqueue.c

    ra8b8086 reb083ad  
    3939#include <io/log.h>
    4040#include <stdlib.h>
    41 #include <thread.h>
     41#include <fibril.h>
    4242#include "conn.h"
    4343#include "pdu.h"
    … …  
    128128}
    129129
    130 /** Receive queue handler thread. */
    131 static void tcp_rqueue_thread(void *arg)
     130/** Receive queue handler fibril. */
     131static int tcp_rqueue_fibril(void *arg)
    132132{
    133133        link_t *link;
    134134        tcp_rqueue_entry_t *rqe;
    135135
    136         log_msg(LVL_DEBUG, "tcp_rqueue_thread()");
     136        log_msg(LVL_DEBUG, "tcp_rqueue_fibril()");
    137137
    138138        while (true) {
    … …  
    142142                tcp_as_segment_arrived(&rqe->sp, rqe->seg);
    143143        }
     144
     145        /* Not reached */
     146        return 0;
    144147}
    145148
    146 /** Start receive queue handler thread. */
    147 void tcp_rqueue_thread_start(void)
     149/** Start receive queue handler fibril. */
     150void tcp_rqueue_fibril_start(void)
    148151{
    149         thread_id_t tid;
    150         int rc;
     152        fid_t fid;
    151153
    152         log_msg(LVL_DEBUG, "tcp_rqueue_thread_start()");
     154        log_msg(LVL_DEBUG, "tcp_rqueue_fibril_start()");
    153155
    154         rc = thread_create(tcp_rqueue_thread, NULL, "rqueue", &tid);
    155         if (rc != EOK) {
    156                 log_msg(LVL_ERROR, "Failed creating rqueue thread.");
     156        fid = fibril_create(tcp_rqueue_fibril, NULL);
     157        if (fid == 0) {
     158                log_msg(LVL_ERROR, "Failed creating rqueue fibril.");
    157159                return;
    158160        }
     161
     162        fibril_add_ready(fid);
    159163}
    160164

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

    ra8b8086 reb083ad  
    4242extern void tcp_rqueue_insert_seg(tcp_sockpair_t *, tcp_segment_t *);
    4343extern void tcp_rqueue_handler(void *);
    44 extern void tcp_rqueue_thread_start(void);
     44extern void tcp_rqueue_fibril_start(void);
    4545
    4646

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

    ra8b8086 reb083ad  
    248248void tcp_segment_dump(tcp_segment_t *seg)
    249249{
    250         log_msg(LVL_DEBUG, "Segment dump:");
    251         log_msg(LVL_DEBUG, " - ctrl = %u", (unsigned)seg->ctrl);
    252         log_msg(LVL_DEBUG, " - seq = % " PRIu32, seg->seq);
    253         log_msg(LVL_DEBUG, " - ack = % " PRIu32, seg->ack);
    254         log_msg(LVL_DEBUG, " - len = % " PRIu32, seg->len);
    255         log_msg(LVL_DEBUG, " - wnd = % " PRIu32, seg->wnd);
    256         log_msg(LVL_DEBUG, " - up = % " PRIu32, seg->up);
     250        log_msg(LVL_DEBUG2, "Segment dump:");
     251        log_msg(LVL_DEBUG2, " - ctrl = %u", (unsigned)seg->ctrl);
     252        log_msg(LVL_DEBUG2, " - seq = % " PRIu32, seg->seq);
     253        log_msg(LVL_DEBUG2, " - ack = % " PRIu32, seg->ack);
     254        log_msg(LVL_DEBUG2, " - len = % " PRIu32, seg->len);
     255        log_msg(LVL_DEBUG2, " - wnd = % " PRIu32, seg->wnd);
     256        log_msg(LVL_DEBUG2, " - up = % " PRIu32, seg->up);
    257257}
    258258

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

    ra8b8086 reb083ad  
    4242#include <ipc/services.h>
    4343#include <ipc/socket.h>
    44 #include <net/modules.h>
    4544#include <net/socket.h>
    4645#include <ns.h>
    … …  
    5251#include "ucall.h"
    5352
    54 #define FRAGMENT_SIZE 1024
    55 
    5653#define MAX_BACKLOG 128
    5754
    … …  
    6764static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    6865static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
     66static int tcp_sock_recv_fibril(void *arg);
    6967
    7068int tcp_sock_init(void)
    … …  
    9896        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    9997        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    100             FRAGMENT_SIZE, 0, 0, 1);
     98            TCP_SOCK_FRAGMENT_SIZE, 0, 0, 1);
    10199        async_exchange_end(exch);
    102100}
    … …  
    107105        async_exch_t *exch = async_exchange_begin(lsock_core->sess);
    108106        async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id,
    109             FRAGMENT_SIZE, 0, 0, 0);
     107            TCP_SOCK_FRAGMENT_SIZE, 0, 0, 0);
    110108        async_exchange_end(exch);
    111109}
    112110
     111static int tcp_sock_create(tcp_client_t *client, tcp_sockdata_t **rsock)
     112{
     113        tcp_sockdata_t *sock;
     114
     115        log_msg(LVL_DEBUG, "tcp_sock_create()");
     116        *rsock = NULL;
     117
     118        sock = calloc(sizeof(tcp_sockdata_t), 1);
     119        if (sock == NULL)
     120                return ENOMEM;
     121
     122        fibril_mutex_initialize(&sock->lock);
     123        sock->client = client;
     124
     125        sock->recv_buffer_used = 0;
     126        sock->recv_error = TCP_EOK;
     127        fibril_mutex_initialize(&sock->recv_buffer_lock);
     128        fibril_condvar_initialize(&sock->recv_buffer_cv);
     129        list_initialize(&sock->ready);
     130
     131        *rsock = sock;
     132        return EOK;
     133}
     134
     135static void tcp_sock_uncreate(tcp_sockdata_t *sock)
     136{
     137        log_msg(LVL_DEBUG, "tcp_sock_uncreate()");
     138        free(sock);
     139}
     140
     141static int tcp_sock_finish_setup(tcp_sockdata_t *sock, int *sock_id)
     142{
     143        socket_core_t *sock_core;
     144        int rc;
     145
     146        log_msg(LVL_DEBUG, "tcp_sock_finish_setup()");
     147
     148        sock->recv_fibril = fibril_create(tcp_sock_recv_fibril, sock);
     149        if (sock->recv_fibril == 0)
     150                return ENOMEM;
     151
     152        rc = socket_create(&sock->client->sockets, sock->client->sess,
     153            sock, sock_id);
     154
     155        if (rc != EOK)
     156                return rc;
     157
     158        sock_core = socket_cores_find(&sock->client->sockets, *sock_id);
     159        assert(sock_core != NULL);
     160        sock->sock_core = sock_core;
     161
     162        return EOK;
     163}
     164
    113165static void tcp_sock_socket(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    114166{
    115167        tcp_sockdata_t *sock;
    116         socket_core_t *sock_core;
    117168        int sock_id;
    118169        int rc;
    … …  
    120171
    121172        log_msg(LVL_DEBUG, "tcp_sock_socket()");
    122         sock = calloc(sizeof(tcp_sockdata_t), 1);
    123         if (sock == NULL) {
    124                 async_answer_0(callid, ENOMEM);
    125                 return;
    126         }
    127 
    128         fibril_mutex_initialize(&sock->lock);
    129         sock->client = client;
     173
     174        rc = tcp_sock_create(client, &sock);
     175        if (rc != EOK) {
     176                async_answer_0(callid, rc);
     177                return;
     178        }
     179
    130180        sock->laddr.ipv4 = TCP_IPV4_ANY;
    131181        sock->lconn = NULL;
    132182        sock->backlog = 0;
    133         list_initialize(&sock->ready);
    134183
    135184        sock_id = SOCKET_GET_SOCKET_ID(call);
    136         rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
     185        rc = tcp_sock_finish_setup(sock, &sock_id);
    137186        if (rc != EOK) {
     187                tcp_sock_uncreate(sock);
    138188                async_answer_0(callid, rc);
    139189                return;
    140190        }
    141191
    142         sock_core = socket_cores_find(&client->sockets, sock_id);
    143         assert(sock_core != NULL);
    144         sock->sock_core = sock_core;
    145 
    146         refresh_answer(&answer, NULL);
    147192        SOCKET_SET_SOCKET_ID(answer, sock_id);
    148193
    149         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     194        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
    150195        SOCKET_SET_HEADER_SIZE(answer, sizeof(tcp_header_t));
    151         answer_call(callid, EOK, &answer, 3);
     196       
     197        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
     198            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    152199}
    153200
    … …  
    361408        }
    362409
     410        if (rc == EOK)
     411                fibril_add_ready(socket->recv_fibril);
     412
    363413        async_answer_0(callid, rc);
    364 
    365         /* Push one fragment notification to client's queue */
    366         tcp_sock_notify_data(sock_core);
    367         log_msg(LVL_DEBUG, "tcp_sock_connect(): notify conn\n");
    368414}
    369415
    … …  
    374420        int asock_id;
    375421        socket_core_t *sock_core;
    376         socket_core_t *asock_core;
    377422        tcp_sockdata_t *socket;
    378423        tcp_sockdata_t *asocket;
    … …  
    444489        /* Allocate socket for accepted connection */
    445490
    446         log_msg(LVL_DEBUG, "tcp_sock_accept(): allocate asocket\n");
    447         asocket = calloc(sizeof(tcp_sockdata_t), 1);
    448         if (asocket == NULL) {
    449                 fibril_mutex_unlock(&socket->lock);
    450                 async_answer_0(callid, ENOMEM);
    451                 return;
    452         }
    453 
    454         fibril_mutex_initialize(&asocket->lock);
    455         asocket->client = client;
     491        rc = tcp_sock_create(client, &asocket);
     492        if (rc != EOK) {
     493                fibril_mutex_unlock(&socket->lock);
     494                async_answer_0(callid, rc);
     495                return;
     496        }
     497
    456498        asocket->conn = conn;
    457499        log_msg(LVL_DEBUG, "tcp_sock_accept():create asocket\n");
    458500
    459         rc = socket_create(&client->sockets, client->sess, asocket, &asock_id);
     501        rc = tcp_sock_finish_setup(asocket, &asock_id);
    460502        if (rc != EOK) {
     503                tcp_sock_uncreate(asocket);
    461504                fibril_mutex_unlock(&socket->lock);
    462505                async_answer_0(callid, rc);
    463506                return;
    464507        }
     508
     509        fibril_add_ready(asocket->recv_fibril);
     510
    465511        log_msg(LVL_DEBUG, "tcp_sock_accept(): find acore\n");
    466512
    467         asock_core = socket_cores_find(&client->sockets, asock_id);
    468         assert(asock_core != NULL);
    469 
    470         refresh_answer(&answer, NULL);
    471 
    472         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     513        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
    473514        SOCKET_SET_SOCKET_ID(answer, asock_id);
    474515        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(struct sockaddr_in));
    475 
    476         answer_call(callid, asock_core->socket_id, &answer, 3);
    477 
     516       
     517        async_answer_3(callid, asocket->sock_core->socket_id,
     518            IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     519            IPC_GET_ARG3(answer));
     520       
    478521        /* Push one fragment notification to client's queue */
    479522        log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n");
    480         tcp_sock_notify_data(asock_core);
    481523        fibril_mutex_unlock(&socket->lock);
    482524}
    … …  
    492534        ipc_callid_t wcallid;
    493535        size_t length;
    494         uint8_t buffer[FRAGMENT_SIZE];
     536        uint8_t buffer[TCP_SOCK_FRAGMENT_SIZE];
    495537        tcp_error_t trc;
    496538        int rc;
    … …  
    523565                }
    524566
    525                 if (length > FRAGMENT_SIZE)
    526                         length = FRAGMENT_SIZE;
     567                if (length > TCP_SOCK_FRAGMENT_SIZE)
     568                        length = TCP_SOCK_FRAGMENT_SIZE;
    527569
    528570                rc = async_data_write_finalize(wcallid, buffer, length);
    … …  
    559601        }
    560602
    561         refresh_answer(&answer, NULL);
    562         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    563         answer_call(callid, EOK, &answer, 2);
     603        IPC_SET_ARG1(answer, 0);
     604        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
     605        async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
     606            IPC_GET_ARG2(answer));
    564607        fibril_mutex_unlock(&socket->lock);
    565608}
    … …  
    580623        ipc_call_t answer;
    581624        ipc_callid_t rcallid;
    582         uint8_t buffer[FRAGMENT_SIZE];
    583625        size_t data_len;
    584         xflags_t xflags;
    585         tcp_error_t trc;
    586626        struct sockaddr_in addr;
    587627        tcp_sock_t *rsock;
    … …  
    610650        (void)flags;
    611651
    612         trc = tcp_uc_receive(socket->conn, buffer, FRAGMENT_SIZE, &data_len,
    613             &xflags);
    614         log_msg(LVL_DEBUG, "**** tcp_uc_receive done");
    615 
    616         switch (trc) {
     652        log_msg(LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
     653        fibril_mutex_lock(&socket->recv_buffer_lock);
     654        while (socket->recv_buffer_used == 0 && socket->recv_error == TCP_EOK) {
     655                log_msg(LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
     656                fibril_condvar_wait(&socket->recv_buffer_cv,
     657                    &socket->recv_buffer_lock);
     658        }
     659
     660        log_msg(LVL_DEBUG, "Got data in sock recv_buffer");
     661
     662        data_len = socket->recv_buffer_used;
     663        rc = socket->recv_error;
     664
     665        switch (socket->recv_error) {
    617666        case TCP_EOK:
    618667                rc = EOK;
    … …  
    629678        }
    630679
    631         log_msg(LVL_DEBUG, "**** tcp_uc_receive -> %d", rc);
     680        log_msg(LVL_DEBUG, "**** recv result -> %d", rc);
    632681        if (rc != EOK) {
     682                fibril_mutex_unlock(&socket->recv_buffer_lock);
    633683                fibril_mutex_unlock(&socket->lock);
    634684                async_answer_0(callid, rc);
    … …  
    645695                log_msg(LVL_DEBUG, "addr read receive");
    646696                if (!async_data_read_receive(&rcallid, &addr_length)) {
     697                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    647698                        fibril_mutex_unlock(&socket->lock);
    648699                        async_answer_0(callid, EINVAL);
    … …  
    656707                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    657708                if (rc != EOK) {
     709                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    658710                        fibril_mutex_unlock(&socket->lock);
    659711                        async_answer_0(callid, EINVAL);
    … …  
    664716        log_msg(LVL_DEBUG, "data read receive");
    665717        if (!async_data_read_receive(&rcallid, &length)) {
     718                fibril_mutex_unlock(&socket->recv_buffer_lock);
    666719                fibril_mutex_unlock(&socket->lock);
    667720                async_answer_0(callid, EINVAL);
    … …  
    673726
    674727        log_msg(LVL_DEBUG, "data read finalize");
    675         rc = async_data_read_finalize(rcallid, buffer, length);
     728        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
     729
     730        socket->recv_buffer_used -= length;
     731        log_msg(LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
     732            socket->recv_buffer_used);
     733        if (socket->recv_buffer_used > 0) {
     734                memmove(socket->recv_buffer, socket->recv_buffer + length,
     735                    socket->recv_buffer_used);
     736                tcp_sock_notify_data(socket->sock_core);
     737        }
     738
     739        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    676740
    677741        if (length < data_len && rc == EOK)
    … …  
    679743
    680744        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    681         answer_call(callid, EOK, &answer, 1);
    682 
    683         /* Push one fragment notification to client's queue */
    684         tcp_sock_notify_data(sock_core);
     745        async_answer_1(callid, EOK, IPC_GET_ARG1(answer));
     746
     747        fibril_mutex_unlock(&socket->recv_buffer_lock);
    685748        fibril_mutex_unlock(&socket->lock);
    686749}
    … …  
    693756        tcp_error_t trc;
    694757        int rc;
    695         uint8_t buffer[FRAGMENT_SIZE];
    696         size_t data_len;
    697         xflags_t xflags;
    698758
    699759        log_msg(LVL_DEBUG, "tcp_sock_close()");
    … …  
    716776                        return;
    717777                }
    718 
    719                 /* Drain incoming data. This should really be done in the background. */
    720                 do {
    721                         trc = tcp_uc_receive(socket->conn, buffer,
    722                             FRAGMENT_SIZE, &data_len, &xflags);
    723                 } while (trc == TCP_EOK);
    724 
    725                 tcp_uc_delete(socket->conn);
    726778        }
    727779
    … …  
    775827        tcp_sock_notify_aconn(socket->sock_core);
    776828        fibril_mutex_unlock(&socket->lock);
     829}
     830
     831static int tcp_sock_recv_fibril(void *arg)
     832{
     833        tcp_sockdata_t *sock = (tcp_sockdata_t *)arg;
     834        size_t data_len;
     835        xflags_t xflags;
     836        tcp_error_t trc;
     837
     838        log_msg(LVL_DEBUG, "tcp_sock_recv_fibril()");
     839
     840        while (true) {
     841                log_msg(LVL_DEBUG, "call tcp_uc_receive()");
     842                fibril_mutex_lock(&sock->recv_buffer_lock);
     843                while (sock->recv_buffer_used != 0)
     844                        fibril_condvar_wait(&sock->recv_buffer_cv,
     845                            &sock->recv_buffer_lock);
     846
     847                trc = tcp_uc_receive(sock->conn, sock->recv_buffer,
     848                    TCP_SOCK_FRAGMENT_SIZE, &data_len, &xflags);
     849
     850                if (trc != TCP_EOK) {
     851                        sock->recv_error = trc;
     852                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
     853                        fibril_mutex_unlock(&sock->recv_buffer_lock);
     854                        tcp_sock_notify_data(sock->sock_core);
     855                        break;
     856                }
     857
     858                log_msg(LVL_DEBUG, "got data - broadcast recv_buffer_cv");
     859
     860                sock->recv_buffer_used = data_len;
     861                fibril_condvar_broadcast(&sock->recv_buffer_cv);
     862                fibril_mutex_unlock(&sock->recv_buffer_lock);
     863                tcp_sock_notify_data(sock->sock_core);
     864        }
     865
     866        tcp_uc_delete(sock->conn);
     867
     868        return 0;
    777869}
    778870

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

    ra8b8086 reb083ad  
    180180
    181181        tcp_rqueue_init();
    182         tcp_rqueue_thread_start();
     182        tcp_rqueue_fibril_start();
    183183
    184184        tcp_ncsim_init();
    185         tcp_ncsim_thread_start();
     185        tcp_ncsim_fibril_start();
    186186
    187187        if (0) tcp_test();

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

    ra8b8086 reb083ad  
    3939#include <async.h>
    4040#include <bool.h>
     41#include <fibril.h>
    4142#include <fibril_synch.h>
    4243#include <socket_core.h>
    … …  
    331332} tcp_client_t;
    332333
     334#define TCP_SOCK_FRAGMENT_SIZE 1024
     335
    333336typedef struct tcp_sockdata {
    334337        /** Lock */
    … …  
    348351        /** List of connections (from lconn) that are ready to be accepted */
    349352        list_t ready;
     353        /** Receiving fibril */
     354        fid_t recv_fibril;
     355        uint8_t recv_buffer[TCP_SOCK_FRAGMENT_SIZE];
     356        size_t recv_buffer_used;
     357        fibril_mutex_t recv_buffer_lock;
     358        fibril_condvar_t recv_buffer_cv;
     359        tcp_error_t recv_error;
    350360} tcp_sockdata_t;
    351361

  • uspace/srv/net/tcp/test.c

    ra8b8086 reb083ad  
    3838#include <errno.h>
    3939#include <stdio.h>
    40 #include <thread.h>
     40#include <fibril.h>
    4141#include <str.h>
    4242#include "tcp_type.h"
    … …  
    4747#define RCV_BUF_SIZE 64
    4848
    49 static void test_srv(void *arg)
     49static int test_srv(void *arg)
    5050{
    5151        tcp_conn_t *conn;
    … …  
    8484
    8585        printf("test_srv() terminating\n");
     86        return 0;
    8687}
    8788
    88 static void test_cli(void *arg)
     89static int test_cli(void *arg)
    8990{
    9091        tcp_conn_t *conn;
    … …  
    112113        printf("C: User close...\n");
    113114        tcp_uc_close(conn);
     115
     116        return 0;
    114117}
    115118
    116119void tcp_test(void)
    117120{
    118         thread_id_t srv_tid;
    119         thread_id_t cli_tid;
    120         int rc;
     121        fid_t srv_fid;
     122        fid_t cli_fid;
    121123
    122124        printf("tcp_test()\n");
    … …  
    125127
    126128        if (0) {
    127                 rc = thread_create(test_srv, NULL, "test_srv", &srv_tid);
    128                 if (rc != EOK) {
    129                         printf("Failed to create server thread.\n");
     129                srv_fid = fibril_create(test_srv, NULL);
     130                if (srv_fid == 0) {
     131                        printf("Failed to create server fibril.\n");
    130132                        return;
    131133                }
     134
     135                fibril_add_ready(srv_fid);
    132136        }
    133137
    134138        if (0) {
    135                 rc = thread_create(test_cli, NULL, "test_cli", &cli_tid);
    136                 if (rc != EOK) {
    137                         printf("Failed to create client thread.\n");
     139                cli_fid = fibril_create(test_cli, NULL);
     140                if (cli_fid == 0) {
     141                        printf("Failed to create client fibril.\n");
    138142                        return;
    139143                }
     144
     145                fibril_add_ready(cli_fid);
    140146        }
    141147}

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

    ra8b8086 reb083ad  
    4343#include <ipc/services.h>
    4444#include <ipc/socket.h>
    45 #include <net/modules.h>
    4645#include <net/socket.h>
    4746#include <ns.h>
    … …  
    134133        assert(sock_core != NULL);
    135134        sock->sock_core = sock_core;
    136 
    137 
    138         refresh_answer(&answer, NULL);
     135       
    139136        SOCKET_SET_SOCKET_ID(answer, sock_id);
    140137
    141138        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    142139        SOCKET_SET_HEADER_SIZE(answer, sizeof(udp_header_t));
    143         answer_call(callid, EOK, &answer, 3);
     140        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
     141            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    144142}
    145143
    … …  
    369367                }
    370368        }
    371 
    372         refresh_answer(&answer, NULL);
     369       
     370        IPC_SET_ARG1(answer, 0);
    373371        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    374         answer_call(callid, EOK, &answer, 2);
     372        async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
     373            IPC_GET_ARG2(answer));
    375374        fibril_mutex_unlock(&socket->lock);
     375       
    376376out:
    377377        if (addr != NULL)
    … …  
    486486
    487487        log_msg(LVL_DEBUG, "read_data_length <- %zu", length);
     488        IPC_SET_ARG2(answer, 0);
    488489        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    489490        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
    490         answer_call(callid, EOK, &answer, 3);
    491 
     491        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
     492            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
     493       
    492494        /* Push one fragment notification to client's queue */
    493495        udp_sock_notify_data(sock_core);
Note: See TracChangeset for help on using the changeset viewer.