Fix broken SpinLock.

The SpinLock was all backwards and didn't actually work. Fixing it exposed
how wrong most of the locking here is.

I need to come up with a better granularity here.

AK/Lock.h

@@ -2,6 +2,20 @@
 
 #include "Types.h"
 
+#ifdef SERENITY
+#include "i386.h"
+#else
+typedef int InterruptDisabler;
+#endif
+
+//#define DEBUG_LOCKS
+
+void log_try_lock(const char*);
+void log_locked(const char*);
+void log_unlocked(const char*);
+
+void yield();
+
 namespace AK {
 
 static inline dword CAS(volatile dword* mem, dword newval, dword oldval)
@@ -9,28 +23,46 @@ static inline dword CAS(volatile dword* mem, dword newval, dword oldval)
     dword ret;
     asm volatile(
         "cmpxchgl %2, %1"
-        :"=a"(ret), "=m"(*mem)
+        :"=a"(ret), "+m"(*mem)
-        :"r"(newval), "m"(*mem), "0"(oldval));
+        :"r"(newval), "0"(oldval)
+        :"memory");
     return ret;
 }
 
 class SpinLock {
 public:
     SpinLock() { }
-    ~SpinLock() { unlock(); }
+    ~SpinLock() { }
 
-    void lock()
+    void lock(const char* func = nullptr)
     {
+#ifdef DEBUG_LOCKS
+        {
+            InterruptDisabler dis;
+            log_try_lock(func);
+        }
+#endif
         for (;;) {
-            if (CAS(&m_lock, 1, 0) == 1)
+            if (CAS(&m_lock, 1, 0) == 0) {
+#ifdef DEBUG_LOCKS
+                InterruptDisabler dis;
+                log_locked(func);
+#endif
                 return;
+            }
+            yield();
         }
     }
 
-    void unlock()
+    void unlock(const char* func = nullptr)
     {
         // barrier();
+        ASSERT(m_lock);
         m_lock = 0;
+#ifdef DEBUG_LOCKS
+        InterruptDisabler dis;
+        log_unlocked(func);
+#endif
     }
 
     void init()
@@ -44,14 +76,18 @@ private:
 
 class Locker {
 public:
-    explicit Locker(SpinLock& l) : m_lock(l) { m_lock.lock(); }
+    explicit Locker(SpinLock& l, const char* func) : m_lock(l), m_func(func) { lock(); }
     ~Locker() { unlock(); }
-    void unlock() { m_lock.unlock(); }
+    void unlock() { m_lock.unlock(m_func); }
+    void lock() { m_lock.lock(m_func); }
 
 private:
     SpinLock& m_lock;
+    const char* m_func { nullptr };
 };
 
+#define LOCKER(lock) Locker locker(lock, __FUNCTION__)
+
 }
 
 using AK::SpinLock;

AK/StringBuilder.cpp

@@ -18,7 +18,7 @@ String StringBuilder::build()
     if (strings.isEmpty())
         return String::empty();
 
-    size_t sizeNeeded = 1;
+    size_t sizeNeeded = 0;
     for (auto& string : strings)
         sizeNeeded += string.length();
 

AK/Traits.h

@@ -29,7 +29,7 @@ struct Traits<T*> {
 #ifdef SERENITY
         return intHash((dword)p);
 #else
-        return intHash((ptrdiff_t)p & 0xffffffff);
+        return intHash((unsigned long long)p & 0xffffffff);
 #endif
     }
     static void dump(const T* p) { kprintf("%p", p); }

AK/test.cpp

@@ -11,13 +11,22 @@
 #include "WeakPtr.h"
 #include "CircularQueue.h"
 #include "FileSystemPath.h"
+#include "Lock.h"
 
 static void testWeakPtr();
 
