Changeset b50b5af2 in mainline for uspace

Timestamp:

2009-08-22T10:48:00Z (17 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

04803bf

Parents:

1ea99cc (diff), a71c158 (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

Files:

• app/trace/syscalls.c (modified) (1 diff)
• lib/libc/generic/async.c (modified) (3 diffs)
• lib/libc/generic/fibril_sync.c (modified) (5 diffs)
• lib/libc/generic/io/printf_core.c (modified) (1 diff)
• lib/libc/generic/io/vsnprintf.c (modified) (1 diff)
• lib/libc/generic/ipc.c (modified) (1 diff)
• lib/libc/generic/malloc.c (modified) (1 diff)
• lib/libc/generic/vfs/vfs.c (modified) (14 diffs)
• lib/libc/include/async.h (modified) (1 diff)
• lib/libc/include/ipc/ipc.h (modified) (1 diff)
• lib/libc/include/ipc/kbd.h (added)
• srv/bd/ata_bd/ata_bd.c (modified) (11 diffs)
• srv/bd/ata_bd/ata_bd.h (modified) (1 diff)
• srv/console/Makefile (modified) (2 diffs)
• srv/console/console.c (modified) (1 diff)
• srv/console/keybuffer.c (moved) (moved from uspace/srv/kbd/generic/keybuffer.c )
• srv/console/keybuffer.h (moved) (moved from uspace/srv/kbd/include/keybuffer.h )
• srv/fs/fat/fat_fat.c (modified) (1 diff)
• srv/fs/fat/fat_fat.h (modified) (1 diff)
• srv/fs/fat/fat_ops.c (modified) (3 diffs)
• srv/kbd/Makefile (modified) (1 diff)
• srv/kbd/ctl/gxe_fb.c (modified) (1 diff)
• srv/kbd/ctl/pc.c (modified) (4 diffs)
• srv/kbd/ctl/pl050.c (modified) (1 diff)
• srv/kbd/ctl/stty.c (modified) (1 diff)
• srv/kbd/ctl/sun.c (modified) (1 diff)
• srv/kbd/generic/kbd.c (modified) (5 diffs)
• srv/kbd/include/kbd.h (modified) (1 diff)
• srv/kbd/include/kbd_ctl.h (modified) (1 diff)
• srv/kbd/include/kbd_port.h (modified) (1 diff)
• srv/kbd/port/dummy.c (modified) (1 diff)
• srv/kbd/port/gxemul.c (modified) (1 diff)
• srv/kbd/port/i8042.c (modified) (1 diff)
• srv/kbd/port/msim.c (modified) (1 diff)
• srv/kbd/port/pl050.c (modified) (1 diff)
• srv/kbd/port/sgcn.c (modified) (1 diff)
• srv/kbd/port/ski.c (modified) (1 diff)
• srv/kbd/port/sun.c (modified) (1 diff)
• srv/ns/task.h (modified) (1 diff)
• srv/vfs/vfs_node.c (modified) (1 diff)

uspace/app/trace/syscalls.c

@@ -62 +62 @@
     [SYS_IPC_FORWARD_SLOW] = { "ipc_forward_slow",      3,      V_ERRNO },
     [SYS_IPC_WAIT] = { "ipc_wait_for_call",             3,      V_HASH },
+    [SYS_IPC_POKE] = { "ipc_poke",                      0,      V_ERRNO },
     [SYS_IPC_HANGUP] = { "ipc_hangup",                  1,      V_ERRNO },
     [SYS_IPC_REGISTER_IRQ] = { "ipc_register_irq",      4,      V_ERRNO },

uspace/lib/libc/generic/async.c

@@ -106 +106 @@
 
 atomic_t async_futex = FUTEX_INITIALIZER;
+
+/** Number of threads waiting for IPC in the kernel. */
+atomic_t threads_in_ipc_wait = { 0 };
 
 /** Structures of this type represent a waiting fibril. */
@@ -683 +686 @@
                 
                 futex_up(&async_futex);
+
+                atomic_inc(&threads_in_ipc_wait);
                 
                 ipc_call_t call;
@@ -688 +693 @@
                     SYNCH_FLAGS_NONE);
                 
+                atomic_dec(&threads_in_ipc_wait);
+
                 if (!callid) {
                         handle_expired_timeouts();

uspace/lib/libc/generic/fibril_sync.c

@@ -40 +40 @@
 #include <assert.h>
 
+static void optimize_execution_power(void)
+{
+        /*
+         * When waking up a worker fibril previously blocked in fibril
+         * synchronization, chances are that there is an idle manager fibril
+         * waiting for IPC, that could start executing the awakened worker
+         * fibril right away. We try to detect this and bring the manager
+         * fibril back to fruitful work.
+         */
+        if (atomic_get(&threads_in_ipc_wait) > 0)
+                ipc_poke();
+}
+
 void fibril_mutex_initialize(fibril_mutex_t *fm)
 {
@@ -84 +97 @@
                 list_remove(&f->link);
                 fibril_add_ready((fid_t) f);
+                optimize_execution_power();
         }
 }
@@ -152 +166 @@
                         fibril_add_ready((fid_t) f);
                         frw->writers++;
+                        optimize_execution_power();
                         break;
                 } else {
@@ -157 +172 @@
                         fibril_add_ready((fid_t) f);
                         frw->readers++;
+                        optimize_execution_power();
                 }
         }
