Changeset 831507b in mainline

Timestamp:

2012-04-14T14:00:02Z (12 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

b6d7b7c

Parents:

1fff583 (diff), 1db6dfd (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:

Merge with mainline

Files:

• tools/imgutil.py (modified) (2 diffs)
• tools/mkfat.py (modified) (6 diffs)
• uspace/app/tester/Makefile (modified) (1 diff)
• uspace/app/tester/ipc/starve.c (added)
• uspace/app/tester/ipc/starve.def (added)
• uspace/app/tester/tester.c (modified) (1 diff)
• uspace/app/tester/tester.h (modified) (1 diff)
• uspace/lib/c/generic/async.c (modified) (19 diffs)
• uspace/lib/c/generic/fibril_synch.c (modified) (4 diffs)
• uspace/lib/c/generic/private/async.h (modified) (1 diff)
• uspace/lib/c/include/async.h (modified) (1 diff)
• uspace/srv/fs/fat/fat_dentry.c (modified) (1 diff)
• uspace/srv/fs/fat/fat_directory.c (modified) (4 diffs)

tools/imgutil.py

@@ -92 +92 @@
                 if name in exclude_names:
                         continue
+                
                 item = ItemToPack(path, name)
+                
                 if not (item.is_dir or item.is_file):
                         continue
+                
                 yield item
 
@@ -102 +105 @@
         inf = open(item.path, 'rb')
         rd = 0
+        
         while (rd < item.size):
                 data = bytes(inf.read(chunk_size))
                 yield data
                 rd += len(data)
+        
         inf.close()

tools/mkfat.py

@@ -168 +168 @@
 """
 
-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 = fname.split('.')
-        
-        name = ''
-        ext = ''
-        lfn = False
-
-        if len(fname) > 11 :
+LFN_DIR_ENTRY = """little:
+        uint8_t seq                /* sequence number */
+        char name1[10]             /* first part of the name */
+        uint8_t attr               /* attributes */
+        uint8_t rec_type           /* LFN record type */
+        uint8_t checksum           /* LFN checksum */
+        char name2[12]             /* second part of the name */
+        uint16_t cluster           /* cluster */
+        char name3[4]              /* third part of the name */
+"""
+
+lchars = set(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+              'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+              'U', 'V', 'W', 'X', 'Y', 'Z',
+              '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+              '!', '#', '$', '%', '&', '\'', '(', ')', '-', '@',
+              '^', '_', '`', '{', '}', '~', '.'])
+
+def fat_lchars(name):
+        "Filter FAT legal characters"
+        
+        filtered_name = ''
+        filtered = False
+        
+        for char in name.encode('ascii', 'replace').upper():
+                if char in lchars:
+                        filtered_name += char
+                else:
+                        filtered_name += b'_'
+                        filtered = True
+        
+        return (filtered_name, filtered)
+
+def fat_name83(name, name83_list):
+        "Create a 8.3 name for the given name"
+        
+        ascii_name, lfn = fat_lchars(name)
+        ascii_parts = ascii_name.split('.')
+        
+        short_name = ''
+        short_ext = ''
+        
+        if len(ascii_name) > 11:
                 lfn = True
-
-        if len(parts) > 0:
-                name = parts[0]
-                if len(name) > 8 :
+        
+        if len(ascii_parts) > 0:
+                short_name = ascii_parts[0]
+                if len(short_name) > 8:
                         lfn = True
-
-        if len(parts) > 1 :
-                ext = parts[-1]
-                if len(ext) > 3 :
+        
+        if len(ascii_parts) > 1:
+                short_ext = ascii_parts[-1]
+                if len(short_ext) > 3:
                         lfn = True
-
-        if len(parts) > 2 :
+        
+        if len(ascii_parts) > 2:
                 lfn = True
-
-        if (lfn == False) :
-                return (name.ljust(8)[0:8], ext.ljust(3)[0:3], False)
-
+        
+        if lfn == False:
+                name83_list.append(short_name + '.' + short_ext)
+                return (short_name.ljust(8)[0:8], short_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 :
+        for part in ascii_parts[1:-1]:
+                short_name += part
+        
+        for number in range(1, 999999):
+                number_str = ('~' + str(number)).upper()
+                
+                if len(short_name) + len(number_str) > 8:
+                        short_name = short_name[0:8 - len(number_str)]
+                
+                short_name += number_str;
+                
+                if not (short_name + '.' + short_ext) 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):
+        
+        name83_list.append(short_name + '.' + short_ext)
+        return (short_name.ljust(8)[0:8], short_ext.ljust(3)[0:3], True)
+
+def create_lfn_dirent(name, seq, checksum):
+        "Create LFN directory entry"
+        
+        entry = xstruct.create(LFN_DIR_ENTRY)
+        name_rest = name[26:]
+        
+        if len(name_rest) > 0:
+                entry.seq = seq
+        else:
+                entry.seq = seq | 0x40
+        
+        entry.name1 = name[0:10]
+        entry.name2 = name[10:22]
+        entry.name3 = name[22:26]
+        
+        entry.attr = 0x0F
+        entry.rec_type = 0
+        entry.checksum = checksum
+        entry.cluster = 0
+        
+        return (entry, name_rest)
+
+def lfn_checksum(name):
+        "Calculate LFN checksum"
+        
+        checksum = 0
+        for i in range(0, 11):
+                checksum = (((checksum & 1) << 7) + (checksum >> 1) + ord(name[i])) & 0xFF
+        
+        return checksum
+
+def create_dirent(name, name83_list, directory, cluster, size):
+        short_name, short_ext, lfn = fat_name83(name, name83_list)
         
         dir_entry = xstruct.create(DIR_ENTRY)
         
-        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')
-
+        dir_entry.name = short_name
+        dir_entry.ext = short_ext
+        
         if (directory):
                 dir_entry.attr = 0x30
@@ -289 +308 @@
                 dir_entry.size = size
         
-
         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)
-
+        
+        long_name = name.encode('utf_16_le')
+        entries = [dir_entry]
+        
+        seq = 1
+        checksum = lfn_checksum(dir_entry.name + dir_entry.ext)
+        
+        while len(long_name) > 0:
+                long_entry, long_name = create_lfn_dirent(long_name, seq, checksum)
+                entries.append(long_entry)
+                seq += 1
+        
+        entries.reverse()
         return entries
 
@@ -355 +367 @@
         
         directory = []
-        
-        if (not head):
+        name83_list = []
+        
+        if not head:
                 # Directory cluster preallocation
                 empty_cluster = fat.index(0)
-                fat[empty_cluster] = 0xffff
+                fat[empty_cluster] = 0xFFFF
                 
                 directory.append(create_dot_dirent(empty_cluster))
@@ -366 +379 @@
                 empty_cluster = 0
         
-        for item in listdir_items(root):                
+        for item in listdir_items(root):
                 if item.is_file:
                         rv = write_file(item, outf, cluster_size, data_start, fat, reserved_clusters)
-                        directory.extend(create_dirent(item.name, False, rv[0], rv[1]))
+                        directory.extend(create_dirent(item.name, name83_list, 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.extend(create_dirent(item.name, True, rv[0], rv[1]))
-        
-        if (head):
+                        directory.extend(create_dirent(item.name, name83_list, True, rv[0], rv[1]))
+        
+        if head:
                 outf.seek(root_start)
                 for dir_entry in directory:
@@ -431 +444 @@
         extra_bytes = int(sys.argv[1])
         
-        path = os.path.abspath(sys.argv[2])
+        path = os.path.abspath(sys.argv[2].decode())
         if (not os.path.isdir(path)):
                 print("<PATH> must be a directory")
@@ -529 +542 @@
         
         outf.close()
-        
+
 if __name__ == '__main__':
         main()

uspace/app/tester/Makefile

@@ -50 +50 @@
         vfs/vfs1.c \
         ipc/ping_pong.c \
+        ipc/starve.c \
         loop/loop1.c \
         mm/common.c \

uspace/app/tester/tester.c

@@ -60 +60 @@
 #include "vfs/vfs1.def"
 #include "ipc/ping_pong.def"
+#include "ipc/starve.def"
 #include "loop/loop1.def"
 #include "mm/malloc1.def"

uspace/app/tester/tester.h

@@ -93 +93 @@
 extern const char *test_vfs1(void);
 extern const char *test_ping_pong(void);
+extern const char *test_starve_ipc(void);
 extern const char *test_loop1(void);
 extern const char *test_malloc1(void);

uspace/lib/c/generic/async.c

@@ -189 +189 @@
         /** If reply was received. */
         bool done;
+
+        /** If the message / reply should be discarded on arrival. */
+        bool forget;
+
+        /** If already destroyed. */
+        bool destroyed;
         
         /** Pointer to where the answer data is stored. */
@@ -240 +246 @@
 /** Identifier of the incoming connection handled by the current fibril. */
 static fibril_local connection_t *fibril_connection;
+
+static void to_event_initialize(to_event_t *to)
+{
+        struct timeval tv = { 0, 0 };
+
+        to->inlist = false;
+        to->occurred = false;
+        link_initialize(&to->link);
+        to->expires = tv;
+}
+
+static void wu_event_initialize(wu_event_t *wu)
+{
+        wu->inlist = false;
+        link_initialize(&wu->link);
+}
+
+void awaiter_initialize(awaiter_t *aw)
+{
+        aw->fid = 0;
+        aw->active = false;
+        to_event_initialize(&aw->to_event);
+        wu_event_initialize(&aw->wu_event);
+}
+
+static amsg_t *amsg_create(void)
+{
+        amsg_t *msg;
+
+        msg = malloc(sizeof(amsg_t));
+        if (msg) {
+                msg->done = false;
+                msg->forget = false;
+                msg->destroyed = false;
+                msg->dataptr = NULL;
+                msg->retval = (sysarg_t) EINVAL;
+                awaiter_initialize(&msg->wdata);
+        }
+
+        return msg;
+}
+
+static void amsg_destroy(amsg_t *msg)
+{
+        assert(!msg->destroyed);
+        msg->destroyed = true;
+        free(msg);
+}
 
 static void *default_client_data_constructor(void)
@@ -963 +1017 @@
                 
                 suseconds_t timeout;
+                unsigned int flags = SYNCH_FLAGS_NONE;
                 if (!list_empty(&timeout_list)) {
                         awaiter_t *waiter = list_get_instance(
@@ -973 +1028 @@
                                 futex_up(&async_futex);
                                 handle_expired_timeouts();
-                                continue;
-                        } else
+                                /*
+                                 * Notice that even if the event(s) already
+                                 * expired (and thus the other fibril was
+                                 * supposed to be running already),
+                                 * we check for incoming IPC.
+                                 *
+                                 * Otherwise, a fibril that continuously
+                                 * creates (almost) expired events could
+                                 * prevent IPC retrieval from the kernel.
+                                 */
+                                timeout = 0;
+                                flags = SYNCH_FLAGS_NON_BLOCKING;
+
+                        } else {
                                 timeout = tv_sub(&waiter->to_event.expires, &tv);
-                } else
+                                futex_up(&async_futex);
+                        }
+                } else {
+                        futex_up(&async_futex);
                         timeout = SYNCH_NO_TIMEOUT;
-                
-                futex_up(&async_futex);
+                }
                 
                 atomic_inc(&threads_in_ipc_wait);
                 
                 ipc_call_t call;
-                ipc_callid_t callid = ipc_wait_cycle(&call, timeout,
-                    SYNCH_FLAGS_NONE);
+                ipc_callid_t callid = ipc_wait_cycle(&call, timeout, flags);
                 
                 atomic_dec(&threads_in_ipc_wait);
@@ -1100 +1168 @@
         
         msg->done = true;
-        if (!msg->wdata.active) {
+
+        if (msg->forget) {
+                assert(msg->wdata.active);
+                amsg_destroy(msg);
+        } else if (!msg->wdata.active) {
                 msg->wdata.active = true;
                 fibril_add_ready(msg->wdata.fid);
         }
-        
+
         futex_up(&async_futex);
 }
@@ -1131 +1203 @@
                 return 0;
         
-        amsg_t *msg = malloc(sizeof(amsg_t));
+        amsg_t *msg = amsg_create();
         if (msg == NULL)
                 return 0;
         
-        msg->done = false;
         msg->dataptr = dataptr;
-        
-        msg->wdata.to_event.inlist = false;
-        
-        /*
-         * We may sleep in the next method,
-         * but it will use its own means
-         */
         msg->wdata.active = true;
         
@@ -1177 +1241 @@
                 return 0;
         
-        amsg_t *msg = malloc(sizeof(amsg_t));
-        
+        amsg_t *msg = amsg_create();
         if (msg == NULL)
                 return 0;
         
-        msg->done = false;
         msg->dataptr = dataptr;
-        
-        msg->wdata.to_event.inlist = false;
-        
-        /*
-         * We may sleep in the next method,
-         * but it will use its own means
-         */
         msg->wdata.active = true;
         
@@ -1213 +1268 @@
         
         futex_down(&async_futex);
+
+        assert(!msg->forget);
+        assert(!msg->destroyed);
+
         if (msg->done) {
                 futex_up(&async_futex);
@@ -1231 +1290 @@
                 *retval = msg->retval;
         
-        free(msg);
+        amsg_destroy(msg);
 }
 
 /** Wait for a message sent by the async framework, timeout variant.
+ *
+ * If the wait times out, the caller may choose to either wait again by calling
+ * async_wait_for() or async_wait_timeout(), or forget the message via
+ * async_forget().
  *
  * @param amsgid  Hash of the message to wait for.
@@ -1249 +1312 @@
         
         amsg_t *msg = (amsg_t *) amsgid;
-        
-        /* TODO: Let it go through the event read at least once */
-        if (timeout < 0)
-                return ETIMEOUT;
-        
+
         futex_down(&async_futex);
+
+        assert(!msg->forget);
+        assert(!msg->destroyed);
+
         if (msg->done) {
                 futex_up(&async_futex);
@@ -1260 +1323 @@
         }
         
+        /*
+         * Negative timeout is converted to zero timeout to avoid
+         * using tv_add with negative augmenter.
+         */
+        if (timeout < 0)
+                timeout = 0;
+
         gettimeofday(&msg->wdata.to_event.expires, NULL);
         tv_add(&msg->wdata.to_event.expires, timeout);
         
+        /*
+         * Current fibril is inserted as waiting regardless of the
+         * "size" of the timeout.
+         *
+         * Checking for msg->done and immediately bailing out when
+         * timeout == 0 would mean that the manager fibril would never
+         * run (consider single threaded program).
+         * Thus the IPC answer would be never retrieved from the kernel.
+         *
+         * Notice that the actual delay would be very small because we
+         * - switch to manager fibril
+         * - the manager sees expired timeout
+         * - and thus adds us back to ready queue
+         * - manager switches back to some ready fibril
+         *   (prior it, it checks for incoming IPC).
+         *
+         */
         msg->wdata.fid = fibril_get_id();
         msg->wdata.active = false;
@@ -1279 +1366 @@
                 *retval = msg->retval;
         
-        free(msg);
+        amsg_destroy(msg);
         
         return 0;
 }
+ 
+/** Discard the message / reply on arrival.
+ *
+ * The message will be marked to be discarded once the reply arrives in
+ * reply_received(). It is not allowed to call async_wait_for() or
+ * async_wait_timeout() on this message after a call to this function.
+ *
+ * @param amsgid  Hash of the message to forget.
+ */
+void async_forget(aid_t amsgid)
+{
+        amsg_t *msg = (amsg_t *) amsgid;
+
+        assert(msg);
+        assert(!msg->forget);
+        assert(!msg->destroyed);
+
+        futex_down(&async_futex);
+        if (msg->done)
+                amsg_destroy(msg);
+        else 
+                msg->forget = true;
+        futex_up(&async_futex);
+}
 
 /** Wait for specified time.
@@ -1293 +1404 @@
 void async_usleep(suseconds_t timeout)
 {
-        amsg_t *msg = malloc(sizeof(amsg_t));
-        
+        amsg_t *msg = amsg_create();
         if (!msg)
                 return;
         
         msg->wdata.fid = fibril_get_id();
-        msg->wdata.active = false;
         
         gettimeofday(&msg->wdata.to_event.expires, NULL);
@@ -1313 +1422 @@
         /* Futex is up automatically after fibril_switch() */
         
-        free(msg);
+        amsg_destroy(msg);
 }
 
@@ -1584 +1693 @@
         ipc_call_t result;
         
-        amsg_t *msg = malloc(sizeof(amsg_t));
-        if (msg == NULL) {
+        amsg_t *msg = amsg_create();
+        if (!msg) {
                 free(sess);
                 errno = ENOMEM;
@@ -1591 +1700 @@
         }
         
-        msg->done = false;
         msg->dataptr = &result;
-        
-        msg->wdata.to_event.inlist = false;
-        
-        /*
-         * We may sleep in the next method,
-         * but it will use its own means
-         */
         msg->wdata.active = true;
         
@@ -1643 +1744 @@
         ipc_call_t result;
         
-        amsg_t *msg = malloc(sizeof(amsg_t));
-        if (msg == NULL)
+        amsg_t *msg = amsg_create();
+        if (!msg)
                 return ENOENT;
         
-        msg->done = false;
         msg->dataptr = &result;
-        
-        msg->wdata.to_event.inlist = false;
-        
-        /*
-         * We may sleep in the next method,
-         * but it will use its own means
-         */
         msg->wdata.active = true;
         
@@ -2251 +2344 @@
             IPC_FF_ROUTE_FROM_ME);
         if (retval != EOK) {
-                async_wait_for(msg, NULL);
+                async_forget(msg);
                 ipc_answer_0(callid, retval);
                 return retval;
@@ -2445 +2538 @@
             IPC_FF_ROUTE_FROM_ME);
         if (retval != EOK) {
-                async_wait_for(msg, NULL);
+                async_forget(msg);
                 ipc_answer_0(callid, retval);
                 return retval;

uspace/lib/c/generic/fibril_synch.c

@@ -112 +112 @@
                 awaiter_t wdata;
 
+                awaiter_initialize(&wdata);
                 wdata.fid = fibril_get_id();
-                wdata.active = false;
                 wdata.wu_event.inlist = true;
-                link_initialize(&wdata.wu_event.link);
                 list_append(&wdata.wu_event.link, &fm->waiters);
                 check_for_deadlock(&fm->oi);
@@ -205 +204 @@
                 awaiter_t wdata;
 
+                awaiter_initialize(&wdata);
                 wdata.fid = (fid_t) f;
-                wdata.active = false;
                 wdata.wu_event.inlist = true;
-                link_initialize(&wdata.wu_event.link);
                 f->flags &= ~FIBRIL_WRITER;
                 list_append(&wdata.wu_event.link, &frw->waiters);
@@ -233 +231 @@
                 awaiter_t wdata;
 
+                awaiter_initialize(&wdata);
                 wdata.fid = (fid_t) f;
-                wdata.active = false;
                 wdata.wu_event.inlist = true;
-                link_initialize(&wdata.wu_event.link);
                 f->flags |= FIBRIL_WRITER;
                 list_append(&wdata.wu_event.link, &frw->waiters);
@@ -375 +372 @@
                 return ETIMEOUT;
 
+        awaiter_initialize(&wdata);
         wdata.fid = fibril_get_id();
-        wdata.active = false;
-        
         wdata.to_event.inlist = timeout > 0;
-        wdata.to_event.occurred = false;
-        link_initialize(&wdata.to_event.link);
-
         wdata.wu_event.inlist = true;
-        link_initialize(&wdata.wu_event.link);
 
         futex_down(&async_futex);

uspace/lib/c/generic/private/async.h

@@ -81 +81 @@
 } awaiter_t;
 
+extern void awaiter_initialize(awaiter_t *);
+
 extern void __async_init(void);
 extern void async_insert_timeout(awaiter_t *);

uspace/lib/c/include/async.h

@@ -139 +139 @@
 extern void async_wait_for(aid_t, sysarg_t *);
 extern int async_wait_timeout(aid_t, sysarg_t *, suseconds_t);
+extern void async_forget(aid_t);
 
 extern fid_t async_new_connection(task_id_t, sysarg_t, ipc_callid_t,

uspace/srv/fs/fat/fat_dentry.c

@@ -334 +334 @@
         while (i < count) {
                 if ((ch = str_decode(src, &off, STR_NO_LIMIT)) != 0) {
-                        if (ascii_check(ch) & IS_D_CHAR(ch))
+                        if (ascii_check(ch) && IS_D_CHAR(ch))
                                 *dst = toupper(ch);
                         else

uspace/srv/fs/fat/fat_directory.c

@@ -162 +162 @@
         int rc;
 
+        void *data;
+        fat_instance_t *instance;
+
+        rc = fs_instance_get(di->nodep->idx->service_id, &data);
+        assert(rc == EOK);
+        instance = (fat_instance_t *) data;
+        
         do {
                 rc = fat_directory_get(di, &d);
@@ -177 +184 @@
                                 long_entry_count--;
                                 if ((FAT_LFN_ORDER(d) == long_entry_count) && 
-                                        (checksum == FAT_LFN_CHKSUM(d))) {
+                                    (checksum == FAT_LFN_CHKSUM(d))) {
                                         /* Right order! */
                                         fat_lfn_get_entry(d, wname,
@@ -189 +196 @@
                                         long_entry = false;
                                 }
-                        } else if (FAT_IS_LFN(d)) {
+                        } else if (FAT_IS_LFN(d) && instance->lfn_enabled) {
                                 /* We found Last long entry! */
                                 if (FAT_LFN_COUNT(d) <= FAT_LFN_MAX_COUNT) {
@@ -308 +315 @@
                 checksum = fat_dentry_chksum(de->name);
 
-                rc = fat_directory_seek(di, start_pos+long_entry_count);
+                rc = fat_directory_seek(di, start_pos + long_entry_count);
                 if (rc != EOK)
                         return rc;