Changeset 65ccd23 in mainline

Timestamp:

2011-06-10T17:17:24Z (13 years ago)

Author:

Oleg Romanenko <romanenko.oleg@…>

Branches:

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

Children:

da2f8d10

Parents:

34fdb75

Message:

Initial support for LFN. Long names could be read from
filesystem through common api: readdir()

Location:

uspace/srv/fs/fat

Files:

• fat_dentry.c (modified) (1 diff)
• fat_dentry.h (modified) (1 diff)
• fat_ops.c (modified) (4 diffs)

uspace/srv/fs/fat/fat_dentry.c

@@ -219 +219 @@
 fat_dentry_clsf_t fat_classify_dentry(const fat_dentry_t *d)
 {
-/*      if (d->attr == FAT_ATTR_LFN) { */
+        if (d->attr == FAT_ATTR_LFN) {
                 /* long name entry */
-/*              if (d->attr & FAT_LFN_ERASED)
+                if (d->attr & FAT_LFN_ERASED)
                         return FAT_DENTRY_FREE;
                 else
                         return FAT_DENTRY_LFN;
-        }*/
+        }
         if (d->attr & FAT_ATTR_VOLLABEL) {
                 /* volume label entry */

uspace/srv/fs/fat/fat_dentry.h

@@ -88 +88 @@
         FAT_DENTRY_LAST,
         FAT_DENTRY_FREE,
-        FAT_DENTRY_VALID
-        /* FAT_DENTRY_LFN */
+        FAT_DENTRY_VALID,
+        FAT_DENTRY_LFN
 } fat_dentry_clsf_t;
 

uspace/srv/fs/fat/fat_ops.c

@@ -56 +56 @@
 #include <align.h>
 #include <malloc.h>
+#include <str.h>
 
 #define FAT_NODE(node)  ((node) ? (fat_node_t *) (node)->data : NULL)
@@ -642 +643 @@
                         d = ((fat_dentry_t *)b->data) + j;
                         switch (fat_classify_dentry(d)) {
+                        case FAT_DENTRY_LFN:
                         case FAT_DENTRY_SKIP:
                         case FAT_DENTRY_VALID:
@@ -1219 +1221 @@
                 unsigned bnum;
                 aoff64_t spos = pos;
-                char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
+                char name[FAT_LFN_NAME_SIZE];
+                uint8_t lfn_utf16[FAT_LFN_MAX_COUNT * FAT_LFN_ENTRY_SIZE];
+                size_t lfn_offset;
+                size_t lfn_size;
+                bool long_entry = false;
+                int long_entry_count = 0;
                 fat_dentry_t *d;
+                uint8_t checksum=0;
 
                 assert(nodep->type == FAT_DIRECTORY);
@@ -1247 +1255 @@
                                 case FAT_DENTRY_SKIP:
                                 case FAT_DENTRY_FREE:
+                                        long_entry_count = 0;
+                                        long_entry = false;
                                         continue;
                                 case FAT_DENTRY_LAST:
+                                        long_entry_count = 0;
+                                        long_entry = false;
                                         rc = block_put(b);
                                         if (rc != EOK)
                                                 goto err;
                                         goto miss;
+                                case FAT_DENTRY_LFN:
+                                        if (long_entry) {
+                                                /* We found long entry */
+                                                long_entry_count--;
+                                                if ((FAT_LFN_ORDER(d) == long_entry_count) && 
+                                                        (checksum == FAT_LFN_CHKSUM(d))) {
+                                                        /* Right order! */
+                                                        fat_lfn_copy_entry(d, lfn_utf16, &lfn_offset);
+                                                } else {
+                                                        /* Something wrong with order. Skip this long entries set */
+                                                        long_entry_count = 0;
+                                                        long_entry = false;
+                                                }
+                                        } else {
+                                                if (FAT_IS_LFN(d)) {
+                                                        /* We found Last long entry! */
+                                                        if (FAT_LFN_COUNT(d) <= FAT_LFN_MAX_COUNT) {
+                                                                long_entry = true;
+                                                                long_entry_count = FAT_LFN_COUNT(d);
+                                                                lfn_size = (FAT_LFN_ENTRY_SIZE * 
+                                                                        (FAT_LFN_COUNT(d) - 1)) + fat_lfn_size(d);
+                                                                lfn_offset = lfn_size;
+                                                                fat_lfn_copy_entry(d, lfn_utf16, &lfn_offset);
+                                                                checksum = FAT_LFN_CHKSUM(d);
+                                                        }
+                                                }
+                                        }
+                                        break;
                                 default:
                                 case FAT_DENTRY_VALID:
-                                        fat_dentry_name_get(d, name);
+                                        if (long_entry && 
+                                                (checksum == fat_dentry_chksum(d->name))) {
+                                                rc = fat_lfn_convert_name(lfn_utf16, lfn_size, (uint8_t*)name, FAT_LFN_NAME_SIZE);
+                                                if (rc!=EOK)
+                                                        fat_dentry_name_get(d, name);
+                                        }
+                                        else
+                                                fat_dentry_name_get(d, name);
+
+                                        long_entry_count = 0;
+                                        long_entry = false;
                                         rc = block_put(b);
                                         if (rc != EOK)