Changes in / [dffabf0:e84d65a] in mainline


Ignore:
Files:
4 added
9 deleted
47 edited

Legend:

Unmodified
Added
Removed

  • .bzrignore

    rdffabf0 re84d65a  
    4444./uspace/app/getterm/getterm
    4545./uspace/app/init/init
    46 ./uspace/app/kill/kill
    47 ./uspace/app/killall/killall
    4846./uspace/app/klog/klog
    4947./uspace/app/mkfat/mkfat
    … …  
    6765./uspace/app/usbinfo/usbinfo
    6866./uspace/app/virtusbkbd/vuk
    69 ./uspace/app/websrv/websrv
    7067./uspace/dist/app/*
    7168./uspace/dist/cfg/net/general

  • boot/Makefile.common

    rdffabf0 re84d65a  
    101101        $(USPACE_PATH)/srv/hw/bus/usb/hcd/virtual/vhcd \
    102102        $(USPACE_PATH)/srv/net/netif/lo/lo \
    103         $(USPACE_PATH)/srv/net/nil/eth/eth \
    104         $(USPACE_PATH)/srv/net/nil/nildummy/nildummy \
    105103        $(USPACE_PATH)/srv/net/il/arp/arp \
    106104        $(USPACE_PATH)/srv/net/il/ip/ip \
    … …  
    119117RD_DRV_CFG =
    120118
     119ifneq ($(CONFIG_NETIF_NIL_BUNDLE),y)
     120        RD_SRVS_NON_ESSENTIAL += \
     121                $(USPACE_PATH)/srv/net/nil/eth/eth \
     122                $(USPACE_PATH)/srv/net/nil/nildummy/nildummy
     123endif
     124
    121125RD_APPS_ESSENTIAL = \
    122126        $(USPACE_PATH)/app/bdsh/bdsh \
    … …  
    126130RD_APPS_NON_ESSENTIAL = \
    127131        $(USPACE_PATH)/app/edit/edit \
    128         $(USPACE_PATH)/app/kill/kill \
    129         $(USPACE_PATH)/app/killall/killall \
    130132        $(USPACE_PATH)/app/mkfat/mkfat \
    131133        $(USPACE_PATH)/app/sbi/sbi \
    … …  
    146148        $(USPACE_PATH)/app/top/top \
    147149        $(USPACE_PATH)/app/usbinfo/usbinfo \
    148         $(USPACE_PATH)/app/virtusbkbd/vuk \
    149         $(USPACE_PATH)/app/websrv/websrv
     150        $(USPACE_PATH)/app/virtusbkbd/vuk
    150151
    151152ifneq ($(CONFIG_BAREBONE),y)

  • boot/arch/ia64/Makefile.inc

    rdffabf0 re84d65a  
    3434ENDIANESS = LE
    3535PAGE_SIZE = 16384
    36 EXTRA_CFLAGS = -fno-unwind-tables -mfixed-range=f32-f127 -mno-pic -mno-sdata
     36EXTRA_CFLAGS = -fno-unwind-tables -mfixed-range=f32-f127 -mno-pic
    3737
    3838RD_SRVS_NON_ESSENTIAL +=

  • contrib/conf/net-qe.sh

    rdffabf0 re84d65a  
    11#!/bin/sh
    22
    3 # Obsolete versions of QEMU
    4 #
    5 #   QEMU 0.10.2 and later 0.10.*
    6 #    qemu $@ -no-kqemu -vga std -M isapc -net nic,model=ne2k_isa -net user -boot d -redir udp:8080::8080 -redir udp:8081::8081 -redir tcp:8080::8080 -redir tcp:8081::8081 -cdrom image.iso
    7 #
    8 #   QEMU 0.11.* and 0.12.*
    9 #    qemu $@ -vga std -M isapc -net nic,model=ne2k_isa -net user -boot d -redir udp:8080::8080 -redir udp:8081::8081 -redir tcp:8080::8080 -redir tcp:8081::8081 -cdrom image.iso
     3arguments="-vga std -M isapc -net nic,model=ne2k_isa -net user -boot d -redir udp:8080::8080 -redir udp:8081::8081 -redir tcp:8080::8080 -redir tcp:8081::8081 -cdrom image.iso"
    104
    11 # QEMU 0.13 and later
    12 qemu $@ -device ne2k_isa,irq=5,vlan=0 -net user -boot d -redir udp:8080::8080 -redir udp:8081::8081 -redir tcp:8080::8080 -redir tcp:8081::8081 -cdrom image.iso
     5#qemu 0.10.2 and later 0.10.*:
     6#qemu $@ -no-kqemu $arguments
     7
     8#qemu 0.11:
     9qemu $@ $arguments

  • defaults/amd64/Makefile.config

    rdffabf0 re84d65a  
    6565CONFIG_MOUNT_DATA = n
    6666
     67# Bundle netif/nil network layer
     68CONFIG_NETIF_NIL_BUNDLE = n

  • defaults/arm32/Makefile.config

    rdffabf0 re84d65a  
    4141CONFIG_MOUNT_DATA = n
    4242
     43# Bundle netif/nil network layer
     44CONFIG_NETIF_NIL_BUNDLE = n

  • defaults/ia32/Makefile.config

    rdffabf0 re84d65a  
    7171CONFIG_MOUNT_DATA = n
    7272
     73# Bundle netif/nil network layer
     74CONFIG_NETIF_NIL_BUNDLE = n

  • defaults/ia64/Makefile.config

    rdffabf0 re84d65a  
    5353CONFIG_MOUNT_DATA = n
    5454
     55# Bundle netif/nil network layer
     56CONFIG_NETIF_NIL_BUNDLE = n

  • defaults/mips32/Makefile.config

    rdffabf0 re84d65a  
    4747CONFIG_MOUNT_DATA = n
    4848
     49# Bundle netif/nil network layer
     50CONFIG_NETIF_NIL_BUNDLE = n

  • defaults/ppc32/Makefile.config

    rdffabf0 re84d65a  
    4747CONFIG_MOUNT_DATA = n
    4848
     49# Bundle netif/nil network layer
     50CONFIG_NETIF_NIL_BUNDLE = n

  • defaults/sparc64/Makefile.config

    rdffabf0 re84d65a  
    6262CONFIG_MOUNT_DATA = n
    6363
     64# Bundle netif/nil network layer
     65CONFIG_NETIF_NIL_BUNDLE = n

  • defaults/special/Makefile.config

    rdffabf0 re84d65a  
    3232CONFIG_START_BD = n
    3333
     34# Bundle netif/nil network layer
     35CONFIG_NETIF_NIL_BUNDLE = n

  • kernel/arch/ia32/include/interrupt.h

    rdffabf0 re84d65a  
    5555#define IRQ_PIC_SPUR  7
    5656#define IRQ_MOUSE     12
    57 #define IRQ_DP8390    5
     57#define IRQ_DP8390    9
    5858
    5959/* This one must have four least significant bits set to ones */

  • kernel/generic/include/interrupt.h

    rdffabf0 re84d65a  
    6060extern void fault_if_from_uspace(istate_t *, const char *, ...)
    6161    PRINTF_ATTRIBUTE(2, 3);
    62 extern istate_t *istate_get(thread_t *);
    6362extern iroutine_t exc_register(unsigned int, const char *, bool, iroutine_t);
    6463extern void exc_dispatch(unsigned int, istate_t *);

  • kernel/generic/include/proc/task.h

    rdffabf0 re84d65a  
    154154
    155155extern sysarg_t sys_task_set_name(const char *, size_t);
    156 extern sysarg_t sys_task_kill(task_id_t *);
    157156
    158157#endif

  • kernel/generic/include/syscall/syscall.h

    rdffabf0 re84d65a  
    4747        SYS_TASK_GET_ID,
    4848        SYS_TASK_SET_NAME,
    49         SYS_TASK_KILL,
    5049        SYS_PROGRAM_SPAWN_LOADER,
    5150       

  • kernel/generic/src/interrupt/interrupt.c

    rdffabf0 re84d65a  
    209209}
    210210
    211 /** Get istate structure of a thread.
    212  *
    213  * Get pointer to the istate structure at the bottom of the kernel stack.
    214  *
    215  * This function can be called in interrupt or user context. In interrupt
    216  * context the istate structure is created by the low-level exception
    217  * handler. In user context the istate structure is created by the
    218  * low-level syscall handler.
    219  */
    220 istate_t *istate_get(thread_t *thread)
    221 {
    222         /*
    223          * The istate structure should be right at the bottom of the kernel
    224          * stack.
    225          */
    226         return (istate_t *) ((uint8_t *) thread->kstack + THREAD_STACK_SIZE -
    227             sizeof(istate_t));
    228 }
    229 
    230211#ifdef CONFIG_KCONSOLE
    231212

  • kernel/generic/src/main/main.c

    rdffabf0 re84d65a  
    185185        LOG("\nconfig.base=%p config.kernel_size=%zu"
    186186            "\nconfig.stack_base=%p config.stack_size=%zu",
    187             (void *) config.base, config.kernel_size,
    188             (void *) config.stack_base, config.stack_size);
     187            config.base, config.kernel_size, config.stack_base,
     188            config.stack_size);
    189189       
    190190#ifdef CONFIG_KCONSOLE
    … …  
    242242                for (i = 0; i < init.cnt; i++)
    243243                        LOG("init[%zu].addr=%p, init[%zu].size=%zu",
    244                             i, (void *) init.tasks[i].addr, i, init.tasks[i].size);
     244                            i, init.tasks[i].addr, i, init.tasks[i].size);
    245245        } else
    246246                printf("No init binaries found.\n");

  • kernel/generic/src/proc/task.c

    rdffabf0 re84d65a  
    360360}
    361361
    362 /** Syscall to forcefully terminate a task
    363  *
    364  * @param uspace_taskid Pointer to task ID in user space.
    365  *
    366  * @return 0 on success or an error code from @ref errno.h.
    367  *
    368  */
    369 sysarg_t sys_task_kill(task_id_t *uspace_taskid)
    370 {
    371         task_id_t taskid;
    372         int rc;
    373 
    374         rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(taskid));
    375         if (rc != 0)
    376                 return (sysarg_t) rc;
    377 
    378         return (sysarg_t) task_kill(taskid);
    379 }
    380 
    381362/** Find task structure corresponding to task ID.
    382363 *

  • kernel/generic/src/syscall/syscall.c

    rdffabf0 re84d65a  
    4545#include <debug.h>
    4646#include <ddi/device.h>
    47 #include <interrupt.h>
    4847#include <ipc/sysipc.h>
    4948#include <synch/futex.h>
    … …  
    6766#ifdef CONFIG_UDEBUG
    6867        /*
    69          * An istate_t-compatible record was created on the stack by the
    70          * low-level syscall handler. This is the userspace space state
    71          * structure.
    72          */
    73         THREAD->udebug.uspace_state = istate_get(THREAD);
    74 
    75         /*
    7668         * Early check for undebugged tasks. We do not lock anything as this
    7769         * test need not be precise in either direction.
     70         *
    7871         */
    7972        if (THREAD->udebug.active)
    … …  
    10598                udebug_stoppable_end();
    10699        }
    107 
    108         /* Clear userspace state pointer */
    109         THREAD->udebug.uspace_state = NULL;
    110100#endif
    111101       
    … …  
    130120        (syshandler_t) sys_task_get_id,
    131121        (syshandler_t) sys_task_set_name,
    132         (syshandler_t) sys_task_kill,
    133122        (syshandler_t) sys_program_spawn_loader,
    134123       

  • uspace/Makefile

    rdffabf0 re84d65a  
    3838        app/getterm \
    3939        app/init \
    40         app/kill \
    41         app/killall \
    4240        app/klog \
    4341        app/mkfat \
    … …  
    5755        app/nettest2 \
    5856        app/ping \
    59         app/websrv \
    6057        app/sysinfo \
    6158        srv/clip \
    … …  
    9996#
    10097
    101 DIRS += \
    102         srv/net/nil/eth \
    103         srv/net/nil/nildummy
     98ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
     99        LIBN = \
     100                srv/net/nil/eth \
     101                srv/net/nil/nildummy
     102else
     103        DIRS += \
     104                srv/net/nil/eth \
     105                srv/net/nil/nildummy
     106endif
    104107
    105108## Platform-specific hardware support

  • uspace/app/init/init.c

    rdffabf0 re84d65a  
    6161
    6262#define DATA_FS_TYPE      "fat"
    63 #define DATA_DEVICE       "bd/ata1disk0"
     63#define DATA_DEVICE       "bd/disk0"
    6464#define DATA_MOUNT_POINT  "/data"
    6565

  • uspace/app/netecho/netecho.c

    rdffabf0 re84d65a  
    3232
    3333/** @file
    34  * Network echo server.
    35  *
    36  * Sockets-based server that echoes incomming messages. If stream mode
    37  * is selected, accepts incoming connections.
     34 * Network echo application.
     35 * Answers received packets.
    3836 */
    3937
    40 #include <assert.h>
     38#include <malloc.h>
    4139#include <stdio.h>
    42 #include <stdlib.h>
    4340#include <str.h>
    4441#include <task.h>
    … …  
    5350#include "print_error.h"
    5451
    55 #define NAME "netecho"
    56 
    57 static int count = -1;
    58 static int family = PF_INET;
    59 static sock_type_t type = SOCK_DGRAM;
    60 static uint16_t port = 7;
    61 static int backlog = 3;
    62 static size_t size = 1024;
    63 static int verbose = 0;
    64 
    65 static char *reply = NULL;
    66 static size_t reply_length;
    67 
    68 static char *data;
     52/** Network echo module name. */
     53#define NAME    "Network Echo"
    6954
    7055static void echo_print_help(void)
    7156{
    7257        printf(
    73             "Network echo server\n"
    74             "Usage: " NAME " [options]\n"
    75             "Where options are:\n"
    76             "-b backlog | --backlog=size\n"
    77             "\tThe size of the accepted sockets queue. Only for SOCK_STREAM. "
    78             "The default is 3.\n"
    79             "\n"
    80             "-c count | --count=count\n"
    81             "\tThe number of received messages to handle. A negative number "
    82             "means infinity. The default is infinity.\n"
    83             "\n"
    84             "-f protocol_family | --family=protocol_family\n"
    85             "\tThe listenning socket protocol family. Only the PF_INET and "
    86             "PF_INET6 are supported.\n"
    87             "\n"
    88             "-h | --help\n"
    89             "\tShow this application help.\n"
    90             "\n"
    91             "-p port_number | --port=port_number\n"
    92             "\tThe port number the application should listen at. The default "
    93             "is 7.\n"
    94             "\n"
    95             "-r reply_string | --reply=reply_string\n"
    96             "\tThe constant reply string. The default is the original data "
    97             "received.\n"
    98             "\n"
    99             "-s receive_size | --size=receive_size\n"
    100             "\tThe maximum receive data size the application should accept. "
    101             "The default is 1024 bytes.\n"
    102             "\n"
    103             "-t socket_type | --type=socket_type\n"
    104             "\tThe listenning socket type. Only the SOCK_DGRAM and the "
    105             "SOCK_STREAM are supported.\n"
    106             "\n"
    107             "-v | --verbose\n"
    108             "\tShow all output messages.\n"
     58                "Network Echo aplication\n" \
     59                "Usage: echo [options]\n" \
     60                "Where options are:\n" \
     61                "-b backlog | --backlog=size\n" \
     62                "\tThe size of the accepted sockets queue. Only for SOCK_STREAM. The default is 3.\n" \
     63                "\n" \
     64                "-c count | --count=count\n" \
     65                "\tThe number of received messages to handle. A negative number means infinity. The default is infinity.\n" \
     66                "\n" \
     67                "-f protocol_family | --family=protocol_family\n" \
     68                "\tThe listenning socket protocol family. Only the PF_INET and PF_INET6 are supported.\n"
     69                "\n" \
     70                "-h | --help\n" \
     71                "\tShow this application help.\n"
     72                "\n" \
     73                "-p port_number | --port=port_number\n" \
     74                "\tThe port number the application should listen at. The default is 7.\n" \
     75                "\n" \
     76                "-r reply_string | --reply=reply_string\n" \
     77                "\tThe constant reply string. The default is the original data received.\n" \
     78                "\n" \
     79                "-s receive_size | --size=receive_size\n" \
     80                "\tThe maximum receive data size the application should accept. The default is 1024 bytes.\n" \
     81                "\n" \
     82                "-t socket_type | --type=socket_type\n" \
     83                "\tThe listenning socket type. Only the SOCK_DGRAM and the SOCK_STREAM are supported.\n" \
     84                "\n" \
     85                "-v | --verbose\n" \
     86                "\tShow all output messages.\n"
    10987        );
    11088}
    11189
    112 static int netecho_parse_option(int argc, char *argv[], int *index)
     90int main(int argc, char *argv[])
    11391{
     92        size_t size = 1024;
     93        int verbose = 0;
     94        char *reply = NULL;
     95        sock_type_t type = SOCK_DGRAM;
     96        int count = -1;
     97        int family = PF_INET;
     98        uint16_t port = 7;
     99        int backlog = 3;
     100
     101        socklen_t max_length = sizeof(struct sockaddr_in6);
     102        uint8_t address_data[max_length];
     103        struct sockaddr *address = (struct sockaddr *) address_data;
     104        struct sockaddr_in *address_in = (struct sockaddr_in *) address;
     105        struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *) address;
     106        socklen_t addrlen;
     107        char address_string[INET6_ADDRSTRLEN];
     108        uint8_t *address_start;
     109        int socket_id;
     110        int listening_id;
     111        char *data;
     112        size_t length;
     113        int index;
     114        size_t reply_length;
    114115        int value;
    115116        int rc;
    116117
    117         switch (argv[*index][1]) {
    118         case 'b':
    119                 rc = arg_parse_int(argc, argv, index, &backlog, 0);
    120                 if (rc != EOK)
    121                         return rc;
    122                 break;
    123         case 'c':
    124                 rc = arg_parse_int(argc, argv, index, &count, 0);
    125                 if (rc != EOK)
    126                         return rc;
    127                 break;
    128         case 'f':
    129                 rc = arg_parse_name_int(argc, argv, index, &family, 0,
    130                     socket_parse_protocol_family);
    131                 if (rc != EOK)
    132                         return rc;
    133                 break;
    134         case 'h':
    135                 echo_print_help();
    136                 exit(0);
    137                 break;
    138         case 'p':
    139                 rc = arg_parse_int(argc, argv, index, &value, 0);
    140                 if (rc != EOK)
    141                         return rc;
    142                 port = (uint16_t) value;
    143                 break;
    144         case 'r':
    145                 rc = arg_parse_string(argc, argv, index, &reply, 0);
    146                 if (rc != EOK)
    147                         return rc;
    148                 break;
    149         case 's':
    150                 rc = arg_parse_int(argc, argv, index, &value, 0);
    151                 if (rc != EOK)
    152                         return rc;
    153                 size = (value >= 0) ? (size_t) value : 0;
    154                 break;
    155         case 't':
    156                 rc = arg_parse_name_int(argc, argv, index, &value, 0,
    157                     socket_parse_socket_type);
    158                 if (rc != EOK)
    159                         return rc;
    160                 type = (sock_type_t) value;
    161                 break;
    162         case 'v':
    163                 verbose = 1;
    164                 break;
    165         /* Long options with double dash */
    166         case '-':
    167                 if (str_lcmp(argv[*index] + 2, "backlog=", 6) == 0) {
    168                         rc = arg_parse_int(argc, argv, index, &backlog, 8);
    169                         if (rc != EOK)
    170                                 return rc;
    171                 } else if (str_lcmp(argv[*index] + 2, "count=", 6) == 0) {
    172                         rc = arg_parse_int(argc, argv, index, &count, 8);
    173                         if (rc != EOK)
    174                                 return rc;
    175                 } else if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    176                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
    177                             socket_parse_protocol_family);
    178                         if (rc != EOK)
    179                                 return rc;
    180                 } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    181                         echo_print_help();
    182                         exit(0);
    183                 } else if (str_lcmp(argv[*index] + 2, "port=", 5) == 0) {
    184                         rc = arg_parse_int(argc, argv, index, &value, 7);
    185                         if (rc != EOK)
    186                                 return rc;
    187                         port = (uint16_t) value;
    188                 } else if (str_lcmp(argv[*index] + 2, "reply=", 6) == 0) {
    189                         rc = arg_parse_string(argc, argv, index, &reply, 8);
    190                         if (rc != EOK)
    191                                 return rc;
    192                 } else if (str_lcmp(argv[*index] + 2, "size=", 5) == 0) {
    193                         rc = arg_parse_int(argc, argv, index, &value, 7);
    194                         if (rc != EOK)
    195                                 return rc;
    196                         size = (value >= 0) ? (size_t) value : 0;
    197                 } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    198                         rc = arg_parse_name_int(argc, argv, index, &value, 7,
    199                             socket_parse_socket_type);
    200                         if (rc != EOK)
    201                                 return rc;
    202                         type = (sock_type_t) value;
    203                 } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    204                         verbose = 1;
     118        // parse the command line arguments
     119        for (index = 1; index < argc; ++ index) {
     120                if (argv[index][0] == '-') {
     121                        switch (argv[index][1]) {
     122                        case 'b':
     123                                rc = arg_parse_int(argc, argv, &index, &backlog, 0);
     124                                if (rc != EOK)
     125                                        return rc;
     126                                break;
     127                        case 'c':
     128                                rc = arg_parse_int(argc, argv, &index, &count, 0);
     129                                if (rc != EOK)
     130                                        return rc;
     131                                break;
     132                        case 'f':
     133                                rc = arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family);
     134                                if (rc != EOK)
     135                                        return rc;
     136                                break;
     137                        case 'h':
     138                                echo_print_help();
     139                                return EOK;
     140                                break;
     141                        case 'p':
     142                                rc = arg_parse_int(argc, argv, &index, &value, 0);
     143                                if (rc != EOK)
     144                                        return rc;
     145                                port = (uint16_t) value;
     146                                break;
     147                        case 'r':
     148                                rc = arg_parse_string(argc, argv, &index, &reply, 0);
     149                                if (rc != EOK)
     150                                        return rc;
     151                                break;
     152                        case 's':
     153                                rc = arg_parse_int(argc, argv, &index, &value, 0);
     154                                if (rc != EOK)
     155                                        return rc;
     156                                size = (value >= 0) ? (size_t) value : 0;
     157                                break;
     158                        case 't':
     159                                rc = arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type);
     160                                if (rc != EOK)
     161                                        return rc;
     162                                type = (sock_type_t) value;
     163                                break;
     164                        case 'v':
     165                                verbose = 1;
     166                                break;
     167                        // long options with the double minus sign ('-')
     168                        case '-':
     169                                if (str_lcmp(argv[index] + 2, "backlog=", 6) == 0) {
     170                                        rc = arg_parse_int(argc, argv, &index, &backlog, 8);
     171                                        if (rc != EOK)
     172                                                return rc;
     173                                } else if (str_lcmp(argv[index] + 2, "count=", 6) == 0) {
     174                                        rc = arg_parse_int(argc, argv, &index, &count, 8);
     175                                        if (rc != EOK)
     176                                                return rc;
     177                                } else if (str_lcmp(argv[index] + 2, "family=", 7) == 0) {
     178                                        rc = arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family);
     179                                        if (rc != EOK)
     180                                                return rc;
     181                                } else if (str_lcmp(argv[index] + 2, "help", 5) == 0) {
     182                                        echo_print_help();
     183                                        return EOK;
     184                                } else if (str_lcmp(argv[index] + 2, "port=", 5) == 0) {
     185                                        rc = arg_parse_int(argc, argv, &index, &value, 7);
     186                                        if (rc != EOK)
     187                                                return rc;
     188                                        port = (uint16_t) value;
     189                                } else if (str_lcmp(argv[index] + 2, "reply=", 6) == 0) {
     190                                        rc = arg_parse_string(argc, argv, &index, &reply, 8);
     191                                        if (rc != EOK)
     192                                                return rc;
     193                                } else if (str_lcmp(argv[index] + 2, "size=", 5) == 0) {
     194                                        rc = arg_parse_int(argc, argv, &index, &value, 7);
     195                                        if (rc != EOK)
     196                                                return rc;
     197                                        size = (value >= 0) ? (size_t) value : 0;
     198                                } else if (str_lcmp(argv[index] + 2, "type=", 5) == 0) {
     199                                        rc = arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type);
     200                                        if (rc != EOK)
     201                                                return rc;
     202                                        type = (sock_type_t) value;
     203                                } else if (str_lcmp(argv[index] + 2, "verbose", 8) == 0) {
     204                                        verbose = 1;
     205                                } else {
     206                                        echo_print_help();
     207                                        return EINVAL;
     208                                }
     209                                break;
     210                        default:
     211                                echo_print_help();
     212                                return EINVAL;
     213                        }
    205214                } else {
    206215                        echo_print_help();
    207216                        return EINVAL;
    208217                }
    209                 break;
    210         default:
    211                 echo_print_help();
    212                 return EINVAL;
    213         }
    214 
    215         return EOK;
    216 }
    217 
    218 /** Echo one message (accept one connection and echo message).
    219  *
    220  * @param listening_id  Listening socket.
    221  * @return              EOK on success or negative error code.
    222  */
    223 static int netecho_socket_process_message(int listening_id)
    224 {
    225         uint8_t address_buf[sizeof(struct sockaddr_in6)];
    226 
    227         socklen_t addrlen;
    228         int socket_id;
    229         ssize_t rcv_size;
    230         size_t length;
    231         uint8_t *address_start;
    232 
    233         char address_string[INET6_ADDRSTRLEN];
    234         struct sockaddr_in *address_in = (struct sockaddr_in *) address_buf;
    235         struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *) address_buf;
    236         struct sockaddr *address = (struct sockaddr *) address_buf;
    237 
    238         int rc;
    239 
    240         if (type == SOCK_STREAM) {
    241                 /* Accept a socket if a stream socket is used */
    242                 addrlen = sizeof(address_buf);
    243                 socket_id = accept(listening_id, (void *) address_buf, &addrlen);
    244                 if (socket_id <= 0) {
    245                         socket_print_error(stderr, socket_id, "Socket accept: ", "\n");
    246                 } else {
    247                         if (verbose)
    248                                 printf("Socket %d accepted\n", socket_id);
    249                 }
    250 
    251                 assert((size_t) addrlen <= sizeof(address_buf));
    252         } else {
    253                 socket_id = listening_id;
    254         }
    255 
    256         /* if the datagram socket is used or the stream socked was accepted */
    257         if (socket_id > 0) {
    258 
    259                 /* Receive a message to echo */
    260                 rcv_size = recvfrom(socket_id, data, size, 0, address,
    261                     &addrlen);
    262                 if (rcv_size < 0) {
    263                         socket_print_error(stderr, rcv_size, "Socket receive: ", "\n");
    264                 } else {
    265                         length = (size_t) rcv_size;
    266                         if (verbose) {
    267                                 /* Print the header */
    268 
    269                                 /* Get the source port and prepare the address buffer */
    270                                 address_start = NULL;
    271                                 switch (address->sa_family) {
    272                                 case AF_INET:
    273                                         port = ntohs(address_in->sin_port);
    274                                         address_start = (uint8_t *) &address_in->sin_addr.s_addr;
    275                                         break;
    276                                 case AF_INET6:
    277                                         port = ntohs(address_in6->sin6_port);
    278                                         address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
    279                                         break;
    280                                 default:
    281                                         fprintf(stderr, "Address family %u (%#x) is not supported.\n",
    282                                             address->sa_family, address->sa_family);
    283                                 }
    284 
    285                                 /* Parse source address */
    286                                 if (address_start) {
    287                                         rc = inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string));
    288                                         if (rc != EOK) {
    289                                                 fprintf(stderr, "Received address error %d\n", rc);
    290                                         } else {
    291                                                 data[length] = '\0';
    292                                                 printf("Socket %d received %zu bytes from %s:%d\n%s\n",
    293                                                     socket_id, length, address_string, port, data);
    294                                         }
    295                                 }
    296                         }
    297 
    298                         /* Answer the request either with the static reply or the original data */
    299                         rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
    300                         if (rc != EOK)
    301                                 socket_print_error(stderr, rc, "Socket send: ", "\n");
    302                 }
    303 
    304                 /* Close accepted stream socket */
    305                 if (type == SOCK_STREAM) {
    306                         rc = closesocket(socket_id);
    307                         if (rc != EOK)
    308                                 socket_print_error(stderr, rc, "Close socket: ", "\n");
    309                 }
    310 
    311         }
    312 
    313         return EOK;
    314 }
    315 
    316 
    317 int main(int argc, char *argv[])
    318 {
    319         struct sockaddr *address;;
    320         struct sockaddr_in address_in;
    321         struct sockaddr_in6 address_in6;
    322         socklen_t addrlen;
    323 
    324         int listening_id;
    325         int index;
    326         int rc;
    327 
    328         /* Parse command line arguments */
    329         for (index = 1; index < argc; ++index) {
    330                 if (argv[index][0] == '-') {
    331                         rc = netecho_parse_option(argc, argv, &index);
    332                         if (rc != EOK)
    333                                 return rc;
    334                 } else {
    335                         echo_print_help();
    336                         return EINVAL;
    337                 }
    338         }
    339 
    340         /* Check buffer size */
     218        }
     219
     220        // check the buffer size
    341221        if (size <= 0) {
    342222                fprintf(stderr, "Receive size too small (%zu). Using 1024 bytes instead.\n", size);
    343223                size = 1024;
    344224        }
    345 
    346         /* size plus the terminating null character. */
     225        // size plus the terminating null (\0)
    347226        data = (char *) malloc(size + 1);
    348227        if (!data) {
    … …  
    351230        }
    352231
    353         /* Set the reply size if set */
     232        // set the reply size if set
    354233        reply_length = reply ? str_length(reply) : 0;
    355234
    356         /* Prepare the address buffer */
     235        // prepare the address buffer
     236        bzero(address_data, max_length);
    357237        switch (family) {
    358238        case PF_INET:
    359                 address_in.sin_family = AF_INET;
    360                 address_in.sin_port = htons(port);
    361                 address = (struct sockaddr *) &address_in;
    362                 addrlen = sizeof(address_in);
     239                address_in->sin_family = AF_INET;
     240                address_in->sin_port = htons(port);
     241                addrlen = sizeof(struct sockaddr_in);
    363242                break;
    364243        case PF_INET6:
    365                 address_in6.sin6_family = AF_INET6;
    366                 address_in6.sin6_port = htons(port);
    367                 address = (struct sockaddr *) &address_in6;
    368                 addrlen = sizeof(address_in6);
     244                address_in6->sin6_family = AF_INET6;
     245                address_in6->sin6_port = htons(port);
     246                addrlen = sizeof(struct sockaddr_in6);
    369247                break;
    370248        default:
    … …  
    373251        }
    374252
    375         /* Get a listening socket */
     253        // get a listening socket
    376254        listening_id = socket(family, type, 0);
    377255        if (listening_id < 0) {
    … …  
    380258        }
    381259
    382         /* if the stream socket is used */
     260        // if the stream socket is used
    383261        if (type == SOCK_STREAM) {
    384                 /* Check backlog size */
     262                // check the backlog
    385263                if (backlog <= 0) {
    386264                        fprintf(stderr, "Accepted sockets queue size too small (%zu). Using 3 instead.\n", size);
    387265                        backlog = 3;
    388266                }
    389 
    390                 /* Set the backlog */
     267                // set the backlog
    391268                rc = listen(listening_id, backlog);
    392269                if (rc != EOK) {
    … …  
    396273        }
    397274
    398         /* Bind the listening socket */
     275        // bind the listenning socket
    399276        rc = bind(listening_id, address, addrlen);
    400277        if (rc != EOK) {
    … …  
    406283                printf("Socket %d listenning at %d\n", listening_id, port);
    407284
    408         /*
    409          * do count times
    410          * or indefinitely if set to a negative value
    411          */
     285        socket_id = listening_id;
     286
     287        // do count times
     288        // or indefinitely if set to a negative value
    412289        while (count) {
    413                 rc = netecho_socket_process_message(listening_id);
    414                 if (rc != EOK)
    415                         break;
    416 
    417                 /* Decrease count if positive */
     290
     291                addrlen = max_length;
     292                if (type == SOCK_STREAM) {
     293                        // acceept a socket if the stream socket is used
     294                        socket_id = accept(listening_id, address, &addrlen);
     295                        if (socket_id <= 0) {
     296                                socket_print_error(stderr, socket_id, "Socket accept: ", "\n");
     297                        } else {
     298                                if (verbose)
     299                                        printf("Socket %d accepted\n", socket_id);
     300                        }
     301                }
     302
     303                // if the datagram socket is used or the stream socked was accepted
     304                if (socket_id > 0) {
     305
     306                        // receive an echo request
     307                        value = recvfrom(socket_id, data, size, 0, address, &addrlen);
     308                        if (value < 0) {
     309                                socket_print_error(stderr, value, "Socket receive: ", "\n");
     310                        } else {
     311                                length = (size_t) value;
     312                                if (verbose) {
     313                                        // print the header
     314
     315                                        // get the source port and prepare the address buffer
     316                                        address_start = NULL;
     317                                        switch (address->sa_family) {
     318                                        case AF_INET:
     319                                                port = ntohs(address_in->sin_port);
     320                                                address_start = (uint8_t *) &address_in->sin_addr.s_addr;
     321                                                break;
     322                                        case AF_INET6:
     323                                                port = ntohs(address_in6->sin6_port);
     324                                                address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
     325                                                break;
     326                                        default:
     327                                                fprintf(stderr, "Address family %u (%#x) is not supported.\n",
     328                                                    address->sa_family, address->sa_family);
     329                                        }
     330                                        // parse the source address
     331                                        if (address_start) {
     332                                                rc = inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string));
     333                                                if (rc != EOK) {
     334                                                        fprintf(stderr, "Received address error %d\n", rc);
     335                                                } else {
     336                                                        data[length] = '\0';
     337                                                        printf("Socket %d received %zu bytes from %s:%d\n%s\n",
     338                                                            socket_id, length, address_string, port, data);
     339                                                }
     340                                        }
     341                                }
     342
     343                                // answer the request either with the static reply or the original data
     344                                rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
     345                                if (rc != EOK)
     346                                        socket_print_error(stderr, rc, "Socket send: ", "\n");
     347                        }
     348
     349                        // close the accepted stream socket
     350                        if (type == SOCK_STREAM) {
     351                                rc = closesocket(socket_id);
     352                                if (rc != EOK)
     353                                        socket_print_error(stderr, rc, "Close socket: ", "\n");
     354                        }
     355
     356                }
     357
     358                // decrease the count if positive
    418359                if (count > 0) {
    419360                        count--;
    420361                        if (verbose)
    421                                 printf("Waiting for next %d message(s)\n", count);
     362                                printf("Waiting for next %d packet(s)\n", count);
    422363                }
    423364        }
    … …  
    426367                printf("Closing the socket\n");
    427368
    428         /* Close listenning socket */
     369        // close the listenning socket
    429370        rc = closesocket(listening_id);
    430371        if (rc != EOK) {

  • uspace/app/taskdump/taskdump.c

    rdffabf0 re84d65a  
    326326
    327327        sym_pc = fmt_sym_address(pc);
    328         printf("Thread %p: PC = %s. FP = %p\n", (void *) thash,
     328        printf("Thread %p crashed at %s. FP = %p\n", (void *) thash,
    329329            sym_pc, (void *) fp);
    330330        free(sym_pc);

  • uspace/lib/c/Makefile

    rdffabf0 re84d65a  
    8787        generic/ipc.c \
    8888        generic/async.c \
    89         generic/async_sess.c \
     89        generic/async_rel.c \
    9090        generic/loader.c \
    9191        generic/getopt.c \

  • uspace/lib/c/generic/async.c

    rdffabf0 re84d65a  
    749749                return ENOMEM;
    750750        }
    751 
    752         _async_sess_init();
    753751       
    754752        return 0;

  • uspace/lib/c/generic/libc.c

    rdffabf0 re84d65a  
    5050#include <ipc/ipc.h>
    5151#include <async.h>
     52#include <async_rel.h>
    5253#include <as.h>
    5354#include <loader/pcb.h>
    … …  
    6566        __heap_init();
    6667        __async_init();
     68        (void) async_rel_init();
    6769        fibril_t *fibril = fibril_setup();
    6870        __tcb_set(fibril->tcb);

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

    rdffabf0 re84d65a  
    8989            tos, (sysarg_t) dont_fragment, NULL);
    9090
    91         /* Send the address */
     91        // send the address
    9292        async_data_write_start(icmp_phone, addr, (size_t) addrlen);
    9393

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

    rdffabf0 re84d65a  
    6464        switch (family) {
    6565        case AF_INET:
    66                 /* Check output buffer size */
     66                // check the output buffer size
    6767                if (length < INET_ADDRSTRLEN)
    6868                        return ENOMEM;
    6969                       
    70                 /* Fill buffer with IPv4 address */
     70                // fill the buffer with the IPv4 address
    7171                snprintf(address, length, "%hhu.%hhu.%hhu.%hhu",
    7272                    data[0], data[1], data[2], data[3]);
    … …  
    7575
    7676        case AF_INET6:
    77                 /* Check output buffer size */
     77                // check the output buffer size
    7878                if (length < INET6_ADDRSTRLEN)
    7979                        return ENOMEM;
    8080               
    81                 /* Fill buffer with IPv6 address */
     81                // fill the buffer with the IPv6 address
    8282                snprintf(address, length,
    8383                    "%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:"
    … …  
    124124                return EINVAL;
    125125
    126         /* Set processing parameters */
     126        // set the processing parameters
    127127        switch (family) {
    128128        case AF_INET:
    … …  
    142142        }
    143143
    144         /* Erase if no address */
     144        // erase if no address
    145145        if (!address) {
    146146                bzero(data, count);
    … …  
    148148        }
    149149
    150         /* Process string from the beginning */
     150        // process the string from the beginning
    151151        next = address;
    152152        index = 0;
    153153        do {
    154                 /* If the actual character is set */
     154                // if the actual character is set
    155155                if (next && *next) {
    156156
    157                         /* If not on the first character */
     157                        // if not on the first character
    158158                        if (index) {
    159                                 /* Move to the next character */
     159                                // move to the next character
    160160                                ++next;
    161161                        }
    162162
    163                         /* Parse the actual integral value */
     163                        // parse the actual integral value
    164164                        value = strtoul(next, &last, base);
    165                         /*
    166                          * Remember the last problematic character
    167                          * should be either '.' or ':' but is ignored to be
    168                          * more generic
    169                          */
     165                        // remember the last problematic character
     166                        // should be either '.' or ':' but is ignored to be more
     167                        // generic
    170168                        next = last;
    171169
    172                         /* Fill the address data byte by byte */
     170                        // fill the address data byte by byte
    173171                        shift = bytes - 1;
    174172                        do {
    175                                 /* like little endian */
     173                                // like little endian
    176174                                data[index + shift] = value;
    177175                                value >>= 8;
    … …  
    180178                        index += bytes;
    181179                } else {
    182                         /* Erase the rest of the address */
     180                        // erase the rest of the address
    183181                        bzero(data + index, count - index);
    184182                        return EOK;

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

    rdffabf0 re84d65a  
    6363    int answer_count)
    6464{
    65         /* Choose the most efficient answer function */
     65        // choose the most efficient answer function
    6666        if (answer || (!answer_count)) {
    6767                switch (answer_count) {
    … …  
    178178        int phone;
    179179
    180         /* If no timeout is set */
     180        // if no timeout is set
    181181        if (timeout <= 0)
    182182                return async_connect_me_to_blocking(PHONE_NS, need, 0, 0);
    … …  
    187187                        return phone;
    188188
    189                 /* Abort if no time is left */
     189                // end if no time is left
    190190                if (timeout <= 0)
    191191                        return ETIMEOUT;
    192192
    193                 /* Wait the minimum of the module wait time and the timeout */
     193                // wait the minimum of the module wait time and the timeout
    194194                usleep((timeout <= MODULE_WAIT_TIME) ?
    195195                    timeout : MODULE_WAIT_TIME);
    … …  
    214214        ipc_callid_t callid;
    215215
    216         /* Fetch the request */
     216        // fetch the request
    217217        if (!async_data_read_receive(&callid, &length))
    218218                return EINVAL;
    219219
    220         /* Check the requested data size */
     220        // check the requested data size
    221221        if (length < data_length) {
    222222                async_data_read_finalize(callid, data, length);
    … …  
    224224        }
    225225
    226         /* Send the data */
     226        // send the data
    227227        return async_data_read_finalize(callid, data, data_length);
    228228}
    … …  
    242242        if (answer) {
    243243                IPC_SET_RETVAL(*answer, 0);
    244                 /* Just to be precise */
     244                // just to be precize
    245245                IPC_SET_IMETHOD(*answer, 0);
    246246                IPC_SET_ARG1(*answer, 0);

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

    rdffabf0 re84d65a  
    191191        }
    192192        gpm_destroy(&pm_globals.packet_map);
    193         /* leave locked */
     193        // leave locked
    194194}
    195195

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

    rdffabf0 re84d65a  
    220220                fibril_rwlock_read_lock(&socket_globals.lock);
    221221
    222                 /* Find the socket */
     222                // find the socket
    223223                socket = sockets_find(socket_get_sockets(),
    224224                    SOCKET_GET_SOCKET_ID(call));
    … …  
    232232                case NET_SOCKET_RECEIVED:
    233233                        fibril_mutex_lock(&socket->receive_lock);
    234                         /* Push the number of received packet fragments */
     234                        // push the number of received packet fragments
    235235                        rc = dyn_fifo_push(&socket->received,
    236236                            SOCKET_GET_DATA_FRAGMENTS(call),
    237237                            SOCKET_MAX_RECEIVED_SIZE);
    238238                        if (rc == EOK) {
    239                                 /* Signal the received packet */
     239                                // signal the received packet
    240240                                fibril_condvar_signal(&socket->receive_signal);
    241241                        }
    … …  
    244244
    245245                case NET_SOCKET_ACCEPTED:
    246                         /* Push the new socket identifier */
     246                        // push the new socket identifier
    247247                        fibril_mutex_lock(&socket->accept_lock);
    248248                        rc = dyn_fifo_push(&socket->accepted, 1,
    249249                            SOCKET_MAX_ACCEPTED_SIZE);
    250250                        if (rc == EOK) {
    251                                 /* Signal the accepted socket */
     251                                // signal the accepted socket
    252252                                fibril_condvar_signal(&socket->accept_signal);
    253253                        }
    … …  
    264264                        fibril_rwlock_write_lock(&socket->sending_lock);
    265265
    266                         /* Set the data fragment size */
     266                        // set the data fragment size
    267267                        socket->data_fragment_size =
    268268                            SOCKET_GET_DATA_FRAGMENT_SIZE(call);
    … …  
    342342                        socket_id = 1;
    343343                        ++count;
    344                 /* Only this branch for last_id */
     344                // only this branch for last_id
    345345                } else {
    346346                        if (socket_id < INT_MAX) {
    … …  
    408408        int rc;
    409409
    410         /* Find the appropriate service */
     410        // find the appropriate service
    411411        switch (domain) {
    412412        case PF_INET:
    … …  
    457457                return phone;
    458458
    459         /* Create a new socket structure */
     459        // create a new socket structure
    460460        socket = (socket_t *) malloc(sizeof(socket_t));
    461461        if (!socket)
    … …  
    465465        fibril_rwlock_write_lock(&socket_globals.lock);
    466466
    467         /* Request a new socket */
     467        // request a new socket
    468468        socket_id = socket_generate_new_id();
    469469        if (socket_id <= 0) {
    … …  
    484484        socket->header_size = (size_t) header_size;
    485485
    486         /* Finish the new socket initialization */
     486        // finish the new socket initialization
    487487        socket_initialize(socket, socket_id, phone, service);
    488         /* Store the new socket */
     488        // store the new socket
    489489        rc = sockets_add(socket_get_sockets(), socket_id, socket);
    490490
    … …  
    531531        fibril_rwlock_read_lock(&socket_globals.lock);
    532532
    533         /* Find the socket */
     533        // find the socket
    534534        socket = sockets_find(socket_get_sockets(), socket_id);
    535535        if (!socket) {
    … …  
    538538        }
    539539
    540         /* Request the message */
     540        // request the message
    541541        message_id = async_send_3(socket->phone, message,
    542542            (sysarg_t) socket->socket_id, arg2, socket->service, NULL);
    543         /* Send the address */
     543        // send the address
    544544        async_data_write_start(socket->phone, data, datalength);
    545545
    … …  
    566566                return EINVAL;
    567567
    568         /* Send the address */
     568        // send the address
    569569        return socket_send_data(socket_id, NET_SOCKET_BIND, 0, my_addr,
    570570            (size_t) addrlen);
    … …  
    591591        fibril_rwlock_read_lock(&socket_globals.lock);
    592592
    593         /* Find the socket */
     593        // find the socket
    594594        socket = sockets_find(socket_get_sockets(), socket_id);
    595595        if (!socket) {
    … …  
    598598        }
    599599
    600         /* Request listen backlog change */
     600        // request listen backlog change
    601601        result = (int) async_req_3_0(socket->phone, NET_SOCKET_LISTEN,
    602602            (sysarg_t) socket->socket_id, (sysarg_t) backlog, socket->service);
    … …  
    634634        fibril_rwlock_write_lock(&socket_globals.lock);
    635635
    636         /* Find the socket */
     636        // find the socket
    637637        socket = sockets_find(socket_get_sockets(), socket_id);
    638638        if (!socket) {
    … …  
    643643        fibril_mutex_lock(&socket->accept_lock);
    644644
    645         /* Wait for an accepted socket */
     645        // wait for an accepted socket
    646646        ++ socket->blocked;
    647647        while (dyn_fifo_value(&socket->accepted) <= 0) {
    648648                fibril_rwlock_write_unlock(&socket_globals.lock);
    649649                fibril_condvar_wait(&socket->accept_signal, &socket->accept_lock);
    650                 /* Drop the accept lock to avoid deadlock */
     650                // drop the accept lock to avoid deadlock
    651651                fibril_mutex_unlock(&socket->accept_lock);
    652652                fibril_rwlock_write_lock(&socket_globals.lock);
    … …  
    655655        -- socket->blocked;
    656656
    657         /* Create a new socket */
     657        // create a new scoket
    658658        new_socket = (socket_t *) malloc(sizeof(socket_t));
    659659        if (!new_socket) {
    … …  
    681681        }
    682682
    683         /* Request accept */
     683        // request accept
    684684        message_id = async_send_5(socket->phone, NET_SOCKET_ACCEPT,
    685685            (sysarg_t) socket->socket_id, 0, socket->service, 0,
    686686            new_socket->socket_id, &answer);
    687687
    688         /* Read address */
     688        // read address
    689689        ipc_data_read_start(socket->phone, cliaddr, *addrlen);
    690690        fibril_rwlock_write_unlock(&socket_globals.lock);
    … …  
    695695                        result = EINVAL;
    696696
    697                 /* Dequeue the accepted socket if successful */
     697                // dequeue the accepted socket if successful
    698698                dyn_fifo_pop(&socket->accepted);
    699                 /* Set address length */
     699                // set address length
    700700                *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
    701701                new_socket->data_fragment_size =
    702702                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    703703        } else if (result == ENOTSOCK) {
    704                 /* Empty the queue if no accepted sockets */
     704                // empty the queue if no accepted sockets
    705705                while (dyn_fifo_pop(&socket->accepted) > 0)
    706706                        ;
    … …  
    731731                return EDESTADDRREQ;
    732732
    733         /* Send the address */
     733        // send the address
    734734        return socket_send_data(socket_id, NET_SOCKET_CONNECT, 0, serv_addr,
    735735            addrlen);
    … …  
    744744        int accepted_id;
    745745
    746         /* Destroy all accepted sockets */
     746        // destroy all accepted sockets
    747747        while ((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0)
    748748                socket_destroy(sockets_find(socket_get_sockets(), accepted_id));
    … …  
    780780        }
    781781
    782         /* Request close */
     782        // request close
    783783        rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
    784784            (sysarg_t) socket->socket_id, 0, socket->service);
    … …  
    787787                return rc;
    788788        }
    789         /* Free the socket structure */
     789        // free the socket structure
    790790        socket_destroy(socket);
    791791
    … …  
    833833        fibril_rwlock_read_lock(&socket_globals.lock);
    834834
    835         /* Find socket */
     835        // find socket
    836836        socket = sockets_find(socket_get_sockets(), socket_id);
    837837        if (!socket) {
    … …  
    842842        fibril_rwlock_read_lock(&socket->sending_lock);
    843843
    844         /* Compute data fragment count */
     844        // compute data fragment count
    845845        if (socket->data_fragment_size > 0) {
    846846                fragments = (datalength + socket->header_size) /
    … …  
    853853        }
    854854
    855         /* Request send */
     855        // request send
    856856        message_id = async_send_5(socket->phone, message,
    857857            (sysarg_t) socket->socket_id,
    … …  
    859859            socket->service, (sysarg_t) flags, fragments, &answer);
    860860
    861         /* Send the address if given */
     861        // send the address if given
    862862        if (!toaddr ||
    863863            (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)) {
    864864                if (fragments == 1) {
    865                         /* Send all if only one fragment */
     865                        // send all if only one fragment
    866866                        async_data_write_start(socket->phone, data, datalength);
    867867                } else {
    868                         /* Send the first fragment */
     868                        // send the first fragment
    869869                        async_data_write_start(socket->phone, data,
    870870                            socket->data_fragment_size - socket->header_size);
    … …  
    872872                            socket->data_fragment_size - socket->header_size;
    873873       
    874                         /* Send the middle fragments */
     874                        // send the middle fragments
    875875                        while (--fragments > 1) {
    876876                                async_data_write_start(socket->phone, data,
    … …  
    880880                        }
    881881
    882                         /* Send the last fragment */
     882                        // send the last fragment
    883883                        async_data_write_start(socket->phone, data,
    884884                            (datalength + socket->header_size) %
    … …  
    892892            (SOCKET_GET_DATA_FRAGMENT_SIZE(answer) !=
    893893            socket->data_fragment_size)) {
    894                 /* Set the data fragment size */
     894                // set the data fragment size
    895895                socket->data_fragment_size =
    896896                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    … …  
    917917int send(int socket_id, void *data, size_t datalength, int flags)
    918918{
    919         /* Without the address */
     919        // without the address
    920920        return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags,
    921921            NULL, 0);
    … …  
    950950                return EDESTADDRREQ;
    951951
    952         /* With the address */
     952        // with the address
    953953        return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength,
    954954            flags, toaddr, addrlen);
    … …  
    966966 *                      read. The actual address length is set. Used only if
    967967 *                      fromaddr is not NULL.
    968  * @return              Positive received message size in bytes on success.
    969  * @return              Zero if no more data (other side closed the connection).
     968 * @return              EOK on success.
    970969 * @return              ENOTSOCK if the socket is not found.
    971970 * @return              EBADMEM if the data parameter is NULL.
    … …  
    973972 * @return              Other error codes as defined for the spcific message.
    974973 */
    975 static ssize_t
     974static int
    976975recvfrom_core(sysarg_t message, int socket_id, void *data, size_t datalength,
    977976    int flags, struct sockaddr *fromaddr, socklen_t *addrlen)
    … …  
    985984        size_t index;
    986985        ipc_call_t answer;
    987         ssize_t retval;
    988986
    989987        if (!data)
    … …  
    998996        fibril_rwlock_read_lock(&socket_globals.lock);
    999997
    1000         /* Find the socket */
     998        // find the socket
    1001999        socket = sockets_find(socket_get_sockets(), socket_id);
    10021000        if (!socket) {
    … …  
    10061004
    10071005        fibril_mutex_lock(&socket->receive_lock);
    1008         /* Wait for a received packet */
     1006        // wait for a received packet
    10091007        ++socket->blocked;
    1010         while ((result = dyn_fifo_value(&socket->received)) < 0) {
     1008        while ((result = dyn_fifo_value(&socket->received)) <= 0) {
    10111009                fibril_rwlock_read_unlock(&socket_globals.lock);
    10121010                fibril_condvar_wait(&socket->receive_signal,
    10131011                    &socket->receive_lock);
    10141012
    1015                 /* Drop the receive lock to avoid deadlock */
     1013                // drop the receive lock to avoid deadlock
    10161014                fibril_mutex_unlock(&socket->receive_lock);
    10171015                fibril_rwlock_read_lock(&socket_globals.lock);
    … …  
    10211019        fragments = (size_t) result;
    10221020
    1023         if (fragments == 0) {
    1024                 /* No more data, other side has closed the connection. */
    1025                 fibril_mutex_unlock(&socket->receive_lock);
    1026                 fibril_rwlock_read_unlock(&socket_globals.lock);
    1027                 return 0;
    1028         }
    1029 
    1030         /* Prepare lengths if more fragments */
     1021        // prepare lengths if more fragments
    10311022        if (fragments > 1) {
    10321023                lengths = (size_t *) malloc(sizeof(size_t) * fragments +
    … …  
    10381029                }
    10391030
    1040                 /* Request packet data */
     1031                // request packet data
    10411032                message_id = async_send_4(socket->phone, message,
    10421033                    (sysarg_t) socket->socket_id, 0, socket->service,
    10431034                    (sysarg_t) flags, &answer);
    10441035
    1045                 /* Read the address if desired */
     1036                // read the address if desired
    10461037                if(!fromaddr ||
    10471038                    (async_data_read_start(socket->phone, fromaddr,
    10481039                    *addrlen) == EOK)) {
    1049                         /* Read the fragment lengths */
     1040                        // read the fragment lengths
    10501041                        if (async_data_read_start(socket->phone, lengths,
    10511042                            sizeof(int) * (fragments + 1)) == EOK) {
    10521043                                if (lengths[fragments] <= datalength) {
    10531044
    1054                                         /* Read all fragments if long enough */
     1045                                        // read all fragments if long enough
    10551046                                        for (index = 0; index < fragments;
    10561047                                            ++index) {
    … …  
    10661057
    10671058                free(lengths);
    1068         } else { /* fragments == 1 */
    1069                 /* Request packet data */
     1059        } else {
     1060                // request packet data
    10701061                message_id = async_send_4(socket->phone, message,
    10711062                    (sysarg_t) socket->socket_id, 0, socket->service,
    10721063                    (sysarg_t) flags, &answer);
    10731064
    1074                 /* Read the address if desired */
     1065                // read the address if desired
    10751066                if (!fromaddr ||
    10761067                    (async_data_read_start(socket->phone, fromaddr,
    10771068                        *addrlen) == EOK)) {
    1078                         /* Read all if only one fragment */
     1069                        // read all if only one fragment
    10791070                        async_data_read_start(socket->phone, data, datalength);
    10801071                }
    … …  
    10841075        result = (int) ipc_result;
    10851076        if (result == EOK) {
    1086                 /* Dequeue the received packet */
     1077                // dequeue the received packet
    10871078                dyn_fifo_pop(&socket->received);
    1088                 /* Return read data length */
    1089                 retval = SOCKET_GET_READ_DATA_LENGTH(answer);
    1090                 /* Set address length */
     1079                // return read data length
     1080                result = SOCKET_GET_READ_DATA_LENGTH(answer);
     1081                // set address length
    10911082                if (fromaddr && addrlen)
    10921083                        *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
    1093         } else {
    1094                 retval = (ssize_t) result;
    10951084        }
    10961085
    10971086        fibril_mutex_unlock(&socket->receive_lock);
    10981087        fibril_rwlock_read_unlock(&socket_globals.lock);
    1099         return retval;
     1088        return result;
    11001089}
    11011090
    … …  
    11061095 * @param[in] datalength The data length.
    11071096 * @param[in] flags     Various receive flags.
    1108  * @return              Positive received message size in bytes on success.
    1109  * @return              Zero if no more data (other side closed the connection).
     1097 * @return              EOK on success.
    11101098 * @return              ENOTSOCK if the socket is not found.
    11111099 * @return              EBADMEM if the data parameter is NULL.
    … …  
    11141102 *                      message.
    11151103 */
    1116 ssize_t recv(int socket_id, void *data, size_t datalength, int flags)
    1117 {
    1118         /* Without the address */
     1104int recv(int socket_id, void *data, size_t datalength, int flags)
     1105{
     1106        // without the address
    11191107        return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength,
    11201108            flags, NULL, NULL);
    … …  
    11301118 * @param[in,out] addrlen The address length. The maximum address length is
    11311119 *                      read. The actual address length is set.
    1132  * @return              Positive received message size in bytes on success.
    1133  * @return              Zero if no more data (other side closed the connection).
     1120 * @return              EOK on success.
    11341121 * @return              ENOTSOCK if the socket is not found.
    11351122 * @return              EBADMEM if the data or fromaddr parameter is NULL.
    … …  
    11381125 *                      message.
    11391126 */
    1140 ssize_t
     1127int
    11411128recvfrom(int socket_id, void *data, size_t datalength, int flags,
    11421129    struct sockaddr *fromaddr, socklen_t *addrlen)
    … …  
    11481135                return NO_DATA;
    11491136
    1150         /* With the address */
     1137        // with the address
    11511138        return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength,
    11521139            flags, fromaddr, addrlen);
    … …  
    11831170        fibril_rwlock_read_lock(&socket_globals.lock);
    11841171
    1185         /* Find the socket */
     1172        // find the socket
    11861173        socket = sockets_find(socket_get_sockets(), socket_id);
    11871174        if (!socket) {
    … …  
    11901177        }
    11911178
    1192         /* Request option value */
     1179        // request option value
    11931180        message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT,
    11941181            (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service,
    11951182            NULL);
    11961183
    1197         /* Read the length */
     1184        // read the length
    11981185        if (async_data_read_start(socket->phone, optlen,
    11991186            sizeof(*optlen)) == EOK) {
    1200                 /* Read the value */
     1187                // read the value
    12011188                async_data_read_start(socket->phone, value, *optlen);
    12021189        }
    … …  
    12251212    size_t optlen)
    12261213{
    1227         /* Send the value */
     1214        // send the value
    12281215        return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT,
    12291216            (sysarg_t) optname, value, optlen);

  • uspace/lib/c/generic/task.c

    rdffabf0 re84d65a  
    6565 *
    6666 * @return Zero on success or negative error code.
     67 *
    6768 */
    6869int task_set_name(const char *name)
    6970{
    7071        return __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, str_size(name));
    71 }
    72 
    73 /** Kill a task.
    74  *
    75  * @param task_id ID of task to kill.
    76  *
    77  * @return Zero on success or negative error code.
    78  */
    79 
    80 int task_kill(task_id_t task_id)
    81 {
    82         return (int) __SYSCALL1(SYS_TASK_KILL, (sysarg_t) &task_id);
    8372}
    8473

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

    rdffabf0 re84d65a  
    3737
    3838#include <ipc/ipc.h>
    39 #include <async_sess.h>
    4039#include <fibril.h>
    4140#include <sys/time.h>

  • uspace/lib/c/include/net/socket.h

    rdffabf0 re84d65a  
    6060extern int sendto(int, const void *, size_t, int, const struct sockaddr *,
    6161    socklen_t);
    62 extern ssize_t recv(int, void *, size_t, int);
    63 extern ssize_t recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
     62extern int recv(int, void *, size_t, int);
     63extern int recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
    6464extern int getsockopt(int, int, int, void *, size_t *);
    6565extern int setsockopt(int, int, int, const void *, size_t);

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

    rdffabf0 re84d65a  
    4747extern task_id_t task_get_id(void);
    4848extern int task_set_name(const char *);
    49 extern int task_kill(task_id_t);
    50 
    5149extern task_id_t task_spawn(const char *, const char *const[], int *);
    5250extern int task_spawnv(task_id_t *, const char *path, const char *const []);

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

    rdffabf0 re84d65a  
    6565#include <macros.h>
    6666
    67 #include "ata_hw.h"
    6867#include "ata_bd.h"
    6968
    … …  
    7170#define NAMESPACE  "bd"
    7271
    73 /** Number of defined legacy controller base addresses. */
    74 #define LEGACY_CTLS 4
    75 
    7672/** Physical block size. Should be always 512. */
    7773static const size_t block_size = 512;
    … …  
    8177
    8278/** I/O base address of the command registers. */
    83 static uintptr_t cmd_physical;
     79static uintptr_t cmd_physical = 0x1f0;
    8480/** I/O base address of the control registers. */
    85 static uintptr_t ctl_physical;
    86 
    87 /** I/O base addresses for legacy (ISA-compatible) controllers. */
    88 static ata_base_t legacy_base[LEGACY_CTLS] = {
    89         { 0x1f0, 0x3f0 },
    90         { 0x170, 0x370 },
    91         { 0x1e8, 0x3e8 },
    92         { 0x168, 0x368 }
    93 };
     81static uintptr_t ctl_physical = 0x170;
    9482
    9583static ata_cmd_t *cmd;
    … …  
    9987static disk_t disk[MAX_DISKS];
    10088
    101 static void print_syntax(void);
    10289static int ata_bd_init(void);
    10390static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall);
    … …  
    123110        int i, rc;
    124111        int n_disks;
    125         unsigned ctl_num;
    126         char *eptr;
    127112
    128113        printf(NAME ": ATA disk driver\n");
    129114
    130         if (argc > 1) {
    131                 ctl_num = strtoul(argv[1], &eptr, 0);
    132                 if (*eptr != '\0' || ctl_num == 0 || ctl_num > 4) {
    133                         printf("Invalid argument.\n");
    134                         print_syntax();
    135                         return -1;
    136                 }
    137         } else {
    138                 ctl_num = 1;
    139         }
    140 
    141         cmd_physical = legacy_base[ctl_num - 1].cmd;
    142         ctl_physical = legacy_base[ctl_num - 1].ctl;
    143 
    144         printf("I/O address %p/%p\n", (void *) cmd_physical,
    145             (void *) ctl_physical);
     115        printf("I/O address %p/%p\n", (void *) ctl_physical,
     116            (void *) cmd_physical);
    146117
    147118        if (ata_bd_init() != EOK)
    … …  
    168139                        continue;
    169140               
    170                 snprintf(name, 16, "%s/ata%udisk%d", NAMESPACE, ctl_num, i);
     141                snprintf(name, 16, "%s/disk%d", NAMESPACE, i);
    171142                rc = devmap_device_register(name, &disk[i].devmap_handle);
    172143                if (rc != EOK) {
    … …  
    189160        /* Not reached */
    190161        return 0;
    191 }
    192 
    193 
    194 static void print_syntax(void)
    195 {
    196         printf("Syntax: " NAME " <controller_number>\n");
    197         printf("Controller number = 1..4\n");
    198162}
    199163

  • uspace/srv/bd/ata_bd/ata_bd.h

    rdffabf0 re84d65a  
    3030 * @{
    3131 */
    32 /** @file ATA driver definitions.
     32/** @file
    3333 */
    3434
    … …  
    4040#include <str.h>
    4141
    42 /** Base addresses for ATA I/O blocks. */
    43 typedef struct {
    44         uintptr_t cmd;  /**< Command block base address. */
    45         uintptr_t ctl;  /**< Control block base address. */
    46 } ata_base_t;
     42enum {
     43        CTL_READ_START  = 0,
     44        CTL_WRITE_START = 1,
     45};
     46
     47enum {
     48        STATUS_FAILURE = 0
     49};
     50
     51enum {
     52        MAX_DISKS       = 2
     53};
     54
     55/** ATA Command Register Block. */
     56typedef union {
     57        /* Read/Write */
     58        struct {
     59                uint16_t data_port;
     60                uint8_t sector_count;
     61                uint8_t sector_number;
     62                uint8_t cylinder_low;
     63                uint8_t cylinder_high;
     64                uint8_t drive_head;
     65                uint8_t pad_rw0;               
     66        };
     67
     68        /* Read Only */
     69        struct {
     70                uint8_t pad_ro0;
     71                uint8_t error;
     72                uint8_t pad_ro1[5];
     73                uint8_t status;
     74        };
     75
     76        /* Write Only */
     77        struct {
     78                uint8_t pad_wo0;
     79                uint8_t features;
     80                uint8_t pad_wo1[5];
     81                uint8_t command;
     82        };
     83} ata_cmd_t;
     84
     85typedef union {
     86        /* Read */
     87        struct {
     88                uint8_t pad0[6];
     89                uint8_t alt_status;
     90                uint8_t drive_address;
     91        };
     92
     93        /* Write */
     94        struct {
     95                uint8_t pad1[6];
     96                uint8_t device_control;
     97                uint8_t pad2;
     98        };
     99} ata_ctl_t;
     100
     101enum devctl_bits {
     102        DCR_SRST        = 0x04, /**< Software Reset */
     103        DCR_nIEN        = 0x02  /**< Interrupt Enable (negated) */
     104};
     105
     106enum status_bits {
     107        SR_BSY          = 0x80, /**< Busy */
     108        SR_DRDY         = 0x40, /**< Drive Ready */
     109        SR_DWF          = 0x20, /**< Drive Write Fault */
     110        SR_DSC          = 0x10, /**< Drive Seek Complete */
     111        SR_DRQ          = 0x08, /**< Data Request */
     112        SR_CORR         = 0x04, /**< Corrected Data */
     113        SR_IDX          = 0x02, /**< Index */
     114        SR_ERR          = 0x01  /**< Error */
     115};
     116
     117enum drive_head_bits {
     118        DHR_LBA         = 0x40, /**< Use LBA addressing mode */
     119        DHR_DRV         = 0x10  /**< Select device 1 */
     120};
     121
     122enum error_bits {
     123        ER_BBK          = 0x80, /**< Bad Block Detected */
     124        ER_UNC          = 0x40, /**< Uncorrectable Data Error */
     125        ER_MC           = 0x20, /**< Media Changed */
     126        ER_IDNF         = 0x10, /**< ID Not Found */
     127        ER_MCR          = 0x08, /**< Media Change Request */
     128        ER_ABRT         = 0x04, /**< Aborted Command */
     129        ER_TK0NF        = 0x02, /**< Track 0 Not Found */
     130        ER_AMNF         = 0x01  /**< Address Mark Not Found */
     131};
     132
     133enum ata_command {
     134        CMD_READ_SECTORS        = 0x20,
     135        CMD_READ_SECTORS_EXT    = 0x24,
     136        CMD_WRITE_SECTORS       = 0x30,
     137        CMD_WRITE_SECTORS_EXT   = 0x34,
     138        CMD_IDENTIFY_DRIVE      = 0xEC
     139};
    47140
    48141/** Timeout definitions. Unit is 10 ms. */
    … …  
    51144        TIMEOUT_BSY     =  100, /*  1 s */
    52145        TIMEOUT_DRDY    = 1000  /* 10 s */
     146};
     147
     148/** Data returned from @c identify command. */
     149typedef struct {
     150        uint16_t gen_conf;
     151        uint16_t cylinders;
     152        uint16_t _res2;
     153        uint16_t heads;
     154        uint16_t _vs4;
     155        uint16_t _vs5;
     156        uint16_t sectors;
     157        uint16_t _vs7;
     158        uint16_t _vs8;
     159        uint16_t _vs9;
     160
     161        uint16_t serial_number[10];
     162        uint16_t _vs20;
     163        uint16_t _vs21;
     164        uint16_t vs_bytes;
     165        uint16_t firmware_rev[4];
     166        uint16_t model_name[20];
     167
     168        uint16_t max_rw_multiple;
     169        uint16_t _res48;
     170        uint16_t caps;
     171        uint16_t _res50;
     172        uint16_t pio_timing;
     173        uint16_t dma_timing;
     174
     175        uint16_t validity;
     176        uint16_t cur_cyl;
     177        uint16_t cur_heads;
     178        uint16_t cur_sectors;
     179        uint16_t cur_capacity0;
     180        uint16_t cur_capacity1;
     181        uint16_t mss;
     182        uint16_t total_lba28_0;
     183        uint16_t total_lba28_1;
     184        uint16_t sw_dma;
     185        uint16_t mw_dma;
     186        uint16_t pio_modes;
     187        uint16_t min_mw_dma_cycle;
     188        uint16_t rec_mw_dma_cycle;
     189        uint16_t min_raw_pio_cycle;
     190        uint16_t min_iordy_pio_cycle;
     191
     192        uint16_t _res69;
     193        uint16_t _res70;
     194        uint16_t _res71;
     195        uint16_t _res72;
     196        uint16_t _res73;
     197        uint16_t _res74;
     198
     199        uint16_t queue_depth;
     200        uint16_t _res76[1 + 79 - 76];
     201        uint16_t version_maj;
     202        uint16_t version_min;
     203        uint16_t cmd_set0;
     204        uint16_t cmd_set1;
     205        uint16_t csf_sup_ext;
     206        uint16_t csf_enabled0;
     207        uint16_t csf_enabled1;
     208        uint16_t csf_default;
     209        uint16_t udma;
     210
     211        uint16_t _res89[1 + 99 - 89];
     212
     213        /* Total number of blocks in LBA-48 addressing */
     214        uint16_t total_lba48_0;
     215        uint16_t total_lba48_1;
     216        uint16_t total_lba48_2;
     217        uint16_t total_lba48_3;
     218
     219        /* Note: more fields are defined in ATA/ATAPI-7 */
     220        uint16_t _res104[1 + 127 - 104];
     221        uint16_t _vs128[1 + 159 - 128];
     222        uint16_t _res160[1 + 255 - 160];
     223} identify_data_t;
     224
     225enum ata_caps {
     226        cap_iordy       = 0x0800,
     227        cap_iordy_cbd   = 0x0400,
     228        cap_lba         = 0x0200,
     229        cap_dma         = 0x0100
     230};
     231
     232/** Bits of @c identify_data_t.cmd_set1 */
     233enum ata_cs1 {
     234        cs1_addr48      = 0x0400        /**< 48-bit address feature set */
    53235};
    54236
    … …  
    87269} block_coord_t;
    88270
    89 /** ATA device state structure. */
    90271typedef struct {
    91272        bool present;

  • uspace/srv/hw/netif/dp8390/Makefile

    rdffabf0 re84d65a  
    3939-include $(CONFIG_MAKEFILE)
    4040
     41ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
     42        LIBS += $(USPACE_PREFIX)/srv/net/nil/eth/libeth.a
     43endif
     44
    4145BINARY = dp8390
    4246

  • uspace/srv/net/cfg/Makefile

    rdffabf0 re84d65a  
    3636-include $(CONFIG_MAKEFILE)
    3737
    38 LO_SOURCE = lo.netif_standalone
    39 NE2K_SOURCE = ne2k.netif_standalone
     38ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
     39        LO_SOURCE = lo.netif_nil_bundle
     40        NE2K_SOURCE = ne2k.netif_nil_bundle
     41else
     42        LO_SOURCE = lo.netif_standalone
     43        NE2K_SOURCE = ne2k.netif_standalone
     44endif
    4045
    4146LO_TARGET = lo

  • uspace/srv/net/cfg/ne2k.netif_standalone

    rdffabf0 re84d65a  
    77IL=ip
    88
    9 IRQ=5
     9IRQ=9
    1010IO=300
    1111

  • uspace/srv/net/netif/lo/Makefile

    rdffabf0 re84d65a  
    3939-include $(CONFIG_MAKEFILE)
    4040
     41ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
     42        LIBS += $(USPACE_PREFIX)/srv/net/nil/nildummy/libnildummy.a
     43endif
     44
    4145BINARY = lo
    4246

  • uspace/srv/net/nil/eth/Makefile

    rdffabf0 re84d65a  
    3939-include $(CONFIG_MAKEFILE)
    4040
    41 BINARY = eth
     41ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
     42        LIBRARY = libeth
     43else
     44        BINARY = eth
     45endif
    4246
    4347SOURCES = \

  • uspace/srv/net/nil/nildummy/Makefile

    rdffabf0 re84d65a  
    3939-include $(CONFIG_MAKEFILE)
    4040
    41 BINARY = nildummy
     41ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
     42        LIBRARY = libnildummy
     43else
     44        BINARY = nildummy
     45endif
    4246
    4347SOURCES = \

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

    rdffabf0 re84d65a  
    205205static int tcp_queue_received_packet(socket_core_t *, tcp_socket_data_t *,
    206206    packet_t *, int, size_t);
    207 static void tcp_queue_received_end_of_data(socket_core_t *socket);
    208207
    209208static int tcp_received_msg(device_id_t, packet_t *, services_t, services_t);
    … …  
    454453
    455454has_error_service:
    456         fibril_rwlock_write_unlock(&tcp_globals.lock);
     455        fibril_rwlock_read_unlock(&tcp_globals.lock);
    457456
    458457        /* TODO error reporting/handling */
    … …  
    505504        size_t offset;
    506505        uint32_t new_sequence_number;
    507         bool forced_ack;
    508506        int rc;
    509507
    … …  
    514512        assert(packet);
    515513
    516         forced_ack = false;
    517 
    518514        new_sequence_number = ntohl(header->sequence_number);
    519515        old_incoming = socket_data->next_incoming;
    520516
    521         if (header->finalize) {
    522                 socket_data->fin_incoming = new_sequence_number +
    523                     total_length - TCP_HEADER_LENGTH(header);
    524         }
     517        if (header->finalize)
     518                socket_data->fin_incoming = new_sequence_number;
    525519
    526520        /* Trim begining if containing expected data */
    … …  
    766760                /* Release duplicite or restricted */
    767761                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    768                 forced_ack = true;
    769         }
    770 
    771         /* If next in sequence is an incoming FIN */
    772         if (socket_data->next_incoming == socket_data->fin_incoming) {
    773                 /* Advance sequence number */
    774                 socket_data->next_incoming += 1;
    775 
    776                 /* Handle FIN */
     762        }
     763
     764        /* Change state according to the acknowledging incoming fin */
     765        if (IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming,
     766            socket_data->next_incoming)) {
    777767                switch (socket_data->state) {
    778768                case TCP_SOCKET_FIN_WAIT_1:
    … …  
    781771                        socket_data->state = TCP_SOCKET_CLOSING;
    782772                        break;
    783                 case TCP_SOCKET_ESTABLISHED:
    784                         /* Queue end-of-data marker on the socket. */
    785                         tcp_queue_received_end_of_data(socket);
    786                         socket_data->state = TCP_SOCKET_CLOSE_WAIT;
    787                         break;
     773                /*case TCP_ESTABLISHED:*/
    788774                default:
    789775                        socket_data->state = TCP_SOCKET_CLOSE_WAIT;
    … …  
    793779
    794780        packet = tcp_get_packets_to_send(socket, socket_data);
    795         if (!packet && (socket_data->next_incoming != old_incoming || forced_ack)) {
     781        if (!packet) {
    796782                /* Create the notification packet */
    797783                rc = tcp_create_notification_packet(&packet, socket,
    … …  
    849835
    850836        return EOK;
    851 }
    852 
    853 /** Queue end-of-data marker on the socket.
    854  *
    855  * Next element in the sequence space is FIN. Queue end-of-data marker
    856  * on the socket.
    857  *
    858  * @param socket        Socket
    859  */
    860 static void tcp_queue_received_end_of_data(socket_core_t *socket)
    861 {
    862         assert(socket != NULL);
    863 
    864         /* Notify the destination socket */
    865         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    866             (sysarg_t) socket->socket_id,
    867             0, 0, 0,
    868             (sysarg_t) 0 /* 0 fragments == no more data */);
    869837}
    870838
    … …  
    18351803                        fibril_rwlock_write_unlock(socket_data->local_lock);
    18361804
    1837                         socket_data->state = TCP_SOCKET_SYN_SENT;
    1838 
    18391805                        /* Send the packet */
    18401806                        printf("connecting %d\n", packet_get_id(packet));
    … …  
    22442210
    22452211                tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
    2246                 rc = tcp_queue_packet(socket, socket_data, packet, total_length);
     2212                rc = tcp_queue_packet(socket, socket_data, packet, 0);
    22472213                if (rc != EOK)
    22482214                        return rc;

  • uspace/srv/vfs/vfs.h

    rdffabf0 re84d65a  
    3434#define VFS_VFS_H_
    3535
    36 #include <async.h>
    3736#include <ipc/ipc.h>
    3837#include <adt/list.h>
    … …  
    5453        vfs_info_t vfs_info;
    5554        fs_handle_t fs_handle;
    56         async_sess_t session;
     55        fibril_mutex_t phone_lock;
     56        sysarg_t phone;
    5757} fs_info_t;
    5858

  • uspace/srv/vfs/vfs_register.c

    rdffabf0 re84d65a  
    3939#include <ipc/services.h>
    4040#include <async.h>
     41#include <async_rel.h>
    4142#include <fibril.h>
    4243#include <fibril_synch.h>
    … …  
    110111void vfs_register(ipc_callid_t rid, ipc_call_t *request)
    111112{
    112         int phone;
    113        
    114113        dprintf("Processing VFS_REGISTER request received from %p.\n",
    115114            request->in_phone_hash);
    … …  
    137136       
    138137        link_initialize(&fs_info->fs_link);
     138        fibril_mutex_initialize(&fs_info->phone_lock);
    139139        fs_info->vfs_info = *vfs_info;
    140140        free(vfs_info);
    … …  
    186186                return;
    187187        }
    188        
    189         phone = IPC_GET_ARG5(call);
    190         async_session_create(&fs_info->session, phone);
     188        fs_info->phone = IPC_GET_ARG5(call);
    191189        ipc_answer_0(callid, EOK);
    192190       
    … …  
    202200                list_remove(&fs_info->fs_link);
    203201                fibril_mutex_unlock(&fs_head_lock);
    204                 async_session_destroy(&fs_info->session);
    205                 ipc_hangup(phone);
     202                ipc_hangup(fs_info->phone);
    206203                free(fs_info);
    207204                ipc_answer_0(callid, EINVAL);
    … …  
    217214                list_remove(&fs_info->fs_link);
    218215                fibril_mutex_unlock(&fs_head_lock);
    219                 async_session_destroy(&fs_info->session);
    220                 ipc_hangup(phone);
     216                ipc_hangup(fs_info->phone);
    221217                free(fs_info);
    222218                ipc_answer_0(callid, EINVAL);
    … …  
    273269                if (fs->fs_handle == handle) {
    274270                        fibril_mutex_unlock(&fs_head_lock);
    275                         phone = async_exchange_begin(&fs->session);
     271                        fibril_mutex_lock(&fs->phone_lock);
     272                        phone = async_relation_create(fs->phone);
     273                        fibril_mutex_unlock(&fs->phone_lock);
    276274
    277275                        assert(phone > 0);
    … …  
    297295                if (fs->fs_handle == handle) {
    298296                        fibril_mutex_unlock(&fs_head_lock);
    299                         async_exchange_end(&fs->session, phone);
     297                        fibril_mutex_lock(&fs->phone_lock);
     298                        async_relation_destroy(fs->phone, phone);
     299                        fibril_mutex_unlock(&fs->phone_lock);
    300300                        return;
    301301                }
Note: See TracChangeset for help on using the changeset viewer.