@@ -200 +216 @@
                 list_remove(&f->link);
                 fibril_add_ready((fid_t) f);
+                optimize_execution_power();
                 if (once)
                         break;

uspace/lib/libc/generic/io/printf_core.c

@@ -490 +490 @@
                 counter += retval;
         
-        /* Print tailing spaces */
+        /* Print trailing spaces */
         
         while (width-- > 0) {

uspace/lib/libc/generic/io/vsnprintf.c

@@ -100 +100 @@
         }
         
-        /* Buffer is big enought to print the whole string */
+        /* Buffer is big enough to print the whole string */
         memcpy((void *)(data->dst + data->len), (void *) str, size);
         data->len += size;

uspace/lib/libc/generic/ipc.c

@@ -565 +565 @@
 }
 
+/** Interrupt one thread of this task from waiting for IPC. */
+void ipc_poke(void)
+{
+        __SYSCALL0(SYS_IPC_POKE);
+}
+
 /** Ask destination to do a callback connection.
  *

uspace/lib/libc/generic/malloc.c

@@ -392 +392 @@
                 if (orig_size - real_size >= STRUCT_OVERHEAD) {
                         /* Split the original block to a full block
-                           and a tailing free block */
+                           and a trailing free block */
                         block_init((void *) head, real_size, false);
                         block_init((void *) head + real_size,

uspace/lib/libc/generic/vfs/vfs.c

@@ -122 +122 @@
         int res;
         ipcarg_t rc;
+        ipcarg_t rc_orig;
         aid_t req;
         dev_handle_t dev_handle;
@@ -141 +142 @@
         rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(mpa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
         
         rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(mpa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
 
         rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(mpa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
 
@@ -169 +179 @@
         rc = async_req_0_0(vfs_phone, IPC_M_PING);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(mpa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
         
@@ -202 +215 @@
         rc = ipc_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                ipcarg_t rc_orig;
+        
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(pa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
         async_wait_for(req, &rc);
@@ -240 +258 @@
         
         if (rc != EOK)
-            return (int) rc;
+                return (int) rc;
         
         return (int) IPC_GET_ARG1(answer);
@@ -274 +292 @@
         rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                return (ssize_t) rc;
+                ipcarg_t rc_orig;
+        
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                if (rc_orig == EOK)
+                        return (ssize_t) rc;
+                else
+                        return (ssize_t) rc_orig;
         }
         async_wait_for(req, &rc);
@@ -301 +324 @@
         rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                return (ssize_t) rc;
+                ipcarg_t rc_orig;
+        
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                if (rc_orig == EOK)
+                        return (ssize_t) rc;
+                else
+                        return (ssize_t) rc_orig;
         }
         async_wait_for(req, &rc);
@@ -376 +404 @@
         rc = ipc_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
         if (rc != EOK) {
-                async_wait_for(req, NULL);
-                async_serialize_end();
-                futex_up(&vfs_phone_futex);
-                return (ssize_t) rc;
+                ipcarg_t rc_orig;
+                
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                if (rc_orig == EOK)
+                        return (ssize_t) rc;
+                else
+                        return (ssize_t) rc_orig;
         }
         async_wait_for(req, &rc);
@@ -391 +424 @@
 {
         ipcarg_t rc;
+        ipcarg_t rc_orig;
         aid_t req;
         
@@ -405 +439 @@
         rc = ipc_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(pa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
         rc = ipc_data_read_start(vfs_phone, stat, sizeof(struct stat));
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(pa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
         async_wait_for(req, &rc);
@@ -476 +516 @@
         rc = ipc_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                ipcarg_t rc_orig;
+        
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(pa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
         async_wait_for(req, &rc);
@@ -506 +551 @@
         rc = ipc_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                ipcarg_t rc_orig;
+
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(pa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
         async_wait_for(req, &rc);
@@ -532 +582 @@
 {
         ipcarg_t rc;
+        ipcarg_t rc_orig;
         aid_t req;
         
@@ -553 +604 @@
         rc = ipc_data_write_start(vfs_phone, olda, olda_size);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(olda);
                 free(newa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
         rc = ipc_data_write_start(vfs_phone, newa, newa_size);
         if (rc != EOK) {
-                async_wait_for(req, NULL);
+                async_wait_for(req, &rc_orig);
                 async_serialize_end();
                 futex_up(&vfs_phone_futex);
                 free(olda);
                 free(newa);
-                return (int) rc;
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
         }
         async_wait_for(req, &rc);

uspace/lib/libc/include/async.h

@@ -47 +47 @@
 extern atomic_t async_futex;
 
+extern atomic_t threads_in_ipc_wait;
+
 extern int __async_init(void);
 extern ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs);

uspace/lib/libc/include/ipc/ipc.h

@@ -192 +192 @@
 extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int);
 extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t);
+extern void ipc_poke(void);
 
 static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data)

uspace/srv/bd/ata_bd/ata_bd.c

@@ -36 +36 @@
  *
  * This driver currently works only with CHS addressing and uses PIO.
- * Currently based on the (now obsolete) ANSI X3.221-1994 (ATA-1) standard.
- * At this point only reading is possible, not writing.
+ * Currently based on the (now obsolete) ATA-1, ATA-2 standards.
  *
  * The driver services a single controller which can have up to two disks
@@ -61 +60 @@
 #define NAME "ata_bd"
 
+/** Physical block size. Should be always 512. */
 static const size_t block_size = 512;
+
+/** Size of the communication area. */
 static size_t comm_size;
 
+/** I/O base address of the command registers. */
 static uintptr_t cmd_physical = 0x1f0;
+/** I/O base address of the control registers. */
 static uintptr_t ctl_physical = 0x170;
+
 static ata_cmd_t *cmd;
 static ata_ctl_t *ctl;
@@ -81 +86 @@
     const void *buf);
 static int drive_identify(int drive_id, disk_t *d);
+static int wait_status(unsigned set, unsigned n_reset, uint8_t *pstatus,
+    unsigned timeout);
 
 int main(int argc, char **argv)
 {
-        uint8_t status;
         char name[16];
         int i, rc;
@@ -96 +102 @@
                 return -1;
 
-        /* Put drives to reset, disable interrupts. */
-        printf("Reset drives... ");
-        fflush(stdout);
-
-        pio_write_8(&ctl->device_control, DCR_SRST);
-        /* FIXME: Find out how to do this properly. */
-        async_usleep(100);
-        pio_write_8(&ctl->device_control, 0);
-
-        do {
-                status = pio_read_8(&cmd->status);
-        } while ((status & SR_BSY) != 0);
-        printf("Done\n");
-
-        (void) drive_identify(0, &disk[0]);
-        (void) drive_identify(1, &disk[1]);
+        for (i = 0; i < MAX_DISKS; i++) {
+                printf("Identify drive %d... ", i);
+                fflush(stdout);
+
+                rc = drive_identify(i, &disk[i]);
+
+                if (rc == EOK) {
+                        printf("%u cylinders, %u heads, %u sectors\n",
+                            disk[i].cylinders, disk[i].heads, disk[i].sectors);
+                } else {
+                        printf("Not found.\n");
+                }
+        }
 
         n_disks = 0;
@@ -144 +147 @@
 }
 
-static int drive_identify(int disk_id, disk_t *d)
-{
-        uint16_t data;
-        uint8_t status;
-        size_t i;
-
-        printf("Identify drive %d... ", disk_id);
-        fflush(stdout);
-
-        pio_write_8(&cmd->drive_head, ((disk_id != 0) ? DHR_DRV : 0));
-        async_usleep(100);
-        pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
-
-        status = pio_read_8(&cmd->status);
-
-        d->present = false;
-
-        /*
-         * Detect if drive is present. This is Qemu only! Need to
-         * do the right thing to work with real drives.
-         */
-        if ((status & SR_DRDY) == 0) {
-                printf("None attached.\n");
-                return ENOENT;
-        }
-
-        for (i = 0; i < block_size / 2; i++) {
-                do {
-                        status = pio_read_8(&cmd->status);
-                } while ((status & SR_DRDY) == 0);
-
-                data = pio_read_16(&cmd->data_port);
-
-                switch (i) {
-                case 1: d->cylinders = data; break;
-                case 3: d->heads = data; break;
-                case 6: d->sectors = data; break;
-                }
-        }
-
-        d->blocks = d->cylinders * d->heads * d->sectors;
-
-        printf("Geometry: %u cylinders, %u heads, %u sectors\n",
-                d->cylinders, d->heads, d->sectors);
-
-        d->present = true;
-        fibril_mutex_initialize(&d->lock);
-
-        return EOK;
-}
-
+
+/** Register driver and enable device I/O. */
 static int ata_bd_init(void)
 {
@@ -226 +180 @@
 }
 
+/** Block device connection handler */
 static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall)
 {
@@ -296 +251 @@
 }
 
+/** Transfer a logical block from/to the device.
+ *
+ * @param disk_id       Device index (0 or 1)
+ * @param method        @c BD_READ_BLOCK or @c BD_WRITE_BLOCK
+ * @param blk_idx       Index of the first block.
+ * @param size          Size of the logical block.
+ * @param buf           Data buffer.
+ *
+ * @return EOK on success, EIO on error.
+ */
 static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, size_t size,
     void *buf)
@@ -327 +292 @@
 }
 
-
+/** Issue IDENTIFY command.
+ *
+ * This is used to detect whether an ATA device is present and if so,
+ * to determine its parameters. The parameters are written to @a d.
+ *
+ * @param disk_id       Device ID, 0 or 1.
+ * @param d             Device structure to store parameters in.
+ */
+static int drive_identify(int disk_id, disk_t *d)
+{
+        uint16_t data;
+        uint8_t status;
+        uint8_t drv_head;
+        size_t i;
+
+        drv_head = ((disk_id != 0) ? DHR_DRV : 0);
+        d->present = false;
+
+        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
+                return EIO;
+
+        pio_write_8(&cmd->drive_head, drv_head);
+
+        /*
+         * This is where we would most likely expect a non-existing device to
+         * show up by not setting SR_DRDY.
+         */
+        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
+                return EIO;
+
+        pio_write_8(&cmd->command, CMD_IDENTIFY_DRIVE);
+
+        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_PROBE) != EOK)
+                return EIO;
+
+        /* Read data from the disk buffer. */
+
+        if ((status & SR_DRQ) != 0) {
+//              for (i = 0; i < block_size / 2; i++) {
+//                      data = pio_read_16(&cmd->data_port);
+//                      ((uint16_t *) buf)[i] = data;
+//              }
+
+                for (i = 0; i < block_size / 2; i++) {
+                        data = pio_read_16(&cmd->data_port);
+
+                        switch (i) {
+                        case 1: d->cylinders = data; break;
+                        case 3: d->heads = data; break;
+                        case 6: d->sectors = data; break;
+                        }
+                }
+        }
+
+        if ((status & SR_ERR) != 0)
+                return EIO;
+
+        d->blocks = d->cylinders * d->heads * d->sectors;
+
+        d->present = true;
+        fibril_mutex_initialize(&d->lock);
+
+        return EOK;
+}
+
+/** Read a physical from the device.
+ *
+ * @param disk_id       Device index (0 or 1)
+ * @param blk_idx       Index of the first block.
+ * @param blk_cnt       Number of blocks to transfer.
+ * @param buf           Buffer for holding the data.
+ *
+ * @return EOK on success, EIO on error.
+ */
 static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
     void *buf)
