Merge pull request #205 from alfkil/beta10

Fix return code for spawnvpe/waitpid.

Author: afxgroup

library/c.lib_rev.h

@@ -2,7 +2,7 @@
 #define REVISION		0
 #define SUBREVISION		0
 
-#define DATE			"27.08.2024"
+#define DATE			"31.08.2024"
 #define VERS			"clib4.library 1.0.0"
-#define VSTRING			"clib4.library 1.0.0 (27.08.2024)\r\n"
-#define VERSTAG			"\0$VER: clib4.library 1.0.0 (27.08.2024)"
+#define VSTRING			"clib4.library 1.0.0 (31.08.2024)\r\n"
+#define VERSTAG			"\0$VER: clib4.library 1.0.0 (31.08.2024)"

library/include/sys/wait.h

@@ -8,8 +8,8 @@ __BEGIN_DECLS
 
 #define WNOHANG 1
 #define WUNTRACED 2
-   
-#define WIFEXITED(w)	(((w) & 0xff) == 0)
+
+#define WIFEXITED(w)	(((w) & 0x80000000) == 0)
 #define WIFSIGNALED(w)	(((w) & 0x7f) > 0 && (((w) & 0x7f) < 0x7f))
 #define WIFSTOPPED(w)	(((w) & 0xff) == 0x7f)
 #define WEXITSTATUS(w)	(((w)) & 0x000000ff)

library/misc/children.c

@@ -32,18 +32,18 @@ pidChildrenScan(const void *children, void *pid) {
 }
 
 BOOL
