Changes in / [fb8dcb4:063ae706] in mainline


Ignore:
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • tools/check.sh

    rfb8dcb4 r063ae706  
    6666do
    6767        echo -n ">>>> Building $P... "
    68         ( make distclean && make PROFILE=$P HANDS_OFF=y "$@" ) >>/dev/null 2>>/dev/null
     68        ( make distclean && make PROFILE=$P HANDS_OFF=y $1 ) >>/dev/null 2>>/dev/null
    6969        if [ $? -ne 0 ];
    7070        then

  • tools/mkfat.py

    rfb8dcb4 r063ae706  
    168168"""
    169169
    170 LFN_ENTRY = """little:
    171         uint8_t pos
    172         uint16_t name1[5]
    173         uint8_t attr
    174         uint8_t type
    175         uint8_t csum
    176         uint16_t name2[6]
    177         uint16_t fc
    178         uint16_t name3[2]
    179 """
    180 
    181 # Global variable to hold the file names in 8.3 format. Needed to
    182 # keep track of "number" when creating a short fname from a LFN.
    183 name83_list = []
    184 
    185 def name83(fname):
    186         "Create a 8.3 name for the given fname"
    187 
     170def mangle_fname(name):
    188171        # FIXME: filter illegal characters
    189         parts = fname.split('.')
    190        
    191         name = ''
    192         ext = ''
    193         lfn = False
    194 
    195         if len(fname) > 11 :
    196                 lfn = True
    197 
     172        parts = name.split('.')
     173       
    198174        if len(parts) > 0:
    199                 name = parts[0]
    200                 if len(name) > 8 :
    201                         lfn = True
    202 
    203         if len(parts) > 1 :
    204                 ext = parts[-1]
    205                 if len(ext) > 3 :
    206                         lfn = True
    207 
    208         if len(parts) > 2 :
    209                 lfn = True
    210 
    211         if (lfn == False) :
    212                 return (name.ljust(8)[0:8], ext.ljust(3)[0:3], False)
    213 
    214         # For filenames with multiple extensions, we treat the last one
    215         # as the actual extension. The rest of the filename is stripped
    216         # of dots and concatenated to form the short name
    217         for _name in parts[1:-1]:
    218                 name = name + _name             
    219 
    220         global name83_list
    221         for number in range(1, 10000) :
    222                 number_str = '~' + str(number)
    223 
    224                 if len(name) + len(number_str) > 8 :
    225                         name = name[0:8 - len(number_str)]
    226 
    227                 name = name + number_str;
    228 
    229                 if (name + ext) not in name83_list :
    230                         break
    231                        
    232         name83_list.append(name + ext) 
    233 
    234         return (name.ljust(8)[0:8], ext.ljust(3)[0:3], True)
    235 
    236 def get_utf16(name, l) :
    237         "Create a int array out of a string which we can store in uint16_t arrays"
    238 
    239         bs = [0xFFFF for i in range(l)]
    240 
    241         for i in range(len(name)) :
    242                 bs[i] = ord(name[i])
    243        
    244         if (len(name) < l) :
    245                 bs[len(name)] = 0;
    246        
    247         return bs
    248 
    249 def create_lfn_entry((name, index)) :
    250         entry = xstruct.create(LFN_ENTRY)
    251 
    252         entry.name1 = get_utf16(name[0:5], 5)
    253         entry.name2 = get_utf16(name[5:11], 6)
    254         entry.name3 = get_utf16(name[11:13], 2)
    255         entry.pos = index
    256 
    257         entry.attr = 0xF
    258         entry.fc = 0
    259         entry.type = 0
    260 
    261         return entry
     175                fname = parts[0]
     176        else:
     177                fname = ''
     178       
     179        if len(fname) > 8:
     180                sys.stdout.write("mkfat.py: error: Directory entry " + name +
     181                    " base name is longer than 8 characters\n")
     182                sys.exit(1);
     183       
     184        return (fname + '          ').upper()[0:8]
     185
     186def mangle_ext(name):
     187        # FIXME: filter illegal characters
     188        parts = name.split('.')
     189       
     190        if len(parts) > 1:
     191                ext = parts[1]
     192        else:
     193                ext = ''
     194       
     195        if len(parts) > 2:
     196                sys.stdout.write("mkfat.py: error: Directory entry " + name +
     197                    " has more than one extension\n")
     198                sys.exit(1);
     199       
     200        if len(ext) > 3:
     201                sys.stdout.write("mkfat.py: error: Directory entry " + name +
     202                    " extension is longer than 3 characters\n")
     203                sys.exit(1);
     204       
     205        return (ext + '   ').upper()[0:3]
    262206
    263207def create_dirent(name, directory, cluster, size):
    264        
    265208        dir_entry = xstruct.create(DIR_ENTRY)
    266209       
    267         dir_entry.name, dir_entry.ext, lfn = name83(name)
    268 
    269         dir_entry.name = dir_entry.name.upper().encode('ascii')
    270         dir_entry.ext = dir_entry.ext.upper().encode('ascii')
    271 
     210        dir_entry.name = mangle_fname(name).encode('ascii')
     211        dir_entry.ext = mangle_ext(name).encode('ascii')
     212       
    272213        if (directory):
    273214                dir_entry.attr = 0x30
    … …  
    289230                dir_entry.size = size
    290231       
    291 
    292         if not lfn:
    293                 return [dir_entry]
    294 
    295         n = len(name) / 13 + 1
    296         names = [(name[i * 13: (i + 1) * 13 + 1], i + 1) for i in range(n)]
    297 
    298         entries = sorted(map (create_lfn_entry, names), reverse = True, key = lambda e : e.pos)
    299         entries[0].pos |= 0x40
    300 
    301         fname11 = dir_entry.name + dir_entry.ext
    302 
    303         csum = 0
    304         for i in range(0, 11) :
    305                 csum = ((csum & 1) << 7) + (csum  >> 1) + ord(fname11[i])
    306                 csum = csum & 0xFF
    307        
    308         for e in entries :
    309                 e.csum = csum;
    310        
    311         entries.append(dir_entry)
    312 
    313         return entries
     232        return dir_entry
    314233
    315234def create_dot_dirent(empty_cluster):
    … …  
    369288                if item.is_file:
    370289                        rv = write_file(item, outf, cluster_size, data_start, fat, reserved_clusters)
    371                         directory.extend(create_dirent(item.name, False, rv[0], rv[1]))
     290                        directory.append(create_dirent(item.name, False, rv[0], rv[1]))
    372291                elif item.is_dir:
    373292                        rv = recursion(False, item.path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
    374                         directory.extend(create_dirent(item.name, True, rv[0], rv[1]))
     293                        directory.append(create_dirent(item.name, True, rv[0], rv[1]))
    375294       
    376295        if (head):

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

    rfb8dcb4 r063ae706  
    5252#define CAT_VERSION "0.0.1"
    5353#define CAT_DEFAULT_BUFLEN 1024
    54 #define CAT_FULL_FILE 0
    55 
     54
     55static const char *cat_oops = "That option is not yet supported\n";
    5656static const char *hexchars = "0123456789abcdef";
    5757
    … …  
    163163}
    164164
    165 static unsigned int cat_file(const char *fname, size_t blen, bool hex,
    166     off64_t head, off64_t tail, bool tail_first)
     165static unsigned int cat_file(const char *fname, size_t blen, bool hex)
    167166{
    168167        int fd, bytes = 0, count = 0, reads = 0;
    169168        char *buff = NULL;
    170169        int i;
    171         size_t offset = 0, copied_bytes = 0;
    172         off64_t file_size = 0, length = 0;
     170        size_t offset = 0;
    173171
    174172        fd = open(fname, O_RDONLY);
    … …  
    185183        }
    186184
    187         if (tail != CAT_FULL_FILE) {
    188                 file_size = lseek(fd, 0, SEEK_END);
    189                 if (head == CAT_FULL_FILE) {
    190                         head = file_size;
    191                         length = tail;
    192                 } else if (tail_first) {
    193                         length = head;
    194                 } else {
    195                         if (tail > head)
    196                                 tail = head;
    197                         length = tail;
    198                 }
    199 
    200                 if (tail_first) {
    201                         lseek(fd, (tail >= file_size) ? 0 : (file_size - tail), SEEK_SET);
    202                 } else {
    203                         lseek(fd, ((head - tail) >= file_size) ? 0 : (head - tail), SEEK_SET);
    204                 }
    205         } else
    206                 length = head;
    207 
    208185        do {
    209                 bytes = read(fd, buff + copied_bytes, (
    210                         (length != CAT_FULL_FILE && length - (off64_t)count <= (off64_t)(blen - copied_bytes)) ?
    211                         (size_t)(length - count) :
    212                         (blen - copied_bytes) ) );
    213                 bytes += copied_bytes;
    214                 copied_bytes = 0;
    215 
     186                bytes = read(fd, buff, blen);
    216187                if (bytes > 0) {
     188                        count += bytes;
    217189                        buff[bytes] = '\0';
    218190                        offset = 0;
    … …  
    221193                                        paged_char(hexchars[((uint8_t)buff[i])/16]);
    222194                                        paged_char(hexchars[((uint8_t)buff[i])%16]);
    223                                         paged_char(((count+i+1) & 0xf) == 0 ? '\n' : ' ');
    224195                                }
    225196                                else {
    … …  
    228199                                                /* Reached end of string */
    229200                                                break;
    230                                         } else if (c == U_SPECIAL && offset + 2 >= (size_t)bytes) {
    231                                                 /* If an extended character is cut off due to the size of the buffer,
    232                                                    we will copy it over to the next buffer so it can be read correctly. */
    233                                                 copied_bytes = bytes - offset + 1;
    234                                                 memcpy(buff, buff + offset - 1, copied_bytes);
    235                                                 break;
    236201                                        }
    237202                                        paged_char(c);
    … …  
    239204                               
    240205                        }
    241                         count += bytes;
    242206                        reads++;
    243207                }
    244         } while (bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
     208        } while (bytes > 0 && !should_quit);
    245209
    246210        close(fd);
    … …  
    259223int cmd_cat(char **argv)
    260224{
    261         unsigned int argc, i, ret = 0;
    262         size_t buffer = 0;
     225        unsigned int argc, i, ret = 0, buffer = 0;
    263226        int c, opt_ind;
    264         aoff64_t head = CAT_FULL_FILE, tail = CAT_FULL_FILE;
    265227        bool hex = false;
    266228        bool more = false;
    267         bool tailFirst = false;
    268229        sysarg_t rows, cols;
    269230        int rc;
    … …  
    293254                        return CMD_SUCCESS;
    294255                case 'H':
    295                         if (!optarg || str_uint64_t(optarg, NULL, 10, false, &head) != EOK ) {
    296                                 puts("Invalid head size\n");
    297                                 return CMD_FAILURE;
    298                         }
    299                         break;
     256                        printf("%s", cat_oops);
     257                        return CMD_FAILURE;
    300258                case 't':
    301                         if (!optarg || str_uint64_t(optarg, NULL, 10, false, &tail) != EOK ) {
    302                                 puts("Invalid tail size\n");
    303                                 return CMD_FAILURE;
    304                         }
    305                         if (head == CAT_FULL_FILE)
    306                                 tailFirst = true;
    307                         break;
     259                        printf("%s", cat_oops);
     260                        return CMD_FAILURE;
    308261                case 'b':
    309                         if (!optarg || str_size_t(optarg, NULL, 10, false, &buffer) != EOK ) {
    310                                 puts("Invalid buffer size\n");
    311                                 return CMD_FAILURE;
    312                         }
     262                        printf("%s", cat_oops);
    313263                        break;
    314264                case 'm':
    … …  
    329279        }
    330280
    331         if (buffer < 4)
     281        if (buffer <= 0)
    332282                buffer = CAT_DEFAULT_BUFLEN;
    333283       
    … …  
    345295
    346296        for (i = optind; argv[i] != NULL && !should_quit; i++)
    347                 ret += cat_file(argv[i], buffer, hex, head, tail, tailFirst);
     297                ret += cat_file(argv[i], buffer, hex);
    348298
    349299        if (ret)

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

    rfb8dcb4 r063ae706  
    44/* Prototypes for the cat command, excluding entry points */
    55
    6 static unsigned int cat_file(const char *, size_t, bool, off64_t, off64_t, bool);
     6static unsigned int cat_file(const char *, size_t, bool);
    77
    88#endif /* CAT_H */

  • uspace/app/sportdmp/sportdmp.c

    rfb8dcb4 r063ae706  
    2727 */
    2828
     29#include <errno.h>
     30#include <stdio.h>
     31#include <devman.h>
     32#include <ipc/devman.h>
    2933#include <device/char_dev.h>
    30 #include <errno.h>
    3134#include <ipc/serial_ctl.h>
    32 #include <loc.h>
    33 #include <stdio.h>
    3435
    3536#define BUF_SIZE 1
    3637
    37 static void syntax_print(void)
    38 {
    39         fprintf(stderr, "Usage: sportdmp <baud> <device_service>\n");
     38static void syntax_print() {
     39        fprintf(stderr, "Usage: sportdmp <baud> <device_path>\n");
    4040}
    4141
    4242int main(int argc, char **argv)
    4343{
    44         const char* svc_path = "devices/\\hw\\pci0\\00:01.0\\com1\\a";
     44        const char* devpath = "/hw/pci0/00:01.0/com1/a";
    4545        sysarg_t baud = 9600;
    4646       
    … …  
    5656       
    5757        if (argc > 2) {
    58                 svc_path = argv[2];
     58                devpath = argv[2];
    5959        }
    6060       
    … …  
    6464        }
    6565       
    66         service_id_t svc_id;
    67         int rc = loc_service_get_id(svc_path, &svc_id, IPC_FLAG_BLOCKING);
     66        devman_handle_t device;
     67        int rc = devman_fun_get_handle(devpath, &device, IPC_FLAG_BLOCKING);
    6868        if (rc != EOK) {
    69                 fprintf(stderr, "Cannot find device service %s\n", svc_path);
     69                fprintf(stderr, "Cannot open device %s\n", devpath);
    7070                return 1;
    7171        }
    7272       
    73         async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
     73        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, device,
    7474            IPC_FLAG_BLOCKING);
    7575        if (!sess) {
    76                 fprintf(stderr, "Failed connecting to service %s\n", svc_path);
     76                fprintf(stderr, "Cannot connect device\n");
    7777        }
    7878       
    … …  
    8383       
    8484        if (rc != EOK) {
    85                 fprintf(stderr, "Failed setting serial properties\n");
     85                fprintf(stderr, "Cannot set serial properties\n");
    8686                return 2;
    8787        }
    … …  
    8989        uint8_t *buf = (uint8_t *) malloc(BUF_SIZE);
    9090        if (buf == NULL) {
    91                 fprintf(stderr, "Failed allocating buffer\n");
     91                fprintf(stderr, "Cannot allocate buffer\n");
    9292                return 3;
    9393        }

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

    rfb8dcb4 r063ae706  
    4242#include <async.h>
    4343#include <ipc/services.h>
    44 #include <loc.h>
     44#include <ipc/devman.h>
     45#include <devman.h>
    4546#include <device/char_dev.h>
    4647#include <str.h>
    … …  
    7071                }
    7172       
    72         service_id_t svc_id;
    73         int res = loc_service_get_id("devices/\\hw\\pci0\\00:01.0\\com1\\a",
    74             &svc_id, IPC_FLAG_BLOCKING);
     73        devman_handle_t handle;
     74        int res = devman_fun_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
     75            IPC_FLAG_BLOCKING);
    7576        if (res != EOK)
    76                 return "Failed getting serial port service ID";
    77        
    78         async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
     77                return "Could not get serial device handle";
     78       
     79        async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
    7980            IPC_FLAG_BLOCKING);
    8081        if (!sess)
    81                 return "Failed connecting to serial device";
     82                return "Unable to connect to serial device";
    8283       
    8384        char *buf = (char *) malloc(cnt + 1);
    8485        if (buf == NULL) {
    8586                async_hangup(sess);
    86                 return "Failed allocating input buffer";
     87                return "Failed to allocate input buffer";
    8788        }
    8889       
    … …  
    111112                free(buf);
    112113                async_hangup(sess);
    113                 return "Failed setting serial communication parameters";
    114         }
    115        
    116         TPRINTF("Trying reading %zu characters from serial device "
    117             "(svc_id=%" PRIun ")\n", cnt, svc_id);
     114                return "Failed to set serial communication parameters";
     115        }
     116       
     117        TPRINTF("Trying to read %zu characters from serial device "
     118            "(handle=%" PRIun ")\n", cnt, handle);
    118119       
    119120        size_t total = 0;
    … …  
    129130                        free(buf);
    130131                        async_hangup(sess);
    131                         return "Failed reading from serial device";
     132                        return "Failed read from serial device";
    132133                }
    133134               
    … …  
    164165                                free(buf);
    165166                                async_hangup(sess);
    166                                 return "Failed writing to serial device";
     167                                return "Failed write to serial device";
    167168                        }
    168169                       

  • uspace/drv/bus/isa/isa.c

    rfb8dcb4 r063ae706  
    6666#include <ops/hw_res.h>
    6767
     68#include <devman.h>
     69#include <ipc/devman.h>
    6870#include <device/hw_res.h>
    6971

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

    rfb8dcb4 r063ae706  
    3737#include <str_error.h>
    3838#include <async.h>
     39#include <devman.h>
    3940
    4041#include <usb/usb.h>    /* usb_address_t */

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

    rfb8dcb4 r063ae706  
    3535
    3636#include <bool.h>
     37#include <devman.h>
    3738#include <errno.h>
    3839#include <str_error.h>

  • uspace/drv/char/ps2mouse/main.c

    rfb8dcb4 r063ae706  
    3535#include <libarch/inttypes.h>
    3636#include <ddf/driver.h>
     37#include <devman.h>
    3738#include <device/hw_res_parsed.h>
    3839#include <errno.h>

  • uspace/drv/char/xtkbd/main.c

    rfb8dcb4 r063ae706  
    3535#include <libarch/inttypes.h>
    3636#include <ddf/driver.h>
     37#include <devman.h>
    3738#include <device/hw_res_parsed.h>
    3839#include <errno.h>

  • uspace/drv/infrastructure/root/root.c

    rfb8dcb4 r063ae706  
    5353#include <ddf/driver.h>
    5454#include <ddf/log.h>
     55#include <devman.h>
     56#include <ipc/devman.h>
    5557
    5658#define NAME "root"

  • uspace/drv/infrastructure/rootpc/rootpc.c

    rfb8dcb4 r063ae706  
    4848#include <ddf/driver.h>
    4949#include <ddf/log.h>
     50#include <devman.h>
     51#include <ipc/devman.h>
    5052#include <ipc/dev_iface.h>
    5153#include <ops/hw_res.h>

  • uspace/drv/nic/e1k/e1k.c

    rfb8dcb4 r063ae706  
    4646#include <ddf/log.h>
    4747#include <ddf/interrupt.h>
     48#include <devman.h>
    4849#include <device/hw_res_parsed.h>
    4950#include <device/pci.h>

  • uspace/lib/net/generic/net_remote.c

    rfb8dcb4 r063ae706  
    4040#include <malloc.h>
    4141#include <async.h>
     42#include <devman.h>
    4243#include <generic.h>
    4344#include <net/modules.h>

  • uspace/lib/usb/src/ddfiface.c

    rfb8dcb4 r063ae706  
    3333 * Implementations of DDF interfaces functions (actual implementation).
    3434 */
     35#include <ipc/devman.h>
    3536#include <devman.h>
    3637#include <async.h>

  • uspace/lib/usbvirt/src/ipc_dev.c

    rfb8dcb4 r063ae706  
    3838#include <assert.h>
    3939#include <async.h>
     40#include <devman.h>
    4041#include <usbvirt/device.h>
    4142#include <usbvirt/ipc.h>

  • uspace/lib/usbvirt/src/ipc_hc.c

    rfb8dcb4 r063ae706  
    3838#include <assert.h>
    3939#include <async.h>
     40#include <devman.h>
    4041#include <usbvirt/device.h>
    4142#include <usbvirt/ipc.h>
Note: See TracChangeset for help on using the changeset viewer.