@@ -361 +399 @@
         /* Program a Read Sectors operation. */
 
+        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
+                fibril_mutex_unlock(&d->lock);
+                return EIO;
+        }
+
         pio_write_8(&cmd->drive_head, drv_head);
+
+        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
+                fibril_mutex_unlock(&d->lock);
+                return EIO;
+        }
+
         pio_write_8(&cmd->sector_count, 1);
         pio_write_8(&cmd->sector_number, s);
         pio_write_8(&cmd->cylinder_low, c & 0xff);
         pio_write_8(&cmd->cylinder_high, c >> 16);
+
         pio_write_8(&cmd->command, CMD_READ_SECTORS);
 
-        /* Read data from the disk buffer. */
-
-        for (i = 0; i < block_size / 2; i++) {
-                do {
-                        status = pio_read_8(&cmd->status);
-                } while ((status & SR_DRDY) == 0);
-
-                data = pio_read_16(&cmd->data_port);
-                ((uint16_t *) buf)[i] = data;
-        }
+        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
+                fibril_mutex_unlock(&d->lock);
+                return EIO;
+        }
+
+        if ((status & SR_DRQ) != 0) {
+                /* Read data from the device buffer. */
+
+                for (i = 0; i < block_size / 2; i++) {
+                        data = pio_read_16(&cmd->data_port);
+                        ((uint16_t *) buf)[i] = data;
+                }
+        }
+
+        if ((status & SR_ERR) != 0)
+                return EIO;
 
         fibril_mutex_unlock(&d->lock);
