Changeset a0a134b in mainline for uspace/srv

Timestamp:

2011-04-13T18:27:21Z (14 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

4c70554

Parents:

d6522dd (diff), b77ce84 (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:

Development branch changes

Location:

uspace/srv

Files:

• bd/ata_bd/ata_bd.c (modified) (5 diffs)
• bd/ata_bd/ata_hw.h (modified) (1 diff)
• devman/devman.c (modified) (2 diffs)
• devman/devman.h (modified) (2 diffs)
• devman/main.c (modified) (6 diffs)
• fs/fat/fat_ops.c (modified) (2 diffs)
• net/il/ip/ip.c (modified) (42 diffs)
• net/nil/eth/eth.c (modified) (1 diff)
• net/tl/tcp/tcp.c (modified) (2 diffs)
• net/tl/tcp/tcp.h (modified) (1 diff)
• net/tl/udp/udp.c (modified) (4 diffs)
• vfs/vfs_file.c (modified) (1 diff)

uspace/srv/bd/ata_bd/ata_bd.c

@@ -372 +372 @@
         uint16_t w;
         uint8_t c;
+        uint16_t bc;
         size_t pos, len;
         int rc;
@@ -387 +388 @@
         } else if (rc == EIO) {
                 /*
-                 * There is something, but not a register device.
-                 * It could be a packet device.
+                 * There is something, but not a register device. Check to see
+                 * whether the IDENTIFY command left the packet signature in
+                 * the registers in case this is a packet device.
+                 *
+                 * According to the ATA specification, the LBA low and
+                 * interrupt reason registers should be set to 0x01. However,
+                 * there are many devices that do not follow this and only set
+                 * the byte count registers. So, only check these.
                  */
-                rc = identify_pkt_dev(disk_id, &idata);
-                if (rc == EOK) {
-                        /* We have a packet device. */
-                        d->dev_type = ata_pkt_dev;
+                bc = ((uint16_t)pio_read_8(&cmd->cylinder_high) << 8) |
+                    pio_read_8(&cmd->cylinder_low);
+
+                if (bc == PDEV_SIGNATURE_BC) {
+                        rc = identify_pkt_dev(disk_id, &idata);
+                        if (rc == EOK) {
+                                /* We have a packet device. */
+                                d->dev_type = ata_pkt_dev;
+                        } else {
+                                return EIO;
+                        }
                 } else {
                         /* Nope. Something's there, but not recognized. */
@@ -403 +417 @@
         }
 
-        printf("device caps: 0x%04x\n", idata.caps);
         if (d->dev_type == ata_pkt_dev) {
                 /* Packet device */
@@ -566 +579 @@
 
         /*
-         * This is where we would most likely expect a non-existing device to
-         * show up by not setting SR_DRDY.
+         * Do not wait for DRDY to be set in case this is a packet device.
+         * We determine whether the device is present by waiting for DRQ to be
+         * set after issuing the command.
          */
-        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
+        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
                 return ETIMEOUT;
 
@@ -577 +591 @@
                 return ETIMEOUT;
 
+        /*
+         * If ERR is set, this may be a packet device, so return EIO to cause
+         * the caller to check for one.
+         */
+        if ((status & SR_ERR) != 0) {
+                return EIO;
+        }
+
+        if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_PROBE) != EOK)
+                return ETIMEOUT;
+
         /* Read data from the disk buffer. */
 
-        if ((status & SR_DRQ) != 0) {
-                for (i = 0; i < identify_data_size / 2; i++) {
-                        data = pio_read_16(&cmd->data_port);
-                        ((uint16_t *) buf)[i] = data;
-                }
-        }
-
-        if ((status & SR_ERR) != 0) {
-                return EIO;
+        for (i = 0; i < identify_data_size / 2; i++) {
+                data = pio_read_16(&cmd->data_port);
+                ((uint16_t *) buf)[i] = data;
         }
 

uspace/srv/bd/ata_bd/ata_hw.h

@@ -293 +293 @@
 };
 
+enum ata_pdev_signature {
+        /**
+         * Signature put by a packet device in byte count register
+         * in response to Identify command.
+         */
+        PDEV_SIGNATURE_BC       = 0xEB14
+};
+
 #endif
 

uspace/srv/devman/devman.c

@@ -555 +555 @@
 }
 
-/** Remember the driver's phone.
- *
- * @param driver        The driver.
- * @param phone         The phone to the driver.
- */
-void set_driver_phone(driver_t *driver, sysarg_t phone)
-{
-        fibril_mutex_lock(&driver->driver_mutex);
-        assert(driver->state == DRIVER_STARTING);
-        driver->phone = phone;
-        fibril_mutex_unlock(&driver->driver_mutex);
-}
-
 /** Notify driver about the devices to which it was assigned.
  *
@@ -685 +672 @@
         list_initialize(&drv->devices);
         fibril_mutex_initialize(&drv->driver_mutex);
+        drv->phone = -1;
 }
 

uspace/srv/devman/devman.h

@@ -88 +88 @@
         
         /** Phone asociated with this driver. */
-        sysarg_t phone;
+        int phone;
         /** Name of the device driver. */
         char *name;
@@ -316 +316 @@
 
 extern driver_t *find_driver(driver_list_t *, const char *);
-extern void set_driver_phone(driver_t *, sysarg_t);
 extern void initialize_running_driver(driver_t *, dev_tree_t *);
 

uspace/srv/devman/main.c

@@ -95 +95 @@
         /* Find driver structure. */
         driver = find_driver(&drivers_list, drv_name);
-        
         if (driver == NULL) {
                 log_msg(LVL_ERROR, "No driver named `%s' was found.", drv_name);
@@ -107 +106 @@
         drv_name = NULL;
         
+        fibril_mutex_lock(&driver->driver_mutex);
+        
+        if (driver->phone >= 0) {
+                /* We already have a connection to the driver. */
+                log_msg(LVL_ERROR, "Driver '%s' already started.\n",
+                    driver->name);
+                fibril_mutex_unlock(&driver->driver_mutex);
+                async_answer_0(iid, EEXISTS);
+                return NULL;
+        }
+        
+        switch (driver->state) {
+        case DRIVER_NOT_STARTED:
+                /* Somebody started the driver manually. */
+                log_msg(LVL_NOTE, "Driver '%s' started manually.\n",
+                    driver->name);
+                driver->state = DRIVER_STARTING;
+                break;
+        case DRIVER_STARTING:
+                /* The expected case */
+                break;
+        case DRIVER_RUNNING:
+                /* Should not happen since we do not have a connected phone */
+                assert(false);
+        }
+        
         /* Create connection to the driver. */
         log_msg(LVL_DEBUG, "Creating connection to the `%s' driver.",
@@ -113 +138 @@
         ipc_callid_t callid = async_get_call(&call);
         if (IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) {
+                fibril_mutex_unlock(&driver->driver_mutex);
                 async_answer_0(callid, ENOTSUP);
                 async_answer_0(iid, ENOTSUP);
@@ -119 +145 @@
         
         /* Remember driver's phone. */
-        set_driver_phone(driver, IPC_GET_ARG5(call));
+        driver->phone = IPC_GET_ARG5(call);
+        
+        fibril_mutex_unlock(&driver->driver_mutex);
         
         log_msg(LVL_NOTE, 
@@ -579 +607 @@
                 method = DRIVER_CLIENT;
         
-        if (driver->phone <= 0) {
+        if (driver->phone < 0) {
                 log_msg(LVL_ERROR, 
                     "Could not forward to driver `%s' (phone is %d).",
@@ -619 +647 @@
         dev = fun->dev;
         
-        if (dev->state != DEVICE_USABLE || dev->drv->phone <= 0) {
+        if (dev->state != DEVICE_USABLE || dev->drv->phone < 0) {
                 async_answer_0(iid, EINVAL);
                 return;

uspace/srv/fs/fat/fat_ops.c

@@ -722 +722 @@
                     (str_cmp((char *) d->name, FAT_NAME_DOT)) == 0) {
                         memset(d, 0, sizeof(fat_dentry_t));
-                        str_cpy((char *) d->name, 8, FAT_NAME_DOT);
-                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
+                        memcpy(d->name, FAT_NAME_DOT, FAT_NAME_LEN);
+                        memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
                         d->attr = FAT_ATTR_SUBDIR;
                         d->firstc = host2uint16_t_le(childp->firstc);
@@ -732 +732 @@
                     (str_cmp((char *) d->name, FAT_NAME_DOT_DOT) == 0)) {
                         memset(d, 0, sizeof(fat_dentry_t));
-                        str_cpy((char *) d->name, 8, FAT_NAME_DOT_DOT);
-                        str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
+                        memcpy(d->name, FAT_NAME_DOT_DOT, FAT_NAME_LEN);
+                        memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
                         d->attr = FAT_ATTR_SUBDIR;
                         d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?

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

@@ -176 +176 @@
         socklen_t addrlen;
 
-        // detach the first packet and release the others
+        /* Detach the first packet and release the others */
         next = pq_detach(packet);
         if (next)
@@ -185 +185 @@
                         return ENOMEM;
 
-                // get header
+                /* Get header */
                 header = (ip_header_t *) packet_get_data(packet);
                 if (!header)
@@ -192 +192 @@
         }
 
-        // only for the first fragment
+        /* Only for the first fragment */
         if (IP_FRAGMENT_OFFSET(header))
                 return EINVAL;
 
-        // not for the ICMP protocol
+        /* Not for the ICMP protocol */
         if (header->protocol == IPPROTO_ICMP)
                 return EPERM;
 
-        // set the destination address
+        /* Set the destination address */
         switch (header->version) {
         case IPVERSION:
@@ -351 +351 @@
         configuration = &names[0];
 
-        // get configuration
+        /* Get configuration */
         rc = net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id,
             &configuration, count, &data);
@@ -419 +419 @@
         }
 
-        // binds the netif service which also initializes the device
+        /* Bind netif service which also initializes the device */
         ip_netif->phone = nil_bind_service(ip_netif->service,
             (sysarg_t) ip_netif->device_id, SERVICE_IP,
@@ -429 +429 @@
         }
 
-        // has to be after the device netif module initialization
+        /* Has to be after the device netif module initialization */
         if (ip_netif->arp) {
                 if (route) {
@@ -445 +445 @@
         }
 
-        // get packet dimensions
+        /* Get packet dimensions */
         rc = nil_packet_size_req(ip_netif->phone, ip_netif->device_id,
             &ip_netif->packet_dimension);
@@ -463 +463 @@
         
         if (gateway.s_addr) {
-                // the default gateway
+                /* The default gateway */
                 ip_globals.gateway.address.s_addr = 0;
                 ip_globals.gateway.netmask.s_addr = 0;
@@ -512 +512 @@
                 ip_netif->arp->usage++;
 
-        // print the settings
+        /* Print the settings */
         printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n",
             NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv,
@@ -587 +587 @@
         ip_netif_t *netif;
 
-        // start with the last netif - the newest one
+        /* Start with the last netif - the newest one */
         index = ip_netifs_count(&ip_globals.netifs) - 1;
         while (index >= 0) {
@@ -629 +629 @@
         size_t length;
 
-        // copy first itself
+        /* Copy first itself */
         memcpy(last, first, sizeof(ip_header_t));
         length = sizeof(ip_header_t);
         next = sizeof(ip_header_t);
 
-        // process all ip options
+        /* Process all IP options */
         while (next < first->header_length) {
                 option = (ip_option_t *) (((uint8_t *) first) + next);
-                // skip end or noop
+                /* Skip end or noop */
                 if ((option->type == IPOPT_END) ||
                     (option->type == IPOPT_NOOP)) {
                         next++;
                 } else {
-                        // copy if told so or skip
+                        /* Copy if told so or skip */
                         if (IPOPT_COPIED(option->type)) {
                                 memcpy(((uint8_t *) last) + length,
@@ -648 +648 @@
                                 length += option->length;
                         }
-                        // next option
+                        /* Next option */
                         next += option->length;
                 }
         }
 
-        // align 4 byte boundary
+        /* Align 4 byte boundary */
         if (length % 4) {
                 bzero(((uint8_t *) last) + length, 4 - (length % 4));
@@ -789 +789 @@
 
         header->total_length = htons(length);
-        // unnecessary for all protocols
+        /* Unnecessary for all protocols */
         header->header_checksum = IP_HEADER_CHECKSUM(header);
 
@@ -916 +916 @@
                 return ENOMEM;
 
-        // get header
+        /* Get header */
         header = (ip_header_t *) packet_get_data(packet);
         if (!header)
                 return EINVAL;
 
-        // fragmentation forbidden?
+        /* Fragmentation forbidden? */
         if(header->flags & IPFLAG_DONT_FRAGMENT)
                 return EPERM;
 
-        // create the last fragment
+        /* Create the last fragment */
         new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length,
             suffix, ((addrlen > addr_len) ? addrlen : addr_len));
@@ -931 +931 @@
                 return ENOMEM;
 
-        // allocate as much as originally
+        /* Allocate as much as originally */
         last_header = (ip_header_t *) packet_suffix(new_packet,
             IP_HEADER_LENGTH(header));
@@ -939 +939 @@
         ip_create_last_header(last_header, header);
 
-        // trim the unused space
+        /* Trim the unused space */
         rc = packet_trim(new_packet, 0,
             IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header));
@@ -945 +945 @@
                 return ip_release_and_return(packet, rc);
 
-        // biggest multiple of 8 lower than content
+        /* Greatest multiple of 8 lower than content */
         // TODO even fragmentation?
         length = length & ~0x7;
@@ -957 +957 @@
                 return ip_release_and_return(packet, rc);
 
-        // mark the first as fragmented
+        /* Mark the first as fragmented */
         header->flags |= IPFLAG_MORE_FRAGMENTS;
 
-        // create middle framgents
+        /* Create middle fragments */
         while (IP_TOTAL_LENGTH(header) > length) {
                 new_packet = packet_get_4_remote(ip_globals.net_phone, prefix,
@@ -981 +981 @@
         }
 
-        // finish the first fragment
+        /* Finish the first fragment */
         header->header_checksum = IP_HEADER_CHECKSUM(header);
 
@@ -1012 +1012 @@
 
         next = packet;
-        // check all packets
+        /* Check all packets */
         while (next) {
                 length = packet_get_data_length(next);
@@ -1021 +1021 @@
                 }
 
-                // too long
+                /* Too long */
                 result = ip_fragment_packet(next, content, prefix,
                     suffix, addr_len);
@@ -1027 +1027 @@
                         new_packet = pq_detach(next);
                         if (next == packet) {
-                                // the new first packet of the queue
+                                /* The new first packet of the queue */
                                 packet = new_packet;
                         }
-                        // fragmentation needed?
+                        /* Fragmentation needed? */
                         if (result == EPERM) {
                                 phone = ip_prepare_icmp_and_get_phone(
                                     error, next, NULL);
                                 if (phone >= 0) {
-                                        // fragmentation necessary ICMP
+                                        /* Fragmentation necessary ICMP */
                                         icmp_destination_unreachable_msg(phone,
                                             ICMP_FRAG_NEEDED, content, next);
@@ -1080 +1080 @@
         int rc;
 
-        // get destination hardware address
+        /* Get destination hardware address */
         if (netif->arp && (route->address.s_addr != dest.s_addr)) {
                 destination.value = route->gateway.s_addr ?
@@ -1102 +1102 @@
                             NULL);
                         if (phone >= 0) {
-                                // unreachable ICMP if no routing
+                                /* Unreachable ICMP if no routing */
                                 icmp_destination_unreachable_msg(phone,
                                     ICMP_HOST_UNREACH, 0, packet);
@@ -1148 +1148 @@
         int rc;
 
-        // addresses in the host byte order
-        // should be the next hop address or the target destination address
+        /*
+         * Addresses in the host byte order
+         * Should be the next hop address or the target destination address
+         */
         addrlen = packet_get_addr(packet, NULL, (uint8_t **) &addr);
         if (addrlen < 0)
@@ -1174 +1176 @@
         fibril_rwlock_read_lock(&ip_globals.netifs_lock);
 
-        // device specified?
+        /* Device specified? */
         if (device_id > 0) {
                 netif = ip_netifs_find(&ip_globals.netifs, device_id);
@@ -1190 +1192 @@
                 phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
                 if (phone >= 0) {
-                        // unreachable ICMP if no routing
+                        /* Unreachable ICMP if no routing */
                         icmp_destination_unreachable_msg(phone,
                             ICMP_NET_UNREACH, 0, packet);
@@ -1198 +1200 @@
 
         if (error) {
-                // do not send for broadcast, anycast packets or network
-                // broadcast
+                /*
+                 * Do not send for broadcast, anycast packets or network
+                 * broadcast.
+                 */
                 if (!dest->s_addr || !(~dest->s_addr) ||
                     !(~((dest->s_addr & ~route->netmask.s_addr) |
@@ -1208 +1212 @@
         }
         
-        // if the local host is the destination
+        /* If the local host is the destination */
         if ((route->address.s_addr == dest->s_addr) &&
             (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
-                // find the loopback device to deliver
+                /* Find the loopback device to deliver */
                 dest->s_addr = IPV4_LOCALHOST_ADDRESS;
                 route = ip_find_route(*dest);
@@ -1220 +1224 @@
                             NULL);
                         if (phone >= 0) {
-                                // unreachable ICMP if no routing
+                                /* Unreachable ICMP if no routing */
                                 icmp_destination_unreachable_msg(phone,
                                     ICMP_HOST_UNREACH, 0, packet);
@@ -1252 +1256 @@
 
         fibril_rwlock_write_lock(&ip_globals.netifs_lock);
-        // find the device
+        /* Find the device */
         netif = ip_netifs_find(&ip_globals.netifs, device_id);
         if (!netif) {
@@ -1344 +1348 @@
                 return ip_release_and_return(packet, rc);
 
-        // trim padding if present
+        /* Trim padding if present */
         if (!error &&
             (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
@@ -1360 +1364 @@
                 phone = ip_prepare_icmp_and_get_phone(error, packet, header);
                 if (phone >= 0) {
-                        // unreachable ICMP
+                        /* Unreachable ICMP */
                         icmp_destination_unreachable_msg(phone,
                             ICMP_PROT_UNREACH, 0, packet);
@@ -1417 +1421 @@
                 return ip_release_and_return(packet, ENOMEM);
 
-        // checksum
+        /* Checksum */
         if ((header->header_checksum) &&
             (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
                 phone = ip_prepare_icmp_and_get_phone(0, packet, header);
                 if (phone >= 0) {
-                        // checksum error ICMP
+                        /* Checksum error ICMP */
                         icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
                             ((size_t) ((void *) &header->header_checksum)) -
@@ -1433 +1437 @@
                 phone = ip_prepare_icmp_and_get_phone(0, packet, header);
                 if (phone >= 0) {
-                        // ttl exceeded ICMP
+                        /* TTL exceeded ICMP */
                         icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
                 }
@@ -1439 +1443 @@
         }
         
-        // process ipopt and get destination
+        /* Process ipopt and get destination */
         dest = ip_get_destination(header);
 
-        // set the addrination address
+        /* Set the destination address */
         switch (header->version) {
         case IPVERSION:
@@ -1464 +1468 @@
                 phone = ip_prepare_icmp_and_get_phone(0, packet, header);
                 if (phone >= 0) {
-                        // unreachable ICMP
+                        /* Unreachable ICMP */
                         icmp_destination_unreachable_msg(phone,
                             ICMP_HOST_UNREACH, 0, packet);
@@ -1472 +1476 @@
 
         if (route->address.s_addr == dest.s_addr) {
-                // local delivery
+                /* Local delivery */
                 return ip_deliver_local(device_id, packet, header, 0);
         }
@@ -1484 +1488 @@
         phone = ip_prepare_icmp_and_get_phone(0, packet, header);
         if (phone >= 0) {
-                // unreachable ICMP if no routing
+                /* Unreachable ICMP if no routing */
                 icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
                     packet);
@@ -1770 +1774 @@
                 header = (ip_header_t *)(data + offset);
 
-                // destination host unreachable?
+                /* Destination host unreachable? */
                 if ((type != ICMP_DEST_UNREACH) ||
                     (code != ICMP_HOST_UNREACH)) {
-                        // no, something else
+                        /* No, something else */
                         break;
                 }
@@ -1787 +1791 @@
                 route = ip_routes_get_index(&netif->routes, 0);
 
-                // from the same network?
+                /* From the same network? */
                 if (route && ((route->address.s_addr & route->netmask.s_addr) ==
                     (header->destination_address & route->netmask.s_addr))) {
-                        // clear the ARP mapping if any
+                        /* Clear the ARP mapping if any */
                         address.value = (uint8_t *) &header->destination_address;
                         address.length = sizeof(header->destination_address);
@@ -1844 +1848 @@
         fibril_rwlock_read_lock(&ip_globals.lock);
         route = ip_find_route(*dest);
-        // if the local host is the destination
+        /* If the local host is the destination */
         if (route && (route->address.s_addr == dest->s_addr) &&
             (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
-                // find the loopback device to deliver
+                /* Find the loopback device to deliver */
                 dest->s_addr = IPV4_LOCALHOST_ADDRESS;
                 route = ip_find_route(*dest);

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

@@ -531 +531 @@
                             proto->service);
                 } else {
-                        // drop invalid/unknown
+                        /* Drop invalid/unknown */
                         pq_release_remote(eth_globals.net_phone,
                             packet_get_id(packet));

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

@@ -299 +299 @@
                 return tcp_release_and_return(packet, NO_DATA);
 
-//      printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
-//          ntohs(header->destination_port));
-
+#if 0
+        printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
+            ntohs(header->destination_port));
+#endif
         result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
         if (result <= 0)
@@ -1062 +1063 @@
         tcp_process_acknowledgement(socket, socket_data, header);
 
-        socket_data->next_incoming = ntohl(header->sequence_number);    // + 1;
+        socket_data->next_incoming = ntohl(header->sequence_number); /* + 1; */
         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
         socket_data->state = TCP_SOCKET_ESTABLISHED;

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

@@ -190 +190 @@
         int backlog;
         
-//      /** Segment size. */
-//      size_t segment_size;
-
         /**
          * Parent listening socket identifier.

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

@@ -499 +499 @@
         device_id_t device_id;
         packet_dimension_t *packet_dimension;
+        size_t size;
         int rc;
+
+        /* In case of error, do not update the data fragment size. */
+        *data_fragment_size = 0;
         
         rc = tl_get_address_port(addr, addrlen, &dest_port);
@@ -539 +543 @@
                 packet_dimension = &udp_globals.packet_dimension;
 //      }
+
+        /*
+         * Update the data fragment size based on what the lower layers can
+         * handle without fragmentation, but not more than the maximum allowed
+         * for UDP.
+         */
+        size = MAX_UDP_FRAGMENT_SIZE;
+        if (packet_dimension->content < size)
+            size = packet_dimension->content;
+        *data_fragment_size = size;
 
         /* Read the first packet fragment */
@@ -740 +754 @@
         int socket_id;
         size_t addrlen;
-        size_t size = 0;
+        size_t size;
         ipc_call_t answer;
         size_t answer_count;
@@ -786 +800 @@
                                 break;
                         
+                        size = MAX_UDP_FRAGMENT_SIZE;
                         if (tl_get_ip_packet_dimension(udp_globals.ip_phone,
                             &udp_globals.dimensions, DEVICE_INVALID_ID,
                             &packet_dimension) == EOK) {
-                                SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
-                                    packet_dimension->content);
+                                if (packet_dimension->content < size)
+                                        size = packet_dimension->content;
                         }
-
-//                      SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
-//                          MAX_UDP_FRAGMENT_SIZE);
+                        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
                         SOCKET_SET_HEADER_SIZE(answer, UDP_HEADER_SIZE);
                         answer_count = 3;

uspace/srv/vfs/vfs_file.c

@@ -258 +258 @@
         if ((fd >= 0) && (fd < MAX_OPEN_FILES)) {
                 vfs_file_t *file = FILES[fd];
-                vfs_file_addref(file);
-                fibril_mutex_unlock(&VFS_DATA->lock);
-                return file;
+                if (file != NULL) {
+                        vfs_file_addref(file);
+                        fibril_mutex_unlock(&VFS_DATA->lock);
+                        return file;
+                }
         }
         fibril_mutex_unlock(&VFS_DATA->lock);