Changeset 8436590 in mainline for uspace/srv


Ignore:
Timestamp:
2011-04-07T21:38:17Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
033cbf82
Parents:
3acb285a (diff), ccca251 (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:
25 edited

Legend:

Unmodified
Added
Removed

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

    r3acb285a r8436590  
    372372        uint16_t w;
    373373        uint8_t c;
     374        uint16_t bc;
    374375        size_t pos, len;
    375376        int rc;
    … …  
    387388        } else if (rc == EIO) {
    388389                /*
    389                  * There is something, but not a register device.
    390                  * It could be a packet device.
     390                 * There is something, but not a register device. Check to see
     391                 * whether the IDENTIFY command left the packet signature in
     392                 * the registers in case this is a packet device.
     393                 *
     394                 * According to the ATA specification, the LBA low and
     395                 * interrupt reason registers should be set to 0x01. However,
     396                 * there are many devices that do not follow this and only set
     397                 * the byte count registers. So, only check these.
    391398                 */
    392                 rc = identify_pkt_dev(disk_id, &idata);
    393                 if (rc == EOK) {
    394                         /* We have a packet device. */
    395                         d->dev_type = ata_pkt_dev;
     399                bc = ((uint16_t)pio_read_8(&cmd->cylinder_high) << 8) |
     400                    pio_read_8(&cmd->cylinder_low);
     401
     402                if (bc == PDEV_SIGNATURE_BC) {
     403                        rc = identify_pkt_dev(disk_id, &idata);
     404                        if (rc == EOK) {
     405                                /* We have a packet device. */
     406                                d->dev_type = ata_pkt_dev;
     407                        } else {
     408                                return EIO;
     409                        }
    396410                } else {
    397411                        /* Nope. Something's there, but not recognized. */
    … …  
    403417        }
    404418
    405         printf("device caps: 0x%04x\n", idata.caps);
    406419        if (d->dev_type == ata_pkt_dev) {
    407420                /* Packet device */
    … …  
    566579
    567580        /*
    568          * This is where we would most likely expect a non-existing device to
    569          * show up by not setting SR_DRDY.
     581         * Do not wait for DRDY to be set in case this is a packet device.
     582         * We determine whether the device is present by waiting for DRQ to be
     583         * set after issuing the command.
    570584         */
    571         if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
     585        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    572586                return ETIMEOUT;
    573587
    … …  
    577591                return ETIMEOUT;
    578592
     593        /*
     594         * If ERR is set, this may be a packet device, so return EIO to cause
     595         * the caller to check for one.
     596         */
     597        if ((status & SR_ERR) != 0) {
     598                return EIO;
     599        }
     600
     601        if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_PROBE) != EOK)
     602                return ETIMEOUT;
     603
    579604        /* Read data from the disk buffer. */
    580605
    581         if ((status & SR_DRQ) != 0) {
    582                 for (i = 0; i < identify_data_size / 2; i++) {
    583                         data = pio_read_16(&cmd->data_port);
    584                         ((uint16_t *) buf)[i] = data;
    585                 }
    586         }
    587 
    588         if ((status & SR_ERR) != 0) {
    589                 return EIO;
     606        for (i = 0; i < identify_data_size / 2; i++) {
     607                data = pio_read_16(&cmd->data_port);
     608                ((uint16_t *) buf)[i] = data;
    590609        }
    591610

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

    r3acb285a r8436590  
    293293};
    294294
     295enum ata_pdev_signature {
     296        /**
     297         * Signature put by a packet device in byte count register
     298         * in response to Identify command.
     299         */
     300        PDEV_SIGNATURE_BC       = 0xEB14
     301};
     302
    295303#endif
    296304

  • uspace/srv/devman/devman.c

    r3acb285a r8436590  
    148148
    149149        log_msg(LVL_NOTE, "Driver `%s' was added to the list of available "
    150             "drivers.\n", drv->name);
     150            "drivers.", drv->name);
    151151}
    152152
    … …  
    238238bool read_match_ids(const char *conf_path, match_id_list_t *ids)
    239239{
    240         log_msg(LVL_DEBUG, "read_match_ids(conf_path=\"%s\")\n", conf_path);
     240        log_msg(LVL_DEBUG, "read_match_ids(conf_path=\"%s\")", conf_path);
    241241       
    242242        bool suc = false;
    … …  
    248248        fd = open(conf_path, O_RDONLY);
    249249        if (fd < 0) {
    250                 log_msg(LVL_ERROR, "Unable to open `%s' for reading: %s.\n",
     250                log_msg(LVL_ERROR, "Unable to open `%s' for reading: %s.",
    251251                    conf_path, str_error(fd));
    252252                goto cleanup;
    … …  
    257257        lseek(fd, 0, SEEK_SET);
    258258        if (len == 0) {
    259                 log_msg(LVL_ERROR, "Configuration file '%s' is empty.\n",
     259                log_msg(LVL_ERROR, "Configuration file '%s' is empty.",
    260260                    conf_path);
    261261                goto cleanup;
    … …  
    265265        if (buf == NULL) {
    266266                log_msg(LVL_ERROR, "Memory allocation failed when parsing file "
    267                     "'%s'.\n", conf_path);
     267                    "'%s'.", conf_path);
    268268                goto cleanup;
    269269        }
    … …  
    271271        ssize_t read_bytes = safe_read(fd, buf, len);
    272272        if (read_bytes <= 0) {
    273                 log_msg(LVL_ERROR, "Unable to read file '%s'.\n", conf_path);
     273                log_msg(LVL_ERROR, "Unable to read file '%s'.", conf_path);
    274274                goto cleanup;
    275275        }
    … …  
    309309bool get_driver_info(const char *base_path, const char *name, driver_t *drv)
    310310{
    311         log_msg(LVL_DEBUG, "get_driver_info(base_path=\"%s\", name=\"%s\")\n",
     311        log_msg(LVL_DEBUG, "get_driver_info(base_path=\"%s\", name=\"%s\")",
    312312            base_path, name);
    313313       
    … …  
    369369int lookup_available_drivers(driver_list_t *drivers_list, const char *dir_path)
    370370{
    371         log_msg(LVL_DEBUG, "lookup_available_drivers(dir=\"%s\")\n", dir_path);
     371        log_msg(LVL_DEBUG, "lookup_available_drivers(dir=\"%s\")", dir_path);
    372372       
    373373        int drv_cnt = 0;
    … …  
    403403        dev_node_t *dev;
    404404       
    405         log_msg(LVL_DEBUG, "create_root_nodes()\n");
     405        log_msg(LVL_DEBUG, "create_root_nodes()");
    406406       
    407407        fibril_rwlock_write_lock(&tree->rwlock);
    … …  
    488488void attach_driver(dev_node_t *dev, driver_t *drv)
    489489{
    490         log_msg(LVL_DEBUG, "attach_driver(dev=\"%s\",drv=\"%s\")\n",
     490        log_msg(LVL_DEBUG, "attach_driver(dev=\"%s\",drv=\"%s\")",
    491491            dev->pfun->pathname, drv->name);
    492492       
    … …  
    511511        assert(fibril_mutex_is_locked(&drv->driver_mutex));
    512512       
    513         log_msg(LVL_DEBUG, "start_driver(drv=\"%s\")\n", drv->name);
     513        log_msg(LVL_DEBUG, "start_driver(drv=\"%s\")", drv->name);
    514514       
    515515        rc = task_spawnl(NULL, drv->binary_path, drv->binary_path, NULL);
    516516        if (rc != EOK) {
    517                 log_msg(LVL_ERROR, "Spawning driver `%s' (%s) failed: %s.\n",
     517                log_msg(LVL_ERROR, "Spawning driver `%s' (%s) failed: %s.",
    518518                    drv->name, drv->binary_path, str_error(rc));
    519519                return false;
    … …  
    578578        int phone;
    579579
    580         log_msg(LVL_DEBUG, "pass_devices_to_driver(driver=\"%s\")\n",
     580        log_msg(LVL_DEBUG, "pass_devices_to_driver(driver=\"%s\")",
    581581            driver->name);
    582582
    … …  
    646646         * immediately and possibly started here as well.
    647647         */
    648         log_msg(LVL_DEBUG, "Driver `%s' enters running state.\n", driver->name);
     648        log_msg(LVL_DEBUG, "Driver `%s' enters running state.", driver->name);
    649649        driver->state = DRIVER_RUNNING;
    650650
    … …  
    663663void initialize_running_driver(driver_t *driver, dev_tree_t *tree)
    664664{
    665         log_msg(LVL_DEBUG, "initialize_running_driver(driver=\"%s\")\n",
     665        log_msg(LVL_DEBUG, "initialize_running_driver(driver=\"%s\")",
    666666            driver->name);
    667667       
    … …  
    754754         * access any structures that would affect driver_t.
    755755         */
    756         log_msg(LVL_DEBUG, "add_device(drv=\"%s\", dev=\"%s\")\n",
     756        log_msg(LVL_DEBUG, "add_device(drv=\"%s\", dev=\"%s\")",
    757757            drv->name, dev->pfun->name);
    758758       
    … …  
    816816        driver_t *drv = find_best_match_driver(drivers_list, dev);
    817817        if (drv == NULL) {
    818                 log_msg(LVL_ERROR, "No driver found for device `%s'.\n",
     818                log_msg(LVL_ERROR, "No driver found for device `%s'.",
    819819                    dev->pfun->pathname);
    820820                return false;
    … …  
    854854bool init_device_tree(dev_tree_t *tree, driver_list_t *drivers_list)
    855855{
    856         log_msg(LVL_DEBUG, "init_device_tree()\n");
     856        log_msg(LVL_DEBUG, "init_device_tree()");
    857857       
    858858        tree->current_handle = 0;
    … …  
    10331033        fun->pathname = (char *) malloc(pathsize);
    10341034        if (fun->pathname == NULL) {
    1035                 log_msg(LVL_ERROR, "Failed to allocate device path.\n");
     1035                log_msg(LVL_ERROR, "Failed to allocate device path.");
    10361036                return false;
    10371037        }
    … …  
    10641064        assert(fibril_rwlock_is_write_locked(&tree->rwlock));
    10651065       
    1066         log_msg(LVL_DEBUG, "insert_dev_node(dev=%p, pfun=%p [\"%s\"])\n",
     1066        log_msg(LVL_DEBUG, "insert_dev_node(dev=%p, pfun=%p [\"%s\"])",
    10671067            dev, pfun, pfun->pathname);
    10681068
    … …  
    11731173}
    11741174
     1175/** Find function with a specified name belonging to given device.
     1176 *
     1177 * Device tree rwlock should be held at least for reading.
     1178 *
     1179 * @param dev Device the function belongs to.
     1180 * @param name Function name (not path).
     1181 * @return Function node.
     1182 * @retval NULL No function with given name.
     1183 */
     1184fun_node_t *find_fun_node_in_device(dev_node_t *dev, const char *name)
     1185{
     1186        assert(dev != NULL);
     1187        assert(name != NULL);
     1188
     1189        fun_node_t *fun;
     1190        link_t *link;
     1191
     1192        for (link = dev->functions.next;
     1193            link != &dev->functions;
     1194            link = link->next) {
     1195                fun = list_get_instance(link, fun_node_t, dev_functions);
     1196
     1197                if (str_cmp(name, fun->name) == 0)
     1198                        return fun;
     1199        }
     1200
     1201        return NULL;
     1202}
     1203
     1204/** Find function node by its class name and index. */
     1205fun_node_t *find_fun_node_by_class(class_list_t *class_list,
     1206    const char *class_name, const char *dev_name)
     1207{
     1208        assert(class_list != NULL);
     1209        assert(class_name != NULL);
     1210        assert(dev_name != NULL);
     1211
     1212        fibril_rwlock_read_lock(&class_list->rwlock);
     1213
     1214        dev_class_t *cl = find_dev_class_no_lock(class_list, class_name);
     1215        if (cl == NULL) {
     1216                fibril_rwlock_read_unlock(&class_list->rwlock);
     1217                return NULL;
     1218        }
     1219
     1220        dev_class_info_t *dev = find_dev_in_class(cl, dev_name);
     1221        if (dev == NULL) {
     1222                fibril_rwlock_read_unlock(&class_list->rwlock);
     1223                return NULL;
     1224        }
     1225
     1226        fun_node_t *fun = dev->fun;
     1227
     1228        fibril_rwlock_read_unlock(&class_list->rwlock);
     1229
     1230        return fun;
     1231}
     1232
     1233
    11751234/** Find child function node with a specified name.
    11761235 *
    … …  
    11831242fun_node_t *find_node_child(fun_node_t *pfun, const char *name)
    11841243{
    1185         fun_node_t *fun;
    1186         link_t *link;
    1187        
    1188         link = pfun->child->functions.next;
    1189        
    1190         while (link != &pfun->child->functions) {
    1191                 fun = list_get_instance(link, fun_node_t, dev_functions);
    1192                
    1193                 if (str_cmp(name, fun->name) == 0)
    1194                         return fun;
    1195                
    1196                 link = link->next;
    1197         }
    1198        
    1199         return NULL;
     1244        return find_fun_node_in_device(pfun->child, name);
    12001245}
    12011246
    … …  
    13591404}
    13601405
     1406dev_class_info_t *find_dev_in_class(dev_class_t *dev_class, const char *dev_name)
     1407{
     1408        assert(dev_class != NULL);
     1409        assert(dev_name != NULL);
     1410
     1411        link_t *link;
     1412        for (link = dev_class->devices.next;
     1413            link != &dev_class->devices;
     1414            link = link->next) {
     1415                dev_class_info_t *dev = list_get_instance(link,
     1416                    dev_class_info_t, link);
     1417
     1418                if (str_cmp(dev->dev_name, dev_name) == 0) {
     1419                        return dev;
     1420                }
     1421        }
     1422
     1423        return NULL;
     1424}
     1425
    13611426void init_class_list(class_list_t *class_list)
    13621427{

  • uspace/srv/devman/devman.h

    r3acb285a r8436590  
    338338extern fun_node_t *find_fun_node(dev_tree_t *tree, devman_handle_t handle);
    339339extern fun_node_t *find_fun_node_by_path(dev_tree_t *, char *);
     340extern fun_node_t *find_fun_node_in_device(dev_node_t *, const char *);
     341extern fun_node_t *find_fun_node_by_class(class_list_t *, const char *, const char *);
    340342
    341343/* Device tree */
    … …  
    359361extern dev_class_t *get_dev_class(class_list_t *, char *);
    360362extern dev_class_t *find_dev_class_no_lock(class_list_t *, const char *);
     363extern dev_class_info_t *find_dev_in_class(dev_class_t *, const char *);
    361364extern void add_dev_class_no_lock(class_list_t *, dev_class_t *);
    362365

  • uspace/srv/devman/main.c

    r3acb285a r8436590  
    7373        driver_t *driver = NULL;
    7474
    75         log_msg(LVL_DEBUG, "devman_driver_register\n");
     75        log_msg(LVL_DEBUG, "devman_driver_register");
    7676       
    7777        iid = async_get_call(&icall);
    … …  
    9090        }
    9191
    92         log_msg(LVL_DEBUG, "The `%s' driver is trying to register.\n",
     92        log_msg(LVL_DEBUG, "The `%s' driver is trying to register.",
    9393            drv_name);
    9494       
    … …  
    9797       
    9898        if (driver == NULL) {
    99                 log_msg(LVL_ERROR, "No driver named `%s' was found.\n", drv_name);
     99                log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name);
    100100                free(drv_name);
    101101                drv_name = NULL;
    … …  
    108108       
    109109        /* Create connection to the driver. */
    110         log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.\n",
     110        log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.",
    111111            driver->name);
    112112        ipc_call_t call;
    … …  
    122122       
    123123        log_msg(LVL_NOTE,
    124             "The `%s' driver was successfully registered as running.\n",
     124            "The `%s' driver was successfully registered as running.",
    125125            driver->name);
    126126       
    … …  
    147147        if (DEVMAN_ADD_MATCH_ID != IPC_GET_IMETHOD(call)) {
    148148                log_msg(LVL_ERROR,
    149                     "Invalid protocol when trying to receive match id.\n");
     149                    "Invalid protocol when trying to receive match id.");
    150150                async_answer_0(callid, EINVAL);
    151151                delete_match_id(match_id);
    … …  
    154154       
    155155        if (match_id == NULL) {
    156                 log_msg(LVL_ERROR, "Failed to allocate match id.\n");
     156                log_msg(LVL_ERROR, "Failed to allocate match id.");
    157157                async_answer_0(callid, ENOMEM);
    158158                return ENOMEM;
    … …  
    168168        if (rc != EOK) {
    169169                delete_match_id(match_id);
    170                 log_msg(LVL_ERROR, "Failed to receive match id string: %s.\n",
     170                log_msg(LVL_ERROR, "Failed to receive match id string: %s.",
    171171                    str_error(rc));
    172172                return rc;
    … …  
    175175        list_append(&match_id->link, &match_ids->ids);
    176176       
    177         log_msg(LVL_DEBUG, "Received match id `%s', score %d.\n",
     177        log_msg(LVL_DEBUG, "Received match id `%s', score %d.",
    178178            match_id->id, match_id->score);
    179179        return rc;
    … …  
    232232                /* Unknown function type */
    233233                log_msg(LVL_ERROR,
    234                     "Unknown function type %d provided by driver.\n",
     234                    "Unknown function type %d provided by driver.",
    235235                    (int) ftype);
    236236
    … …  
    248248        }
    249249       
     250        /* Check that function with same name is not there already. */
     251        if (find_fun_node_in_device(pdev, fun_name) != NULL) {
     252                fibril_rwlock_write_unlock(&tree->rwlock);
     253                async_answer_0(callid, EEXISTS);
     254                printf(NAME ": Warning, driver tried to register `%s' twice.\n",
     255                    fun_name);
     256                free(fun_name);
     257                return;
     258        }
     259
    250260        fun_node_t *fun = create_fun_node();
    251261        if (!insert_fun_node(&device_tree, fun, fun_name, pdev)) {
    … …  
    270280        fibril_rwlock_write_unlock(&tree->rwlock);
    271281       
    272         log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")\n", fun->pathname);
     282        log_msg(LVL_DEBUG, "devman_add_function(fun=\"%s\")", fun->pathname);
    273283       
    274284        devman_receive_match_ids(match_count, &fun->match_ids);
    … …  
    352362        devmap_register_class_dev(class_info);
    353363       
    354         log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.\n",
     364        log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.",
    355365            fun->pathname, class_name, class_info->dev_name);
    356366
    … …  
    368378       
    369379        initialize_running_driver(driver, &device_tree);
    370         log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.\n",
     380        log_msg(LVL_DEBUG, "The `%s` driver was successfully initialized.",
    371381            driver->name);
    372382        return 0;
    … …  
    391401        if (fid == 0) {
    392402                log_msg(LVL_ERROR, "Failed to create initialization fibril " \
    393                     "for driver `%s' .\n", driver->name);
     403                    "for driver `%s'.", driver->name);
    394404                return;
    395405        }
    … …  
    443453}
    444454
     455/** Find handle for the device instance identified by device class name. */
     456static void devman_function_get_handle_by_class(ipc_callid_t iid,
     457    ipc_call_t *icall)
     458{
     459        char *classname;
     460        char *devname;
     461
     462        int rc = async_data_write_accept((void **) &classname, true, 0, 0, 0, 0);
     463        if (rc != EOK) {
     464                async_answer_0(iid, rc);
     465                return;
     466        }
     467        rc = async_data_write_accept((void **) &devname, true, 0, 0, 0, 0);
     468        if (rc != EOK) {
     469                free(classname);
     470                async_answer_0(iid, rc);
     471                return;
     472        }
     473
     474
     475        fun_node_t *fun = find_fun_node_by_class(&class_list,
     476            classname, devname);
     477
     478        free(classname);
     479        free(devname);
     480
     481        if (fun == NULL) {
     482                async_answer_0(iid, ENOENT);
     483                return;
     484        }
     485
     486        async_answer_1(iid, EOK, fun->handle);
     487}
     488
    445489
    446490/** Function for handling connections from a client to the device manager. */
    … …  
    462506                        devman_function_get_handle(callid, &call);
    463507                        break;
     508                case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS:
     509                        devman_function_get_handle_by_class(callid, &call);
     510                        break;
    464511                default:
    465512                        async_answer_0(callid, ENOENT);
    … …  
    490537        if (dev == NULL) {
    491538                log_msg(LVL_ERROR, "IPC forwarding failed - no device or "
    492                     "function with handle %" PRIun " was found.\n", handle);
     539                    "function with handle %" PRIun " was found.", handle);
    493540                async_answer_0(iid, ENOENT);
    494541                return;
    … …  
    497544        if (fun == NULL && !drv_to_parent) {
    498545                log_msg(LVL_ERROR, NAME ": devman_forward error - cannot "
    499                     "connect to handle %" PRIun ", refers to a device.\n",
     546                    "connect to handle %" PRIun ", refers to a device.",
    500547                    handle);
    501548                async_answer_0(iid, ENOENT);
    … …  
    520567        if (driver == NULL) {
    521568                log_msg(LVL_ERROR, "IPC forwarding refused - " \
    522                     "the device %" PRIun " is not in usable state.\n", handle);
     569                    "the device %" PRIun " is not in usable state.", handle);
    523570                async_answer_0(iid, ENOENT);
    524571                return;
    … …  
    533580        if (driver->phone <= 0) {
    534581                log_msg(LVL_ERROR,
    535                     "Could not forward to driver `%s' (phone is %d).\n",
     582                    "Could not forward to driver `%s' (phone is %d).",
    536583                    driver->name, (int) driver->phone);
    537584                async_answer_0(iid, EINVAL);
    … …  
    541588        if (fun != NULL) {
    542589                log_msg(LVL_DEBUG,
    543                     "Forwarding request for `%s' function to driver `%s'.\n",
     590                    "Forwarding request for `%s' function to driver `%s'.",
    544591                    fun->pathname, driver->name);
    545592        } else {
    546593                log_msg(LVL_DEBUG,
    547                     "Forwarding request for `%s' device to driver `%s'.\n",
     594                    "Forwarding request for `%s' device to driver `%s'.",
    548595                    dev->pfun->pathname, driver->name);
    549596        }
    … …  
    579626            IPC_FF_NONE);
    580627        log_msg(LVL_DEBUG,
    581             "Forwarding devmapper request for `%s' function to driver `%s'.\n",
     628            "Forwarding devmapper request for `%s' function to driver `%s'.",
    582629            fun->pathname, dev->drv->name);
    583630}
    … …  
    615662static bool devman_init(void)
    616663{
    617         log_msg(LVL_DEBUG, "devman_init - looking for available drivers.\n");
     664        log_msg(LVL_DEBUG, "devman_init - looking for available drivers.");
    618665       
    619666        /* Initialize list of available drivers. */
    … …  
    621668        if (lookup_available_drivers(&drivers_list,
    622669            DRIVER_DEFAULT_STORE) == 0) {
    623                 log_msg(LVL_FATAL, "no drivers found.");
     670                log_msg(LVL_FATAL, "No drivers found.");
    624671                return false;
    625672        }
    626673
    627         log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized.\n");
     674        log_msg(LVL_DEBUG, "devman_init - list of drivers has been initialized.");
    628675
    629676        /* Create root device node. */
    … …  
    656703
    657704        if (!devman_init()) {
    658                 log_msg(LVL_ERROR, "Error while initializing service.\n");
     705                log_msg(LVL_ERROR, "Error while initializing service.");
    659706                return -1;
    660707        }
    … …  
    665712        /* Register device manager at naming service. */
    666713        if (service_register(SERVICE_DEVMAN) != EOK) {
    667                 log_msg(LVL_ERROR, "Failed registering as a service.\n");
     714                log_msg(LVL_ERROR, "Failed registering as a service.");
    668715                return -1;
    669716        }

  • uspace/srv/devmap/devmap.c

    r3acb285a r8436590  
    551551        if (devmap_device_find_name(namespace->name, device->name) != NULL) {
    552552                printf("%s: Device '%s/%s' already registered\n", NAME,
    553                     device->namespace->name, device->name);
     553                    namespace->name, device->name);
    554554                devmap_namespace_destroy(namespace);
    555555                fibril_mutex_unlock(&devices_list_mutex);

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

    r3acb285a r8436590  
    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

    r3acb285a r8436590  
    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

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

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

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

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

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

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

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

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

    r3acb285a r8436590  
    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

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

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

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

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

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

  • uspace/srv/loader/main.c

    r3acb285a r8436590  
    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

    r3acb285a r8436590  
    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

    r3acb285a r8436590  
    176176        socklen_t addrlen;
    177177
    178         // detach the first packet and release the others
     178        /* Detach the first packet and release the others */
    179179        next = pq_detach(packet);
    180180        if (next)
    … …  
    185185                        return ENOMEM;
    186186
    187                 // get header
     187                /* Get header */
    188188                header = (ip_header_t *) packet_get_data(packet);
    189189                if (!header)
    … …  
    192192        }
    193193
    194         // only for the first fragment
     194        /* Only for the first fragment */
    195195        if (IP_FRAGMENT_OFFSET(header))
    196196                return EINVAL;
    197197
    198         // not for the ICMP protocol
     198        /* Not for the ICMP protocol */
    199199        if (header->protocol == IPPROTO_ICMP)
    200200                return EPERM;
    201201
    202         // set the destination address
     202        /* Set the destination address */
    203203        switch (header->version) {
    204204        case IPVERSION:
    … …  
    351351        configuration = &names[0];
    352352
    353         // get configuration
     353        /* Get configuration */
    354354        rc = net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id,
    355355            &configuration, count, &data);
    … …  
    419419        }
    420420
    421         // binds the netif service which also initializes the device
     421        /* Bind netif service which also initializes the device */
    422422        ip_netif->phone = nil_bind_service(ip_netif->service,
    423423            (sysarg_t) ip_netif->device_id, SERVICE_IP,
    … …  
    429429        }
    430430
    431         // has to be after the device netif module initialization
     431        /* Has to be after the device netif module initialization */
    432432        if (ip_netif->arp) {
    433433                if (route) {
    … …  
    445445        }
    446446
    447         // get packet dimensions
     447        /* Get packet dimensions */
    448448        rc = nil_packet_size_req(ip_netif->phone, ip_netif->device_id,
    449449            &ip_netif->packet_dimension);
    … …  
    463463       
    464464        if (gateway.s_addr) {
    465                 // the default gateway
     465                /* The default gateway */
    466466                ip_globals.gateway.address.s_addr = 0;
    467467                ip_globals.gateway.netmask.s_addr = 0;
    … …  
    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;
    … …  
    512512                ip_netif->arp->usage++;
    513513
    514         // print the settings
     514        /* Print the settings */
    515515        printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n",
    516516            NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv,
    … …  
    587587        ip_netif_t *netif;
    588588
    589         // start with the last netif - the newest one
     589        /* Start with the last netif - the newest one */
    590590        index = ip_netifs_count(&ip_globals.netifs) - 1;
    591591        while (index >= 0) {
    … …  
    629629        size_t length;
    630630
    631         // copy first itself
     631        /* Copy first itself */
    632632        memcpy(last, first, sizeof(ip_header_t));
    633633        length = sizeof(ip_header_t);
    634634        next = sizeof(ip_header_t);
    635635
    636         // process all ip options
     636        /* Process all IP options */
    637637        while (next < first->header_length) {
    638638                option = (ip_option_t *) (((uint8_t *) first) + next);
    639                 // skip end or noop
     639                /* Skip end or noop */
    640640                if ((option->type == IPOPT_END) ||
    641641                    (option->type == IPOPT_NOOP)) {
    642642                        next++;
    643643                } else {
    644                         // copy if told so or skip
     644                        /* Copy if told so or skip */
    645645                        if (IPOPT_COPIED(option->type)) {
    646646                                memcpy(((uint8_t *) last) + length,
    … …  
    648648                                length += option->length;
    649649                        }
    650                         // next option
     650                        /* Next option */
    651651                        next += option->length;
    652652                }
    653653        }
    654654
    655         // align 4 byte boundary
     655        /* Align 4 byte boundary */
    656656        if (length % 4) {
    657657                bzero(((uint8_t *) last) + length, 4 - (length % 4));
    … …  
    789789
    790790        header->total_length = htons(length);
    791         // unnecessary for all protocols
     791        /* Unnecessary for all protocols */
    792792        header->header_checksum = IP_HEADER_CHECKSUM(header);
    793793
    … …  
    916916                return ENOMEM;
    917917
    918         // get header
     918        /* Get header */
    919919        header = (ip_header_t *) packet_get_data(packet);
    920920        if (!header)
    921921                return EINVAL;
    922922
    923         // fragmentation forbidden?
     923        /* Fragmentation forbidden? */
    924924        if(header->flags & IPFLAG_DONT_FRAGMENT)
    925925                return EPERM;
    926926
    927         // create the last fragment
     927        /* Create the last fragment */
    928928        new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length,
    929929            suffix, ((addrlen > addr_len) ? addrlen : addr_len));
    … …  
    931931                return ENOMEM;
    932932
    933         // allocate as much as originally
     933        /* Allocate as much as originally */
    934934        last_header = (ip_header_t *) packet_suffix(new_packet,
    935935            IP_HEADER_LENGTH(header));
    … …  
    939939        ip_create_last_header(last_header, header);
    940940
    941         // trim the unused space
     941        /* Trim the unused space */
    942942        rc = packet_trim(new_packet, 0,
    943943            IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header));
    … …  
    945945                return ip_release_and_return(packet, rc);
    946946
    947         // biggest multiple of 8 lower than content
     947        /* Greatest multiple of 8 lower than content */
    948948        // TODO even fragmentation?
    949949        length = length & ~0x7;
    … …  
    957957                return ip_release_and_return(packet, rc);
    958958
    959         // mark the first as fragmented
     959        /* Mark the first as fragmented */
    960960        header->flags |= IPFLAG_MORE_FRAGMENTS;
    961961
    962         // create middle framgents
     962        /* Create middle fragments */
    963963        while (IP_TOTAL_LENGTH(header) > length) {
    964964                new_packet = packet_get_4_remote(ip_globals.net_phone, prefix,
    … …  
    981981        }
    982982
    983         // finish the first fragment
     983        /* Finish the first fragment */
    984984        header->header_checksum = IP_HEADER_CHECKSUM(header);
    985985
    … …  
    10121012
    10131013        next = packet;
    1014         // check all packets
     1014        /* Check all packets */
    10151015        while (next) {
    10161016                length = packet_get_data_length(next);
    … …  
    10211021                }
    10221022
    1023                 // too long
     1023                /* Too long */
    10241024                result = ip_fragment_packet(next, content, prefix,
    10251025                    suffix, addr_len);
    … …  
    10271027                        new_packet = pq_detach(next);
    10281028                        if (next == packet) {
    1029                                 // the new first packet of the queue
     1029                                /* The new first packet of the queue */
    10301030                                packet = new_packet;
    10311031                        }
    1032                         // fragmentation needed?
     1032                        /* Fragmentation needed? */
    10331033                        if (result == EPERM) {
    10341034                                phone = ip_prepare_icmp_and_get_phone(
    10351035                                    error, next, NULL);
    10361036                                if (phone >= 0) {
    1037                                         // fragmentation necessary ICMP
     1037                                        /* Fragmentation necessary ICMP */
    10381038                                        icmp_destination_unreachable_msg(phone,
    10391039                                            ICMP_FRAG_NEEDED, content, next);
    … …  
    10801080        int rc;
    10811081
    1082         // get destination hardware address
     1082        /* Get destination hardware address */
    10831083        if (netif->arp && (route->address.s_addr != dest.s_addr)) {
    10841084                destination.value = route->gateway.s_addr ?
    … …  
    11021102                            NULL);
    11031103                        if (phone >= 0) {
    1104                                 // unreachable ICMP if no routing
     1104                                /* Unreachable ICMP if no routing */
    11051105                                icmp_destination_unreachable_msg(phone,
    11061106                                    ICMP_HOST_UNREACH, 0, packet);
    … …  
    11481148        int rc;
    11491149
    1150         // addresses in the host byte order
    1151         // should be the next hop address or the target destination address
     1150        /*
     1151         * Addresses in the host byte order
     1152         * Should be the next hop address or the target destination address
     1153         */
    11521154        addrlen = packet_get_addr(packet, NULL, (uint8_t **) &addr);
    11531155        if (addrlen < 0)
    … …  
    11741176        fibril_rwlock_read_lock(&ip_globals.netifs_lock);
    11751177
    1176         // device specified?
     1178        /* Device specified? */
    11771179        if (device_id > 0) {
    11781180                netif = ip_netifs_find(&ip_globals.netifs, device_id);
    … …  
    11901192                phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
    11911193                if (phone >= 0) {
    1192                         // unreachable ICMP if no routing
     1194                        /* Unreachable ICMP if no routing */
    11931195                        icmp_destination_unreachable_msg(phone,
    11941196                            ICMP_NET_UNREACH, 0, packet);
    … …  
    11981200
    11991201        if (error) {
    1200                 // do not send for broadcast, anycast packets or network
    1201                 // broadcast
     1202                /*
     1203                 * Do not send for broadcast, anycast packets or network
     1204                 * broadcast.
     1205                 */
    12021206                if (!dest->s_addr || !(~dest->s_addr) ||
    12031207                    !(~((dest->s_addr & ~route->netmask.s_addr) |
    … …  
    12081212        }
    12091213       
    1210         // if the local host is the destination
     1214        /* If the local host is the destination */
    12111215        if ((route->address.s_addr == dest->s_addr) &&
    12121216            (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
    1213                 // find the loopback device to deliver
     1217                /* Find the loopback device to deliver */
    12141218                dest->s_addr = IPV4_LOCALHOST_ADDRESS;
    12151219                route = ip_find_route(*dest);
    … …  
    12201224                            NULL);
    12211225                        if (phone >= 0) {
    1222                                 // unreachable ICMP if no routing
     1226                                /* Unreachable ICMP if no routing */
    12231227                                icmp_destination_unreachable_msg(phone,
    12241228                                    ICMP_HOST_UNREACH, 0, packet);
    … …  
    12521256
    12531257        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
    1254         // find the device
     1258        /* Find the device */
    12551259        netif = ip_netifs_find(&ip_globals.netifs, device_id);
    12561260        if (!netif) {
    … …  
    13441348                return ip_release_and_return(packet, rc);
    13451349
    1346         // trim padding if present
     1350        /* Trim padding if present */
    13471351        if (!error &&
    13481352            (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
    … …  
    13601364                phone = ip_prepare_icmp_and_get_phone(error, packet, header);
    13611365                if (phone >= 0) {
    1362                         // unreachable ICMP
     1366                        /* Unreachable ICMP */
    13631367                        icmp_destination_unreachable_msg(phone,
    13641368                            ICMP_PROT_UNREACH, 0, packet);
    … …  
    14171421                return ip_release_and_return(packet, ENOMEM);
    14181422
    1419         // checksum
     1423        /* Checksum */
    14201424        if ((header->header_checksum) &&
    14211425            (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
    14221426                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14231427                if (phone >= 0) {
    1424                         // checksum error ICMP
     1428                        /* Checksum error ICMP */
    14251429                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
    14261430                            ((size_t) ((void *) &header->header_checksum)) -
    … …  
    14331437                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14341438                if (phone >= 0) {
    1435                         // ttl exceeded ICMP
     1439                        /* TTL exceeded ICMP */
    14361440                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
    14371441                }
    … …  
    14391443        }
    14401444       
    1441         // process ipopt and get destination
     1445        /* Process ipopt and get destination */
    14421446        dest = ip_get_destination(header);
    14431447
    1444         // set the addrination address
     1448        /* Set the destination address */
    14451449        switch (header->version) {
    14461450        case IPVERSION:
    … …  
    14641468                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14651469                if (phone >= 0) {
    1466                         // unreachable ICMP
     1470                        /* Unreachable ICMP */
    14671471                        icmp_destination_unreachable_msg(phone,
    14681472                            ICMP_HOST_UNREACH, 0, packet);
    … …  
    14721476
    14731477        if (route->address.s_addr == dest.s_addr) {
    1474                 // local delivery
     1478                /* Local delivery */
    14751479                return ip_deliver_local(device_id, packet, header, 0);
    14761480        }
    … …  
    14841488        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
    14851489        if (phone >= 0) {
    1486                 // unreachable ICMP if no routing
     1490                /* Unreachable ICMP if no routing */
    14871491                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
    14881492                    packet);
    … …  
    17701774                header = (ip_header_t *)(data + offset);
    17711775
    1772                 // destination host unreachable?
     1776                /* Destination host unreachable? */
    17731777                if ((type != ICMP_DEST_UNREACH) ||
    17741778                    (code != ICMP_HOST_UNREACH)) {
    1775                         // no, something else
     1779                        /* No, something else */
    17761780                        break;
    17771781                }
    … …  
    17871791                route = ip_routes_get_index(&netif->routes, 0);
    17881792
    1789                 // from the same network?
     1793                /* From the same network? */
    17901794                if (route && ((route->address.s_addr & route->netmask.s_addr) ==
    17911795                    (header->destination_address & route->netmask.s_addr))) {
    1792                         // clear the ARP mapping if any
     1796                        /* Clear the ARP mapping if any */
    17931797                        address.value = (uint8_t *) &header->destination_address;
    17941798                        address.length = sizeof(header->destination_address);
    … …  
    18441848        fibril_rwlock_read_lock(&ip_globals.lock);
    18451849        route = ip_find_route(*dest);
    1846         // if the local host is the destination
     1850        /* If the local host is the destination */
    18471851        if (route && (route->address.s_addr == dest->s_addr) &&
    18481852            (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
    1849                 // find the loopback device to deliver
     1853                /* Find the loopback device to deliver */
    18501854                dest->s_addr = IPV4_LOCALHOST_ADDRESS;
    18511855                route = ip_find_route(*dest);

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

    r3acb285a r8436590  
    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

    r3acb285a r8436590  
    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:
    … …  
    531531                            proto->service);
    532532                } else {
    533                         // drop invalid/unknown
     533                        /* Drop invalid/unknown */
    534534                        pq_release_remote(eth_globals.net_phone,
    535535                            packet_get_id(packet));

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

    r3acb285a r8436590  
    299299                return tcp_release_and_return(packet, NO_DATA);
    300300
    301 //      printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
    302 //          ntohs(header->destination_port));
    303 
     301#if 0
     302        printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
     303            ntohs(header->destination_port));
     304#endif
    304305        result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
    305306        if (result <= 0)
    … …  
    10621063        tcp_process_acknowledgement(socket, socket_data, header);
    10631064
    1064         socket_data->next_incoming = ntohl(header->sequence_number);    // + 1;
     1065        socket_data->next_incoming = ntohl(header->sequence_number); /* + 1; */
    10651066        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    10661067        socket_data->state = TCP_SOCKET_ESTABLISHED;
    … …  
    17071708                if (socket->port > 0) {
    17081709                        socket_ports_exclude(&tcp_globals.sockets,
    1709                             socket->port);
     1710                            socket->port, free);
    17101711                        socket->port = 0;
    17111712                }
    … …  
    24922493        rc = packet_dimensions_initialize(&tcp_globals.dimensions);
    24932494        if (rc != EOK) {
    2494                 socket_ports_destroy(&tcp_globals.sockets);
     2495                socket_ports_destroy(&tcp_globals.sockets, free);
    24952496                goto out;
    24962497        }

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

    r3acb285a r8436590  
    190190        int backlog;
    191191       
    192 //      /** Segment size. */
    193 //      size_t segment_size;
    194 
    195192        /**
    196193         * Parent listening socket identifier.

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

    r3acb285a r8436590  
    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;
    … …  
    499499        device_id_t device_id;
    500500        packet_dimension_t *packet_dimension;
     501        size_t size;
    501502        int rc;
     503
     504        /* In case of error, do not update the data fragment size. */
     505        *data_fragment_size = 0;
    502506       
    503507        rc = tl_get_address_port(addr, addrlen, &dest_port);
    … …  
    539543                packet_dimension = &udp_globals.packet_dimension;
    540544//      }
     545
     546        /*
     547         * Update the data fragment size based on what the lower layers can
     548         * handle without fragmentation, but not more than the maximum allowed
     549         * for UDP.
     550         */
     551        size = MAX_UDP_FRAGMENT_SIZE;
     552        if (packet_dimension->content < size)
     553            size = packet_dimension->content;
     554        *data_fragment_size = size;
    541555
    542556        /* Read the first packet fragment */
    … …  
    740754        int socket_id;
    741755        size_t addrlen;
    742         size_t size = 0;
     756        size_t size;
    743757        ipc_call_t answer;
    744758        size_t answer_count;
    … …  
    786800                                break;
    787801                       
     802                        size = MAX_UDP_FRAGMENT_SIZE;
    788803                        if (tl_get_ip_packet_dimension(udp_globals.ip_phone,
    789804                            &udp_globals.dimensions, DEVICE_INVALID_ID,
    790805                            &packet_dimension) == EOK) {
    791                                 SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
    792                                     packet_dimension->content);
     806                                if (packet_dimension->content < size)
     807                                        size = packet_dimension->content;
    793808                        }
    794 
    795 //                      SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
    796 //                          MAX_UDP_FRAGMENT_SIZE);
     809                        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
    797810                        SOCKET_SET_HEADER_SIZE(answer, UDP_HEADER_SIZE);
    798811                        answer_count = 3;

  • uspace/srv/vfs/vfs_file.c

    r3acb285a r8436590  
    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);
Note: See TracChangeset for help on using the changeset viewer.