@@ -383 +439 @@
 }
 
+/** Write a physical block to the device.
+ *
+ * @param disk_id       Device index (0 or 1)
+ * @param blk_idx       Index of the first block.
+ * @param blk_cnt       Number of blocks to transfer.
+ * @param buf           Buffer holding the data to write.
+ *
+ * @return EOK on success, EIO on error.
+ */
 static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt,
     const void *buf)
@@ -413 +478 @@
         fibril_mutex_lock(&d->lock);
 
-        /* Program a Read Sectors operation. */
+        /* Program a Write Sectors operation. */
+
+        if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_BSY) != EOK) {
+                fibril_mutex_unlock(&d->lock);
+                return EIO;
+        }
 
         pio_write_8(&cmd->drive_head, drv_head);
+
+        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_DRDY) != EOK) {
+                fibril_mutex_unlock(&d->lock);
+                return EIO;
+        }
+
         pio_write_8(&cmd->sector_count, 1);
         pio_write_8(&cmd->sector_number, s);
         pio_write_8(&cmd->cylinder_low, c & 0xff);
         pio_write_8(&cmd->cylinder_high, c >> 16);
+
         pio_write_8(&cmd->command, CMD_WRITE_SECTORS);
 
-        /* Write data to the disk buffer. */
-
-        for (i = 0; i < block_size / 2; i++) {
-                do {
-                        status = pio_read_8(&cmd->status);
-                } while ((status & SR_DRDY) == 0);
-
-                pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
+        if (wait_status(0, ~SR_BSY, &status, TIMEOUT_BSY) != EOK) {
+                fibril_mutex_unlock(&d->lock);
+                return EIO;
+        }
+
+        if ((status & SR_DRQ) != 0) {
+                /* Write data to the device buffer. */
+
+                for (i = 0; i < block_size / 2; i++) {
+                        pio_write_16(&cmd->data_port, ((uint16_t *) buf)[i]);
+                }
         }
 
         fibril_mutex_unlock(&d->lock);
+
+        if (status & SR_ERR)
+                return EIO;
+
         return EOK;
 }
 
