Changes in / [4b82445:738b549] in mainline


Ignore:
Files:
5 deleted
23 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r4b82445 r738b549  
    578578# USB settings
    579579
    580 % USB verbose messages
    581 ! CONFIG_USB_VERBOSE (n/y)
     580% USB release build (less logging)
     581! CONFIG_USB_RELEASE_BUILD (y/n)
    582582
    583583% Start virtual USB host controller

  • boot/Makefile.common

    r4b82445 r738b549  
    177177        $(USPACE_PATH)/app/nettest3/nettest3 \
    178178        $(USPACE_PATH)/app/netecho/netecho \
    179         $(USPACE_PATH)/app/nterm/nterm \
    180179        $(USPACE_PATH)/app/ping/ping \
    181180        $(USPACE_PATH)/app/stats/stats \

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

    r4b82445 r738b549  
    3131 */
    3232/** @file
     33 */
     34
     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 *
    3342 */
    3443

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

    r4b82445 r738b549  
    4848#include <align.h>
    4949#include <macros.h>
    50 #include <bitops.h>
    5150
    5251static void pt_mapping_insert(as_t *, uintptr_t, uintptr_t, unsigned int);
    … …  
    293292}
    294293
    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  */
    299 static 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 
    309294/** Make the mappings in the given range global accross all address spaces.
    310295 *
    … …  
    324309{
    325310        uintptr_t ptl0 = PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
    326         uintptr_t ptl0_step = ptl0_step_get();
     311        uintptr_t ptl0step = (((uintptr_t) -1) / PTL0_ENTRIES) + 1;
    327312        size_t order;
    328313        uintptr_t addr;
    … …  
    336321#endif
    337322
     323        ASSERT(ispwr2(ptl0step));
    338324        ASSERT(size > 0);
    339325
    340         for (addr = ALIGN_DOWN(base, ptl0_step); addr - 1 < base + size - 1;
    341             addr += ptl0_step) {
     326        for (addr = ALIGN_DOWN(base, ptl0step); addr - 1 < base + size - 1;
     327            addr += ptl0step) {
    342328                uintptr_t l1;
    343329

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

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

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

    r4b82445 r738b549  
    8181        slab_magazine_t *current;
    8282        slab_magazine_t *last;
    83         IRQ_SPINLOCK_DECLARE(lock);
     83        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         IRQ_SPINLOCK_DECLARE(slablock);
     115        SPINLOCK_DECLARE(slablock);
    116116        /* Magazines */
    117117        list_t magazines;  /**< List o full magazines */
    118         IRQ_SPINLOCK_DECLARE(maglock);
     118        SPINLOCK_DECLARE(maglock);
    119119       
    120120        /** CPU cache */

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

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

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

    r4b82445 r738b549  
    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();
    10931088                mutex_lock(&mem_avail_mtx);
    10941089               
    … …  
    11031098               
    11041099                mutex_unlock(&mem_avail_mtx);
    1105                 interrupts_restore(ipl);
    11061100               
    11071101#ifdef CONFIG_DEBUG
    … …  
    11671161         * Signal that some memory has been freed.
    11681162         */
    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();
    11761163        mutex_lock(&mem_avail_mtx);
    11771164        if (mem_avail_req > 0)
    … …  
    11831170        }
    11841171        mutex_unlock(&mem_avail_mtx);
    1185         interrupts_restore(ipl);
    11861172       
    11871173        if (!(flags & FRAME_NO_RESERVE))

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

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

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

    r4b82445 r738b549  
    4040#include <debug.h>
    4141#include <arch.h>
    42 #include <stacktrace.h>
    4342
    4443/** Initialize mutex.
    … …  
    6261        return semaphore_count_get(&mtx->sem) <= 0;
    6362}
    64 
    65 #define MUTEX_DEADLOCK_THRESHOLD        100000000
    6663
    6764/** Acquire mutex.
    … …  
    9087                ASSERT(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
    9188               
    92                 unsigned int cnt = 0;
    93                 bool deadlock_reported = false;
    9489                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                         }
    10290                        rc = semaphore_trydown(&mtx->sem);
    10391                } while (SYNCH_FAILED(rc) &&
    10492                    !(flags & SYNCH_FLAGS_NON_BLOCKING));
    105                 if (deadlock_reported)
    106                         printf("cpu%u: not deadlocked\n", CPU->id);
    10793        }
    10894

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

    r4b82445 r738b549  
    4444#include <debug.h>
    4545#include <symtab.h>
    46 #include <stacktrace.h>
    4746
    4847#ifdef CONFIG_SMP
    … …  
    105104                            "caller=%p (%s)\n", CPU->id, lock, lock->name,
    106105                            (void *) CALLER, symtab_fmt_name_lookup(CALLER));
    107                         stack_trace();
    108106                       
    109107                        i = 0;
    … …  
    262260        int rc = spinlock_trylock(&(lock->lock));
    263261       
    264         ASSERT_IRQ_SPINLOCK(!rc || !lock->guard, lock);
     262        ASSERT_IRQ_SPINLOCK(!lock->guard, lock);
    265263        return rc;
    266264}

  • uspace/Makefile

    r4b82445 r738b549  
    5151        app/mkexfat \
    5252        app/mkmfs \
    53         app/nterm \
    5453        app/redir \
    5554        app/sbi \

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

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

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

    r4b82445 r738b549  
    184184void tcp_conn_addref(tcp_conn_t *conn)
    185185{
    186         log_msg(LVL_DEBUG2, "%s: tcp_conn_addref(%p)", conn->name, conn);
     186        log_msg(LVL_DEBUG, "%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_DEBUG2, "%s: tcp_conn_delref(%p)", conn->name, conn);
     198        log_msg(LVL_DEBUG, "%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_DEBUG2, "tcp_socket_match(sock=(%x,%u), pat=(%x,%u))",
     314        log_msg(LVL_DEBUG, "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_DEBUG2, " -> match");
     325        log_msg(LVL_DEBUG, " -> match");
    326326
    327327        return true;
    … …  
    331331static bool tcp_sockpair_match(tcp_sockpair_t *sp, tcp_sockpair_t *pattern)
    332332{
    333         log_msg(LVL_DEBUG2, "tcp_sockpair_match(%p, %p)", sp, pattern);
     333        log_msg(LVL_DEBUG, "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_DEBUG2, "compare with conn (f:(%x,%u), l:(%x,%u))",
     362                log_msg(LVL_DEBUG, "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

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

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

    r4b82445 r738b549  
    4040extern void tcp_ncsim_init(void);
    4141extern void tcp_ncsim_bounce_seg(tcp_sockpair_t *, tcp_segment_t *);
    42 extern void tcp_ncsim_fibril_start(void);
     42extern void tcp_ncsim_thread_start(void);
     43
    4344
    4445#endif

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

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

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

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

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

    r4b82445 r738b549  
    248248void tcp_segment_dump(tcp_segment_t *seg)
    249249{
    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);
     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);
    257257}
    258258

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

    r4b82445 r738b549  
    5151#include "ucall.h"
    5252
     53#define FRAGMENT_SIZE 1024
     54
    5355#define MAX_BACKLOG 128
    5456
    … …  
    6466static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    6567static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
    66 static int tcp_sock_recv_fibril(void *arg);
    6768
    6869int tcp_sock_init(void)
    … …  
    9697        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    9798        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    98             TCP_SOCK_FRAGMENT_SIZE, 0, 0, 1);
     99            FRAGMENT_SIZE, 0, 0, 1);
    99100        async_exchange_end(exch);
    100101}
    … …  
    105106        async_exch_t *exch = async_exchange_begin(lsock_core->sess);
    106107        async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id,
    107             TCP_SOCK_FRAGMENT_SIZE, 0, 0, 0);
     108            FRAGMENT_SIZE, 0, 0, 0);
    108109        async_exchange_end(exch);
    109110}
    110111
    111 static int tcp_sock_create(tcp_client_t *client, tcp_sockdata_t **rsock)
     112static void tcp_sock_socket(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    112113{
    113114        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 
    135 static void tcp_sock_uncreate(tcp_sockdata_t *sock)
    136 {
    137         log_msg(LVL_DEBUG, "tcp_sock_uncreate()");
    138         free(sock);
    139 }
    140 
    141 static int tcp_sock_finish_setup(tcp_sockdata_t *sock, int *sock_id)
    142 {
    143115        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 
    165 static void tcp_sock_socket(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    166 {
    167         tcp_sockdata_t *sock;
    168116        int sock_id;
    169117        int rc;
    … …  
    171119
    172120        log_msg(LVL_DEBUG, "tcp_sock_socket()");
    173 
    174         rc = tcp_sock_create(client, &sock);
    175         if (rc != EOK) {
    176                 async_answer_0(callid, rc);
    177                 return;
    178         }
    179 
     121        sock = calloc(sizeof(tcp_sockdata_t), 1);
     122        if (sock == NULL) {
     123                async_answer_0(callid, ENOMEM);
     124                return;
     125        }
     126
     127        fibril_mutex_initialize(&sock->lock);
     128        sock->client = client;
    180129        sock->laddr.ipv4 = TCP_IPV4_ANY;
    181130        sock->lconn = NULL;
    182131        sock->backlog = 0;
     132        list_initialize(&sock->ready);
    183133
    184134        sock_id = SOCKET_GET_SOCKET_ID(call);
    185         rc = tcp_sock_finish_setup(sock, &sock_id);
     135        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
    186136        if (rc != EOK) {
    187                 tcp_sock_uncreate(sock);
    188137                async_answer_0(callid, rc);
    189138                return;
    190139        }
    191140
     141        sock_core = socket_cores_find(&client->sockets, sock_id);
     142        assert(sock_core != NULL);
     143        sock->sock_core = sock_core;
     144
    192145        SOCKET_SET_SOCKET_ID(answer, sock_id);
    193146
    194         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
     147        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    195148        SOCKET_SET_HEADER_SIZE(answer, sizeof(tcp_header_t));
    196149       
    … …  
    408361        }
    409362
    410         if (rc == EOK)
    411                 fibril_add_ready(socket->recv_fibril);
    412 
    413363        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");
    414368}
    415369
    … …  
    420374        int asock_id;
    421375        socket_core_t *sock_core;
     376        socket_core_t *asock_core;
    422377        tcp_sockdata_t *socket;
    423378        tcp_sockdata_t *asocket;
    … …  
    489444        /* Allocate socket for accepted connection */
    490445
    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 
     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;
    498456        asocket->conn = conn;
    499457        log_msg(LVL_DEBUG, "tcp_sock_accept():create asocket\n");
    500458
    501         rc = tcp_sock_finish_setup(asocket, &asock_id);
     459        rc = socket_create(&client->sockets, client->sess, asocket, &asock_id);
    502460        if (rc != EOK) {
    503                 tcp_sock_uncreate(asocket);
    504461                fibril_mutex_unlock(&socket->lock);
    505462                async_answer_0(callid, rc);
    506463                return;
    507464        }
    508 
    509         fibril_add_ready(asocket->recv_fibril);
    510 
    511465        log_msg(LVL_DEBUG, "tcp_sock_accept(): find acore\n");
    512466
    513         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
     467        asock_core = socket_cores_find(&client->sockets, asock_id);
     468        assert(asock_core != NULL);
     469
     470        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    514471        SOCKET_SET_SOCKET_ID(answer, asock_id);
    515472        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(struct sockaddr_in));
    516473       
    517         async_answer_3(callid, asocket->sock_core->socket_id,
     474        async_answer_3(callid, asock_core->socket_id,
    518475            IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
    519476            IPC_GET_ARG3(answer));
    … …  
    521478        /* Push one fragment notification to client's queue */
    522479        log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n");
     480        tcp_sock_notify_data(asock_core);
    523481        fibril_mutex_unlock(&socket->lock);
    524482}
    … …  
    534492        ipc_callid_t wcallid;
    535493        size_t length;
    536         uint8_t buffer[TCP_SOCK_FRAGMENT_SIZE];
     494        uint8_t buffer[FRAGMENT_SIZE];
    537495        tcp_error_t trc;
    538496        int rc;
    … …  
    565523                }
    566524
    567                 if (length > TCP_SOCK_FRAGMENT_SIZE)
    568                         length = TCP_SOCK_FRAGMENT_SIZE;
     525                if (length > FRAGMENT_SIZE)
     526                        length = FRAGMENT_SIZE;
    569527
    570528                rc = async_data_write_finalize(wcallid, buffer, length);
    … …  
    602560
    603561        IPC_SET_ARG1(answer, 0);
    604         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
     562        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    605563        async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
    606564            IPC_GET_ARG2(answer));
    … …  
    623581        ipc_call_t answer;
    624582        ipc_callid_t rcallid;
     583        uint8_t buffer[FRAGMENT_SIZE];
    625584        size_t data_len;
     585        xflags_t xflags;
     586        tcp_error_t trc;
    626587        struct sockaddr_in addr;
    627588        tcp_sock_t *rsock;
    … …  
    650611        (void)flags;
    651612
    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) {
     613        trc = tcp_uc_receive(socket->conn, buffer, FRAGMENT_SIZE, &data_len,
     614            &xflags);
     615        log_msg(LVL_DEBUG, "**** tcp_uc_receive done");
     616
     617        switch (trc) {
    666618        case TCP_EOK:
    667619                rc = EOK;
    … …  
    678630        }
    679631
    680         log_msg(LVL_DEBUG, "**** recv result -> %d", rc);
     632        log_msg(LVL_DEBUG, "**** tcp_uc_receive -> %d", rc);
    681633        if (rc != EOK) {
    682                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    683634                fibril_mutex_unlock(&socket->lock);
    684635                async_answer_0(callid, rc);
    … …  
    695646                log_msg(LVL_DEBUG, "addr read receive");
    696647                if (!async_data_read_receive(&rcallid, &addr_length)) {
    697                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    698648                        fibril_mutex_unlock(&socket->lock);
    699649                        async_answer_0(callid, EINVAL);
    … …  
    707657                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    708658                if (rc != EOK) {
    709                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    710659                        fibril_mutex_unlock(&socket->lock);
    711660                        async_answer_0(callid, EINVAL);
    … …  
    716665        log_msg(LVL_DEBUG, "data read receive");
    717666        if (!async_data_read_receive(&rcallid, &length)) {
    718                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    719667                fibril_mutex_unlock(&socket->lock);
    720668                async_answer_0(callid, EINVAL);
    … …  
    726674
    727675        log_msg(LVL_DEBUG, "data read finalize");
    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);
     676        rc = async_data_read_finalize(rcallid, buffer, length);
    740677
    741678        if (length < data_len && rc == EOK)
    … …  
    744681        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    745682        async_answer_1(callid, EOK, IPC_GET_ARG1(answer));
    746 
    747         fibril_mutex_unlock(&socket->recv_buffer_lock);
     683       
     684        /* Push one fragment notification to client's queue */
     685        tcp_sock_notify_data(sock_core);
    748686        fibril_mutex_unlock(&socket->lock);
    749687}
    … …  
    756694        tcp_error_t trc;
    757695        int rc;
     696        uint8_t buffer[FRAGMENT_SIZE];
     697        size_t data_len;
     698        xflags_t xflags;
    758699
    759700        log_msg(LVL_DEBUG, "tcp_sock_close()");
    … …  
    776717                        return;
    777718                }
     719
     720                /* Drain incoming data. This should really be done in the background. */
     721                do {
     722                        trc = tcp_uc_receive(socket->conn, buffer,
     723                            FRAGMENT_SIZE, &data_len, &xflags);
     724                } while (trc == TCP_EOK);
     725
     726                tcp_uc_delete(socket->conn);
    778727        }
    779728
    … …  
    827776        tcp_sock_notify_aconn(socket->sock_core);
    828777        fibril_mutex_unlock(&socket->lock);
    829 }
    830 
    831 static 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;
    869778}
    870779

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

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

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

    r4b82445 r738b549  
    3939#include <async.h>
    4040#include <bool.h>
    41 #include <fibril.h>
    4241#include <fibril_synch.h>
    4342#include <socket_core.h>
    … …  
    332331} tcp_client_t;
    333332
    334 #define TCP_SOCK_FRAGMENT_SIZE 1024
    335 
    336333typedef struct tcp_sockdata {
    337334        /** Lock */
    … …  
    351348        /** List of connections (from lconn) that are ready to be accepted */
    352349        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;
    360350} tcp_sockdata_t;
    361351

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

    r4b82445 r738b549  
    3838#include <errno.h>
    3939#include <stdio.h>
    40 #include <fibril.h>
     40#include <thread.h>
    4141#include <str.h>
    4242#include "tcp_type.h"
    … …  
    4747#define RCV_BUF_SIZE 64
    4848
    49 static int test_srv(void *arg)
     49static void test_srv(void *arg)
    5050{
    5151        tcp_conn_t *conn;
    … …  
    8484
    8585        printf("test_srv() terminating\n");
    86         return 0;
    8786}
    8887
    89 static int test_cli(void *arg)
     88static void test_cli(void *arg)
    9089{
    9190        tcp_conn_t *conn;
    … …  
    113112        printf("C: User close...\n");
    114113        tcp_uc_close(conn);
    115 
    116         return 0;
    117114}
    118115
    119116void tcp_test(void)
    120117{
    121         fid_t srv_fid;
    122         fid_t cli_fid;
     118        thread_id_t srv_tid;
     119        thread_id_t cli_tid;
     120        int rc;
    123121
    124122        printf("tcp_test()\n");
    … …  
    127125
    128126        if (0) {
    129                 srv_fid = fibril_create(test_srv, NULL);
    130                 if (srv_fid == 0) {
    131                         printf("Failed to create server fibril.\n");
     127                rc = thread_create(test_srv, NULL, "test_srv", &srv_tid);
     128                if (rc != EOK) {
     129                        printf("Failed to create server thread.\n");
    132130                        return;
    133131                }
    134 
    135                 fibril_add_ready(srv_fid);
    136132        }
    137133
    138134        if (0) {
    139                 cli_fid = fibril_create(test_cli, NULL);
    140                 if (cli_fid == 0) {
    141                         printf("Failed to create client fibril.\n");
     135                rc = thread_create(test_cli, NULL, "test_cli", &cli_tid);
     136                if (rc != EOK) {
     137                        printf("Failed to create client thread.\n");
    142138                        return;
    143139                }
    144 
    145                 fibril_add_ready(cli_fid);
    146140        }
    147141}
Note: See TracChangeset for help on using the changeset viewer.