Changes in / [969d88e:88ccd8b8] in mainline


Ignore:
Files:
2 added
23 edited

Legend:

Unmodified
Added
Removed

  • kernel/Makefile

    r969d88e r88ccd8b8  
    226226        generic/src/proc/task.c \
    227227        generic/src/proc/the.c \
     228        generic/src/proc/tasklet.c \
    228229        generic/src/syscall/syscall.c \
    229230        generic/src/syscall/copy.c \
    … …  
    381382                generic/src/main/kinit.c \
    382383                generic/src/proc/the.c \
     384                generic/src/proc/tasklet.c \
    383385                generic/src/mm/frame.c \
    384386                generic/src/mm/page.c \

  • kernel/arch/mips32/include/atomic.h

    r969d88e r88ccd8b8  
    9191                "       sc %0, %1\n"
    9292                "       beqz %0, 1b\n"
    93                 "       nop\n"
    9493                "2:\n"
    9594                : "=&r" (tmp),

  • kernel/generic/include/ipc/ipc.h

    r969d88e r88ccd8b8  
    115115 */
    116116#define IPC_FF_ROUTE_FROM_ME  (1 << 0)
    117 
    118 /* Data transfer flags. */
    119 #define IPC_XF_NONE             0
    120 
    121 /** Restrict the transfer size if necessary. */
    122 #define IPC_XF_RESTRICT         (1 << 0)
    123117
    124118/** Kernel IPC interfaces

  • kernel/generic/src/ipc/sysipc.c

    r969d88e r88ccd8b8  
    426426        case IPC_M_DATA_READ: {
    427427                size_t size = IPC_GET_ARG2(call->data);
    428                 if (size <= 0)
     428                if ((size <= 0 || (size > DATA_XFER_LIMIT)))
    429429                        return ELIMIT;
    430                 if (size > DATA_XFER_LIMIT) {
    431                         int flags = IPC_GET_ARG3(call->data);
    432                         if (flags & IPC_XF_RESTRICT)
    433                                 IPC_SET_ARG2(call->data, DATA_XFER_LIMIT);
    434                         else
    435                                 return ELIMIT;
    436                 }
     430               
    437431                break;
    438432        }
    … …  
    441435                size_t size = IPC_GET_ARG2(call->data);
    442436               
    443                 if (size > DATA_XFER_LIMIT) {
    444                         int flags = IPC_GET_ARG3(call->data);
    445                         if (flags & IPC_XF_RESTRICT) {
    446                                 size = DATA_XFER_LIMIT;
    447                                 IPC_SET_ARG2(call->data, size);
    448                         } else
    449                                 return ELIMIT;
    450                 }
     437                if (size > DATA_XFER_LIMIT)
     438                        return ELIMIT;
    451439               
    452440                call->buffer = (uint8_t *) malloc(size, 0);

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

    r969d88e r88ccd8b8  
    5858#include <proc/thread.h>
    5959#include <proc/task.h>
     60#include <proc/tasklet.h>
    6061#include <main/kinit.h>
    6162#include <main/version.h>
    … …  
    216217        tlb_init();
    217218        ddi_init();
     219        tasklet_init();
    218220        arch_post_mm_init();
    219221        arch_pre_smp_init();

  • uspace/app/stats/stats.c

    r969d88e r88ccd8b8  
    265265                /* Threads */
    266266                if ((off = arg_parse_short_long(argv[i], "-t", "--task=")) != -1) {
    267                         // TODO: Support for 64b range
     267                        /* TODO: Support for 64b range */
    268268                        int tmp;
    269269                        int ret = arg_parse_int(argc, argv, &i, &tmp, off);

  • uspace/lib/c/arch/mips32/include/atomic.h

    r969d88e r88ccd8b8  
    7070                "       sc %0, %1\n"
    7171                "       beq %0, %4, 1b\n"       /* if the atomic operation failed, try again */
     72                /*      nop     */              /* nop is inserted automatically by compiler */
    7273                "       nop\n"
    7374                : "=&r" (tmp),

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

    r969d88e r88ccd8b8  
    15721572 * @param dst     Address of the beginning of the destination buffer.
    15731573 * @param size    Size of the destination buffer.
    1574  * @param flags   Flags to control the data transfer.
    15751574 *
    15761575 * @return Zero on success or a negative error code from errno.h.
    15771576 *
    15781577 */
    1579 int
    1580 async_data_read_start_generic(int phoneid, void *dst, size_t size, int flags)
    1581 {
    1582         return async_req_3_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
    1583             (sysarg_t) size, (sysarg_t) flags);
     1578int async_data_read_start(int phoneid, void *dst, size_t size)
     1579{
     1580        return async_req_2_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
     1581            (sysarg_t) size);
    15841582}
    15851583
    … …  
    16711669 * @param src     Address of the beginning of the source buffer.
    16721670 * @param size    Size of the source buffer.
    1673  * @param flags   Flags to control the data transfer.
    16741671 *
    16751672 * @return Zero on success or a negative error code from errno.h.
    16761673 *
    16771674 */
    1678 int
    1679 async_data_write_start_generic(int phoneid, const void *src, size_t size,
    1680     int flags)
    1681 {
    1682         return async_req_3_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
    1683             (sysarg_t) size, (sysarg_t) flags);
     1675int async_data_write_start(int phoneid, const void *src, size_t size)
     1676{
     1677        return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
     1678            (sysarg_t) size);
    16841679}
    16851680

  • uspace/lib/c/generic/vfs/vfs.c

    r969d88e r88ccd8b8  
    378378       
    379379        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
    380         rc = async_data_read_start_generic(vfs_phone, (void *) buf, nbyte,
    381             IPC_XF_RESTRICT);
     380        rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
    382381        if (rc != EOK) {
    383382                vfs_exchange_end(vfs_phone);
    … …  
    408407       
    409408        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
    410         rc = async_data_write_start_generic(vfs_phone, (void *) buf, nbyte,
    411             IPC_XF_RESTRICT);
     409        rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
    412410        if (rc != EOK) {
    413411                vfs_exchange_end(vfs_phone);

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

    r969d88e r88ccd8b8  
    340340            (arg4), (answer))
    341341
    342 #define async_data_read_start(p, buf, len) \
    343         async_data_read_start_generic((p), (buf), (len), IPC_XF_NONE)
    344 
    345 extern int async_data_read_start_generic(int, void *, size_t, int);
     342extern int async_data_read_start(int, void *, size_t);
    346343extern bool async_data_read_receive(ipc_callid_t *, size_t *);
    347344extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
    … …  
    382379            (arg4), (answer))
    383380
    384 #define async_data_write_start(p, buf, len) \
    385         async_data_write_start_generic((p), (buf), (len), IPC_XF_NONE)
    386 
    387 extern int async_data_write_start_generic(int, const void *, size_t, int);
     381extern int async_data_write_start(int, const void *, size_t);
    388382extern bool async_data_write_receive(ipc_callid_t *, size_t *);
    389383extern int async_data_write_finalize(ipc_callid_t, void *, size_t);

  • uspace/lib/drv/generic/driver.c

    r969d88e r88ccd8b8  
    4747#include <stdlib.h>
    4848#include <str.h>
    49 #include <str_error.h>
    5049#include <ctype.h>
    5150#include <errno.h>
    … …  
    656655int ddf_driver_main(driver_t *drv)
    657656{
    658         int rc;
    659 
    660657        /*
    661658         * Remember the driver structure - driver_ops will be called by generic
    … …  
    671668       
    672669        /*
    673          * Register driver with device manager using generic handler for
    674          * incoming connections.
     670         * Register driver by device manager with generic handler for incoming
     671         * connections.
    675672         */
    676         rc = devman_driver_register(driver->name, driver_connection);
    677         if (rc != EOK) {
    678                 printf("Error: Failed to register driver with device manager "
    679                     "(%s).\n", (rc == EEXISTS) ? "driver already started" :
    680                     str_error(rc));
    681                
    682                 return 1;
    683         }
    684        
    685         /* Return success from the task since server has started. */
    686         rc = task_retval(0);
    687         if (rc != EOK)
    688                 return 1;
    689 
     673        devman_driver_register(driver->name, driver_connection);
     674       
    690675        async_manager();
    691676       

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

    r969d88e r88ccd8b8  
    106106                                seed = (seed << 1) ^ ((uint32_t) CRC_DIVIDER_BE);
    107107                        } else {
    108                                 /* Shift otherwise */
     108                                /* shift otherwise */
    109109                                seed <<= 1;
    110110                        }

  • uspace/lib/net/il/ip_client.c

    r969d88e r88ccd8b8  
    123123                return EOK;
    124124
    125         // TODO IPv6
    126 #if 0
    127         case AF_INET6:
     125        /* TODO IPv6 */
     126/*      case AF_INET6:
    128127                if (addrlen != sizeof(struct sockaddr_in6))
    129128                        return EINVAL;
    … …  
    131130                address_in6 = (struct sockaddr_in6 *) addr;
    132131                return EOK;
    133 #endif
     132*/
    134133
    135134        default:
    … …  
    259258                header_in->data_length = htons(data_length);
    260259                return EOK;
    261         // TODO IPv6
     260        /* TODO IPv6 */
    262261        } else {
    263262                return EINVAL;

  • uspace/lib/net/include/ip_client.h

    r969d88e r88ccd8b8  
    5454    socklen_t, struct sockaddr *, socklen_t, size_t, void **, size_t *);
    5555
    56 // TODO ipopt manipulation
     56/* TODO ipopt manipulation */
    5757
    5858#endif

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

    r969d88e r88ccd8b8  
    306306               
    307307        case AF_INET6:
    308                 // TODO IPv6
     308                /* TODO IPv6 */
    309309                break;
    310310        }
    … …  
    376376
    377377        count = 0;
    378 #if 0
    379         socket_id = socket_globals.last_id;
    380 #endif
     378//      socket_id = socket_globals.last_id;
    381379        do {
    382380                if (count < SOCKET_ID_TRIES) {
    … …  
    390388                        if (socket_id < INT_MAX) {
    391389                                ++ socket_id;
    392 #if 0
    393                         } else if(socket_globals.last_id) {
    394                                 socket_globals.last_id = 0;
    395                                 socket_id = 1;
    396 #endif
    397                         } else {
     390/*                      } else if(socket_globals.last_id) {
     391*                               socket_globals.last_id = 0;
     392*                               socket_id = 1;
     393*/                      } else {
    398394                                return ELIMIT;
    399395                        }

  • uspace/srv/devman/devman.c

    r969d88e r88ccd8b8  
    555555}
    556556
     557/** Remember the driver's phone.
     558 *
     559 * @param driver        The driver.
     560 * @param phone         The phone to the driver.
     561 */
     562void set_driver_phone(driver_t *driver, sysarg_t phone)
     563{
     564        fibril_mutex_lock(&driver->driver_mutex);
     565        assert(driver->state == DRIVER_STARTING);
     566        driver->phone = phone;
     567        fibril_mutex_unlock(&driver->driver_mutex);
     568}
     569
    557570/** Notify driver about the devices to which it was assigned.
    558571 *
    … …  
    672685        list_initialize(&drv->devices);
    673686        fibril_mutex_initialize(&drv->driver_mutex);
    674         drv->phone = -1;
    675687}
    676688

  • uspace/srv/devman/devman.h

    r969d88e r88ccd8b8  
    8888       
    8989        /** Phone asociated with this driver. */
    90         int phone;
     90        sysarg_t phone;
    9191        /** Name of the device driver. */
    9292        char *name;
    … …  
    316316
    317317extern driver_t *find_driver(driver_list_t *, const char *);
     318extern void set_driver_phone(driver_t *, sysarg_t);
    318319extern void initialize_running_driver(driver_t *, dev_tree_t *);
    319320

  • uspace/srv/devman/main.c

    r969d88e r88ccd8b8  
    9595        /* Find driver structure. */
    9696        driver = find_driver(&drivers_list, drv_name);
     97       
    9798        if (driver == NULL) {
    9899                log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name);
    … …  
    106107        drv_name = NULL;
    107108       
    108         fibril_mutex_lock(&driver->driver_mutex);
    109        
    110         if (driver->phone >= 0) {
    111                 /* We already have a connection to the driver. */
    112                 log_msg(LVL_ERROR, "Driver '%s' already started.\n",
    113                     driver->name);
    114                 fibril_mutex_unlock(&driver->driver_mutex);
    115                 async_answer_0(iid, EEXISTS);
    116                 return NULL;
    117         }
    118        
    119         switch (driver->state) {
    120         case DRIVER_NOT_STARTED:
    121                 /* Somebody started the driver manually. */
    122                 log_msg(LVL_NOTE, "Driver '%s' started manually.\n",
    123                     driver->name);
    124                 driver->state = DRIVER_STARTING;
    125                 break;
    126         case DRIVER_STARTING:
    127                 /* The expected case */
    128                 break;
    129         case DRIVER_RUNNING:
    130                 /* Should not happen since we do not have a connected phone */
    131                 assert(false);
    132         }
    133        
    134109        /* Create connection to the driver. */
    135110        log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.",
    … …  
    138113        ipc_callid_t callid = async_get_call(&call);
    139114        if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
    140                 fibril_mutex_unlock(&driver->driver_mutex);
    141115                async_answer_0(callid, ENOTSUP);
    142116                async_answer_0(iid, ENOTSUP);
    … …  
    145119       
    146120        /* Remember driver's phone. */
    147         driver->phone = IPC_GET_ARG5(call);
    148        
    149         fibril_mutex_unlock(&driver->driver_mutex);
     121        set_driver_phone(driver, IPC_GET_ARG5(call));
    150122       
    151123        log_msg(LVL_NOTE,
    … …  
    606578                method = DRIVER_CLIENT;
    607579       
    608         if (driver->phone < 0) {
     580        if (driver->phone <= 0) {
    609581                log_msg(LVL_ERROR,
    610582                    "Could not forward to driver `%s' (phone is %d).",
    … …  
    646618        dev = fun->dev;
    647619       
    648         if (dev->state != DEVICE_USABLE || dev->drv->phone < 0) {
     620        if (dev->state != DEVICE_USABLE || dev->drv->phone <= 0) {
    649621                async_answer_0(iid, EINVAL);
    650622                return;

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

    r969d88e r88ccd8b8  
    722722                    (str_cmp((char *) d->name, FAT_NAME_DOT)) == 0) {
    723723                        memset(d, 0, sizeof(fat_dentry_t));
    724                         memcpy(d->name, FAT_NAME_DOT, FAT_NAME_LEN);
    725                         memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
     724                        str_cpy((char *) d->name, 8, FAT_NAME_DOT);
     725                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
    726726                        d->attr = FAT_ATTR_SUBDIR;
    727727                        d->firstc = host2uint16_t_le(childp->firstc);
    … …  
    732732                    (str_cmp((char *) d->name, FAT_NAME_DOT_DOT) == 0)) {
    733733                        memset(d, 0, sizeof(fat_dentry_t));
    734                         memcpy(d->name, FAT_NAME_DOT_DOT, FAT_NAME_LEN);
    735                         memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
     734                        str_cpy((char *) d->name, 8, FAT_NAME_DOT_DOT);
     735                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
    736736                        d->attr = FAT_ATTR_SUBDIR;
    737737                        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?

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

    r969d88e r88ccd8b8  
    5656static int apic_enable_irq(sysarg_t irq)
    5757{
    58         // FIXME: TODO
     58        /* FIXME: TODO */
    5959        return ENOTSUP;
    6060}

  • uspace/srv/net/il/ip/ip.c

    r969d88e r88ccd8b8  
    365365               
    366366                if (ip_netif->dhcp) {
    367                         // TODO dhcp
     367                        /* TODO dhcp */
    368368                        net_free_settings(configuration, data);
    369369                        return ENOTSUP;
    … …  
    398398                        }
    399399                } else {
    400                         // TODO ipv6 in separate module
     400                        /* TODO ipv6 in separate module */
    401401                        net_free_settings(configuration, data);
    402402                        return ENOTSUP;
    … …  
    517517            ip_netif->dhcp ? "dhcp" : "static");
    518518       
    519         // TODO ipv6 addresses
     519        /* TODO ipv6 addresses */
    520520       
    521521        char address[INET_ADDRSTRLEN];
    … …  
    946946
    947947        /* Greatest multiple of 8 lower than content */
    948         // TODO even fragmentation?
     948        /* TODO even fragmentation? */
    949949        length = length & ~0x7;
    950950       
    … …  
    12121212        }
    12131213       
    1214         /* If the local host is the destination */
     1214        /* Ff the local host is the destination */
    12151215        if ((route->address.s_addr == dest->s_addr) &&
    12161216            (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
    … …  
    12791279        in_addr_t destination;
    12801280
    1281         // TODO search set ipopt route?
     1281        /* TODO search set ipopt route? */
    12821282        destination.s_addr = header->destination_address;
    12831283        return destination;
    … …  
    13211321        if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
    13221322            IP_FRAGMENT_OFFSET(header)) {
    1323                 // TODO fragmented
     1323                /* TODO fragmented */
    13241324                return ENOTSUP;
    13251325        }
    … …  
    14371437                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14381438                if (phone >= 0) {
    1439                         /* TTL exceeded ICMP */
     1439                        /* ttl exceeded ICMP */
    14401440                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
    14411441                }
    … …  
    17771777                if ((type != ICMP_DEST_UNREACH) ||
    17781778                    (code != ICMP_HOST_UNREACH)) {
    1779                         /* No, something else */
     1779                        /* No, something else */
    17801780                        break;
    17811781                }

  • uspace/srv/vfs/vfs_file.c

    r969d88e r88ccd8b8  
    258258        if ((fd >= 0) && (fd < MAX_OPEN_FILES)) {
    259259                vfs_file_t *file = FILES[fd];
    260                 if (file != NULL) {
    261                         vfs_file_addref(file);
    262                         fibril_mutex_unlock(&VFS_DATA->lock);
    263                         return file;
    264                 }
     260                vfs_file_addref(file);
     261                fibril_mutex_unlock(&VFS_DATA->lock);
     262                return file;
    265263        }
    266264        fibril_mutex_unlock(&VFS_DATA->lock);

  • uspace/srv/vfs/vfs_ops.c

    r969d88e r88ccd8b8  
    611611void vfs_open_node(ipc_callid_t rid, ipc_call_t *request)
    612612{
    613         // FIXME: check for sanity of the supplied fs, dev and index
     613        /* FIXME: check for sanity of the supplied fs, dev and index */
    614614       
    615615        /*
Note: See TracChangeset for help on using the changeset viewer.