+/** Wait until some status bits are set and some are reset.
+ *
+ * Example: wait_status(SR_DRDY, ~SR_BSY) waits for SR_DRDY to become
+ * set and SR_BSY to become reset.
+ *
+ * @param set           Combination if bits which must be all set.
+ * @param n_reset       Negated combination of bits which must be all reset.
+ * @param pstatus       Pointer where to store last read status or NULL.
+ * @param timeout       Timeout in 10ms units.
+ *
+ * @return              EOK on success, EIO on timeout.
+ */
+static int wait_status(unsigned set, unsigned n_reset, uint8_t *pstatus,
+    unsigned timeout)
+{
+        uint8_t status;
+        int cnt;
+
+        status = pio_read_8(&cmd->status);
+
+        /*
+         * This is crude, yet simple. First try with 1us delays
+         * (most likely the device will respond very fast). If not,
+         * start trying every 10 ms.
+         */
+
+        cnt = 100;
+        while ((status & ~n_reset) != 0 || (status & set) != set) {
+                async_usleep(1);
+                --cnt;
+                if (cnt <= 0) break;
+
+                status = pio_read_8(&cmd->status);
+        }
+
+        cnt = timeout;
+        while ((status & ~n_reset) != 0 || (status & set) != set) {
+                async_usleep(10000);
+                --cnt;
+                if (cnt <= 0) break;
+
+                status = pio_read_8(&cmd->status);
+        }
+
+        if (pstatus)
+                *pstatus = status;
+
+        if (cnt == 0)
+                return EIO;
+
+        return EOK;
+}
 
 /**

uspace/srv/bd/ata_bd/ata_bd.h

@@ -135 +135 @@
 };
 
+/** Timeout definitions. Unit is 10 ms. */
+enum ata_timeout {
+        TIMEOUT_PROBE   =  100, /*  1 s */
+        TIMEOUT_BSY     =  100, /*  1 s */
+        TIMEOUT_DRDY    = 1000  /* 10 s */
+};
+
 typedef struct {
         bool present;

uspace/srv/console/Makefile

@@ -35 +35 @@
 include $(LIBC_PREFIX)/Makefile.toolchain
 
-CFLAGS += -I. -I../kbd/include -I../fb
+CFLAGS += -I.
 
 LIBS = $(LIBC_PREFIX)/libc.a
@@ -47 +47 @@
         console.c \
         screenbuffer.c \
-        ../kbd/generic/keybuffer.c \
+        keybuffer.c \
         gcons.c
 

uspace/srv/console/console.c

@@ -34 +34 @@
 
 #include <libc.h>
-#include <fb.h>
 #include <ipc/ipc.h>
-#include <kbd.h>
+#include <ipc/kbd.h>
 #include <io/keycode.h>
 #include <ipc/fb.h>

uspace/srv/fs/fat/fat_fat.c

@@ -451 +451 @@
 }
 
