Introduce file executable flag in FFS and expose it to user app

Author: scopeInfinity

Makefile

@@ -79,7 +79,7 @@ NASM=nasm -f elf32 -i include/ $(NASM_DEBUG)
 
 CC=gcc -std=c11 -fno-builtin -Os -nostartfiles -nostdlib -static $(CC_DEBUG)
 KERNEL_CC = $(CC) -m32 -fno-pie -Isrc --sysroot=$(BUILD_DIR) -Iinclude -Isrc/usr/include
-USER_CC = $(CC) -m32 -fno-pie -Isrc --sysroot=$(BUILD_DIR)
+USER_CC = $(CC) -m32 -fno-pie -Isrc --sysroot=$(BUILD_DIR) -Isrc/usr/include
 
 LD=ld -nostdlib -nostartfiles -nodefaultlibs $(LD_DEBUG)
 KERNEL_LD=$(LD) -m elf_i386 -T linker.ld -Ttext 0x0

external/src/mkfs_ffs.c

@@ -18,7 +18,9 @@ void write_first_block(FILE *out) {
     fwrite(block.bytes, 1, sizeof(block.bytes), out);
 }
 
-void write_file(int file_id, FILE *outfile, int *outfile_nextdata_block, const char *filename, FILE *srcfile) {
+void write_file(int file_id, FILE *outfile, int *outfile_nextdata_block,
+        const char *filename, FILE *srcfile,
+        int is_executable) {
     fseek(srcfile, 0L, SEEK_END);
     int file_size = ftell(srcfile);
     rewind(srcfile);
@@ -27,6 +29,10 @@ void write_file(int file_id, FILE *outfile, int *outfile_nextdata_block, const c
     strncpy(entry.content.filename, filename, sizeof(entry.content.filename));
     entry.content.filesize = file_size;
     entry.content.start_block_id = (*outfile_nextdata_block);
+    entry.content.flags = 0;
+    if (is_executable) {
+        entry.content.flags |= FFS_FILE_FLAG_EXECUTABLE;
+    }
 
     // Write file entry
     fseek(outfile, FILEENTRY_LOCATION(file_id), SEEK_SET);
@@ -88,9 +94,10 @@ int create_partition(char *src_dir, char *out_filepath) {
             fprintf("skipping non-regular file '%s': %d", buffer_filename, file_stat.st_mode);
             continue;
         }
+        int is_executable = file_stat.st_mode & S_IXUSR;
 
         FILE *file_src = fopen(buffer_filename, "rb");
-        write_file(file_id++, out, &outfile_nextdata_block, de->d_name, file_src);
+        write_file(file_id++, out, &outfile_nextdata_block, de->d_name, file_src, is_executable);
         fclose(file_src);
     }
     while (file_id < FS_FFS_FILEENTRY_COUNT) {

include/fuzzy/fs/ffs.h

@@ -16,10 +16,15 @@ Number of file which can be stored: 64
 */
 
 #include <stdint.h>
+#include <stddef.h>
 
-#define FS_FFS_FILENAME_LIMIT 120  // including NULL
+#define FS_FFS_FILENAME_LIMIT 100  // including NULL, same as dirent.h
 #define FFS_UNIQUE_PARITION_ID  0  // only paritition 0 is supported for now
 
+enum FFSFileFlagMask {
+    FFS_FILE_FLAG_EXECUTABLE = 1 << 0
+};
+
 union FFSMetaData {
     struct {
         char signature[16];
@@ -32,6 +37,7 @@ union FFSFileEntry {
         int32_t start_block_id;  // 0 implies no file.
         int32_t filesize;
         char filename[FS_FFS_FILENAME_LIMIT];
+        uint32_t flags;
     } content;
     char bytes[128];
 }; // size: 128 bytes

src/kernel/syscall/file_handler.c

@@ -3,6 +3,7 @@
 #include <stddef.h>
 #include <string.h>
 #include <stdio.h>
+#include <dirent.h>
 
 #include <lib/utils/logging.h>
 
@@ -64,7 +65,8 @@ int _file_handler_read(int user_ds, int file_id, char _us_buffer[FILEIO_BUFFER_S
     return len;
 }
 
-int _file_handler_read_dir(int user_ds, int last_file_id, char *_us_filename) {
+int _file_handler_read_dir(int user_ds, int last_file_id, struct dirent *_us_dirent) {
+    // char *_us_filename
     union FFSFileEntry entry;
     int file_id;
     if (last_file_id < 0) {
@@ -80,9 +82,16 @@ int _file_handler_read_dir(int user_ds, int last_file_id, char *_us_filename) {
             continue;
         }
         // next file
+        struct dirent centry = {0};
+        memcpy(centry.d_name, entry.content.filename, sizeof(centry.d_name));
+        centry.size = entry.content.filesize;
+        if(entry.content.flags&FFS_FILE_FLAG_EXECUTABLE) {
+            centry.flag |= DIRENT_EXECUTABLE;
+        }
+
         syscall_strncpy_kernel_to_user(
-            user_ds, _us_filename,
-            entry.content.filename, sizeof(entry.content.filename));
+            user_ds, _us_dirent,
+            &centry, sizeof(struct dirent));
         return file_id;
     }
     return -1; // there is no next file
@@ -95,7 +104,7 @@ int syscall_2_file_handler(int operation, int a1, int a2, int a3, int user_ds) {
         case SYSCALL_FILE_SUB_READBUFFER:
             return _file_handler_read(user_ds, a1, (char*)a2, a3);
         case SYSCALL_FILE_SUB_READ_DIR:
-            return _file_handler_read_dir(user_ds, a1, (char*)a2);
+            return _file_handler_read_dir(user_ds, a1, (struct dirent*)a2);
     }
     return -1;
 }

src/usr/include/dirent.h

@@ -1,10 +1,18 @@
 #pragma once
 
-#define FILENAME_LIMIT 120  // same as fuzzy/fs/ffs.h
+#include <stddef.h>
+
+#define FILENAME_LIMIT 100  // same as fuzzy/fs/ffs.h
+
+enum dirent_flag {
+    DIRENT_EXECUTABLE = 1 << 0
+};
 
 struct dirent {
     // In FFS the only file types are only normal file.
     char d_name[FILENAME_LIMIT];
+    uint32_t size;
+    uint32_t flag;
 };
 
 struct DIR {

src/usr/lib/dirent.c

@@ -11,7 +11,7 @@ struct dirent *readdir(struct DIR *dirp) {
         SYSCALL_FILE_OP,
         SYSCALL_FILE_SUB_READ_DIR,
         dirp->kernel_file_id,
-        dirp->entry.d_name);
+        &dirp->entry);
     if (dirp->kernel_file_id == -1) {
         return NULL;
     }

src/usr/local/src/cat.c

@@ -20,7 +20,7 @@ void process(char filename[]) {
 }
 
 int print_usage() {
-    printf("Usage: cat <filename>");
+    printf("Usage: cat <filename>\n");
     return 0;
 }
 

src/usr/local/src/ls.c

@@ -2,17 +2,46 @@
 #include <stdio.h>
 #include <dirent.h>
 
-void process() {
+void process(int is_long_listing) {
     struct DIR dir;
     opendir(&dir);
     struct dirent *dp;
 
     while ((dp = readdir(&dir)) !=NULL) {
-        printf("%s\n", dp->d_name);
+        if(is_long_listing) {
+            printf("r-%c  %d  %s\n",
+                (dp->flag & DIRENT_EXECUTABLE)?'x':'-',
+                dp->size,
+                dp->d_name
+                );
+        } else {
+            printf("%s\n", dp->d_name);
+        }
     }
 }
 
+int print_usage() {
+    printf("Usage: ls [-h] [-l]\n");
+    return 0;
+}
+
 int main(int argc,char *argv[]) {
-    process();
+    int is_long_listing = 0;
+
+    // command line argument parsing
+    for (size_t i = 1; i < argc; i++) {
+        if(strcmp(argv[i],"-h")==0) {
+            print_usage();
+            return 0;
+        } else if(strcmp(argv[i],"-l")==0) {
+            is_long_listing=1;
+        } else {
+            printf("unrecognized flag: '%s'\n", argv[i]);
+            print_usage();
+            return 1;
+        }
+    }
+
+    process(is_long_listing);
     return 0;
 }