Changeset 969d88e in mainline


Ignore:
Timestamp:
2011-04-09T11:04:11Z (13 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
534d08e8
Parents:
88ccd8b8 (diff), 17279ead (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

Files:
2 deleted
23 edited

Legend:

Unmodified
Added
Removed

  • kernel/Makefile

    r88ccd8b8 r969d88e  
    226226        generic/src/proc/task.c \
    227227        generic/src/proc/the.c \
    228         generic/src/proc/tasklet.c \
    229228        generic/src/syscall/syscall.c \
    230229        generic/src/syscall/copy.c \
    … …  
    382381                generic/src/main/kinit.c \
    383382                generic/src/proc/the.c \
    384                 generic/src/proc/tasklet.c \
    385383                generic/src/mm/frame.c \
    386384                generic/src/mm/page.c \

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

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

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

    r88ccd8b8 r969d88e  
    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)
    117123
    118124/** Kernel IPC interfaces

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

    r88ccd8b8 r969d88e  
    426426        case IPC_M_DATA_READ: {
    427427                size_t size = IPC_GET_ARG2(call->data);
    428                 if ((size <= 0 || (size > DATA_XFER_LIMIT)))
     428                if (size <= 0)
    429429                        return ELIMIT;
    430                
     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                }
    431437                break;
    432438        }
    … …  
    435441                size_t size = IPC_GET_ARG2(call->data);
    436442               
    437                 if (size > DATA_XFER_LIMIT)
    438                         return ELIMIT;
     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                }
    439451               
    440452                call->buffer = (uint8_t *) malloc(size, 0);

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

    r88ccd8b8 r969d88e  
    5858#include <proc/thread.h>
    5959#include <proc/task.h>
    60 #include <proc/tasklet.h>
    6160#include <main/kinit.h>
    6261#include <main/version.h>
    … …  
    217216        tlb_init();
    218217        ddi_init();
    219         tasklet_init();
    220218        arch_post_mm_init();
    221219        arch_pre_smp_init();

  • uspace/app/stats/stats.c

    r88ccd8b8 r969d88e  
    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

    r88ccd8b8 r969d88e  
    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 */
    7372                "       nop\n"
    7473                : "=&r" (tmp),

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

    r88ccd8b8 r969d88e  
    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.
    15741575 *
    15751576 * @return Zero on success or a negative error code from errno.h.
    15761577 *
    15771578 */
    1578 int 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);
     1579int
     1580async_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);
    15821584}
    15831585
    … …  
    16691671 * @param src     Address of the beginning of the source buffer.
    16701672 * @param size    Size of the source buffer.
     1673 * @param flags   Flags to control the data transfer.
    16711674 *
    16721675 * @return Zero on success or a negative error code from errno.h.
    16731676 *
    16741677 */
    1675 int 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);
     1678int
     1679async_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);
    16791684}
    16801685

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

    r88ccd8b8 r969d88e  
    378378       
    379379        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
    380         rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
     380        rc = async_data_read_start_generic(vfs_phone, (void *) buf, nbyte,
     381            IPC_XF_RESTRICT);
    381382        if (rc != EOK) {
    382383                vfs_exchange_end(vfs_phone);
    … …  
    407408       
    408409        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
    409         rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
     410        rc = async_data_write_start_generic(vfs_phone, (void *) buf, nbyte,
     411            IPC_XF_RESTRICT);
    410412        if (rc != EOK) {
    411413                vfs_exchange_end(vfs_phone);

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

    r88ccd8b8 r969d88e  
    340340            (arg4), (answer))
    341341
    342 extern int async_data_read_start(int, void *, size_t);
     342#define async_data_read_start(p, buf, len) \
     343        async_data_read_start_generic((p), (buf), (len), IPC_XF_NONE)
     344
     345extern int async_data_read_start_generic(int, void *, size_t, int);
    343346extern bool async_data_read_receive(ipc_callid_t *, size_t *);
    344347extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
    … …  
    379382            (arg4), (answer))
    380383
    381 extern int async_data_write_start(int, const void *, size_t);
     384#define async_data_write_start(p, buf, len) \
     385        async_data_write_start_generic((p), (buf), (len), IPC_XF_NONE)
     386
     387extern int async_data_write_start_generic(int, const void *, size_t, int);
    382388extern bool async_data_write_receive(ipc_callid_t *, size_t *);
    383389extern int async_data_write_finalize(ipc_callid_t, void *, size_t);

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

    r88ccd8b8 r969d88e  
    4747#include <stdlib.h>
    4848#include <str.h>
     49#include <str_error.h>
    4950#include <ctype.h>
    5051#include <errno.h>
    … …  
    655656int ddf_driver_main(driver_t *drv)
    656657{
     658        int rc;
     659
    657660        /*
    658661         * Remember the driver structure - driver_ops will be called by generic
    … …  
    668671       
    669672        /*
    670          * Register driver by device manager with generic handler for incoming
    671          * connections.
     673         * Register driver with device manager using generic handler for
     674         * incoming connections.
    672675         */
    673         devman_driver_register(driver->name, driver_connection);
    674        
     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
    675690        async_manager();
    676691       

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

    r88ccd8b8 r969d88e  
    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

    r88ccd8b8 r969d88e  
    123123                return EOK;
    124124
    125         /* TODO IPv6 */
    126 /*      case AF_INET6:
     125        // TODO IPv6
     126#if 0
     127        case AF_INET6:
    127128                if (addrlen != sizeof(struct sockaddr_in6))
    128129                        return EINVAL;
    … …  
    130131                address_in6 = (struct sockaddr_in6 *) addr;
    131132                return EOK;
    132 */
     133#endif
    133134
    134135        default:
    … …  
    258259                header_in->data_length = htons(data_length);
    259260                return EOK;
    260         /* TODO IPv6 */
     261        // TODO IPv6
    261262        } else {
    262263                return EINVAL;

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

    r88ccd8b8 r969d88e  
    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

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

  • uspace/srv/devman/devman.c

    r88ccd8b8 r969d88e  
    555555}
    556556
    557 /** Remember the driver's phone.
    558  *
    559  * @param driver        The driver.
    560  * @param phone         The phone to the driver.
    561  */
    562 void 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 
    570557/** Notify driver about the devices to which it was assigned.
    571558 *
    … …  
    685672        list_initialize(&drv->devices);
    686673        fibril_mutex_initialize(&drv->driver_mutex);
     674        drv->phone = -1;
    687675}
    688676

  • uspace/srv/devman/devman.h

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

  • uspace/srv/devman/main.c

    r88ccd8b8 r969d88e  
    9595        /* Find driver structure. */
    9696        driver = find_driver(&drivers_list, drv_name);
    97        
    9897        if (driver == NULL) {
    9998                log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name);
    … …  
    107106        drv_name = NULL;
    108107       
     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       
    109134        /* Create connection to the driver. */
    110135        log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.",
    … …  
    113138        ipc_callid_t callid = async_get_call(&call);
    114139        if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
     140                fibril_mutex_unlock(&driver->driver_mutex);
    115141                async_answer_0(callid, ENOTSUP);
    116142                async_answer_0(iid, ENOTSUP);
    … …  
    119145       
    120146        /* Remember driver's phone. */
    121         set_driver_phone(driver, IPC_GET_ARG5(call));
     147        driver->phone = IPC_GET_ARG5(call);
     148       
     149        fibril_mutex_unlock(&driver->driver_mutex);
    122150       
    123151        log_msg(LVL_NOTE,
    … …  
    578606                method = DRIVER_CLIENT;
    579607       
    580         if (driver->phone <= 0) {
     608        if (driver->phone < 0) {
    581609                log_msg(LVL_ERROR,
    582610                    "Could not forward to driver `%s' (phone is %d).",
    … …  
    618646        dev = fun->dev;
    619647       
    620         if (dev->state != DEVICE_USABLE || dev->drv->phone <= 0) {
     648        if (dev->state != DEVICE_USABLE || dev->drv->phone < 0) {
    621649                async_answer_0(iid, EINVAL);
    622650                return;

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

    r88ccd8b8 r969d88e  
    722722                    (str_cmp((char *) d->name, FAT_NAME_DOT)) == 0) {
    723723                        memset(d, 0, sizeof(fat_dentry_t));
    724                         str_cpy((char *) d->name, 8, FAT_NAME_DOT);
    725                         str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
     724                        memcpy(d->name, FAT_NAME_DOT, FAT_NAME_LEN);
     725                        memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
    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                         str_cpy((char *) d->name, 8, FAT_NAME_DOT_DOT);
    735                         str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
     734                        memcpy(d->name, FAT_NAME_DOT_DOT, FAT_NAME_LEN);
     735                        memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
    736736                        d->attr = FAT_ATTR_SUBDIR;
    737737                        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?

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

    r88ccd8b8 r969d88e  
    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

    r88ccd8b8 r969d88e  
    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         /* Ff the local host is the destination */
     1214        /* If 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

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

  • uspace/srv/vfs/vfs_ops.c

    r88ccd8b8 r969d88e  
    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.