+void
+fat_zero_cluster(struct fat_bs *bs, dev_handle_t dev_handle, fat_cluster_t c)
+{
+        int i;
+        block_t *b;
+        unsigned bps;
+
+        bps = uint16_t_le2host(bs->bps);
+        
+        for (i = 0; i < bs->spc; i++) {
+                b = _fat_block_get(bs, dev_handle, c, i, BLOCK_FLAGS_NOREAD);
+                memset(b->data, 0, bps);
+                b->dirty = true;
+                block_put(b);
+        }
+}
+
 /**
  * @}

uspace/srv/fs/fat/fat_fat.h

@@ -84 +84 @@
 extern void fat_fill_gap(struct fat_bs *, struct fat_node *, fat_cluster_t,
     off_t);
+extern void fat_zero_cluster(struct fat_bs *, dev_handle_t, fat_cluster_t);
 
 #endif

uspace/srv/fs/fat/fat_ops.c

@@ -332 +332 @@
         /* idxp->lock held */
         if (flags & L_DIRECTORY) {
-                int i;
-                block_t *b;
-
-                /*
-                 * Populate the new cluster with unused dentries.
-                 */
-                for (i = 0; i < bs->spc; i++) {
-                        b = _fat_block_get(bs, dev_handle, mcl, i,
-                            BLOCK_FLAGS_NOREAD);
-                        /* mark all dentries as never-used */
-                        memset(b->data, 0, bps);
-                        b->dirty = false;
-                        block_put(b);
-                }
+                /* Populate the new cluster with unused dentries. */
+                fat_zero_cluster(bs, dev_handle, mcl);
                 nodep->type = FAT_DIRECTORY;
                 nodep->firstc = mcl;
@@ -462 +450 @@
          * We need to grow the parent in order to create a new unused dentry.
          */
-        if (parentp->idx->pfc == FAT_CLST_ROOT) {
+        if (parentp->firstc == FAT_CLST_ROOT) {
                 /* Can't grow the root directory. */
                 fibril_mutex_unlock(&parentp->idx->lock);
@@ -472 +460 @@
                 return rc;
         }
+        fat_zero_cluster(bs, parentp->idx->dev_handle, mcl);
         fat_append_clusters(bs, parentp, mcl);
-        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NOREAD);
+        parentp->size += bps * bs->spc;
+        parentp->dirty = true;          /* need to sync node */
+        b = fat_block_get(bs, parentp, i, BLOCK_FLAGS_NONE);
         d = (fat_dentry_t *)b->data;
-        /*
-         * Clear all dentries in the block except for the first one (the first
-         * dentry will be cleared in the next step).
-         */
-        memset(d + 1, 0, bps - sizeof(fat_dentry_t));
 
 hit:

uspace/srv/kbd/Makefile

@@ -45 +45 @@
         generic/kbd.c \
         genarch/gsp.c \
-        genarch/stroke.c \
-        generic/keybuffer.c
+        genarch/stroke.c
 
 ARCH_SOURCES =

uspace/srv/kbd/ctl/gxe_fb.c

@@ -225 +225 @@
 }
 