-insertSpawnedChildren(uint32 pid, uint32 gid) {
+insertSpawnedChildren(uint32 pid, uint32 ppid, uint32 gid) {
     DECLARE_UTILITYBASE();
 
     struct Clib4Resource *res = (APTR) OpenResource(RESOURCE_NAME);
     if (res) {
-        uint32 parent = GetPID(0, GPID_PARENT);
+        uint32 parent = ppid; //GetPID(0, GPID_PARENT);
         size_t iter = 0;
         void *item;
 
         struct Clib4Children children;
         children.pid = pid;
-        children.returnCode = 0;
+        children.returnCode = 0x80000000; //set this flag for WIFEXITED
         children.groupId = gid;
 
         while (hashmap_iter(res->children, &iter, &item)) {
@@ -99,10 +99,12 @@ findSpawnedChildrenByGid(uint32 pid, uint32 gid) {
 }
 
 void
-spawnedProcessEnter(int32 entry_data UNUSED) {
-    struct Library *UserGroupBase;
-    struct UserGroupIFace *IUserGroup;
-    gid_t groupId = 0;
+spawnedProcessEnter(int32 entry_data) {
+    struct Library *UserGroupBase = 0;
+    struct UserGroupIFace *IUserGroup = 0;
+    gid_t groupId = (gid_t)entry_data;
+
+#if 0
     UserGroupBase = OpenLibrary("usergroup.library", 0);
 
     if (UserGroupBase != NULL) {
@@ -116,9 +118,11 @@ spawnedProcessEnter(int32 entry_data UNUSED) {
         }
         CloseLibrary(UserGroupBase);
     }
+#endif
 
-    uint32 pid = ((struct Process *) FindTask(NULL))->pr_ProcessID;
-    if (insertSpawnedChildren(pid, groupId)) {
+    uint32 pid = GetPID(0, GPID_PROCESS); //((struct Process *) FindTask(NULL))->pr_ProcessID;
+    uint32 ppid = GetPID(0, GPID_PARENT);
+    if (insertSpawnedChildren(pid, ppid, groupId)) {
         __CLIB4->__children++;
         D(("Children with pid %ld and gid %ld inserted into list\n", pid, groupId));
     }
@@ -138,13 +142,18 @@ spawnedProcessExit(int32 rc, int32 data UNUSED) {
 
         while (hashmap_iter(res->children, &iter, &item)) {
             const struct Clib4Node *node = item;
+
+            // DebugPrintF("[spawneeExit :] *** iteration : pid=%d\n", node->pid);
+
             if (node->pid == parent) {
                 struct Clib4Children key;
                 key.pid = me;
                 struct Clib4Children *item = (struct Clib4Children *) hashmap_get(node->spawnedProcesses, &key);
                 if (item != NULL) {
-                    SHOWMSG("[spawneeExit :] SUCCESS");
-                    item->returnCode = rc;
+                    // SHOWMSG("[spawneeExit :] SUCCESS");
+                    // DebugPrintF("[spawneeExit :] SUCCESS\n");
+                    item->returnCode = ~0x80000000 & rc;
+                    break;
                 }
             }
         }

library/misc/children.h

@@ -7,7 +7,7 @@
 
 #include "clib4.h"
 
-BOOL insertSpawnedChildren(uint32 pid, uint32 gid);
+BOOL insertSpawnedChildren(uint32 pid, uint32 ppid, uint32 gid);
 struct Clib4Children *findSpawnedChildrenByPid(uint32 pid);
 struct Clib4Children *findSpawnedChildrenByGid(uint32 pid, uint32 gid);
 void spawnedProcessExit(int32 rc, int32 data UNUSED);

library/unistd/spawnvpe.c

@@ -117,12 +117,35 @@ get_arg_string_length(char *const argv[]) {
 
     return (result);
 }
+/* * * * *
+    Apparently this doesn't work. You cannot delay a child by using signals in the EntryCode,
+    because - as it seems - SystemTags only returns AFTER executing EntryCode. Which, of course,
+    means, that the parent is never allowed to send the signal. 
+ * * * * */
+// struct EntryData {
+//     uint8 childSignal;
+//     uint8 parentSignal;
+//     struct Task *parent, *child;
+// };
+// void amiga_entryCode(int32 entry_data);
+// void
+// amiga_entryCode(int32 entry_data) {
+//     struct EntryData *ed = (struct EntryData *)entry_data;
+//     ed->childSignal = AllocSignal(-1);
+//     ed->child = FindTask(0);
+//     DebugPrintF("[child :] Signalling parent...\n");
+//     Signal(ed->parent, 1 << ed->parentSignal);
+//     DebugPrintF("[child :] Waiting for signal from parent...\n");
+//     Wait(1 << ed->childSignal);
+//     DebugPrintF("[child :] Done.");
+//     FreeSignal(ed->childSignal);
+// }
 int
 spawnvpe(
     const char *file,
     const char **argv,
     char **deltaenv,
-    const char *cwd,
+    const char *_cwd,
     int fhin,
     int fhout,
     int fherr
@@ -131,6 +154,7 @@ spawnvpe(
     struct name_translation_info nti_name;
     const char *name = file;
     struct name_translation_info nti_cwd;
+    const char *cwd = _cwd;
     BPTR iofh[3] = {BZERO, BZERO, BZERO};
     int closefh[3] = {FALSE, FALSE, FALSE};
     BPTR fh;
@@ -156,6 +180,7 @@ spawnvpe(
     }
 
     D(("name after conversion: [%s]\n", name));
+    // printf("[spawnvpe :] name after conversion [%s]\n", name);
 
 #if 0
     seglist = LoadSeg(name);
@@ -169,6 +194,20 @@ spawnvpe(
         UnLock(fileLock);
     }
 
+    // printf("[spawnvpe :] cwd before conversion: [%s]\n", cwd);
+
+    if(cwd) {
+        error = __translate_unix_to_amiga_path_name(&cwd, &nti_cwd);
+        if (error) {
+            __set_errno(EINVAL);
+            D(("__translate_unix_to_amiga_path_name failed: %s\n", strerror(error)));
+            return ret;
+        }
+    }
+
+    D(("cwd after conversion: [%s]\n", cwd));
+    // printf("[spawnvpe :] cwd after conversion [%s]\n", cwd);
+
     BPTR cwdLock = cwd ? Lock(cwd, SHARED_LOCK) : 0;
 
     parameter_string_len = get_arg_string_length((char *const *) argv);
@@ -178,6 +217,7 @@ spawnvpe(
     }
 
     D(("parameter_string_len: [%ld]\n", parameter_string_len));
+    // printf("[spawnvpe :] parameter_string_len: [%ld]\n", parameter_string_len);
 
     arg_string = malloc(parameter_string_len + 1);
     if (arg_string == NULL) {
@@ -206,6 +246,7 @@ spawnvpe(
     D(("File to execute: [%s]\n", finalpath));
 
     // printf("[spawnvpe :] full command == <%s>\n", finalpath);
+    // printf("[spawnvpe :] processName == <%s>\n", processName);
 
     if (fhin >= 0) {
         err = __get_default_file(fhin, &fh);
@@ -252,6 +293,8 @@ spawnvpe(
     D(("(*)Calling SystemTags.\n"));
 
     // struct EntryData ed;
+    // ed.parent = FindTask(0);
+    // ed.parentSignal = AllocSignal(-1);
 
     struct Task *_me = FindTask(0);
 #if 0
@@ -296,6 +339,8 @@ spawnvpe(
   );
   if (p) ret = 0;
 #else
+    // printf("(*)Calling SystemTags.\n");
+
     ret = SystemTags(finalpath,
                      NP_NotifyOnDeathSigTask, _me,
                      SYS_Input, iofh[0],
@@ -309,12 +354,14 @@ spawnvpe(
                      NP_Name, strdup(processName),
 
                      NP_EntryCode,  spawnedProcessEnter,
+                     NP_EntryData, getgid(),
+                    //  NP_EntryCode,  amiga_entryCode,
+                    //  NP_EntryData,  &ed,
                      NP_ExitCode,   spawnedProcessExit,
 
                      TAG_DONE);
-#endif
 
-    D(("SystemTags completed. return value: [%ld]\n", ret));
+#endif
 
     if (ret != 0) {
         __set_errno(__translate_io_error_to_errno(IoErr()));
@@ -329,8 +376,34 @@ spawnvpe(
         /*
          * If mode is set as P_NOWAIT we can retrieve process id calling IoErr()
          * just after SystemTags. In this case spawnv will return pid
+         * IoErr() must be called IMMEDIATELY after SystemTags() == no other DOS calls inbetween
          */
-        ret = IoErr();
+
+        // DebugPrintF("[main :] Child created with success.\n");
+
+        pid_t pid = IoErr();
+        // gid_t groupId = getgid();
+        // uint32 ppid = ((struct Process *) FindTask(NULL))->pr_ProcessID;
+
+        // if (insertSpawnedChildren(pid, ppid, groupId)) {
+        //     __CLIB4->__children++;
+        //     D(("Children with pid %ld and gid %ld inserted into list\n", pid, groupId));
+        // }
+        // else {
+        //     D(("Cannot insert children with pid %ld and gid %ld into list\n", pid, groupId));
+        // }
+
+        // DebugPrintF("[parent :] Waiting for signal from child...\n");
+        // Wait(1 << ed.parentSignal);
+        // DebugPrintF("[parent :] Signalling child...\n");
+        // Signal(ed.child, 1 << ed.childSignal);
+        // DebugPrintF("[parent :] Done.\n");
+        // FreeSignal(ed.parentSignal);
+
+        ret = pid;
     }
+    // D(("SystemTags completed. return value: [%ld]\n", ret));
+    // printf("SystemTags completed. return value: [%ld]\n", ret);
+
     return ret;
 }