+void log_locked() { }
+void log_unlocked() { }
+
 int main(int c, char** v)
 {
     StringImpl::initializeGlobals();
 
+    {
+        SpinLock lock;
+        Locker locker(lock);
+    }
+
     {
         const char* testpath = "/proc/../proc/1/../../proc/1/vm";
         if (c == 2)

ELFLoader/ELFImage.cpp

@@ -178,7 +178,7 @@ const ELFImage::RelocationSection ELFImage::Section::relocations() const
 {
     // FIXME: This is ugly.
     char relocationSectionName[128];
-    int x = ksprintf(relocationSectionName, ".rel%s", name());
+    ksprintf(relocationSectionName, ".rel%s", name());
 
 #ifdef ELFIMAGE_DEBUG
     kprintf("looking for '%s'\n", relocationSectionName);

Kernel/Console.cpp

@@ -28,11 +28,10 @@ bool Console::hasDataAvailableForRead() const
     return false;
 }
 
-ssize_t Console::read(byte* buffer, size_t bufferSize)
+ssize_t Console::read(byte*, size_t)
 {
     // FIXME: Implement reading from the console.
     //        Maybe we could use a ring buffer for this device?
-    //        A generalized ring buffer would probably be useful.
     return 0;
 }
 

Kernel/Syscall.cpp

@@ -41,18 +41,15 @@ asm(
 
 namespace Syscall {
 
-static SpinLock* s_lock;
-
 void initialize()
 {
-    s_lock = new SpinLock;
     registerUserCallableInterruptHandler(0x80, syscall_ISR);
     kprintf("syscall: int 0x80 handler installed\n");
 }
 
 DWORD handle(DWORD function, DWORD arg1, DWORD arg2, DWORD arg3)
 {
-    Locker locker(*s_lock);
+    ASSERT_INTERRUPTS_ENABLED();
     switch (function) {
     case Syscall::Yield:
         yield();
@@ -73,8 +70,7 @@ DWORD handle(DWORD function, DWORD arg1, DWORD arg2, DWORD arg3)
     case Syscall::PosixGetcwd:
         return current->sys$getcwd((char*)arg1, (size_t)arg2);
     case Syscall::PosixOpen:
-        //kprintf("syscall: open('%s', %u)\n", arg1, arg2);
+        return current->sys$open((const char*)arg1, (int)arg2);
-        return current->sys$open((const char*)arg1, (size_t)arg2);
     case Syscall::PosixClose:
         //kprintf("syscall: close(%d)\n", arg1);
         return current->sys$close((int)arg1);
@@ -104,7 +100,7 @@ DWORD handle(DWORD function, DWORD arg1, DWORD arg2, DWORD arg3)
         return current->sys$gethostname((char*)arg1, (size_t)arg2);
     case Syscall::PosixExit:
         cli();
-        locker.unlock();
+        //locker.unlock();
         current->sys$exit((int)arg1);
         ASSERT_NOT_REACHED();
         return 0;

Kernel/Task.cpp

@@ -17,6 +17,7 @@
 
 //#define DEBUG_IO
 //#define TASK_DEBUG
+//#define SCHEDULER_DEBUG
 
 #define VALIDATE_USER_BUFFER(b, s) \
     do { \
@@ -605,12 +606,12 @@ bool scheduleNewTask()
         }
     }
 
-#if 0
+#ifdef SCHEDULER_DEBUG
-    kprintf("Scheduler choices:\n");
+    dbgprintf("Scheduler choices:\n");
     for (auto* task = s_tasks->head(); task; task = task->next()) {
-        if (task->state() == Task::BlockedWait || task->state() == Task::BlockedSleep)
+        //if (task->state() == Task::BlockedWait || task->state() == Task::BlockedSleep)
-            continue;
+//            continue;
-        kprintf("%w %s(%u)\n", task->state(), task->name().characters(), task->pid());
+        dbgprintf("%w %s(%u)\n", task->state(), task->name().characters(), task->pid());
     }
 #endif
 
@@ -621,7 +622,9 @@ bool scheduleNewTask()
         auto* task = s_tasks->head();
 
         if (task->state() == Task::Runnable || task->state() == Task::Running) {
-            //kprintf("switch to %s (%p vs %p)\n", task->name().characters(), task, current);
+#ifdef SCHEDULER_DEBUG
+            dbgprintf("switch to %s(%u) (%p vs %p)\n", task->name().characters(), task->pid(), task, current);
+#endif
             return contextSwitch(task);
         }
 
@@ -844,7 +847,7 @@ int Task::sys$open(const char* path, int options)
     if (m_fileHandles.size() >= m_maxFileHandles)
         return -EMFILE;
     int error;
-    auto handle = VirtualFileSystem::the().open(path, error, 0, cwdInode());
+    auto handle = VirtualFileSystem::the().open(path, error, options, cwdInode());
     if (!handle)
         return error;
     if (options & O_DIRECTORY && !handle->isDirectory())

Kernel/init.cpp

@@ -247,3 +247,17 @@ void init()
     }
 }
 
+void log_try_lock(const char* where)
+{
+    kprintf("[%u] >>> locking... (%s)\n", current->pid(), where);
+}
+
+void log_locked(const char* where)
+{
+    kprintf("[%u] >>> locked() in %s\n", current->pid(), where);
+}
+
+void log_unlocked(const char* where)
+{
+    kprintf("[%u] <<< unlocked()\n", current->pid(), where);
+}

Kernel/kassert.h

@@ -8,3 +8,4 @@
 #define RELEASE_ASSERT(x) do { if (!(x)) CRASH(); } while(0)
 #define ASSERT_NOT_REACHED() ASSERT(false)
 #define ASSERT_INTERRUPTS_DISABLED() ASSERT(!(cpuFlags() & 0x200))
+#define ASSERT_INTERRUPTS_ENABLED() ASSERT(cpuFlags() & 0x200)

Kernel/kmalloc.cpp

@@ -20,7 +20,7 @@ typedef struct
 } PACKED allocation_t;
 
 #define CHUNK_SIZE  128
-#define POOL_SIZE   (512 * 1024)
+#define POOL_SIZE   (1024 * 1024)
 
 #define BASE_PHYS   0x200000
 

Kernel/kprintf.cpp

@@ -1,10 +1,11 @@
 #include "kprintf.h"
 #include "Console.h"
+#include "IO.h"
 #include <stdarg.h>
 #include <AK/Types.h>
 #include <AK/printf.cpp>
 
-static void console_putch(char*, char ch)
+static void console_putch(char*&, char ch)
 {
     Console::the().write((byte*)&ch, 1);
 }
@@ -32,3 +33,17 @@ int ksprintf(char* buffer, const char* fmt, ...)
     va_end(ap);
     return ret;
 }
+
+static void debugger_putch(char*&, char ch)
+{
+    IO::out8(0xe9, ch);
+}
+
+int dbgprintf(const char* fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    int ret = printfInternal(debugger_putch, nullptr, fmt, ap);
+    va_end(ap);
+    return ret;
+}

Kernel/kprintf.h

@@ -2,6 +2,7 @@
 
 #include <AK/Compiler.h>
 
+int dbgprintf(const char *fmt, ...);
 int kprintf(const char *fmt, ...);
 int ksprintf(char* buf, const char *fmt, ...);
 

Userland/sh.cpp

@@ -17,7 +17,7 @@ static void prompt()
     if (getuid() == 0)
         printf("# ");
     else
-        printf("\033[32;1m%s\033[0m:\033[34;1m%s\033[0m$> ", g->hostname, g->cwd.characters());
+        printf("(%u) \033[32;1m%s\033[0m:\033[34;1m%s\033[0m$> ", getpid(), g->hostname, g->cwd.characters());
 }
 
 static int sh_pwd(int, const char**)
