Changes in / [9d58539:d9f53877] in mainline

Files:

• tools/check.sh (modified) (1 diff)
• tools/checkers/clang.py (modified) (1 diff)
• tools/checkers/stanse.py (modified) (1 diff)
• tools/checkers/vcc.py (modified) (1 diff)
• tools/filldir.py (modified) (1 diff)
• tools/gentestfile.py (modified) (1 diff)
• tools/mkfat.py (modified) (3 diffs)
• tools/mkuimage.py (modified) (3 diffs)
• tools/xstruct.py (modified) (1 diff)
• uspace/app/bdsh/cmds/builtins/cd/cd.c (modified) (2 diffs)
• uspace/app/bdsh/cmds/modules/cat/cat.c (modified) (10 diffs)
• uspace/app/bdsh/cmds/modules/cat/cat.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/cp/cp.c (modified) (12 diffs)
• uspace/app/bdsh/cmds/modules/help/help.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/mkdir/mkdir.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/printf/TODO (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/printf/printf.c (modified) (2 diffs)
• uspace/app/bdsh/cmds/modules/rm/rm.c (modified) (4 diffs)
• uspace/app/bdsh/cmds/modules/rm/rm.h (modified) (1 diff)
• uspace/app/bdsh/cmds/modules/sleep/sleep.c (modified) (3 diffs)
• uspace/app/sportdmp/sportdmp.c (modified) (5 diffs)
• uspace/app/tester/hw/serial/serial1.c (modified) (5 diffs)
• uspace/app/websrv/websrv.c (modified) (1 diff)
• uspace/dist/data/web/bar.htm (deleted)
• uspace/dist/data/web/bar.html (added)
• uspace/dist/data/web/foo.htm (deleted)
• uspace/dist/data/web/foo.html (added)
• uspace/dist/data/web/index.htm (deleted)
• uspace/dist/data/web/index.html (added)
• uspace/drv/bus/isa/isa.c (modified) (1 diff)
• uspace/drv/bus/usb/uhcirh/port.c (modified) (1 diff)
• uspace/drv/bus/usb/usbhub/port.c (modified) (1 diff)
• uspace/drv/char/ns8250/ns8250.c (modified) (32 diffs)
• uspace/drv/char/ps2mouse/main.c (modified) (1 diff)
• uspace/drv/char/xtkbd/main.c (modified) (1 diff)
• uspace/drv/infrastructure/root/root.c (modified) (1 diff)
• uspace/drv/infrastructure/rootpc/rootpc.c (modified) (1 diff)
• uspace/drv/nic/e1k/e1k.c (modified) (1 diff)
• uspace/lib/c/generic/vfs/vfs.c (modified) (3 diffs)
• uspace/lib/c/include/unistd.h (modified) (2 diffs)
• uspace/lib/net/generic/net_remote.c (modified) (1 diff)
• uspace/lib/usb/src/ddfiface.c (modified) (1 diff)
• uspace/lib/usbvirt/src/ipc_dev.c (modified) (1 diff)
• uspace/lib/usbvirt/src/ipc_hc.c (modified) (1 diff)

tools/check.sh

@@ -66 +66 @@
 do
         echo -n ">>>> Building $P... "
-        ( make distclean && make PROFILE=$P HANDS_OFF=y $1 ) >>/dev/null 2>>/dev/null
+        ( make distclean && make PROFILE=$P HANDS_OFF=y "$@" ) >>/dev/null 2>>/dev/null
         if [ $? -ne 0 ];
         then

tools/checkers/clang.py

@@ -114 +114 @@
         for job in jobs:
                 if (not clang(rootdir, job)):
-                        print
+                        print()
                         print("Failed job: %s" % job)
                         return

tools/checkers/stanse.py

@@ -127 +127 @@
         for job in jobs:
                 if (not stanse(rootdir, job)):
-                        print
+                        print()
                         print("Failed job: %s" % job)
                         return

tools/checkers/vcc.py

@@ -204 +204 @@
         for job in jobs:
                 if (not vcc(vcc_path, rootdir, job)):
-                        print
+                        print()
                         print("Failed job: %s" % job)
                         return
         
-        print
+        print()
         print("All jobs passed")
 

tools/filldir.py

@@ -37 +37 @@
 
 if len(sys.argv) < 3:
-        print 'Usage: filldir <parent-dir> <count>'
+        print('Usage: filldir <parent-dir> <count>')
         exit(2)
 

tools/gentestfile.py

@@ -36 +36 @@
 
 if len(sys.argv) < 2:
-        print "Usage: gentestfile.py <count of 64-bit numbers to output>"
+        print("Usage: gentestfile.py <count of 64-bit numbers to output>")
         exit()
 
-m = long(sys.argv[1])
+m = int(sys.argv[1])
 i = 0
 pow_2_64 = 2 ** 64

tools/mkfat.py

@@ -168 +168 @@
 """
 
-def mangle_fname(name):
+LFN_ENTRY = """little:
+        uint8_t pos
+        uint16_t name1[5]
+        uint8_t attr
+        uint8_t type
+        uint8_t csum
+        uint16_t name2[6]
+        uint16_t fc
+        uint16_t name3[2]
+"""
+
+# Global variable to hold the file names in 8.3 format. Needed to 
+# keep track of "number" when creating a short fname from a LFN.
+name83_list = []
+
+def name83(fname):
+        "Create a 8.3 name for the given fname"
+
         # FIXME: filter illegal characters
-        parts = name.split('.')
-        
+        parts = fname.split('.')
+        
+        name = ''
+        ext = ''
+        lfn = False
+
+        if len(fname) > 11 :
+                lfn = True
+
         if len(parts) > 0:
-                fname = parts[0]
-        else:
-                fname = ''
-        
-        if len(fname) > 8:
-                sys.stdout.write("mkfat.py: error: Directory entry " + name +
-                    " base name is longer than 8 characters\n")
-                sys.exit(1);
-        
-        return (fname + '          ').upper()[0:8]
-
-def mangle_ext(name):
-        # FIXME: filter illegal characters
-        parts = name.split('.')
-        
-        if len(parts) > 1:
-                ext = parts[1]
-        else:
-                ext = ''
-        
-        if len(parts) > 2:
-                sys.stdout.write("mkfat.py: error: Directory entry " + name +
-                    " has more than one extension\n")
-                sys.exit(1);
-        
-        if len(ext) > 3:
-                sys.stdout.write("mkfat.py: error: Directory entry " + name +
-                    " extension is longer than 3 characters\n")
-                sys.exit(1);
-        
-        return (ext + '   ').upper()[0:3]
+                name = parts[0]
+                if len(name) > 8 :
+                        lfn = True
+
+        if len(parts) > 1 :
+                ext = parts[-1]
+                if len(ext) > 3 :
+                        lfn = True
+
+        if len(parts) > 2 :
+                lfn = True
+
+        if (lfn == False) :
+                return (name.ljust(8)[0:8], ext.ljust(3)[0:3], False)
+
+        # For filenames with multiple extensions, we treat the last one
+        # as the actual extension. The rest of the filename is stripped
+        # of dots and concatenated to form the short name
+        for _name in parts[1:-1]:
+                name = name + _name             
+
+        global name83_list
+        for number in range(1, 10000) :
+                number_str = '~' + str(number)
+
+                if len(name) + len(number_str) > 8 :
+                        name = name[0:8 - len(number_str)]
+
+                name = name + number_str;
+
+                if (name + ext) not in name83_list :
+                        break
+                        
+        name83_list.append(name + ext)  
+
+        return (name.ljust(8)[0:8], ext.ljust(3)[0:3], True)
+
+def get_utf16(name, l) :
+        "Create a int array out of a string which we can store in uint16_t arrays"
+
+        bs = [0xFFFF for i in range(l)]
+
+        for i in range(len(name)) :
+                bs[i] = ord(name[i])
+        
+        if (len(name) < l) :
+                bs[len(name)] = 0;
+        
+        return bs
+
+def create_lfn_entry(name_index) :
+        (name, index) = name_index
+        entry = xstruct.create(LFN_ENTRY)
+
+        entry.name1 = get_utf16(name[0:5], 5)
+        entry.name2 = get_utf16(name[5:11], 6)
+        entry.name3 = get_utf16(name[11:13], 2)
+        entry.pos = index
+
+        entry.attr = 0xF
+        entry.fc = 0
+        entry.type = 0
+
+        return entry
 
 def create_dirent(name, directory, cluster, size):
+        
         dir_entry = xstruct.create(DIR_ENTRY)
         
-        dir_entry.name = mangle_fname(name).encode('ascii')
-        dir_entry.ext = mangle_ext(name).encode('ascii')
-        
+        dir_entry.name, dir_entry.ext, lfn = name83(name)
+
+        dir_entry.name = dir_entry.name.upper().encode('ascii')
+        dir_entry.ext = dir_entry.ext.upper().encode('ascii')
+
         if (directory):
                 dir_entry.attr = 0x30
@@ -230 +290 @@
                 dir_entry.size = size
         
-        return dir_entry
+
+        if not lfn:
+                return [dir_entry]
+
+        n = (int) (len(name) / 13 + 1)
+        names = [(name[i * 13: (i + 1) * 13 + 1], i + 1) for i in range(n)]
+
+        entries = sorted(map (create_lfn_entry, names), reverse = True, key = lambda e : e.pos)
+        entries[0].pos |= 0x40
+
+        fname11 = str(dir_entry.name + dir_entry.ext)
+
+        csum = 0
+        for i in range(0, 11) :
+                csum = ((csum & 1) << 7) + (csum  >> 1) + ord(fname11[i])
+                csum = csum & 0xFF
+        
+        for e in entries :
+                e.csum = csum;
+        
+        entries.append(dir_entry)
+
+        return entries
 
 def create_dot_dirent(empty_cluster):
@@ -288 +370 @@
                 if item.is_file:
                         rv = write_file(item, outf, cluster_size, data_start, fat, reserved_clusters)
-                        directory.append(create_dirent(item.name, False, rv[0], rv[1]))
+                        directory.extend(create_dirent(item.name, False, rv[0], rv[1]))
                 elif item.is_dir:
                         rv = recursion(False, item.path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
-                        directory.append(create_dirent(item.name, True, rv[0], rv[1]))
+                        directory.extend(create_dirent(item.name, True, rv[0], rv[1]))
         
         if (head):

tools/mkuimage.py

@@ -124 +124 @@
         header.img_type = 2             # Kernel
         header.compression = 0          # None
-        header.img_name = image_name
+        header.img_name = image_name.encode('ascii')
 
         header_crc = calc_crc32(header.pack())
@@ -140 +140 @@
         signed_crc = zlib.crc32(byteseq, 0)
         if signed_crc < 0:
-                return (long(signed_crc) + (long(2) ** long(32))) # 2^32L
+                return signed_crc + (1 << 32)
         else:
                 return signed_crc
@@ -148 +148 @@
 def print_syntax(cmd):
         print("syntax: " + cmd + " [<options>] <raw_image> <uImage>")
-        print
+        print()
         print("\traw_image\tInput image name (raw binary data)")
         print("\tuImage\t\tOutput uImage name (U-Boot image)")
-        print
+        print()
         print("options:")
         print("\t-name <name>\tImage name (default: 'Noname')")

tools/xstruct.py

@@ -32 +32 @@
 
 import struct
+import sys
 import types
 
+integer_types = (int, long) if sys.version < '3' else (int,)
+
 ranges = {
-        'B': ((int, long), 0x00, 0xff),
-        'H': ((int, long), 0x0000, 0xffff),
-        'L': ((int, long), 0x00000000, 0xffffffff),
-        'Q': ((int, long), 0x0000000000000000, 0xffffffffffffffff),
-        'b': ((int, long), -0x80, 0x7f),
-        'h': ((int, long), -0x8000, 0x7fff),
-        'l': ((int, long), -0x80000000, 0x7fffffff) ,
-        'q': ((int, long), -0x8000000000000000, 0x7fffffffffffffff),
+        'B': (integer_types, 0x00, 0xff),
+        'H': (integer_types, 0x0000, 0xffff),
+        'L': (integer_types, 0x00000000, 0xffffffff),
+        'Q': (integer_types, 0x0000000000000000, 0xffffffffffffffff),
+        'b': (integer_types, -0x80, 0x7f),
+        'h': (integer_types, -0x8000, 0x7fff),
+        'l': (integer_types, -0x80000000, 0x7fffffff) ,
+        'q': (integer_types, -0x8000000000000000, 0x7fffffffffffffff),
 }
 

uspace/app/bdsh/cmds/builtins/cd/cd.c

@@ -63 +63 @@
         argc = cli_count_args(argv);
 
+        /* Handle cd -- -. Override to switch to a directory named '-' */
+        bool hyphen_override = false;
+        if (argc == 3) {
+                if(!str_cmp(argv[1], "--")) {
+                        hyphen_override = true;
+                        argc--;
+                }
+        }
+
         /* We don't yet play nice with whitespace, a getopt implementation should
          * protect "quoted\ destination" as a single argument. Its not our job to
@@ -79 +88 @@
         }
 
-        /* We have the correct # of arguments
-     * TODO: handle tidle (~) expansion? */
+        /* We have the correct # of arguments */
+        // TODO: handle tidle (~) expansion? */
 
-        rc = chdir(argv[1]);
+        /* Handle 'cd -' first. */
+        if (!str_cmp(argv[1], "-") && !hyphen_override) {
+                char *buffer = (char *) malloc(PATH_MAX);
+                if (!buffer) {
+                        cli_error(CL_ENOMEM, "Cannot switch to previous directory");
+                        return CMD_FAILURE;
+                }
+                memset(buffer, 0, PATH_MAX);
+                getprevwd(buffer, PATH_MAX);
+                if (*buffer == '\0') {
+                        cli_error(CL_EFAIL, "No previous directory to switch to");
+                        free(buffer);
+                        return CMD_FAILURE;
+                } else {
+                        rc = chdir(buffer);
+                        free(buffer);
+                }
+        } else if (hyphen_override) {
+                /* Handles 'cd -- <dirname>'.
+                 * Override for directory named '-'.
+                 */
+                rc = chdir(argv[2]);
+        } else {
+                rc = chdir(argv[1]);
+        }
 
         if (rc == 0) {

uspace/app/bdsh/cmds/modules/cat/cat.c

@@ -52 +52 @@
 #define CAT_VERSION "0.0.1"
 #define CAT_DEFAULT_BUFLEN 1024
-
-static const char *cat_oops = "That option is not yet supported\n";
+#define CAT_FULL_FILE 0
+
 static const char *hexchars = "0123456789abcdef";
 
@@ -163 +163 @@
 }
 
-static unsigned int cat_file(const char *fname, size_t blen, bool hex)
+static unsigned int cat_file(const char *fname, size_t blen, bool hex,
+    off64_t head, off64_t tail, bool tail_first)
 {
         int fd, bytes = 0, count = 0, reads = 0;
         char *buff = NULL;
         int i;
-        size_t offset = 0;
+        size_t offset = 0, copied_bytes = 0;
+        off64_t file_size = 0, length = 0;
 
         fd = open(fname, O_RDONLY);
@@ -183 +185 @@
         }
 
+        if (tail != CAT_FULL_FILE) {
+                file_size = lseek(fd, 0, SEEK_END);
+                if (head == CAT_FULL_FILE) {
+                        head = file_size;
+                        length = tail;
+                } else if (tail_first) {
+                        length = head;
+                } else {
+                        if (tail > head)
+                                tail = head;
+                        length = tail;
+                }
+
+                if (tail_first) {
+                        lseek(fd, (tail >= file_size) ? 0 : (file_size - tail), SEEK_SET);
+                } else {
+                        lseek(fd, ((head - tail) >= file_size) ? 0 : (head - tail), SEEK_SET);
+                }
+        } else
+                length = head;
+
         do {
-                bytes = read(fd, buff, blen);
+                bytes = read(fd, buff + copied_bytes, (
+                        (length != CAT_FULL_FILE && length - (off64_t)count <= (off64_t)(blen - copied_bytes)) ?
+                        (size_t)(length - count) :
+                        (blen - copied_bytes) ) );
+                bytes += copied_bytes;
+                copied_bytes = 0;
+
                 if (bytes > 0) {
-                        count += bytes;
                         buff[bytes] = '\0';
                         offset = 0;
@@ -193 +221 @@
                                         paged_char(hexchars[((uint8_t)buff[i])/16]);
                                         paged_char(hexchars[((uint8_t)buff[i])%16]);
+                                        paged_char(((count+i+1) & 0xf) == 0 ? '\n' : ' ');
                                 }
                                 else {
@@ -199 +228 @@
                                                 /* Reached end of string */
                                                 break;
+                                        } else if (c == U_SPECIAL && offset + 2 >= (size_t)bytes) {
+                                                /* If an extended character is cut off due to the size of the buffer,
+                                                   we will copy it over to the next buffer so it can be read correctly. */
+                                                copied_bytes = bytes - offset + 1;
+                                                memcpy(buff, buff + offset - 1, copied_bytes);
+                                                break;
                                         }
                                         paged_char(c);
@@ -204 +239 @@
                                 
                         }
+                        count += bytes;
                         reads++;
                 }
-        } while (bytes > 0 && !should_quit);
+        } while (bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
 
         close(fd);
@@ -223 +259 @@
 int cmd_cat(char **argv)
 {
-        unsigned int argc, i, ret = 0, buffer = 0;
+        unsigned int argc, i, ret = 0;
+        size_t buffer = 0;
         int c, opt_ind;
+        aoff64_t head = CAT_FULL_FILE, tail = CAT_FULL_FILE;
         bool hex = false;
         bool more = false;
+        bool tailFirst = false;
         sysarg_t rows, cols;
         int rc;
@@ -254 +293 @@
                         return CMD_SUCCESS;
                 case 'H':
-                        printf("%s", cat_oops);
-                        return CMD_FAILURE;
+                        if (!optarg || str_uint64_t(optarg, NULL, 10, false, &head) != EOK ) {
+                                puts("Invalid head size\n");
+                                return CMD_FAILURE;
+                        }
+                        break;
                 case 't':
-                        printf("%s", cat_oops);
-                        return CMD_FAILURE;
+                        if (!optarg || str_uint64_t(optarg, NULL, 10, false, &tail) != EOK ) {
+                                puts("Invalid tail size\n");
+                                return CMD_FAILURE;
+                        }
+                        if (head == CAT_FULL_FILE)
+                                tailFirst = true;
+                        break;
                 case 'b':
-                        printf("%s", cat_oops);
+                        if (!optarg || str_size_t(optarg, NULL, 10, false, &buffer) != EOK ) {
+                                puts("Invalid buffer size\n");
+                                return CMD_FAILURE;
+                        }
                         break;
                 case 'm':
@@ -279 +329 @@
         }
 
-        if (buffer <= 0)
+        if (buffer < 4)
                 buffer = CAT_DEFAULT_BUFLEN;
         
@@ -295 +345 @@
 
         for (i = optind; argv[i] != NULL && !should_quit; i++)
-                ret += cat_file(argv[i], buffer, hex);
+                ret += cat_file(argv[i], buffer, hex, head, tail, tailFirst);
 
         if (ret)

uspace/app/bdsh/cmds/modules/cat/cat.h

@@ -4 +4 @@
 /* Prototypes for the cat command, excluding entry points */
 
-static unsigned int cat_file(const char *, size_t, bool);
-
 #endif /* CAT_H */
 

uspace/app/bdsh/cmds/modules/cp/cp.c

@@ -30 +30 @@
 #include <stdlib.h>
 #include <unistd.h>
+#include <io/console.h>
+#include <io/keycode.h>
 #include <getopt.h>
 #include <str.h>
@@ -46 +48 @@
 
 static const char *cmdname = "cp";
+static console_ctrl_t *con;
 
 static struct option const long_options[] = {
         { "buffer", required_argument, 0, 'b' },
         { "force", no_argument, 0, 'f' },
+        { "interactive", no_argument, 0, 'i'},
         { "recursive", no_argument, 0, 'r' },
         { "help", no_argument, 0, 'h' },
@@ -139 +143 @@
 }
 
+static bool get_user_decision(bool bdefault, const char *message, ...)
+{
+        va_list args;
+
+        va_start(args, message);
+        vprintf(message, args);
+        va_end(args);
+
+        while (true) {
+                kbd_event_t ev;
+                console_flush(con);
+                console_get_kbd_event(con, &ev);
+                if ((ev.type != KEY_PRESS)
+                    || (ev.mods & (KM_CTRL | KM_ALT)) != 0) {
+                        continue;
+                }
+
+                switch(ev.key) {
+                case KC_Y:
+                        printf("y\n");
+                        return true;
+                case KC_N:
+                        printf("n\n");
+                        return false;
+                case KC_ENTER:
+                        printf("%c\n", bdefault ? 'Y' : 'N');
+                        return bdefault;
+                default:
+                        break;
+                }
+        }
+}
+
 static int64_t do_copy(const char *src, const char *dest,
-    size_t blen, int vb, int recursive, int force)
+    size_t blen, int vb, int recursive, int force, int interactive)
 {
         int r = -1;
@@ -192 +229 @@
                         /* e.g. cp file_name existing_file */
 
-                        /* dest already exists, if force is set we will
-                         * try to remove it.
+                        /* dest already exists, 
+                         * if force is set we will try to remove it.
+                         * if interactive is set user input is required.
                          */
-                        if (force) {
+                        if (force && !interactive) {
                                 if (unlink(dest_path)) {
                                         printf("Unable to remove %s\n",
@@ -201 +239 @@
                                         goto exit;
                                 }
+                        } else if (!force && interactive) {
+                                bool overwrite = get_user_decision(false,
+                                    "File already exists: %s. Overwrite? [y/N]: ",
+                                    dest_path);
+                                if (overwrite) {
+                                        printf("Overwriting file: %s\n", dest_path);
+                                        if (unlink(dest_path)) {
+                                                printf("Unable to remove %s\n", dest_path);
+                                                goto exit;
+                                        }
+                                } else {
+                                        printf("Not overwriting file: %s\n", dest_path);
+                                        r = 0;
+                                        goto exit;
+                                }
                         } else {
-                                printf("file already exists: %s\n", dest_path);
+                                printf("File already exists: %s\n", dest_path);
                                 goto exit;
                         }
@@ -302 +355 @@
                         /* Recursively call do_copy() */
                         r = do_copy(src_dent, dest_dent, blen, vb, recursive,
-                            force);
+                            force, interactive);
                         if (r)
                                 goto exit;
@@ -315 +368 @@
         return r;
 }
-
 
 static int64_t copy_file(const char *src, const char *dest,
@@ -380 +432 @@
             "  -v, --version    Print version information and exit\n"
             "  -V, --verbose    Be annoyingly noisy about what's being done\n"
-            "  -f, --force      Do not complain when <dest> exists\n"
+            "  -f, --force      Do not complain when <dest> exists (overrides a previous -i)\n"
+            "  -i, --interactive Ask what to do when <dest> exists (overrides a previous -f)\n"
             "  -r, --recursive  Copy entire directories\n"
             "  -b, --buffer ## Set the read buffer size to ##\n";
@@ -397 +450 @@
         unsigned int argc, verbose = 0;
         int buffer = 0, recursive = 0;
-        int force = 0;
+        int force = 0, interactive = 0;
         int c, opt_ind;
         int64_t ret;
 
+        con = console_init(stdin, stdout);
         argc = cli_count_args(argv);
 
         for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
-                c = getopt_long(argc, argv, "hvVfrb:", long_options, &opt_ind);
+                c = getopt_long(argc, argv, "hvVfirb:", long_options, &opt_ind);
                 switch (c) { 
                 case 'h':
@@ -416 +470 @@
                         break;
                 case 'f':
+                        interactive = 0;
                         force = 1;
+                        break;
+                case 'i':
+                        force = 0;
+                        interactive = 1;
                         break;
                 case 'r':
@@ -426 +485 @@
                                     "(should be a number greater than zero)\n",
                                     cmdname);
+                                console_done(con);
                                 return CMD_FAILURE;
                         }
@@ -442 +502 @@
                 printf("%s: invalid number of arguments. Try %s --help\n",
                     cmdname, cmdname);
+                console_done(con);
                 return CMD_FAILURE;
         }
 
         ret = do_copy(argv[optind], argv[optind + 1], buffer, verbose,
-            recursive, force);
+            recursive, force, interactive);
+
+        console_done(con);
 
         if (ret == 0)

uspace/app/bdsh/cmds/modules/help/help.h

@@ -3 +3 @@
 
 /* Prototypes for the help command (excluding entry points) */
-static int is_mod_or_builtin(char *);
 
 #endif

uspace/app/bdsh/cmds/modules/mkdir/mkdir.h

@@ -4 +4 @@
 /* Prototypes for the mkdir command, excluding entry points */
 
-static unsigned int create_directory(const char *, unsigned int);
 #endif /* MKDIR_H */
 

uspace/app/bdsh/cmds/modules/printf/TODO

@@ -11 +11 @@
  * Add width/precision options for number printings
  * Add more format flags (%f %b ...)
+ 

uspace/app/bdsh/cmds/modules/printf/printf.c

@@ -47 +47 @@
                 help_cmd_printf(HELP_SHORT);
                 printf(
-                "Usage:  %s FORMAT [ARGS ...] \n"
-                "Prints ARGS according to FORMAT. Number of expected arguments in\n"
-                "FORMAT must be equals to the number of ARGS. Currently supported\n"
-                "format flags are:\n",
-                cmdname);
+                    "Usage:  %s FORMAT [ARGS ...] \n"
+                    "Prints ARGS according to FORMAT. Number of expected arguments in\n"
+                    "FORMAT must be equals to the number of ARGS. Currently supported\n"
+                    "format flags are:\n",
+                    cmdname);
         }
 
@@ -172 +172 @@
                         break;
 
-                emit:           putchar(ch);
-                                esc_flag = false;
+                emit:
+                        putchar(ch);
+                        esc_flag = false;
                 }
         }       

uspace/app/bdsh/cmds/modules/rm/rm.c

@@ -46 +46 @@
 #define RM_VERSION "0.0.1"
 
-static rm_job_t rm;
-
 static struct option const long_options[] = {
         { "help", no_argument, 0, 'h' },
@@ -57 +55 @@
 };
 
+/* Return values for rm_scope() */
+#define RM_BOGUS 0
+#define RM_FILE  1
+#define RM_DIR   2
+
+/* Flags for rm_update() */
+#define _RM_ENTRY   0
+#define _RM_ADVANCE 1
+#define _RM_REWIND  2
+#define _RM_EXIT    3
+
+/* A simple job structure */
+typedef struct {
+        /* Options set at run time */
+        unsigned int force;      /* -f option */
+        unsigned int recursive;  /* -r option */
+        unsigned int safe;       /* -s option */
+
+        /* Keeps track of the job in progress */
+        int advance; /* How far deep we've gone since entering */
+        DIR *entry;  /* Entry point to the tree being removed */
+        char *owd;   /* Where we were when we invoked rm */
+        char *cwd;   /* Current directory being transversed */
+        char *nwd;   /* Next directory to be transversed */
+
+        /* Counters */
+        int f_removed; /* Number of files unlinked */
+        int d_removed; /* Number of directories unlinked */
+} rm_job_t;
+
+static rm_job_t rm;
+
+static unsigned int rm_recursive(const char *);
+
 static unsigned int rm_start(rm_job_t *rm)
 {
@@ -95 +127 @@
         if (NULL != rm->cwd)
                 free(rm->cwd);
+}
+
+static unsigned int rm_single(const char *path)
+{
+        if (unlink(path)) {
+                cli_error(CL_EFAIL, "rm: could not remove file %s", path);
+                return 1;
+        }
+        return 0;
+}
+
+static unsigned int rm_scope(const char *path)
+{
+        int fd;
+        DIR *dirp;
+
+        dirp = opendir(path);
+        if (dirp) {
+                closedir(dirp);
+                return RM_DIR;
+        }
+
+        fd = open(path, O_RDONLY);
+        if (fd > 0) {
+                close(fd);
+                return RM_FILE;
+        }
+
+        return RM_BOGUS;
 }
 
@@ -154 +215 @@
 
         return ret + 1;
-}
-
-static unsigned int rm_single(const char *path)
-{
-        if (unlink(path)) {
-                cli_error(CL_EFAIL, "rm: could not remove file %s", path);
-                return 1;
-        }
-        return 0;
-}
-
-static unsigned int rm_scope(const char *path)
-{
-        int fd;
-        DIR *dirp;
-
-        dirp = opendir(path);
-        if (dirp) {
-                closedir(dirp);
-                return RM_DIR;
-        }
-
-        fd = open(path, O_RDONLY);
-        if (fd > 0) {
-                close(fd);
-                return RM_FILE;
-        }
-
-        return RM_BOGUS;
 }
 

uspace/app/bdsh/cmds/modules/rm/rm.h

@@ -2 +2 @@
 #define RM_H
 
-/* Return values for rm_scope() */
-#define RM_BOGUS 0
-#define RM_FILE  1
-#define RM_DIR   2
-
-/* Flags for rm_update() */
-#define _RM_ENTRY   0
-#define _RM_ADVANCE 1
-#define _RM_REWIND  2
-#define _RM_EXIT    3
-
-/* A simple job structure */
-typedef struct {
-        /* Options set at run time */
-        unsigned int force;      /* -f option */
-        unsigned int recursive;  /* -r option */
-        unsigned int safe;       /* -s option */
-
-        /* Keeps track of the job in progress */
-        int advance; /* How far deep we've gone since entering */
-        DIR *entry;  /* Entry point to the tree being removed */
-        char *owd;   /* Where we were when we invoked rm */
-        char *cwd;   /* Current directory being transversed */
-        char *nwd;   /* Next directory to be transversed */
-
-        /* Counters */
-        int f_removed; /* Number of files unlinked */
-        int d_removed; /* Number of directories unlinked */
-} rm_job_t;
-
-
 /* Prototypes for the rm command, excluding entry points */
-static unsigned int rm_start(rm_job_t *);
-static void rm_end(rm_job_t *rm);
-static unsigned int rm_recursive(const char *);
-static unsigned int rm_single(const char *);
-static unsigned int rm_scope(const char *);
 
 #endif /* RM_H */

uspace/app/bdsh/cmds/modules/sleep/sleep.c

@@ -27 +27 @@
  */
 
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 #include "config.h"
 #include "util.h"
@@ -41 +43 @@
 void help_cmd_sleep(unsigned int level)
 {
-        printf("This is the %s help for '%s'.\n",
-                level ? EXT_HELP : SHORT_HELP, cmdname);
+        if (level == HELP_SHORT) {
+                printf("`%s' pauses for a given time interval\n", cmdname);
+        } else {
+                help_cmd_sleep(HELP_SHORT);
+                printf(
+                    "Usage:  %s <duration>\n"
+                    "The duration is a decimal number of seconds.\n",
+                    cmdname);
+        }
+
         return;
+}
+
+/** Convert string containing decimal seconds to useconds_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param result Result of the conversion.
+ * @return EOK if conversion was successful.
+ */
+static int decimal_to_useconds(const char *nptr, useconds_t *result)
+{
+        int ret;
+        uint64_t whole_seconds;
+        uint64_t frac_seconds;
+        char *endptr;
+
+        /* Check for whole seconds */
+        if (*nptr == '.') {
+                whole_seconds = 0;
+                endptr = (char *)nptr;
+        } else {
+                ret = str_uint64_t(nptr, &endptr, 10, false, &whole_seconds);
+                if (ret != EOK)
+                        return ret;
+        }
+
+        /* Check for fractional seconds */
+        if (*endptr == '\0') {
+                frac_seconds = 0;
+        } else if (*endptr == '.' && endptr[1] == '\0') {
+                frac_seconds = 0;
+        } else if (*endptr == '.') {
+                nptr = endptr + 1;
+                ret = str_uint64_t(nptr, &endptr, 10, true, &frac_seconds);
+                if (ret != EOK)
+                        return ret;
+
+                int ndigits = endptr - nptr;
+                for (; ndigits < 6; ndigits++) 
+                        frac_seconds *= 10;
+                for (; ndigits > 6; ndigits--)
+                        frac_seconds /= 10;
+        } else {
+                return EINVAL;
+        }
+
+        /* Check for overflow */
+        useconds_t total = whole_seconds * 1000000 + frac_seconds;
+        if (total / 1000000 != whole_seconds)
+                return EOVERFLOW;
+
+        *result = total;
+
+        return EOK;
 }
 
@@ -49 +112 @@
 int cmd_sleep(char **argv)
 {
+        int ret;
         unsigned int argc;
-        unsigned int i;
+        useconds_t duration;
 
         /* Count the arguments */
-        for (argc = 0; argv[argc] != NULL; argc ++);
+        argc = cli_count_args(argv);
 
-        printf("%s %s\n", TEST_ANNOUNCE, cmdname);
-        printf("%d arguments passed to %s", argc - 1, cmdname);
-
-        if (argc < 2) {
-                printf("\n");
-                return CMD_SUCCESS;
+        if (argc != 2) {
+                printf("%s - incorrect number of arguments. Try `help %s'\n",
+                    cmdname, cmdname);
+                return CMD_FAILURE;
         }
 
-        printf(":\n");
-        for (i = 1; i < argc; i++)
-                printf("[%d] -> %s\n", i, argv[i]);
+        ret = decimal_to_useconds(argv[1], &duration);
+        if (ret != EOK) {
+                printf("%s - invalid duration.\n", cmdname);
+                return CMD_FAILURE;
+        }
+
+        (void) usleep(duration);
 
         return CMD_SUCCESS;

uspace/app/sportdmp/sportdmp.c

@@ -27 +27 @@
  */
 
+#include <device/char_dev.h>
 #include <errno.h>
+#include <ipc/serial_ctl.h>
+#include <loc.h>
 #include <stdio.h>
-#include <devman.h>
-#include <ipc/devman.h>
-#include <device/char_dev.h>
-#include <ipc/serial_ctl.h>
 
 #define BUF_SIZE 1
 
-static void syntax_print() {
-        fprintf(stderr, "Usage: sportdmp <baud> <device_path>\n");
+static void syntax_print(void)
+{
+        fprintf(stderr, "Usage: sportdmp <baud> <device_service>\n");
 }
 
 int main(int argc, char **argv)
 {
-        const char* devpath = "/hw/pci0/00:01.0/com1/a";
+        const char* svc_path = "devices/\\hw\\pci0\\00:01.0\\com1\\a";
         sysarg_t baud = 9600;
         
@@ -56 +56 @@
         
         if (argc > 2) {
-                devpath = argv[2];
+                svc_path = argv[2];
         }
         
@@ -64 +64 @@
         }
         
-        devman_handle_t device;
-        int rc = devman_fun_get_handle(devpath, &device, IPC_FLAG_BLOCKING);
+        service_id_t svc_id;
+        int rc = loc_service_get_id(svc_path, &svc_id, IPC_FLAG_BLOCKING);
         if (rc != EOK) {
-                fprintf(stderr, "Cannot open device %s\n", devpath);
+                fprintf(stderr, "Cannot find device service %s\n", svc_path);
                 return 1;
         }
         
-        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, device,
+        async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
             IPC_FLAG_BLOCKING);
         if (!sess) {
-                fprintf(stderr, "Cannot connect device\n");
+                fprintf(stderr, "Failed connecting to service %s\n", svc_path);
         }
         
@@ -83 +83 @@
         
         if (rc != EOK) {
-                fprintf(stderr, "Cannot set serial properties\n");
+                fprintf(stderr, "Failed setting serial properties\n");
                 return 2;
         }
@@ -89 +89 @@
         uint8_t *buf = (uint8_t *) malloc(BUF_SIZE);
         if (buf == NULL) {
-                fprintf(stderr, "Cannot allocate buffer\n");
+                fprintf(stderr, "Failed allocating buffer\n");
                 return 3;
         }

uspace/app/tester/hw/serial/serial1.c

@@ -42 +42 @@
 #include <async.h>
 #include <ipc/services.h>
-#include <ipc/devman.h>
-#include <devman.h>
+#include <loc.h>
 #include <device/char_dev.h>
 #include <str.h>
@@ -71 +70 @@
                 }
         
-        devman_handle_t handle;
-        int res = devman_fun_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
-            IPC_FLAG_BLOCKING);
+        service_id_t svc_id;
+        int res = loc_service_get_id("devices/\\hw\\pci0\\00:01.0\\com1\\a",
+            &svc_id, IPC_FLAG_BLOCKING);
         if (res != EOK)
-                return "Could not get serial device handle";
-        
-        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
+                return "Failed getting serial port service ID";
+        
+        async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
             IPC_FLAG_BLOCKING);
         if (!sess)
-                return "Unable to connect to serial device";
+                return "Failed connecting to serial device";
         
         char *buf = (char *) malloc(cnt + 1);
         if (buf == NULL) {
                 async_hangup(sess);
-                return "Failed to allocate input buffer";
+                return "Failed allocating input buffer";
         }
         
@@ -112 +111 @@
                 free(buf);
                 async_hangup(sess);
-                return "Failed to set serial communication parameters";
-        }
-        
-        TPRINTF("Trying to read %zu characters from serial device "
-            "(handle=%" PRIun ")\n", cnt, handle);
+                return "Failed setting serial communication parameters";
+        }
+        
+        TPRINTF("Trying reading %zu characters from serial device "
+            "(svc_id=%" PRIun ")\n", cnt, svc_id);
         
         size_t total = 0;
@@ -130 +129 @@
                         free(buf);
                         async_hangup(sess);
-                        return "Failed read from serial device";
+                        return "Failed reading from serial device";
                 }
                 
@@ -165 +164 @@
                                 free(buf);
                                 async_hangup(sess);
-                                return "Failed write to serial device";
+                                return "Failed writing to serial device";
                         }
                         

uspace/app/websrv/websrv.c

@@ -200 +200 @@
 {
         if (str_cmp(uri, "/") == 0)
-                uri = "/index.htm";
+                uri = "/index.html";
         
         char *fname;

uspace/drv/bus/isa/isa.c

@@ -66 +66 @@
 #include <ops/hw_res.h>
 
-#include <devman.h>
-#include <ipc/devman.h>
 #include <device/hw_res.h>
 

uspace/drv/bus/usb/uhcirh/port.c

@@ -37 +37 @@
 #include <str_error.h>
 #include <async.h>
-#include <devman.h>
 
 #include <usb/usb.h>    /* usb_address_t */

uspace/drv/bus/usb/usbhub/port.c

@@ -35 +35 @@
 
 #include <bool.h>
-#include <devman.h>
 #include <errno.h>
 #include <str_error.h>

uspace/drv/char/ns8250/ns8250.c

@@ -74 +74 @@
 #define DLAB_MASK (1 << 7)
 
+/** Interrupt Enable Register definition. */
+#define NS8250_IER_RXREADY      (1 << 0)
+#define NS8250_IER_THRE         (1 << 1)
+#define NS8250_IER_RXSTATUS     (1 << 2)
+#define NS8250_IER_MODEM_STATUS (1 << 3)
+
+/** Interrupt ID Register definition. */
+#define NS8250_IID_ACTIVE       (1 << 0)
+
+/** FIFO Control Register definition. */
+#define NS8250_FCR_FIFOENABLE   (1 << 0)
+#define NS8250_FCR_RXFIFORESET  (1 << 1)
+#define NS8250_FCR_TXFIFORESET  (1 << 2)
+#define NS8250_FCR_DMAMODE      (1 << 3)
+#define NS8250_FCR_RXTRIGGERLOW (1 << 6)
+#define NS8250_FCR_RXTRIGGERHI  (1 << 7)
+
+/** Line Control Register definition. */
+#define NS8250_LCR_STOPBITS     (1 << 2)
+#define NS8250_LCR_PARITY       (1 << 3)
+#define NS8250_LCR_SENDBREAK    (1 << 6)
+#define NS8250_LCR_DLAB         (1 << 7)
+
+/** Modem Control Register definition. */
+#define NS8250_MCR_DTR          (1 << 0)
+#define NS8250_MCR_RTS          (1 << 1)
+#define NS8250_MCR_OUT1         (1 << 2)
+#define NS8250_MCR_OUT2         (1 << 3)
+#define NS8250_MCR_LOOPBACK     (1 << 4)
+#define NS8250_MCR_ALL          (0x1f)
+
+/** Line Status Register definition. */
+#define NS8250_LSR_RXREADY      (1 << 0)
+#define NS8250_LSR_OE           (1 << 1)
+#define NS8250_LSR_PE           (1 << 2)
+#define NS8250_LSR_FE           (1 << 3)
+#define NS8250_LSR_BREAK        (1 << 4)
+#define NS8250_LSR_THRE         (1 << 5)
+#define NS8250_LSR_TSE          (1 << 6)
+
+/** Modem Status Register definition. */
+#define NS8250_MSR_DELTACTS     (1 << 0)
+#define NS8250_MSR_DELTADSR     (1 << 1)
+#define NS8250_MSR_RITRAILING   (1 << 2)
+#define NS8250_MSR_DELTADCD     (1 << 3)
+#define NS8250_MSR_CTS          (1 << 4)
+#define NS8250_MSR_DSR          (1 << 5)
+#define NS8250_MSR_RI           (1 << 6)
+#define NS8250_MSR_DCD          (1 << 7)
+#define NS8250_MSR_SIGNALS      (NS8250_MSR_CTS | NS8250_MSR_DSR \
+    | NS8250_MSR_RI | NS8250_MSR_DCD)
+
 /** Obtain soft-state structure from function node */
 #define NS8250(fnode) ((ns8250_t *) ((fnode)->dev->driver_data))
@@ -96 +148 @@
 } stop_bit_t;
 
+/** 8250 UART registers layout. */
+typedef struct {
+        ioport8_t data;         /**< Data register. */
+        ioport8_t ier;          /**< Interrupt Enable Reg. */
+        ioport8_t iid;          /**< Interrupt ID Reg. */
+        ioport8_t lcr;          /**< Line Control Reg. */
+        ioport8_t mcr;          /**< Modem Control Reg. */
+        ioport8_t lsr;          /**< Line Status Reg. */
+        ioport8_t msr;          /**< Modem Status Reg. */
+} ns8250_regs_t;
+
 /** The driver data for the serial port devices. */
 typedef struct ns8250 {
@@ -102 +165 @@
         /** DDF function node */
         ddf_fun_t *fun;
+        /** I/O registers **/
+        ns8250_regs_t *regs;
         /** Is there any client conntected to the device? */
         bool client_connected;
@@ -124 +189 @@
  *                      otherwise.
  */
-static bool ns8250_received(ioport8_t *port)
-{
-        return (pio_read_8(port + 5) & 1) != 0;
+static bool ns8250_received(ns8250_regs_t *regs)
+{
+        return (pio_read_8(&regs->lsr) & NS8250_LSR_RXREADY) != 0;
 }
 
@@ -134 +199 @@
  * @return              The data read.
  */
-static uint8_t ns8250_read_8(ioport8_t *port)
-{
-        return pio_read_8(port);
+static uint8_t ns8250_read_8(ns8250_regs_t *regs)
+{
+        return pio_read_8(&regs->data);
 }
 
@@ -143 +208 @@
  * @param port          The base address of the serial port device's ports.
  */
-static bool is_transmit_empty(ioport8_t *port)
-{
-        return (pio_read_8(port + 5) & 0x20) != 0;
+static bool is_transmit_empty(ns8250_regs_t *regs)
+{
+        return (pio_read_8(&regs->lsr) & NS8250_LSR_THRE) != 0;
 }
 
@@ -153 +218 @@
  * @param c             The character to be written to the serial port device.
  */
-static void ns8250_write_8(ioport8_t *port, uint8_t c)
-{
-        while (!is_transmit_empty(port))
+static void ns8250_write_8(ns8250_regs_t *regs, uint8_t c)
+{
+        while (!is_transmit_empty(regs))
                 ;
         
-        pio_write_8(port, c);
+        pio_write_8(&regs->data, c);
 }
 
@@ -193 +258 @@
 {
         fibril_mutex_lock(&ns->mutex);
-        ns8250_write_8(ns->port, c);
+        ns8250_write_8(ns->regs, c);
         fibril_mutex_unlock(&ns->mutex);
 }
@@ -212 +277 @@
                 ns8250_putchar(ns, (uint8_t) buf[idx]);
         
-        return 0;
+        return count;
 }
 
@@ -266 +331 @@
                 return false;
         }
+
+        ns->regs = (ns8250_regs_t *)ns->port;
         
         return true;
@@ -279 +346 @@
         ddf_msg(LVL_DEBUG, "ns8250_dev_probe %s", ns->dev->name);
         
-        ioport8_t *port_addr = ns->port;
         bool res = true;
         uint8_t olddata;
         
-        olddata = pio_read_8(port_addr + 4);
-        
-        pio_write_8(port_addr + 4, 0x10);
-        if (pio_read_8(port_addr + 6) & 0xf0)
+        olddata = pio_read_8(&ns->regs->mcr);
+        
+        pio_write_8(&ns->regs->mcr, NS8250_MCR_LOOPBACK);
+        if (pio_read_8(&ns->regs->msr) & NS8250_MSR_SIGNALS)
                 res = false;
         
-        pio_write_8(port_addr + 4, 0x1f);
-        if ((pio_read_8(port_addr + 6) & 0xf0) != 0xf0)
+        pio_write_8(&ns->regs->mcr, NS8250_MCR_ALL);
+        if ((pio_read_8(&ns->regs->msr) & NS8250_MSR_SIGNALS) 
+            != NS8250_MSR_SIGNALS)
                 res = false;
         
-        pio_write_8(port_addr + 4, olddata);
+        pio_write_8(&ns->regs->mcr, olddata);
         
         if (!res) {
@@ -390 +457 @@
  * @param port          The base address of the serial port device's ports.
  */
-static inline void ns8250_port_interrupts_enable(ioport8_t *port)
-{
-        pio_write_8(port + 1, 0x1);     /* Interrupt when data received. */
-        pio_write_8(port + 4, 0xB);
+static inline void ns8250_port_interrupts_enable(ns8250_regs_t *regs)
+{
+        /* Interrupt when data received. */
+        pio_write_8(&regs->ier, NS8250_IER_RXREADY);
+        pio_write_8(&regs->mcr, NS8250_MCR_DTR | NS8250_MCR_RTS 
+            | NS8250_MCR_OUT2);
 }
 
@@ -400 +469 @@
  * @param port          The base address of the serial port device's ports
  */
-static inline void ns8250_port_interrupts_disable(ioport8_t *port)
-{
-        pio_write_8(port + 1, 0x0);     /* Disable all interrupts. */
+static inline void ns8250_port_interrupts_disable(ns8250_regs_t *regs)
+{
+        pio_write_8(&regs->ier, 0x0);   /* Disable all interrupts. */
 }
 
@@ -431 +500 @@
 
         /* Enable interrupt on the serial port. */
-        ns8250_port_interrupts_enable(ns->port);
+        ns8250_port_interrupts_enable(ns->regs);
         
         return EOK;
@@ -443 +512 @@
  * @param port          The base address of the serial port device's ports.
  */
-static inline void enable_dlab(ioport8_t *port)
-{
-        uint8_t val = pio_read_8(port + 3);
-        pio_write_8(port + 3, val | DLAB_MASK);
+static inline void enable_dlab(ns8250_regs_t *regs)
+{
+        uint8_t val = pio_read_8(&regs->lcr);
+        pio_write_8(&regs->lcr, val | NS8250_LCR_DLAB);
 }
 
@@ -453 +522 @@
  * @param port          The base address of the serial port device's ports.
  */
-static inline void clear_dlab(ioport8_t *port)
-{
-        uint8_t val = pio_read_8(port + 3);
-        pio_write_8(port + 3, val & (~DLAB_MASK));
+static inline void clear_dlab(ns8250_regs_t *regs)
+{
+        uint8_t val = pio_read_8(&regs->lcr);
+        pio_write_8(&regs->lcr, val & (~NS8250_LCR_DLAB));
 }
 
@@ -466 +535 @@
  *                      if the specified baud_rate is not valid).
  */
-static int ns8250_port_set_baud_rate(ioport8_t *port, unsigned int baud_rate)
+static int ns8250_port_set_baud_rate(ns8250_regs_t *regs, unsigned int baud_rate)
 {
         uint16_t divisor;
@@ -482 +551 @@
         
         /* Enable DLAB to be able to access baud rate divisor. */
-        enable_dlab(port);
+        enable_dlab(regs);
         
         /* Set divisor low byte. */
-        pio_write_8(port + 0, div_low);
+        pio_write_8(&regs->data, div_low);
         /* Set divisor high byte. */
-        pio_write_8(port + 1, div_high);
-        
-        clear_dlab(port);
+        pio_write_8(&regs->ier, div_high);
+        
+        clear_dlab(regs);
         
         return EOK;
@@ -499 +568 @@
  * @param baud_rate     The ouput parameter to which the baud rate is stored.
  */
-static unsigned int ns8250_port_get_baud_rate(ioport8_t *port)
+static unsigned int ns8250_port_get_baud_rate(ns8250_regs_t *regs)
 {
         uint16_t divisor;
@@ -505 +574 @@
         
         /* Enable DLAB to be able to access baud rate divisor. */
-        enable_dlab(port);
+        enable_dlab(regs);
         
         /* Get divisor low byte. */
-        div_low = pio_read_8(port + 0);
+        div_low = pio_read_8(&regs->data);
         /* Get divisor high byte. */
-        div_high = pio_read_8(port + 1);
-        
-        clear_dlab(port);
+        div_high = pio_read_8(&regs->ier);
+        
+        clear_dlab(regs);
         
         divisor = (div_high << 8) | div_low;
@@ -525 +594 @@
  * @param stop_bits     The number of stop bits used (one or two).
  */
-static void ns8250_port_get_com_props(ioport8_t *port, unsigned int *parity,
+static void ns8250_port_get_com_props(ns8250_regs_t *regs, unsigned int *parity,
     unsigned int *word_length, unsigned int *stop_bits)
 {
         uint8_t val;
         
-        val = pio_read_8(port + 3);
-        *parity = ((val >> 3) & 7);
+        val = pio_read_8(&regs->lcr);
+        *parity = ((val >> NS8250_LCR_PARITY) & 7);
         
         switch (val & 3) {
@@ -548 +617 @@
         }
         
-        if ((val >> 2) & 1)
+        if ((val >> NS8250_LCR_STOPBITS) & 1)
                 *stop_bits = 2;
         else
@@ -562 +631 @@
  *                      is invalid.
  */
-static int ns8250_port_set_com_props(ioport8_t *port, unsigned int parity,
+static int ns8250_port_set_com_props(ns8250_regs_t *regs, unsigned int parity,
     unsigned int word_length, unsigned int stop_bits)
 {
@@ -586 +655 @@
         switch (stop_bits) {
         case 1:
-                val |= ONE_STOP_BIT << 2;
+                val |= ONE_STOP_BIT << NS8250_LCR_STOPBITS;
                 break;
         case 2:
-                val |= TWO_STOP_BITS << 2;
+                val |= TWO_STOP_BITS << NS8250_LCR_STOPBITS;
                 break;
         default:
@@ -601 +670 @@
         case SERIAL_MARK_PARITY:
         case SERIAL_SPACE_PARITY:
-                val |= parity << 3;
+                val |= parity << NS8250_LCR_PARITY;
                 break;
         default:
@@ -607 +676 @@
         }
         
-        pio_write_8(port + 3, val);
+        pio_write_8(&regs->lcr, val);
         
         return EOK;
@@ -620 +689 @@
 static void ns8250_initialize_port(ns8250_t *ns)
 {
-        ioport8_t *port = ns->port;
-        
         /* Disable interrupts. */
-        ns8250_port_interrupts_disable(port);
+        ns8250_port_interrupts_disable(ns->regs);
         /* Set baud rate. */
-        ns8250_port_set_baud_rate(port, 38400);
+        ns8250_port_set_baud_rate(ns->regs, 38400);
         /* 8 bits, no parity, two stop bits. */
-        ns8250_port_set_com_props(port, SERIAL_NO_PARITY, 8, 2);
+        ns8250_port_set_com_props(ns->regs, SERIAL_NO_PARITY, 8, 2);
         /* Enable FIFO, clear them, with 14-byte threshold. */
-        pio_write_8(port + 2, 0xC7);
+        pio_write_8(&ns->regs->iid, NS8250_FCR_FIFOENABLE
+            | NS8250_FCR_RXFIFORESET | NS8250_FCR_TXFIFORESET 
+            | NS8250_FCR_RXTRIGGERLOW | NS8250_FCR_RXTRIGGERHI);
         /*
          * RTS/DSR set (Request to Send and Data Terminal Ready lines enabled),
          * Aux Output2 set - needed for interrupts.
          */
-        pio_write_8(port + 4, 0x0B);
+        pio_write_8(&ns->regs->mcr, NS8250_MCR_DTR | NS8250_MCR_RTS
+            | NS8250_MCR_OUT2);
 }
 
@@ -644 +714 @@
 {
         /* Disable FIFO */
-        pio_write_8(ns->port + 2, 0x00);
+        pio_write_8(&ns->regs->iid, 0x00);
         /* Disable DTR, RTS, OUT1, OUT2 (int. enable) */
-        pio_write_8(ns->port + 4, 0x00);
+        pio_write_8(&ns->regs->mcr, 0x00);
         /* Disable all interrupts from the port */
-        ns8250_port_interrupts_disable(ns->port);
+        ns8250_port_interrupts_disable(ns->regs);
 }
 
@@ -658 +728 @@
 static void ns8250_read_from_device(ns8250_t *ns)
 {
-        ioport8_t *port = ns->port;
+        ns8250_regs_t *regs = ns->regs;
         bool cont = true;
         
@@ -664 +734 @@
                 fibril_mutex_lock(&ns->mutex);
                 
-                cont = ns8250_received(port);
+                cont = ns8250_received(regs);
                 if (cont) {
-                        uint8_t val = ns8250_read_8(port);
+                        uint8_t val = ns8250_read_8(regs);
                         
                         if (ns->client_connected) {
@@ -896 +966 @@
 {
         ns8250_t *data = (ns8250_t *) dev->driver_data;
-        ioport8_t *port = data->port;
+        ns8250_regs_t *regs = data->regs;
         
         fibril_mutex_lock(&data->mutex);
-        ns8250_port_interrupts_disable(port);
-        *baud_rate = ns8250_port_get_baud_rate(port);
-        ns8250_port_get_com_props(port, parity, word_length, stop_bits);
-        ns8250_port_interrupts_enable(port);
+        ns8250_port_interrupts_disable(regs);
+        *baud_rate = ns8250_port_get_baud_rate(regs);
+        ns8250_port_get_com_props(regs, parity, word_length, stop_bits);
+        ns8250_port_interrupts_enable(regs);
         fibril_mutex_unlock(&data->mutex);
         
@@ -927 +997 @@
         
         ns8250_t *data = (ns8250_t *) dev->driver_data;
-        ioport8_t *port = data->port;
+        ns8250_regs_t *regs = data->regs;
         int ret;
         
         fibril_mutex_lock(&data->mutex);
-        ns8250_port_interrupts_disable(port);
-        ret = ns8250_port_set_baud_rate(port, baud_rate);
+        ns8250_port_interrupts_disable(regs);
+        ret = ns8250_port_set_baud_rate(regs, baud_rate);
         if (ret == EOK)
-                ret = ns8250_port_set_com_props(port, parity, word_length, stop_bits);
-        ns8250_port_interrupts_enable(port);
+                ret = ns8250_port_set_com_props(regs, parity, word_length, stop_bits);
+        ns8250_port_interrupts_enable(regs);
         fibril_mutex_unlock(&data->mutex);
         

uspace/drv/char/ps2mouse/main.c

@@ -35 +35 @@
 #include <libarch/inttypes.h>
 #include <ddf/driver.h>
-#include <devman.h>
 #include <device/hw_res_parsed.h>
 #include <errno.h>

uspace/drv/char/xtkbd/main.c

@@ -35 +35 @@
 #include <libarch/inttypes.h>
 #include <ddf/driver.h>
-#include <devman.h>
 #include <device/hw_res_parsed.h>
 #include <errno.h>

uspace/drv/infrastructure/root/root.c

@@ -53 +53 @@
 #include <ddf/driver.h>
 #include <ddf/log.h>
-#include <devman.h>
-#include <ipc/devman.h>
 
 #define NAME "root"

uspace/drv/infrastructure/rootpc/rootpc.c

@@ -48 +48 @@
 #include <ddf/driver.h>
 #include <ddf/log.h>
-#include <devman.h>
-#include <ipc/devman.h>
 #include <ipc/dev_iface.h>
 #include <ops/hw_res.h>

uspace/drv/nic/e1k/e1k.c

@@ -46 +46 @@
 #include <ddf/log.h>
 #include <ddf/interrupt.h>
-#include <devman.h>
 #include <device/hw_res_parsed.h>
 #include <device/pci.h>

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

@@ -58 +58 @@
 static async_sess_t *vfs_sess = NULL;
 
+/* Current (working) directory. */
 static FIBRIL_MUTEX_INITIALIZE(cwd_mutex);
-
 static int cwd_fd = -1;
 static char *cwd_path = NULL;
 static size_t cwd_size = 0;
+
+/* Previous directory. */
+static FIBRIL_MUTEX_INITIALIZE(pwd_mutex);
+static int pwd_fd = -1;
+static char *pwd_path = NULL;
+static size_t pwd_size = 0;
+
 
 /** Start an async exchange on the VFS session.
@@ -751 +758 @@
         fibril_mutex_lock(&cwd_mutex);
         
-        if (cwd_fd >= 0)
-                close(cwd_fd);
-        
-        
-        if (cwd_path)
-                free(cwd_path);
-        
+
+        fibril_mutex_lock(&pwd_mutex);
+
+        if (pwd_fd >= 0)
+                close(pwd_fd);
+
+
+        if (pwd_path)
+                free(pwd_path);
+
+
+        pwd_fd = cwd_fd;
+        pwd_path = cwd_path;
+        pwd_size = cwd_size;
+
+        fibril_mutex_unlock(&pwd_mutex);
+
         cwd_fd = fd;
         cwd_path = abs;
@@ -781 +798 @@
         fibril_mutex_unlock(&cwd_mutex);
         
+        return buf;
+}
+
+
+char *getprevwd(char *buf, size_t size)
+{
+        if (size == 0)
+                return NULL;
+
+        fibril_mutex_lock(&pwd_mutex);
+
+        if ((pwd_size == 0) || (size < pwd_size + 1)) {
+                fibril_mutex_unlock(&pwd_mutex);
+                return NULL;
+        }
+
+        str_cpy(buf, size, pwd_path);
+        fibril_mutex_unlock(&pwd_mutex);
+
         return buf;
 }

uspace/lib/c/include/unistd.h

@@ -58 +58 @@
 #define getpagesize()  (PAGE_SIZE)
 
-extern int dup2(int oldfd, int newfd);
+extern int dup2(int, int);
 
 extern ssize_t write(int, const void *, size_t);
@@ -73 +73 @@
 extern int unlink(const char *);
 
-extern char *getcwd(char *buf, size_t);
+extern char *getcwd(char *, size_t);
+extern char *getprevwd(char *, size_t);
 extern int rmdir(const char *);
 extern int chdir(const char *);

uspace/lib/net/generic/net_remote.c

@@ -40 +40 @@
 #include <malloc.h>
 #include <async.h>
-#include <devman.h>
 #include <generic.h>
 #include <net/modules.h>

uspace/lib/usb/src/ddfiface.c

@@ -33 +33 @@
  * Implementations of DDF interfaces functions (actual implementation).
  */
-#include <ipc/devman.h>
 #include <devman.h>
 #include <async.h>

uspace/lib/usbvirt/src/ipc_dev.c

@@ -38 +38 @@
 #include <assert.h>
 #include <async.h>
-#include <devman.h>
 #include <usbvirt/device.h>
 #include <usbvirt/ipc.h>

uspace/lib/usbvirt/src/ipc_hc.c

@@ -38 +38 @@
 #include <assert.h>
 #include <async.h>
-#include <devman.h>
 #include <usbvirt/device.h>
 #include <usbvirt/ipc.h>