Changes in / [eb083ad:a8b8086] in mainline


Ignore:
Files:
34 added
37 deleted
34 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    reb083ad ra8b8086  
    556556
    557557% Include development files (headers, libraries)
    558 ! CONFIG_DEVEL_FILES (n/y)
     558! [RDFMT=tmpfs|RDFMT=ext2fs] CONFIG_DEVEL_FILES (n/y)
    559559
    560560% Strip binaries
    … …  
    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

    reb083ad ra8b8086  
    7272        $(USPACE_PATH)/srv/loader/loader \
    7373        $(USPACE_PATH)/app/init/init \
    74         $(USPACE_PATH)/srv/locsrv/locsrv \
     74        $(USPACE_PATH)/srv/loc/loc \
    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/inetsrv/inetsrv \
     109        $(USPACE_PATH)/srv/net/inet/inet \
    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/inet/inet \
     159        $(USPACE_PATH)/app/inetcfg/inetcfg \
    160160        $(USPACE_PATH)/app/kill/kill \
    161161        $(USPACE_PATH)/app/killall/killall \
    162         $(USPACE_PATH)/app/loc/loc \
     162        $(USPACE_PATH)/app/locinfo/locinfo \
    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 \
    180179        $(USPACE_PATH)/app/ping/ping \
    181180        $(USPACE_PATH)/app/stats/stats \

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

    reb083ad ra8b8086  
    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/fb/fb.c

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

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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    4242        app/getterm \
    4343        app/init \
    44         app/inet \
     44        app/inetcfg \
    4545        app/kill \
    4646        app/killall \
    4747        app/klog \
    48         app/loc \
     48        app/locinfo \
    4949        app/lsusb \
    5050        app/mkfat \
    5151        app/mkexfat \
    5252        app/mkmfs \
    53         app/nterm \
    5453        app/redir \
    5554        app/sbi \
    … …  
    6968        app/nettest3 \
    7069        app/ping \
     70        app/websrv \
    7171        app/sysinfo \
    7272        app/mkbd \
    7373        app/date \
    74         app/websrv \
    7574        srv/clipboard \
    76         srv/locsrv \
     75        srv/loc \
    7776        srv/devman \
    7877        srv/loader \
    7978        srv/net/ethip \
    80         srv/net/inetsrv \
     79        srv/net/inet \
    8180        srv/net/loopip \
    8281        srv/net/tcp \

  • uspace/app/init/init.c

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

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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    4141#include <stdlib.h>
    4242#include <fcntl.h>
    43 #include <task.h>
    4443
    4544#include <net/in.h>
    … …  
    7271
    7372static char fbuf[BUFFER_SIZE];
    74 
    75 static bool verbose = false;
    7673
    7774/** Responses to send to client. */
    … …  
    190187        size_t response_size = str_size(msg);
    191188       
    192         if (verbose)
    193             fprintf(stderr, "Sending response\n");
    194        
     189        fprintf(stderr, "Sending response\n");
    195190        ssize_t rc = send(conn_sd, (void *) msg, response_size, 0);
    196191        if (rc < 0) {
    … …  
    256251        }
    257252       
    258         if (verbose)
    259                 fprintf(stderr, "Request: %s", lbuf);
     253        fprintf(stderr, "Request: %s", lbuf);
    260254       
    261255        if (str_lcmp(lbuf, "GET ", 4) != 0) {
    … …  
    272266       
    273267        *end_uri = '\0';
    274         if (verbose)
    275                 fprintf(stderr, "Requested URI: %s\n", uri);
     268        fprintf(stderr, "Requested URI: %s\n", uri);
    276269       
    277270        if (!uri_is_valid(uri)) {
    … …  
    294287            "\n"
    295288            "-h | --help\n"
    296             "\tShow this application help.\n"
    297             "-v | --verbose\n"
    298             "\tVerbose mode\n");
     289            "\tShow this application help.\n");
    299290}
    300291
    … …  
    315306               
    316307                port = (uint16_t) value;
    317                 break;
    318         case 'v':
    319                 verbose = true;
    320308                break;
    321309        /* Long options with double dash */
    … …  
    330318                       
    331319                        port = (uint16_t) value;
    332                 } else if (str_cmp(argv[*index] +2, "verbose") == 0) {
    333                         verbose = true;
    334320                } else {
    335321                        usage();
    … …  
    372358        }
    373359       
    374         printf("%s: HelenOS web server\n", NAME);
    375 
    376         if (verbose)
    377                 fprintf(stderr, "Creating socket\n");
     360        fprintf(stderr, "Creating socket\n");
    378361       
    379362        int listen_sd = socket(PF_INET, SOCK_STREAM, 0);
    … …  
    397380        }
    398381       
    399         fprintf(stderr, "%s: Listening for connections at port %" PRIu16 "\n",
    400             NAME, port);
    401 
    402         task_retval(0);
    403 
     382        fprintf(stderr, "Listening for connections at port %" PRIu16 "\n",
     383            port);
    404384        while (true) {
    405385                struct sockaddr_in raddr;
    … …  
    413393                }
    414394               
    415                 if (verbose) {
    416                         fprintf(stderr, "Connection accepted (sd=%d), "
    417                             "waiting for request\n", conn_sd);
    418                 }
     395                fprintf(stderr, "Connection accepted (sd=%d), "
     396                    "waiting for request\n", conn_sd);
    419397               
    420398                rbuf_out = 0;
    … …  
    434412                }
    435413               
    436                 if (verbose)
    437                         fprintf(stderr, "Connection closed\n");
     414                fprintf(stderr, "Connection closed\n");
    438415        }
    439416       

  • uspace/lib/c/Makefile

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

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

    reb083ad ra8b8086  
    4444#include <errno.h>
    4545#include <task.h>
    46 #include <ns.h>
    4746#include <ipc/services.h>
    4847#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 = service_bind(SERVICE_TCP,
     286                socket_globals.tcp_sess = bind_service(SERVICE_TCP,
    287287                    0, 0, SERVICE_TCP, socket_connection);
    288288        }
    … …  
    301301{
    302302        if (socket_globals.udp_sess == NULL) {
    303                 socket_globals.udp_sess = service_bind(SERVICE_UDP,
     303                socket_globals.udp_sess = bind_service(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  *                      service_bind() function.
     380 *                      bind_service() function.
    381381 */
    382382int socket(int domain, int type, int protocol)

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

    reb083ad ra8b8086  
    3737#include <async.h>
    3838#include <macros.h>
    39 #include <errno.h>
    4039#include "private/ns.h"
    4140
    … …  
    4948}
    5049
    51 async_sess_t *service_connect(exch_mgmt_t mgmt, services_t service, sysarg_t arg2,
     50async_sess_t *service_connect(exch_mgmt_t mgmt, sysarg_t service, sysarg_t arg2,
    5251    sysarg_t arg3)
    5352{
    … …  
    7372}
    7473
    75 async_sess_t *service_connect_blocking(exch_mgmt_t mgmt, services_t service,
     74async_sess_t *service_connect_blocking(exch_mgmt_t mgmt, sysarg_t service,
    7675    sysarg_t arg2, sysarg_t arg3)
    7776{
    … …  
    8281            async_connect_me_to_blocking(mgmt, exch, service, arg2, arg3);
    8382        async_exchange_end(exch);
    84        
     83
    8584        if (!sess)
    8685                return NULL;
    … …  
    9291         */
    9392        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  */
    110 async_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         }
    12993       
    13094        return sess;

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

    reb083ad ra8b8086  
    3737
    3838#include <sys/types.h>
    39 #include <ipc/services.h>
    4039#include <task.h>
    4140#include <async.h>
    4241
    4342extern int service_register(sysarg_t);
    44 extern async_sess_t *service_connect(exch_mgmt_t, services_t, sysarg_t, sysarg_t);
    45 extern async_sess_t *service_connect_blocking(exch_mgmt_t, services_t, sysarg_t,
     43extern async_sess_t *service_connect(exch_mgmt_t, sysarg_t, sysarg_t, sysarg_t);
     44extern async_sess_t *service_connect_blocking(exch_mgmt_t, sysarg_t, sysarg_t,
    4645    sysarg_t);
    47 extern async_sess_t *service_bind(services_t, sysarg_t, sysarg_t, sysarg_t,
    48     async_client_conn_t);
    4946
    5047extern int ns_ping(void);

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

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

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

    reb083ad ra8b8086  
    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/lib/usb/src/hc.c

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    4242#include <ipc/services.h>
    4343#include <ipc/socket.h>
     44#include <net/modules.h>
    4445#include <net/socket.h>
    4546#include <ns.h>
    … …  
    5152#include "ucall.h"
    5253
     54#define FRAGMENT_SIZE 1024
     55
    5356#define MAX_BACKLOG 128
    5457
    … …  
    6467static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    6568static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
    66 static int tcp_sock_recv_fibril(void *arg);
    6769
    6870int tcp_sock_init(void)
    … …  
    9698        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    9799        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    98             TCP_SOCK_FRAGMENT_SIZE, 0, 0, 1);
     100            FRAGMENT_SIZE, 0, 0, 1);
    99101        async_exchange_end(exch);
    100102}
    … …  
    105107        async_exch_t *exch = async_exchange_begin(lsock_core->sess);
    106108        async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id,
    107             TCP_SOCK_FRAGMENT_SIZE, 0, 0, 0);
     109            FRAGMENT_SIZE, 0, 0, 0);
    108110        async_exchange_end(exch);
    109111}
    110112
    111 static int tcp_sock_create(tcp_client_t *client, tcp_sockdata_t **rsock)
     113static void tcp_sock_socket(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    112114{
    113115        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 {
    143116        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;
    168117        int sock_id;
    169118        int rc;
    … …  
    171120
    172121        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 
     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;
    180130        sock->laddr.ipv4 = TCP_IPV4_ANY;
    181131        sock->lconn = NULL;
    182132        sock->backlog = 0;
     133        list_initialize(&sock->ready);
    183134
    184135        sock_id = SOCKET_GET_SOCKET_ID(call);
    185         rc = tcp_sock_finish_setup(sock, &sock_id);
     136        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
    186137        if (rc != EOK) {
    187                 tcp_sock_uncreate(sock);
    188138                async_answer_0(callid, rc);
    189139                return;
    190140        }
    191141
     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);
    192147        SOCKET_SET_SOCKET_ID(answer, sock_id);
    193148
    194         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
     149        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    195150        SOCKET_SET_HEADER_SIZE(answer, sizeof(tcp_header_t));
    196        
    197         async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    198             IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
     151        answer_call(callid, EOK, &answer, 3);
    199152}
    200153
    … …  
    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        refresh_answer(&answer, NULL);
     471
     472        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    514473        SOCKET_SET_SOCKET_ID(answer, asock_id);
    515474        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(struct sockaddr_in));
    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        
     475
     476        answer_call(callid, asock_core->socket_id, &answer, 3);
     477
    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);
    … …  
    601559        }
    602560
    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));
     561        refresh_answer(&answer, NULL);
     562        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     563        answer_call(callid, EOK, &answer, 2);
    607564        fibril_mutex_unlock(&socket->lock);
    608565}
    … …  
    623580        ipc_call_t answer;
    624581        ipc_callid_t rcallid;
     582        uint8_t buffer[FRAGMENT_SIZE];
    625583        size_t data_len;
     584        xflags_t xflags;
     585        tcp_error_t trc;
    626586        struct sockaddr_in addr;
    627587        tcp_sock_t *rsock;
    … …  
    650610        (void)flags;
    651611
    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) {
     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) {
    666617        case TCP_EOK:
    667618                rc = EOK;
    … …  
    678629        }
    679630
    680         log_msg(LVL_DEBUG, "**** recv result -> %d", rc);
     631        log_msg(LVL_DEBUG, "**** tcp_uc_receive -> %d", rc);
    681632        if (rc != EOK) {
    682                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    683633                fibril_mutex_unlock(&socket->lock);
    684634                async_answer_0(callid, rc);
    … …  
    695645                log_msg(LVL_DEBUG, "addr read receive");
    696646                if (!async_data_read_receive(&rcallid, &addr_length)) {
    697                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    698647                        fibril_mutex_unlock(&socket->lock);
    699648                        async_answer_0(callid, EINVAL);
    … …  
    707656                rc = async_data_read_finalize(rcallid, &addr, addr_length);
    708657                if (rc != EOK) {
    709                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    710658                        fibril_mutex_unlock(&socket->lock);
    711659                        async_answer_0(callid, EINVAL);
    … …  
    716664        log_msg(LVL_DEBUG, "data read receive");
    717665        if (!async_data_read_receive(&rcallid, &length)) {
    718                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    719666                fibril_mutex_unlock(&socket->lock);
    720667                async_answer_0(callid, EINVAL);
    … …  
    726673
    727674        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);
     675        rc = async_data_read_finalize(rcallid, buffer, length);
    740676
    741677        if (length < data_len && rc == EOK)
    … …  
    743679
    744680        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    745         async_answer_1(callid, EOK, IPC_GET_ARG1(answer));
    746 
    747         fibril_mutex_unlock(&socket->recv_buffer_lock);
     681        answer_call(callid, EOK, &answer, 1);
     682
     683        /* Push one fragment notification to client's queue */
     684        tcp_sock_notify_data(sock_core);
    748685        fibril_mutex_unlock(&socket->lock);
    749686}
    … …  
    756693        tcp_error_t trc;
    757694        int rc;
     695        uint8_t buffer[FRAGMENT_SIZE];
     696        size_t data_len;
     697        xflags_t xflags;
    758698
    759699        log_msg(LVL_DEBUG, "tcp_sock_close()");
    … …  
    776716                        return;
    777717                }
     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);
    778726        }
    779727
    … …  
    827775        tcp_sock_notify_aconn(socket->sock_core);
    828776        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;
    869777}
    870778

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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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

    reb083ad ra8b8086  
    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}

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

    reb083ad ra8b8086  
    4343#include <ipc/services.h>
    4444#include <ipc/socket.h>
     45#include <net/modules.h>
    4546#include <net/socket.h>
    4647#include <ns.h>
    … …  
    133134        assert(sock_core != NULL);
    134135        sock->sock_core = sock_core;
    135        
     136
     137
     138        refresh_answer(&answer, NULL);
    136139        SOCKET_SET_SOCKET_ID(answer, sock_id);
    137140
    138141        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    139142        SOCKET_SET_HEADER_SIZE(answer, sizeof(udp_header_t));
    140         async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    141             IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
     143        answer_call(callid, EOK, &answer, 3);
    142144}
    143145
    … …  
    367369                }
    368370        }
    369        
    370         IPC_SET_ARG1(answer, 0);
     371
     372        refresh_answer(&answer, NULL);
    371373        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
    372         async_answer_2(callid, EOK, IPC_GET_ARG1(answer),
    373             IPC_GET_ARG2(answer));
     374        answer_call(callid, EOK, &answer, 2);
    374375        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);
    489488        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    490489        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
    491         async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    492             IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    493        
     490        answer_call(callid, EOK, &answer, 3);
     491
    494492        /* Push one fragment notification to client's queue */
    495493        udp_sock_notify_data(sock_core);
Note: See TracChangeset for help on using the changeset viewer.