File io fixes

library/fcntl/open.c

@@ -13,7 +13,10 @@
 int
 open(const char *path_name, int open_flag, ... /* mode_t mode */) {
     struct _clib4 *__clib4 = __CLIB4;
-    return __open_r(__clib4, path_name, open_flag);
+    va_list ap;
+    va_start(ap, open_flag);
+    return __open_r(__clib4, path_name, open_flag, va_arg(ap, int));
+    va_end(ap);
 }
 
 int
@@ -265,10 +268,12 @@ __open_r(struct _clib4 *__clib4, const char *path_name, int open_flag, ... /* mo
 
     fd = __clib4->__fd[fd_slot_number];
 
-    if (is_directory || FLAG_IS_SET(open_flag, O_PATH))
+    if (is_directory || FLAG_IS_SET(open_flag, O_PATH)) {
         __initialize_fd(fd, __fd_hook_entry, dir_lock, 0, fd_lock); // TODO - Create a new dir hook
-    else
+    }
+    else {
         __initialize_fd(fd, __fd_hook_entry, handle, 0, fd_lock);
+    }
 
     fd->fd_Aux = (char *) path_name;
 
@@ -384,7 +389,7 @@ __open_r(struct _clib4 *__clib4, const char *path_name, int open_flag, ... /* mo
     if (lock != BZERO)
         UnLock(lock);
 
-    if (dir_lock != BZERO)
+    if (!is_directory && dir_lock != BZERO)
       	UnLock(dir_lock);
 
     __stdio_unlock(__clib4);

library/libc_init_global.c

@@ -153,6 +153,7 @@ reent_init(struct _clib4 *__clib4, const BOOL fallback) {
         .isTZSet = 0,
         .__IDebug = NULL,
         .resolv_conf = NULL,
+        .__file_lock_semaphore_name = "Advisory File Locking"
     };
 
     if (!__clib4->__random_lock || !__clib4->__pipe_semaphore) {

library/stdio/fclose.c

@@ -84,7 +84,10 @@ fclose(FILE *stream) {
     /* Get rid of any custom file buffer allocated. */
     if (file->iob_CustomBuffer != NULL) {
         SHOWMSG("Delete allocated buffer");
-        ItemPoolFree(__clib4->_iob_pool, file->iob_CustomBuffer);
+        if (file->iob_isVBuffer)
+            FreeVec(file->iob_CustomBuffer);
+        else
+            ItemPoolFree(__clib4->_iob_pool, file->iob_CustomBuffer);
         file->iob_CustomBuffer = NULL;
     }
 

library/stdio/fdhookentry.c

@@ -503,10 +503,10 @@ int64_t __fd_hook_entry(struct _clib4 *__clib4, struct fd *fd, struct file_actio
                 // TODO - Check this on OS4 with NIL:
                 fam->fam_FileInfo->Type = ST_NIL;
             } else {
-                BPTR lock_type = FLAG_IS_SET(fd->fd_Flags, FDF_IS_DIRECTORY) || FLAG_IS_SET(fd->fd_Flags, FDF_PATH_ONLY)
-                                 ? EX_LockInput
-                                 : EX_FileHandleInput;
-                fam->fam_FileInfo = ExamineObjectTags(lock_type, file, TAG_DONE);
+                if (FLAG_IS_SET(fd->fd_Flags, FDF_IS_DIRECTORY) || FLAG_IS_SET(fd->fd_Flags, FDF_PATH_ONLY))
+                    fam->fam_FileInfo = ExamineObjectTags(EX_LockInput, file, TAG_DONE);
+                else
+                    fam->fam_FileInfo = ExamineObjectTags(EX_FileHandleInput, file, TAG_DONE);
                 if (fam->fam_FileInfo == NULL) {
                     LONG error;
 

library/stdio/initializeiob.c

@@ -24,6 +24,7 @@ __initialize_iob(
 	memset(iob, 0, sizeof(*iob));
 
 	iob->iob_CustomBuffer = custom_buffer;
+	iob->iob_isVBuffer = FALSE;
 	iob->iob_Buffer = (UBYTE *)buffer;
 	iob->iob_BufferSize = buffer_size;
 	iob->iob_Descriptor = file_descriptor;

library/stdio/record_locking.c

@@ -562,11 +562,11 @@ __handle_record_locking(struct _clib4 *__clib4, int cmd, struct flock *l, struct
     _off64_t seek_position;
     _off64_t current_position;
     int result = ERROR;
-    _off64_t original_len;
+    _off64_t original_len = 0;
     LONG error = OK;
     _off64_t start = 0;
     _off64_t len = 0;
-    _off64_t stop;
+    _off64_t stop = 0;
 
     ENTER();
 
@@ -591,7 +591,7 @@ __handle_record_locking(struct _clib4 *__clib4, int cmd, struct flock *l, struct
     /* Remember to unlock any records before closing the file. */
     fd->fd_Cleanup = cleanup_locked_records;
 
-    if ((cmd == F_SETLK || cmd == F_SETLKW) && (l->l_type != F_UNLCK)) {
+    if ((cmd == F_SETLK || cmd == F_SETLKW) && (l->l_type == F_WRLCK || l->l_type == F_RDLCK)) {
         SHOWMSG("this is a lock request");
 
         error = create_file_lock_node(__clib4, fd, &fln);
@@ -605,7 +605,11 @@ __handle_record_locking(struct _clib4 *__clib4, int cmd, struct flock *l, struct
             SHOWMSG("could not create region node");
             goto out;
         }
-    } else {
+    }
+    else if (l->l_type == F_UNLCK) {
+        SHOWMSG("this is an unlock request");
+    }
+    else {
         SHOWMSG("this is not a lock request");
         goto out;
     }

library/stdio/setvbuf.c

@@ -76,11 +76,12 @@ setvbuf(FILE *stream, char *buf, int bufmode, size_t size) {
 		   allocate some memory for it. */
         if (size > 0 && buf == NULL) {
             /* Allocate a little more memory than necessary. */
-            new_buffer = ItemPoolAlloc(__clib4->_iob_pool);
+            new_buffer = AllocVecTags(size, AVT_Type, MEMF_SHARED, AVT_ClearWithValue, 0, TAG_DONE);
             if (new_buffer == NULL) {
                 __set_errno_r(__clib4, ENOBUFS);
                 goto out;
             }
+            file->iob_isVBuffer = TRUE;
         }
     }
 
@@ -98,7 +99,11 @@ setvbuf(FILE *stream, char *buf, int bufmode, size_t size) {
     /* Get rid of any buffer specially allocated for this stream. */
     if (file->iob_CustomBuffer != NULL) {
         SHOWMSG("Delete allocated buffer");
-        ItemPoolFree(__clib4->_iob_pool, file->iob_CustomBuffer);
+        if (file->iob_isVBuffer)
+            FreeVec(file->iob_CustomBuffer);
+        else
+            ItemPoolFree(__clib4->_iob_pool, file->iob_CustomBuffer);
+
         file->iob_CustomBuffer = NULL;
     }
 
@@ -137,8 +142,12 @@ setvbuf(FILE *stream, char *buf, int bufmode, size_t size) {
 
     __funlockfile_r(__clib4, stream);
 
-    if (new_buffer != NULL)
-        ItemPoolFree(__clib4->_iob_pool, new_buffer);
+    if (new_buffer != NULL) {
+        if (file->iob_isVBuffer)
+            FreeVec(file->iob_CustomBuffer);
+        else
+            ItemPoolFree(__clib4->_iob_pool, file->iob_CustomBuffer);
+    }
 
     RETURN(result);
     return result;

library/stdio/stdio_headers.h

@@ -204,6 +204,7 @@ typedef struct iob {
     UBYTE				iob_SingleByte;			/* Fall-back buffer for 'unbuffered' files */
     APTR				iob_Lock;		    	/* For thread locking */
     struct Task *       iob_TaskLock;           /* Task who owns lock */
+	BOOL				iob_isVBuffer;			/* TRUE if iob_CustomBuffer is set from setvbuf */
 } __iob64;
 
 

library/wmem/wmem_allocator_block.c

@@ -667,7 +667,7 @@ wmem_block_split_used_chunk(wmem_block_allocator_t *allocator,
     bool last;
 
 #ifdef MEMORY_DEBUG
-    D(("[split_used :] chunk : 0x%lx\n", chunk));
+    D(("[split_used :] data : 0x%lx\n", data));
 #endif
 
     aligned_size = size + ((uintptr_t)data - (uintptr_t)WMEM_DATA_TO_CHUNK(data));

test_programs/io/open_dir.c

@@ -0,0 +1,45 @@
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+int main(void) {
+    const char *dir_path = "T:"; // Use the current directory
+    int fd;
+    struct stat sb;
+
+    // Open the directory
+    printf("Attempting to open directory: '%s'\n", dir_path);
+    fd = open(dir_path, O_RDONLY);
+    if (fd == -1) {
+        perror("open");
+        exit(EXIT_FAILURE);
+    }
+    printf("Directory opened successfully with file descriptor: %d\n", fd);
+
+    // Get file status using fstat() on the file descriptor
+    if (fstat(fd, &sb) == -1) {
+        perror("fstat");
+        close(fd);
+        exit(EXIT_FAILURE);
+    }
+    printf("fstat() called successfully on the file descriptor.\n");
+
+    // Print some information from the stat buffer
+    printf("File type:                ");
+    switch (sb.st_mode & S_IFMT) {
+        case S_IFDIR:  printf("directory\n");        break;
+        case S_IFREG:  printf("regular file\n");     break;
+        case S_IFLNK:  printf("symbolic link\n");    break;
+        default:       printf("unknown?\n");         break;
+    }
+    printf("Number of hard links:     %ld\n", (long) sb.st_nlink);
+    printf("File size:                %lld bytes\n", (long long) sb.st_size);
+
+    // Close the file descriptor
+    close(fd);
+    printf("File descriptor closed.\n");
+
+    return 0;
+}

test_programs/io/setvbuf.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define BUF_SIZE 1024
+
+int main(void) {
+	char buffer[BUF_SIZE];
+
+	printf("Initial output.\n");
+	printf("This line is in the default buffer, but will be flushed at the end.\n");
+
+	// Use setvbuf to assign a new, fully buffered buffer to stdout.
+	if (setvbuf(stdout, buffer, _IOFBF, BUF_SIZE) != 0) {
+		perror("setvbuf failed");
+		return 1;
+	}
+
+	printf("This text is now being written to the new custom buffer.\n");
+	printf("You will not see this until the buffer is full, or the program ends.\n");
+
+	// We can prove the custom buffer is used by forcing a flush.
+	// Uncomment the next line to see the output immediately.
+	fflush(stdout);
+
+	printf("Final line before exit.\n");
+
+	return 0;
+}