@@ -91,6 +91,21 @@ static bool handle_builtin(int argc, const char** argv, int& retval)
     return false;
 }
 
+static int try_spawn(const char* path, const char** argv)
+{
+    int ret = spawn(path, argv);
+    if (ret >= 0)
+        return ret;
+
+    const char* search_path = "/bin";
+    char pathbuf[128];
+    sprintf(pathbuf, "%s/%s", search_path, argv[0]);
+    ret = spawn(pathbuf, argv);
+    if (ret == -1)
+        return -1;
+    return ret;
+}
+
 static int runcmd(char* cmd)
 {
     if (cmd[0] == 0)
@@ -115,15 +130,12 @@ static int runcmd(char* cmd)
         return 0;
     }
 
-    const char* search_path = "/bin";
+    int ret = try_spawn(argv[0], argv);
-
+    if (ret < 0) {
-    char pathbuf[128];
-    sprintf(pathbuf, "%s/%s", search_path, argv[0]);
-    int ret = spawn(pathbuf, argv);
-    if (ret == -1) {
         printf("spawn failed: %s (%s)\n", cmd, strerror(errno));
         return 1;
     }
+
     // FIXME: waitpid should give us the spawned process's exit status
     int wstatus = 0;
     waitpid(ret, &wstatus, 0);

VirtualFileSystem/DiskBackedFileSystem.cpp

@@ -7,6 +7,7 @@ typedef int InterruptDisabler;
 #endif
 
 //#define DBFS_DEBUG
+#define BLOCK_CACHE
 
 DiskBackedFileSystem::DiskBackedFileSystem(RetainPtr<DiskDevice>&& device)
     : m_device(move(device))
@@ -42,6 +43,8 @@ ByteBuffer DiskBackedFileSystem::readBlock(unsigned index) const
 #ifdef DBFS_DEBUG
     kprintf("DiskBackedFileSystem::readBlock %u\n", index);
 #endif
+
+#ifdef BLOCK_CACHE
     {
         InterruptDisabler disabler;
         auto it = m_blockCache.find(index);
@@ -49,19 +52,24 @@ ByteBuffer DiskBackedFileSystem::readBlock(unsigned index) const
             return (*it).value;
         }
     }