+void kbd_ctl_set_ind(unsigned mods)
+{
+        (void) mods;
+}
+
 /**
  * @}

uspace/srv/kbd/ctl/pc.c

@@ -40 +40 @@
 #include <io/keycode.h>
 #include <kbd_ctl.h>
+#include <kbd_port.h>
 #include <gsp.h>
 
@@ -45 +46 @@
         ds_s,
         ds_e
+};
+
+enum special_code {
+        SC_ACK = 0xfa,
+        SC_NAK = 0xfe
+};
+
+enum lock_ind_bits {
+        LI_SCROLL       = 0x01,
+        LI_NUM          = 0x02,
+        LI_CAPS         = 0x04
+};
+
+enum kbd_command {
+        KBD_CMD_SET_LEDS = 0xed
 };
 
@@ -194 +210 @@
         size_t map_length;
 
+        /*
+         * ACK/NAK are returned as response to us sending a command.
+         * We are not interested in them.
+         */
+        if (scancode == SC_ACK || scancode == SC_NAK)
+                return;
+
         if (scancode == 0xe0) {
                 ds = ds_e;
@@ -230 +253 @@
 }
 
+void kbd_ctl_set_ind(unsigned mods)
+{
+        uint8_t b;
+
+        b = 0;
+        if ((mods & KM_CAPS_LOCK) != 0)
+                b = b | LI_CAPS;
+        if ((mods & KM_NUM_LOCK) != 0)
+                b = b | LI_NUM;
+        if ((mods & KM_SCROLL_LOCK) != 0)
+                b = b | LI_SCROLL;
+
+        kbd_port_write(KBD_CMD_SET_LEDS);
+        kbd_port_write(b);
+}
+
 /**
  * @}

uspace/srv/kbd/ctl/pl050.c

@@ -258 +258 @@
 }
 
+void kbd_ctl_set_ind(unsigned mods)
+{
+        (void) mods;
+}
+
 /**
  * @}

uspace/srv/kbd/ctl/stty.c

@@ -224 +224 @@
 }
 
+void kbd_ctl_set_ind(unsigned mods)
+{
+        (void) mods;
+}
+
 /**
  * @}

uspace/srv/kbd/ctl/sun.c

@@ -72 +72 @@
         if (key != 0)
                 kbd_push_ev(type, key);
+}
+
+void kbd_ctl_set_ind(unsigned mods)
+{
+        (void) mods;
 }
 

uspace/srv/kbd/generic/kbd.c

@@ -38 +38 @@
 #include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <ipc/kbd.h>
 #include <sysinfo.h>
 #include <stdio.h>
@@ -51 +52 @@
 
 #include <kbd.h>
-#include <keybuffer.h>
 #include <kbd_port.h>
 #include <kbd_ctl.h>
@@ -60 +60 @@
 int cons_connected = 0;
 int phone2cons = -1;
-keybuffer_t keybuffer;
 
 /** Currently active modifiers. */
@@ -125 +124 @@
                         mods = mods ^ (mod_mask & ~lock_keys);
                         lock_keys = lock_keys | mod_mask;
