Changes in / [081d60f:1dbe465] in mainline

Files:

• tools/check.sh (modified) (1 diff)
• tools/mkfat.py (modified) (3 diffs)
• 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/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/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)) :
+        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 +289 @@
                 dir_entry.size = size
         
-        return dir_entry
+
+        if not lfn:
+                return [dir_entry]
+
+        n = 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 = 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 +369 @@
                 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):

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 */
 
-
 #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/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>