Changeset 27bdfa5 in mainline for uspace/srv


Ignore:
Timestamp:
2011-03-30T17:34:59Z (14 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
48d4231, 87b52c9, 98169ab, e353e85
Parents:
51e5608 (diff), 917a8c8 (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

Location:
uspace/srv
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/devman/devman.c

    r51e5608 r27bdfa5  
    274274        }
    275275       
    276         if (read(fd, buf, len) <= 0) {
     276        ssize_t read_bytes = safe_read(fd, buf, len);
     277        if (read_bytes <= 0) {
    277278                printf(NAME ": unable to read file '%s'.\n", conf_path);
    278279                goto cleanup;
    279280        }
    280         buf[len] = 0;
     281        buf[read_bytes] = 0;
    281282       
    282283        suc = parse_match_ids(buf, ids);
    … …  
    11311132fun_node_t *find_fun_node_by_path(dev_tree_t *tree, char *path)
    11321133{
     1134        assert(path != NULL);
     1135
     1136        bool is_absolute = path[0] == '/';
     1137        if (!is_absolute) {
     1138                return NULL;
     1139        }
     1140
    11331141        fibril_rwlock_read_lock(&tree->rwlock);
    11341142       
    … …  
    11401148        char *rel_path = path;
    11411149        char *next_path_elem = NULL;
    1142         bool cont = (rel_path[0] == '/');
     1150        bool cont = true;
    11431151       
    11441152        while (cont && fun != NULL) {

  • uspace/srv/devman/main.c

    r51e5608 r27bdfa5  
    477477                dev = fun->dev;
    478478
    479         if (fun == NULL && dev == NULL) {
     479        /*
     480         * For a valid function to connect to we need a device. The root
     481         * function, for example, has no device and cannot be connected to.
     482         * This means @c dev needs to be valid regardless whether we are
     483         * connecting to a device or to a function.
     484         */
     485        if (dev == NULL) {
    480486                printf(NAME ": devman_forward error - no device or function with "
    481487                    "handle %" PRIun " was found.\n", handle);

  • uspace/srv/devman/util.c

    r51e5608 r27bdfa5  
    111111}
    112112
     113ssize_t safe_read(int fd, void *buffer, size_t size)
     114{
     115        if (size == 0) {
     116                return 0;
     117        }
     118
     119        uint8_t *buf_ptr = (uint8_t *) buffer;
     120
     121        size_t total_read = 0;
     122        while (total_read < size) {
     123                ssize_t bytes_read = read(fd, buf_ptr, size - total_read);
     124                if (bytes_read < 0) {
     125                        /* Error. */
     126                        return bytes_read;
     127                } else if (bytes_read == 0) {
     128                        /* Possibly end of file. */
     129                        break;
     130                } else {
     131                        /* Read at least something. */
     132                        buf_ptr += bytes_read;
     133                        total_read += bytes_read;
     134                }
     135        }
     136
     137        return (ssize_t) total_read;
     138}
     139
    113140/** @}
    114141 */

  • uspace/srv/devman/util.h

    r51e5608 r27bdfa5  
    4747extern void replace_char(char *, char, char);
    4848
     49extern ssize_t safe_read(int, void *, size_t);
     50
    4951#endif
    5052

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    r51e5608 r27bdfa5  
    367367static void cuda_irq_rcv_end(void *buf, size_t *len)
    368368{
    369         uint8_t data, b;
    370 
     369        uint8_t b;
     370       
    371371        b = pio_read_8(&dev->b);
    372         data = pio_read_8(&dev->sr);
    373 
     372        pio_read_8(&dev->sr);
     373       
    374374        if ((b & TREQ) == 0) {
    375375                instance->xstate = cx_receive;
    … …  
    379379                cuda_send_start();
    380380        }
    381 
    382         memcpy(buf, instance->rcv_buf, instance->bidx);
    383         *len = instance->bidx;
     381       
     382        memcpy(buf, instance->rcv_buf, instance->bidx);
     383        *len = instance->bidx;
    384384        instance->bidx = 0;
    385385}

  • uspace/srv/hw/netif/ne2000/dp8390.c

    r51e5608 r27bdfa5  
    391391       
    392392        if ((size < ETH_MIN_PACK_SIZE) || (size > ETH_MAX_PACK_SIZE_TAGGED)) {
     393                fibril_mutex_unlock(&ne2k->sq_mutex);
    393394                fprintf(stderr, "%s: Frame dropped (invalid size %zu bytes)\n",
    394395                    NAME, size);

  • uspace/srv/loader/arch/abs32le/_link.ld.in

    r51e5608 r27bdfa5  
    2121       
    2222        .text : {
    23                 *(.text);
    24                 *(.rodata*);
     23                *(.text .text.*);
     24                *(.rodata .rodata.*);
    2525        } :text
    2626       

  • uspace/srv/loader/arch/amd64/_link.ld.in

    r51e5608 r27bdfa5  
    2727       
    2828        .text : {
    29                 *(.text);
    30                 *(.rodata*);
     29                *(.text .text.*);
     30                *(.rodata .rodata.*);
    3131        } :text
    3232       

  • uspace/srv/loader/arch/arm32/_link.ld.in

    r51e5608 r27bdfa5  
    2525       
    2626        .text : {
    27                 *(.text);
    28                 *(.rodata*);
     27                *(.text .text.*);
     28                *(.rodata .rodata.*);
    2929        } :text
    3030       

  • uspace/srv/loader/arch/ia32/_link.ld.in

    r51e5608 r27bdfa5  
    2626       
    2727        .text : {
    28                 *(.text);
    29                 *(.rodata*);
     28                *(.text .text.*);
     29                *(.rodata .rodata.*);
    3030        } :text
    3131       

  • uspace/srv/loader/arch/ia64/_link.ld.in

    r51e5608 r27bdfa5  
    2121       
    2222        .text : {
    23                 *(.text);
    24                 *(.rodata*);
     23                *(.text .text.*);
     24                *(.rodata .rodata.*);
    2525        } :text
    2626       
    … …  
    2929        .got : {
    3030                _gp = .;
    31                 *(.got*);
     31                *(.got .got.*);
    3232        } :data
    3333       

  • uspace/srv/loader/arch/mips32/_link.ld.in

    r51e5608 r27bdfa5  
    2525       
    2626        .text : {
    27                 *(.text);
    28                 *(.rodata*);
     27                *(.text .text.*);
     28                *(.rodata .rodata.*);
    2929        } :text
    3030       

  • uspace/srv/loader/arch/ppc32/_link.ld.in

    r51e5608 r27bdfa5  
    2525       
    2626        .text : {
    27                 *(.text);
    28                 *(.rodata*);
     27                *(.text .text.*);
     28                *(.rodata .rodata.*);
    2929        } :text
    3030       

  • uspace/srv/loader/arch/sparc64/_link.ld.in

    r51e5608 r27bdfa5  
    2020       
    2121        .text : {
    22                 *(.text);
    23                 *(.rodata*);
     22                *(.text .text.*);
     23                *(.rodata .rodata.*);
    2424        } :text
    2525       

  • uspace/srv/loader/main.c

    r51e5608 r27bdfa5  
    407407                        /* Not reached */
    408408                default:
    409                         retval = ENOENT;
     409                        retval = EINVAL;
    410410                        break;
    411411                }
    412                 if (IPC_GET_IMETHOD(call) != IPC_M_PHONE_HUNGUP) {
    413                         DPRINTF("Responding EINVAL to method %d.\n",
    414                             IPC_GET_IMETHOD(call));
    415                         async_answer_0(callid, EINVAL);
    416                 }
     412               
     413                if (IPC_GET_IMETHOD(call) != IPC_M_PHONE_HUNGUP)
     414                        async_answer_0(callid, retval);
    417415        }
    418416}

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

    r51e5608 r27bdfa5  
    157157                       
    158158                        arp_clear_addr(&proto->addresses);
    159                         arp_addr_destroy(&proto->addresses);
    160                 }
    161         }
    162        
    163         arp_protos_clear(&device->protos);
     159                        arp_addr_destroy(&proto->addresses, free);
     160                }
     161        }
     162       
     163        arp_protos_clear(&device->protos, free);
    164164}
    165165
    … …  
    184184        }
    185185       
    186         arp_cache_clear(&arp_globals.cache);
     186        arp_cache_clear(&arp_globals.cache, free);
    187187        fibril_mutex_unlock(&arp_globals.lock);
    188188       
    … …  
    212212                arp_clear_trans(trans);
    213213       
    214         arp_addr_exclude(&proto->addresses, address->value, address->length);
     214        arp_addr_exclude(&proto->addresses, address->value, address->length, free);
    215215       
    216216        fibril_mutex_unlock(&arp_globals.lock);
    … …  
    345345                            header->protocol_length, trans);
    346346                        if (rc != EOK) {
    347                                 /* The generic char map has already freed trans! */
     347                                free(trans);
    348348                                return rc;
    349349                        }
    … …  
    556556                if (index < 0) {
    557557                        fibril_mutex_unlock(&arp_globals.lock);
    558                         arp_protos_destroy(&device->protos);
     558                        arp_protos_destroy(&device->protos, free);
    559559                        free(device);
    560560                        return index;
    … …  
    569569                if (device->phone < 0) {
    570570                        fibril_mutex_unlock(&arp_globals.lock);
    571                         arp_protos_destroy(&device->protos);
     571                        arp_protos_destroy(&device->protos, free);
    572572                        free(device);
    573573                        return EREFUSED;
    … …  
    579579                if (rc != EOK) {
    580580                        fibril_mutex_unlock(&arp_globals.lock);
    581                         arp_protos_destroy(&device->protos);
     581                        arp_protos_destroy(&device->protos, free);
    582582                        free(device);
    583583                        return rc;
    … …  
    589589                if (rc != EOK) {
    590590                        fibril_mutex_unlock(&arp_globals.lock);
    591                         arp_protos_destroy(&device->protos);
     591                        arp_protos_destroy(&device->protos, free);
    592592                        free(device);
    593593                        return rc;
    … …  
    601601                        free(device->addr);
    602602                        free(device->addr_data);
    603                         arp_protos_destroy(&device->protos);
     603                        arp_protos_destroy(&device->protos, free);
    604604                        free(device);
    605605                        return rc;
    … …  
    614614                        free(device->broadcast_addr);
    615615                        free(device->broadcast_data);
    616                         arp_protos_destroy(&device->protos);
     616                        arp_protos_destroy(&device->protos, free);
    617617                        free(device);
    618618                        return rc;
    … …  
    746746                        arp_clear_trans(trans);
    747747                        arp_addr_exclude(&proto->addresses, target->value,
    748                             target->length);
     748                            target->length, free);
    749749                        return EAGAIN;
    750750                }
    … …  
    794794            trans);
    795795        if (rc != EOK) {
    796                 /* The generic char map has already freed trans! */
     796                free(trans);
    797797                return rc;
    798798        }
    … …  
    807807                arp_clear_trans(trans);
    808808                arp_addr_exclude(&proto->addresses, target->value,
    809                     target->length);
     809                    target->length, free);
    810810                return ENOENT;
    811811        }

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

    r51e5608 r27bdfa5  
    505505        if (rc != EOK) {
    506506                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    507                 ip_routes_destroy(&ip_netif->routes);
     507                ip_routes_destroy(&ip_netif->routes, free);
    508508                free(ip_netif);
    509509                return rc;

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

    r51e5608 r27bdfa5  
    555555                rc = read_netif_configuration(conf_files[i], netif);
    556556                if (rc != EOK) {
    557                         measured_strings_destroy(&netif->configuration);
     557                        measured_strings_destroy(&netif->configuration, free);
    558558                        free(netif);
    559559                        return rc;
    … …  
    565565                if (!setting) {
    566566                        fprintf(stderr, "%s: Network interface name is missing\n", NAME);
    567                         measured_strings_destroy(&netif->configuration);
     567                        measured_strings_destroy(&netif->configuration, free);
    568568                        free(netif);
    569569                        return EINVAL;
    … …  
    574574                int index = netifs_add(&net_globals.netifs, netif->id, netif);
    575575                if (index < 0) {
    576                         measured_strings_destroy(&netif->configuration);
     576                        measured_strings_destroy(&netif->configuration, free);
    577577                        free(netif);
    578578                        return index;
    … …  
    586586                    index);
    587587                if (rc != EOK) {
    588                         measured_strings_destroy(&netif->configuration);
    589                         netifs_exclude_index(&net_globals.netifs, index);
     588                        measured_strings_destroy(&netif->configuration, free);
     589                        netifs_exclude_index(&net_globals.netifs, index, free);
    590590                        return rc;
    591591                }
    … …  
    595595                        printf("%s: Ignoring failed interface %s (%s)\n", NAME,
    596596                            netif->name, str_error(rc));
    597                         measured_strings_destroy(&netif->configuration);
    598                         netifs_exclude_index(&net_globals.netifs, index);
     597                        measured_strings_destroy(&netif->configuration, free);
     598                        netifs_exclude_index(&net_globals.netifs, index, free);
    599599                        continue;
    600600                }

  • uspace/srv/net/nil/eth/eth.c

    r51e5608 r27bdfa5  
    214214        if (rc != EOK) {
    215215                free(eth_globals.broadcast_addr);
    216                 eth_devices_destroy(&eth_globals.devices);
     216                eth_devices_destroy(&eth_globals.devices, free);
    217217        }
    218218out:

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

    r51e5608 r27bdfa5  
    17071707                if (socket->port > 0) {
    17081708                        socket_ports_exclude(&tcp_globals.sockets,
    1709                             socket->port);
     1709                            socket->port, free);
    17101710                        socket->port = 0;
    17111711                }
    … …  
    24922492        rc = packet_dimensions_initialize(&tcp_globals.dimensions);
    24932493        if (rc != EOK) {
    2494                 socket_ports_destroy(&tcp_globals.sockets);
     2494                socket_ports_destroy(&tcp_globals.sockets, free);
    24952495                goto out;
    24962496        }

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

    r51e5608 r27bdfa5  
    417417        rc = packet_dimensions_initialize(&udp_globals.dimensions);
    418418        if (rc != EOK) {
    419                 socket_ports_destroy(&udp_globals.sockets);
     419                socket_ports_destroy(&udp_globals.sockets, free);
    420420                fibril_rwlock_write_unlock(&udp_globals.lock);
    421421                return rc;
    … …  
    434434            &data);
    435435        if (rc != EOK) {
    436                 socket_ports_destroy(&udp_globals.sockets);
     436                socket_ports_destroy(&udp_globals.sockets, free);
    437437                fibril_rwlock_write_unlock(&udp_globals.lock);
    438438                return rc;
Note: See TracChangeset for help on using the changeset viewer.