Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset fb8dcb4 in mainline


Ignore:
Timestamp:
2012-04-05T05:31:04Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master
Children:
2096871
Parents:
063ae706 (diff), e882e3a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Mainline changes.

Files:
18 edited

Legend:

Unmodified
Added
Removed
  • tools/check.sh

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

    r063ae706 rfb8dcb4  
    168168"""
    169169
    170 def mangle_fname(name):
     170LFN_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.
     183name83_list = []
     184
     185def name83(fname):
     186        "Create a 8.3 name for the given fname"
     187
    171188        # FIXME: filter illegal characters
    172         parts = name.split('.')
    173        
     189        parts = fname.split('.')
     190       
     191        name = ''
     192        ext = ''
     193        lfn = False
     194
     195        if len(fname) > 11 :
     196                lfn = True
     197
    174198        if len(parts) > 0:
    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 
    186 def 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]
     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
     236def 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
     249def 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
    206262
    207263def create_dirent(name, directory, cluster, size):
     264       
    208265        dir_entry = xstruct.create(DIR_ENTRY)
    209266       
    210         dir_entry.name = mangle_fname(name).encode('ascii')
    211         dir_entry.ext = mangle_ext(name).encode('ascii')
    212        
     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
    213272        if (directory):
    214273                dir_entry.attr = 0x30
     
    230289                dir_entry.size = size
    231290       
    232         return dir_entry
     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
    233314
    234315def create_dot_dirent(empty_cluster):
     
    288369                if item.is_file:
    289370                        rv = write_file(item, outf, cluster_size, data_start, fat, reserved_clusters)
    290                         directory.append(create_dirent(item.name, False, rv[0], rv[1]))
     371                        directory.extend(create_dirent(item.name, False, rv[0], rv[1]))
    291372                elif item.is_dir:
    292373                        rv = recursion(False, item.path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
    293                         directory.append(create_dirent(item.name, True, rv[0], rv[1]))
     374                        directory.extend(create_dirent(item.name, True, rv[0], rv[1]))
    294375       
    295376        if (head):
  • uspace/app/bdsh/cmds/modules/cat/cat.c

    r063ae706 rfb8dcb4  
    5252#define CAT_VERSION "0.0.1"
    5353#define CAT_DEFAULT_BUFLEN 1024
    54 
    55 static const char *cat_oops = "That option is not yet supported\n";
     54#define CAT_FULL_FILE 0
     55
    5656static const char *hexchars = "0123456789abcdef";
    5757
     
    163163}
    164164
    165 static unsigned int cat_file(const char *fname, size_t blen, bool hex)
     165static unsigned int cat_file(const char *fname, size_t blen, bool hex,
     166    off64_t head, off64_t tail, bool tail_first)
    166167{
    167168        int fd, bytes = 0, count = 0, reads = 0;
    168169        char *buff = NULL;
    169170        int i;
    170         size_t offset = 0;
     171        size_t offset = 0, copied_bytes = 0;
     172        off64_t file_size = 0, length = 0;
    171173
    172174        fd = open(fname, O_RDONLY);
     
    183185        }
    184186
     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
    185208        do {
    186                 bytes = read(fd, buff, blen);
     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
    187216                if (bytes > 0) {
    188                         count += bytes;
    189217                        buff[bytes] = '\0';
    190218                        offset = 0;
     
    193221                                        paged_char(hexchars[((uint8_t)buff[i])/16]);
    194222                                        paged_char(hexchars[((uint8_t)buff[i])%16]);
     223                                        paged_char(((count+i+1) & 0xf) == 0 ? '\n' : ' ');
    195224                                }
    196225                                else {
     
    199228                                                /* Reached end of string */
    200229                                                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;
    201236                                        }
    202237                                        paged_char(c);
     
    204239                               
    205240                        }
     241                        count += bytes;
    206242                        reads++;
    207243                }
    208         } while (bytes > 0 && !should_quit);
     244        } while (bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
    209245
    210246        close(fd);
     
    223259int cmd_cat(char **argv)
    224260{
    225         unsigned int argc, i, ret = 0, buffer = 0;
     261        unsigned int argc, i, ret = 0;
     262        size_t buffer = 0;
    226263        int c, opt_ind;
     264        aoff64_t head = CAT_FULL_FILE, tail = CAT_FULL_FILE;
    227265        bool hex = false;
    228266        bool more = false;
     267        bool tailFirst = false;
    229268        sysarg_t rows, cols;
    230269        int rc;
     
    254293                        return CMD_SUCCESS;
    255294                case 'H':
    256                         printf("%s", cat_oops);
    257                         return CMD_FAILURE;
     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;
    258300                case 't':
    259                         printf("%s", cat_oops);
    260                         return CMD_FAILURE;
     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;
    261308                case 'b':
    262                         printf("%s", cat_oops);
     309                        if (!optarg || str_size_t(optarg, NULL, 10, false, &buffer) != EOK ) {
     310                                puts("Invalid buffer size\n");
     311                                return CMD_FAILURE;
     312                        }
    263313                        break;
    264314                case 'm':
     
    279329        }
    280330
    281         if (buffer <= 0)
     331        if (buffer < 4)
    282332                buffer = CAT_DEFAULT_BUFLEN;
    283333       
     
    295345
    296346        for (i = optind; argv[i] != NULL && !should_quit; i++)
    297                 ret += cat_file(argv[i], buffer, hex);
     347                ret += cat_file(argv[i], buffer, hex, head, tail, tailFirst);
    298348
    299349        if (ret)
  • uspace/app/bdsh/cmds/modules/cat/cat.h

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

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

    r063ae706 rfb8dcb4  
    4242#include <async.h>
    4343#include <ipc/services.h>
    44 #include <ipc/devman.h>
    45 #include <devman.h>
     44#include <loc.h>
    4645#include <device/char_dev.h>
    4746#include <str.h>
     
    7170                }
    7271       
    73         devman_handle_t handle;
    74         int res = devman_fun_get_handle("/hw/pci0/00:01.0/com1/a", &handle,
    75             IPC_FLAG_BLOCKING);
     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);
    7675        if (res != EOK)
    77                 return "Could not get serial device handle";
    78        
    79         async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
     76                return "Failed getting serial port service ID";
     77       
     78        async_sess_t *sess = loc_service_connect(EXCHANGE_SERIALIZE, svc_id,
    8079            IPC_FLAG_BLOCKING);
    8180        if (!sess)
    82                 return "Unable to connect to serial device";
     81                return "Failed connecting to serial device";
    8382       
    8483        char *buf = (char *) malloc(cnt + 1);
    8584        if (buf == NULL) {
    8685                async_hangup(sess);
    87                 return "Failed to allocate input buffer";
     86                return "Failed allocating input buffer";
    8887        }
    8988       
     
    112111                free(buf);
    113112                async_hangup(sess);
    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);
     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);
    119118       
    120119        size_t total = 0;
     
    130129                        free(buf);
    131130                        async_hangup(sess);
    132                         return "Failed read from serial device";
     131                        return "Failed reading from serial device";
    133132                }
    134133               
     
    165164                                free(buf);
    166165                                async_hangup(sess);
    167                                 return "Failed write to serial device";
     166                                return "Failed writing to serial device";
    168167                        }
    169168                       
  • uspace/drv/bus/isa/isa.c

    r063ae706 rfb8dcb4  
    6666#include <ops/hw_res.h>
    6767
    68 #include <devman.h>
    69 #include <ipc/devman.h>
    7068#include <device/hw_res.h>
    7169
  • uspace/drv/bus/usb/uhcirh/port.c

    r063ae706 rfb8dcb4  
    3737#include <str_error.h>
    3838#include <async.h>
    39 #include <devman.h>
    4039
    4140#include <usb/usb.h>    /* usb_address_t */
  • uspace/drv/bus/usb/usbhub/port.c

    r063ae706 rfb8dcb4  
    3535
    3636#include <bool.h>
    37 #include <devman.h>
    3837#include <errno.h>
    3938#include <str_error.h>
  • uspace/drv/char/ps2mouse/main.c

    r063ae706 rfb8dcb4  
    3535#include <libarch/inttypes.h>
    3636#include <ddf/driver.h>
    37 #include <devman.h>
    3837#include <device/hw_res_parsed.h>
    3938#include <errno.h>
  • uspace/drv/char/xtkbd/main.c

    r063ae706 rfb8dcb4  
    3535#include <libarch/inttypes.h>
    3636#include <ddf/driver.h>
    37 #include <devman.h>
    3837#include <device/hw_res_parsed.h>
    3938#include <errno.h>
  • uspace/drv/infrastructure/root/root.c

    r063ae706 rfb8dcb4  
    5353#include <ddf/driver.h>
    5454#include <ddf/log.h>
    55 #include <devman.h>
    56 #include <ipc/devman.h>
    5755
    5856#define NAME "root"
  • uspace/drv/infrastructure/rootpc/rootpc.c

    r063ae706 rfb8dcb4  
    4848#include <ddf/driver.h>
    4949#include <ddf/log.h>
    50 #include <devman.h>
    51 #include <ipc/devman.h>
    5250#include <ipc/dev_iface.h>
    5351#include <ops/hw_res.h>
  • uspace/drv/nic/e1k/e1k.c

    r063ae706 rfb8dcb4  
    4646#include <ddf/log.h>
    4747#include <ddf/interrupt.h>
    48 #include <devman.h>
    4948#include <device/hw_res_parsed.h>
    5049#include <device/pci.h>
  • uspace/lib/net/generic/net_remote.c

    r063ae706 rfb8dcb4  
    4040#include <malloc.h>
    4141#include <async.h>
    42 #include <devman.h>
    4342#include <generic.h>
    4443#include <net/modules.h>
  • uspace/lib/usb/src/ddfiface.c

    r063ae706 rfb8dcb4  
    3333 * Implementations of DDF interfaces functions (actual implementation).
    3434 */
    35 #include <ipc/devman.h>
    3635#include <devman.h>
    3736#include <async.h>
  • uspace/lib/usbvirt/src/ipc_dev.c

    r063ae706 rfb8dcb4  
    3838#include <assert.h>
    3939#include <async.h>
    40 #include <devman.h>
    4140#include <usbvirt/device.h>
    4241#include <usbvirt/ipc.h>
  • uspace/lib/usbvirt/src/ipc_hc.c

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