Processes - Evan Carlstrom

ex1/ex1.c

@@ -9,6 +9,23 @@
 int main(void)
 {
     // Your code here
+    int x = 100;
+    int pid = fork();
+
+    if(pid < 0) {
+        fprintf(stderr, "Fork failed!\n");
+        exit(1);
+    }
+    else if(pid == 0) {
+        printf("Hello, I'm a child process!\n");
+    }
+    else {
+        printf("Hello, I'm a parent process!\n");
+    }
+    printf("%d %d", 100, x);
 
     return 0;
 }
+
+/* After initialization, the variable in the child process would be the same as its value in the parent process. When the parent and child change the value of x, we can access both values of x within their respective forks.
+If we were to do something like (x * 2) in the parent fork and (x / 2) in the child fork, we could work with both 200 and 50. */

ex2/ex2.c

@@ -9,6 +9,25 @@
 int main(void)
 {
     // Your code here 
-
+    FILE * file_pointer;
+
+    file_pointer = fopen("text.txt", "r+");
+    int pid = fork();
+
+    if(pid < 0) {
+        fprintf(stderr, "Fork failed!\n");
+        exit(1);
+    }
+    else if(pid == 0) {
+        fprintf(file_pointer, "%s %s", "Child", "text.\n");
+        fclose(file_pointer);
+    }
+    else {
+        fprintf(file_pointer, "%s %s", "Parent", "text.");
+        fclose(file_pointer);
+    }
+
     return 0;
 }
+
+/* Yes, both child and parent can access the file returned by fopen(). In the case of concurrent attempts, they are saved together as in the example above. */

ex2/text.txt

@@ -0,0 +1 @@
+Parent text.Child text.

ex3/ex3.c

@@ -10,6 +10,23 @@
 int main(void)
 {
     // Your code here
+    pid_t pid = fork();
+    // waitpid(pid, NULL, 0);
+
+    if(pid < 0) {
+        fprintf(stderr, "Fork failed!\n");
+        exit(1);
+    }
+    else if(pid == 0) {
+        printf("%s", "hello\n");
+        // waitpid(pid, NULL, 0);
+    }
+    else {
+        waitpid(pid, NULL, 0);
+        printf("%s", "goodbye\n");    
+    }
 
     return 0;
 }
+
+/* currently testing out the results of implementing waitpid() in various spots in the code */

ex4/ex4.c

@@ -11,6 +11,19 @@
 int main(void)
 {
     // Your code here    
+    pid_t pid = fork();
 
+    char *bin_ref = {"./bin/ls", NULL}; /* might try running another file from this project at some point too */
+    exec(bin_ref[0], bin_ref);
+    // execl(bin_ref[0], bin_ref);
+    // execle(bin_ref[0], bin_ref);
+    // execvp(bin_ref[0], bin_ref);
     return 0;
 }
+
+/* The different versions seem to mainly reference parameters.
+For example, -l includes individual parameters in the call, whereas -v is useful when
+variables are not known in advance because it allows you to pass in a char* array
+rather than a specific number of parameters. There is some additional functionality 
+with things like -e and -p and I'd be lying if I said I understand this fully yet, so
+I'm going to keep looking into these differences. */