+#endif
 
     auto buffer = ByteBuffer::createUninitialized(blockSize());
+    //kprintf("created block buffer with size %u\n", blockSize());
     DiskOffset baseOffset = static_cast<DiskOffset>(index) * static_cast<DiskOffset>(blockSize());
     auto* bufferPointer = buffer.pointer();
-    device().read(baseOffset, blockSize(), bufferPointer);
+    bool success = device().read(baseOffset, blockSize(), bufferPointer);
+    ASSERT(success);
     ASSERT(buffer.size() == blockSize());
 
+#ifdef BLOCK_CACHE
     {
         InterruptDisabler disabler;
         if (m_blockCache.size() >= 32)
             m_blockCache.removeOneRandomly();
         m_blockCache.set(index, buffer);
     }
+#endif
     return buffer;
 }
 

VirtualFileSystem/DiskDevice.cpp

@@ -10,6 +10,7 @@ DiskDevice::~DiskDevice()
 
 bool DiskDevice::read(DiskOffset offset, unsigned length, byte* out) const
 {
+    //kprintf("DD::read %u x%u\n", offset, length);
     ASSERT((offset % blockSize()) == 0);
     ASSERT((length % blockSize()) == 0);
     dword firstBlock = offset / blockSize();

VirtualFileSystem/Ext2FileSystem.cpp

@@ -293,7 +293,6 @@ Unix::ssize_t Ext2FileSystem::readInodeBytes(InodeIdentifier inode, Unix::off_t
     static const unsigned maxInlineSymlinkLength = 60;
     if (isSymbolicLink(e2inode->i_mode) && e2inode->i_size < maxInlineSymlinkLength) {
         Unix::ssize_t nread = min((Unix::off_t)e2inode->i_size - offset, static_cast<Unix::off_t>(count));
-        kprintf("nread = %d\n", nread);
         memcpy(buffer, e2inode->i_block + offset, nread);
         return nread;
     }

VirtualFileSystem/FileHandle.cpp

@@ -25,7 +25,7 @@ bool additionWouldOverflow(Unix::off_t a, Unix::off_t b)
 
 int FileHandle::stat(Unix::stat* buffer)
 {
-    Locker locker(VirtualFileSystem::lock());
+    LOCKER(VirtualFileSystem::lock());
 
     if (!m_vnode)
         return -EBADF;
@@ -52,7 +52,7 @@ int FileHandle::stat(Unix::stat* buffer)
 
 Unix::off_t FileHandle::seek(Unix::off_t offset, int whence)
 {
-    Locker locker(VirtualFileSystem::lock());
+    LOCKER(VirtualFileSystem::lock());
 
     if (!m_vnode)
         return -EBADF;
@@ -96,7 +96,7 @@ Unix::off_t FileHandle::seek(Unix::off_t offset, int whence)
 
 Unix::ssize_t FileHandle::read(byte* buffer, Unix::size_t count)
 {
-    Locker locker(VirtualFileSystem::lock());
+    LOCKER(VirtualFileSystem::lock());
 
     if (m_vnode->isCharacterDevice()) {
         // FIXME: What should happen to m_currentOffset?
@@ -116,7 +116,7 @@ bool FileHandle::hasDataAvailableForRead()
 
 ByteBuffer FileHandle::readEntireFile()
 {
-    Locker locker(VirtualFileSystem::lock());
+    LOCKER(VirtualFileSystem::lock());
 
     if (m_vnode->isCharacterDevice()) {
         auto buffer = ByteBuffer::createUninitialized(1024);
@@ -135,7 +135,7 @@ bool FileHandle::isDirectory() const
 
 ssize_t FileHandle::get_dir_entries(byte* buffer, Unix::size_t size)
 {
-    Locker locker(VirtualFileSystem::lock());
+    LOCKER(VirtualFileSystem::lock());
 
     auto metadata = m_vnode->metadata();
     if (!metadata.isValid())

VirtualFileSystem/FileSystem.cpp

@@ -78,11 +78,13 @@ ByteBuffer FileSystem::readEntireInode(InodeIdentifier inode, FileHandle* handle
     auto contents = ByteBuffer::createUninitialized(initialSize);
 
     Unix::ssize_t nread;
-    byte buffer[512];
+    byte buffer[4096];
     byte* out = contents.pointer();
     Unix::off_t offset = 0;
     for (;;) {
         nread = readInodeBytes(inode, offset, sizeof(buffer), buffer, handle);
+        //kprintf("nread: %u, bufsiz: %u, initialSize: %u\n", nread, sizeof(buffer), initialSize);
+        ASSERT(nread <= sizeof(buffer));
         if (nread <= 0)
             break;
         memcpy(out, buffer, nread);
@@ -95,6 +97,7 @@ ByteBuffer FileSystem::readEntireInode(InodeIdentifier inode, FileHandle* handle
         return nullptr;
     }
 
+    contents.trim(offset);
     return contents;
 }
 

VirtualFileSystem/Makefile

@@ -6,6 +6,7 @@ AK_OBJS = \
     ../AK/MappedFile.o \
     ../AK/TemporaryFile.o \
     ../AK/SimpleMalloc.o \
+    ../AK/StringBuilder.o \
     ../AK/kmalloc.o
 
 VFS_OBJS = \

VirtualFileSystem/SyntheticFileSystem.cpp

@@ -2,6 +2,11 @@
 #include "FileHandle.h"
 #include <AK/StdLib.h>
 
+#ifndef SERENITY
+typedef int InterruptDisabler;
+#define ASSERT_INTERRUPTS_DISABLED()
+#endif
+
 //#define SYNTHFS_DEBUG
 
 RetainPtr<SyntheticFileSystem> SyntheticFileSystem::create()
@@ -31,11 +36,10 @@ bool SyntheticFileSystem::initialize()
     rootDir->metadata.mtime = mepoch;
     m_inodes.set(RootInodeIndex, move(rootDir));
 
-#if 0
 #ifndef SERENITY
     addFile(createTextFile("file", "I'm a synthetic file!\n"));
     addFile(createTextFile("message", "Hey! This isn't my bottle!\n"));
-#endif
+    addFile(createGeneratedFile("lunk", [] { return String("/home/andreas/file1").toByteBuffer(); }, 00120777));
 #endif
     return true;
 }
@@ -60,7 +64,7 @@ auto SyntheticFileSystem::createTextFile(String&& name, String&& text) -> OwnPtr
     file->metadata.size = file->data.size();
     file->metadata.uid = 100;
     file->metadata.gid = 200;
-    file->metadata.mode = 0040644;
+    file->metadata.mode = 0010644;
     file->metadata.mtime = mepoch;
     return file;
 }

VirtualFileSystem/VirtualFileSystem.cpp

@@ -103,10 +103,11 @@ auto VirtualFileSystem::getOrCreateNode(InodeIdentifier inode) -> RetainPtr<Node
 
 bool VirtualFileSystem::mount(RetainPtr<FileSystem>&& fileSystem, const String& path)
 {
+    kprintf("mount\n");
+    LOCKER(VirtualFileSystem::lock());
     ASSERT(fileSystem);
-
     int error;
-    auto inode = resolvePath(path, error);
+    auto inode = resolvePath(path, error, locker);
     if (!inode.isValid()) {
         kprintf("[VFS] mount can't resolve mount point '%s'\n", path.characters());
         return false;
@@ -150,6 +151,7 @@ bool VirtualFileSystem::mountRoot(RetainPtr<FileSystem>&& fileSystem)
 
 auto VirtualFileSystem::allocateNode() -> RetainPtr<Node>
 {
+
     if (m_nodeFreeList.isEmpty()) {
         kprintf("[VFS] allocateNode has no nodes left\n");
         return nullptr;
@@ -172,6 +174,7 @@ void VirtualFileSystem::freeNode(Node* node)
     m_nodeFreeList.append(move(node));
 }
 
+#ifndef SERENITY
 bool VirtualFileSystem::isDirectory(const String& path, InodeIdentifier base)
 {
     int error;
@@ -181,6 +184,7 @@ bool VirtualFileSystem::isDirectory(const String& path, InodeIdentifier base)
 
     return inode.metadata().isDirectory();
 }
+#endif
 
 auto VirtualFileSystem::findMountForHost(InodeIdentifier inode) -> Mount*
 {
@@ -227,6 +231,7 @@ void VirtualFileSystem::enumerateDirectoryInode(InodeIdentifier directoryInode,
     });
 }
 
+#ifndef SERENITY
 void VirtualFileSystem::listDirectory(const String& path)
 {
     int error;
@@ -351,13 +356,14 @@ void VirtualFileSystem::listDirectoryRecursively(const String& path)
         return true;
     });
 }
+#endif
 
 bool VirtualFileSystem::touch(const String& path)
 {
-    Locker locker(VirtualFileSystem::lock());
+    LOCKER(VirtualFileSystem::lock());
 
     int error;
-    auto inode = resolvePath(path, error);
+    auto inode = resolvePath(path, error, locker);
     if (!inode.isValid())
         return false;
     return inode.fileSystem()->setModificationTime(inode, ktime(nullptr));
@@ -365,9 +371,9 @@ bool VirtualFileSystem::touch(const String& path)
 
 OwnPtr<FileHandle> VirtualFileSystem::open(const String& path, int& error, int options, InodeIdentifier base)
 {
-    Locker locker(VirtualFileSystem::lock());
+    LOCKER(VirtualFileSystem::lock());
 
-    auto inode = resolvePath(path, error, base, options);
+    auto inode = resolvePath(path, error, locker, base, options);
     if (!inode.isValid())
         return nullptr;
     auto vnode = getOrCreateNode(inode);
@@ -378,7 +384,7 @@ OwnPtr<FileHandle> VirtualFileSystem::open(const String& path, int& error, int o
 
 OwnPtr<FileHandle> VirtualFileSystem::create(const String& path, InodeIdentifier base)
 {
-    Locker locker(VirtualFileSystem::lock());
+    LOCKER(VirtualFileSystem::lock());
 
     // FIXME: Do the real thing, not just this fake thing!
     (void) path;
@@ -388,26 +394,29 @@ OwnPtr<FileHandle> VirtualFileSystem::create(const String& path, InodeIdentifier
 
 OwnPtr<FileHandle> VirtualFileSystem::mkdir(const String& path, InodeIdentifier base)
 {
-    Locker locker(VirtualFileSystem::lock());
+    LOCKER(VirtualFileSystem::lock());
-
     // FIXME: Do the real thing, not just this fake thing!
     (void) path;
     m_rootNode->fileSystem()->makeDirectory(m_rootNode->fileSystem()->rootInode(), "mydir", 0400755);
     return nullptr;
 }
 
-InodeIdentifier VirtualFileSystem::resolveSymbolicLink(InodeIdentifier base, InodeIdentifier symlinkInode, int& error)
+InodeIdentifier VirtualFileSystem::resolveSymbolicLink(InodeIdentifier base, InodeIdentifier symlinkInode, int& error, Locker& locker)
 {
+    locker.unlock();
     auto symlinkContents = symlinkInode.readEntireFile();
+    locker.lock();
     if (!symlinkContents)
         return { };
-    return resolvePath((const char*)symlinkContents.pointer(), error, base);
+    auto linkee = String((const char*)symlinkContents.pointer(), symlinkContents.size());
+#ifdef VFS_DEBUG
+    kprintf("linkee (%s)(%u) from %u:%u\n", linkee.characters(), linkee.length(), base.fileSystemID(), base.index());
+#endif
+    return resolvePath(linkee, error, locker, base);
 }
 
-String VirtualFileSystem::absolutePath(InodeIdentifier inode)
+String VirtualFileSystem::absolutePathInternal(InodeIdentifier inode, Locker& locker)
 {
-    Locker locker(VirtualFileSystem::lock());
-
     if (!inode.isValid())
         return String();
 
@@ -419,7 +428,7 @@ String VirtualFileSystem::absolutePath(InodeIdentifier inode)
         else
             lineage.append(inode);
         if (inode.metadata().isDirectory()) {
-            inode = resolvePath("..", error, inode);
+            inode = resolvePath("..", error, locker, inode);
         } else
             inode = inode.fileSystem()->findParentOfInode(inode);
         ASSERT(inode.isValid());
@@ -439,7 +448,13 @@ String VirtualFileSystem::absolutePath(InodeIdentifier inode)
     return builder.build();
 }
 
-InodeIdentifier VirtualFileSystem::resolvePath(const String& path, int& error, InodeIdentifier base, int options)
+String VirtualFileSystem::absolutePath(InodeIdentifier inode)
+{
+    LOCKER(VirtualFileSystem::lock());
+    return absolutePathInternal(inode, locker);
+}
+
+InodeIdentifier VirtualFileSystem::resolvePath(const String& path, int& error, Locker& locker, InodeIdentifier base, int options)
 {
     if (path.isEmpty())
         return { };
@@ -465,7 +480,7 @@ InodeIdentifier VirtualFileSystem::resolvePath(const String& path, int& error, I
         }
         if (!metadata.isDirectory()) {
 #ifdef VFS_DEBUG
-            kprintf("not directory\n");
+            kprintf("parent of <%s> not directory, it's inode %u:%u / %u:%u, mode: %u, size: %u\n", part.characters(), inode.fileSystemID(), inode.index(), metadata.inode.fileSystemID(), metadata.inode.index(), metadata.mode, metadata.size);
 #endif
             error = -EIO;
             return { };
@@ -474,7 +489,7 @@ InodeIdentifier VirtualFileSystem::resolvePath(const String& path, int& error, I
         inode = inode.fileSystem()->childOfDirectoryInodeWithName(inode, part);
         if (!inode.isValid()) {
 #ifdef VFS_DEBUG
-            kprintf("bad child\n");
+            kprintf("child <%s>(%u) not found in directory, %02u:%08u\n", part.characters(), part.length(), parent.fileSystemID(), parent.index());
 #endif
             error = -ENOENT;
             return { };
@@ -506,12 +521,7 @@ InodeIdentifier VirtualFileSystem::resolvePath(const String& path, int& error, I
                 if (options & O_NOFOLLOW_NOERROR)
                     return inode;
             }
-            char buf[4096] = "";
+            inode = resolveSymbolicLink(parent, inode, error, locker);
-            char* p = buf;
-            for (unsigned j = 0; j < i; ++j) {
-                p += ksprintf(p, "/%s", parts[j].characters());
-            }
-            inode = resolveSymbolicLink(parent, inode, error);
             if (!inode.isValid()) {
                 kprintf("Symbolic link resolution failed :(\n");
                 return { };

VirtualFileSystem/VirtualFileSystem.h

@@ -104,9 +104,11 @@ public:
 private:
     friend class FileHandle;
 
+    String absolutePathInternal(InodeIdentifier, Locker&);
+
     void enumerateDirectoryInode(InodeIdentifier, Function<bool(const FileSystem::DirectoryEntry&)>);
-    InodeIdentifier resolvePath(const String& path, int& error, InodeIdentifier base = InodeIdentifier(), int options = 0);
+    InodeIdentifier resolvePath(const String& path, int& error, Locker&, InodeIdentifier base = InodeIdentifier(), int options = 0);
-    InodeIdentifier resolveSymbolicLink(InodeIdentifier base, InodeIdentifier symlinkInode, int& error);
+    InodeIdentifier resolveSymbolicLink(InodeIdentifier base, InodeIdentifier symlinkInode, int& error, Locker&);
 
     RetainPtr<Node> allocateNode();
     void freeNode(Node*);

VirtualFileSystem/test.cpp

@@ -53,7 +53,8 @@ int main(int c, char** v)
     //return 0;
 
     if (!strcmp(v[0], "./vcat")) {
-        auto handle = vfs.open(v[2]);
+        int error;
+        auto handle = vfs.open(v[2], error);
         if (!handle) {
             printf("failed to open %s inside fs image\n", v[2]);
             return 1;
@@ -149,7 +150,8 @@ int main(int c, char** v)
         if (cmd == "stat" && parts.size() > 1) {
             char buf[1024];
             sprintf(buf, "%s/%s", currentDirectory.characters(), parts[1].characters());
-            auto handle = vfs.open(buf);
+            int error;
+            auto handle = vfs.open(buf, error);
             if (!handle) {
                 printf("Can't open '%s' :(\n", buf);
                 continue;
@@ -179,7 +181,8 @@ int main(int c, char** v)
         if (cmd == "cat" && parts.size() > 1) {
             char pathbuf[1024];
             sprintf(pathbuf, "%s/%s", currentDirectory.characters(), parts[1].characters());
-            auto handle = vfs.open(pathbuf);
+            int error;
+            auto handle = vfs.open(pathbuf, error);
             if (!handle) {
                 printf("failed to open %s\n", pathbuf);
                 continue;
@@ -192,7 +195,8 @@ int main(int c, char** v)
         if (cmd == "kat" && parts.size() > 1) {
             char pathbuf[1024];
             sprintf(pathbuf, "%s/%s", currentDirectory.characters(), parts[1].characters());
-            auto handle = vfs.open(pathbuf);
+            int error;
+            auto handle = vfs.open(pathbuf, error);
             if (!handle) {
                 printf("failed to open %s\n", pathbuf);
                 continue;