+
+                        /* Update keyboard lock indicator lights. */
+                        kbd_ctl_set_ind(mods);
                 } else {
                         lock_keys = lock_keys & ~mod_mask;
@@ -239 +241 @@
         layout[active_layout]->reset();
         
-        /* Initialize key buffer */
-        keybuffer_init(&keybuffer);
-        
         async_set_client_connection(console_connection);
 

uspace/srv/kbd/include/kbd.h

@@ -38 +38 @@
 #define KBD_KBD_H_
 
-#include <keybuffer.h>
-#include <ipc/ipc.h>
-
-#define KBD_EVENT      1024
-#define KBD_MS_LEFT    1025
-#define KBD_MS_RIGHT   1026
-#define KBD_MS_MIDDLE  1027
-#define KBD_MS_MOVE    1028
-
-typedef enum {
-        KBD_YIELD = IPC_FIRST_USER_METHOD,
-        KBD_RECLAIM
-} kbd_request_t;
-
 extern int cir_service;
 extern int cir_phone;

uspace/srv/kbd/include/kbd_ctl.h

@@ -40 +40 @@
 extern void kbd_ctl_parse_scancode(int);
 extern int kbd_ctl_init(void);
-
+extern void kbd_ctl_set_ind(unsigned);
 
 #endif

uspace/srv/kbd/include/kbd_port.h

@@ -38 +38 @@
 #define KBD_PORT_H_
 
+#include <sys/types.h>
+
 extern int kbd_port_init(void);
 extern void kbd_port_yield(void);
 extern void kbd_port_reclaim(void);
+extern void kbd_port_write(uint8_t);
 
 #endif

uspace/srv/kbd/port/dummy.c

@@ -51 +51 @@
 }
 
+void kbd_port_write(uint8_t data)
+{
+        (void) data;
+}
+
 /** @}
 */

uspace/srv/kbd/port/gxemul.c

@@ -78 +78 @@
 }
 
+void kbd_port_write(uint8_t data)
+{
+        (void) data;
+}
+
 /** Process data sent when a key is pressed.
  *  

uspace/srv/kbd/port/i8042.c

@@ -160 +160 @@
 }
 
+void kbd_port_write(uint8_t data)
+{
+        pio_write_8(&i8042->data, data);
+        wait_ready();
+}
+
 static void i8042_irq_handler(ipc_callid_t iid, ipc_call_t *call)
 {

uspace/srv/kbd/port/msim.c

@@ -78 +78 @@
 }
 
+void kbd_port_write(uint8_t data)
+{
+        (void) data;
+}
+
 static void msim_irq_handler(ipc_callid_t iid, ipc_call_t *call)
 {

uspace/srv/kbd/port/pl050.c

@@ -102 +102 @@
 }
 
+void kbd_port_write(uint8_t data)
+{
+        (void) data;
+}
+
 static void pl050_irq_handler(ipc_callid_t iid, ipc_call_t *call)
 {

uspace/srv/kbd/port/sgcn.c

@@ -133 +133 @@
 }
 
+void kbd_port_write(uint8_t data)
+{
+        (void) data;
+}
+
 /**
  * Handler of the "key pressed" event. Reads codes of all the pressed keys from

uspace/srv/kbd/port/ski.c

@@ -78 +78 @@
 }
 
+void kbd_port_write(uint8_t data)
+{
+        (void) data;
+}
+
 /** Thread to poll Ski for keypresses. */
 static void *ski_thread_impl(void *arg)

uspace/srv/kbd/port/sun.c

@@ -71 +71 @@
 }
 
+void kbd_port_write(uint8_t data)
+{
+        (void) data;
+}
+
 /** @}
 */

uspace/srv/ns/task.h

@@ -35 +35 @@
 
 #include <ipc/ipc.h>
-#include <event.h>
 
 extern int task_init(void);
 extern void process_pending_wait(void);
 
-extern void wait_notification(wait_type_t et, task_id_t id);
 extern void wait_for_task(task_id_t id, ipc_call_t *call, ipc_callid_t callid);
 

uspace/srv/vfs/vfs_node.c

@@ -188 +188 @@
         }
 
-        assert(node->size == result->size);
+        assert(node->size == result->size || node->type != VFS_NODE_FILE);
         assert(node->lnkcnt == result->lnkcnt);
         assert(node->type == result->type || result->type == VFS_NODE_UNKNOWN);