Jan Kończak

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
===== Creating, opening and closing files =====

To create or open a file, POSIX defines: \\
<html><span style="float:right"><small>Needs header:<br><code>fcntl.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html"></html>
''int **open**(const char *//pathname//, int //flags//)'' \\
''int **open**(const char *//pathname//, int //flags//, mode_t //mode//)''
<html></a></html>\\
and a ''creat'' function that is a shorthand to ''open(//pathname//, O_WRONLY|O_CREAT|O_TRUNC, //mode//)''.

''//pathname//'' is a path.

''//mode//'' is used only if ''open'' creates a new file, and it defines its
permissions. Either use [[https://en.cppreference.com/w/c/language/integer_constant|octal]]
number, or use symbolic constants described in the manual.

''//flags//'' is a rat's nest.\\
''//flags//'' must contain exactly one of the following flags: ''**O_RDONLY**'', ''**O_WRONLY**'', or ''**O_RDWR**'' that choose whether file is opened for reading, writing or both. \\
''//flags//'' may additionally contain other flags, including the following:
  * ''**O_APPEND**'' sets file position to the end of a file before every write
  * ''**O_TRUNC**'' (shall be used only in conjunction with ''O_WRONLY'' or ''O_RDWR'') truncates the file (sets its size to 0)
  * ''**O_CREAT**'' tells ''open'' that if the file does not exist, it should be created
  * ''**O_EXCL**'' (shall be used only in conjunction with ''O_CREAT'') makes open fail when the file exists
  * and at least a dozen of other flags

For example:
<code c>
int fd1 = open("/tmp/foo", O_RDONLY);
if (fd1 == -1) perror("Opening /tmp/foo for reading failed");

int fd2 = open("/tmp/baz", O_WRONLY|O_APPEND);
if (fd2 == -1) perror("Opening /tmp/baz for appending (write-only) failed");

int fd3 = open("/tmp/bar", O_RDWR|O_CREAT|O_EXCL, 0600);
if (fd3 == -1) perror("Creating a new file /tmp/bar failed");
// if open succeeds, the file is open for reading and writing and has permissions of 0600
</code>

To close a file, POSIX defines:
\\
<html><span style="float:right"><small>Needs header:<code>unistd.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html"></html>
''int **close**(int //filedes//)''
<html></a></html>
\\
that closes a file number ''//filedes//''.
\\
<small>On Linux, invoking ''close(fd)'' always closes ''fd'', even if ''close'' returns ''-1''.</small>

~~Exercise.#~~ Open a file with hardcoded filename, read its contents and
write it to standard output.

~~Exercise.#~~ Open a file specified as the first argument of your program, read
its contents and write it to standard output.

~~Exercise.#~~ Open a file specified as the first argument of your program, read
its contents and write it to standard output with line numbers (just like
''cat -n //file//'').
\\
<small>''memchr'' looks up a character (e.g., ''\n'') in memory.</small>

~~Exercise.#~~ Implement a program that checks if two files have the same contents. \\
<small>''memcmp'' compares two memory areas.</small>

<small>
~~Exercise.#~~ Implement a program that works as ''paste [//file//]...''. \\
Hint: the dirty solution reads single character a time.
</small>

===== Fork =====

=== Forking ===

To create a new process, POSIX defines the ''fork'' function:
<html><span style="float:right"><small>Needs header:<code>unistd.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html"></html>
''pid_t **fork**()''
<html></a></html>
\\
**''fork'' creates a copy((Nowadays forking is considered cheap, for it uses
[[https://en.wikipedia.org/wiki/Copy-on-write|copy-on-write]] to reduce costs.))
of the running process.**
\\
**Upon success, ''fork'' returns the pid of the child process in the parent
process, and the value of ''0'' in the the child process.**
\\
Fork may fail if the resource limits are exhausted, and in such case the
expected ''-1'' is returned.

There is a list of things that ''fork'' does not clone or that are reset for the
child process upon ''fork''. See POSIX standard or Linux manual on fork for details.
Notice that:
  * all stack and heap memory is copied
  * the list of open files is copied
  * memory mappings are copied (unless one provides an explicit flag not to copy a mapping upon creating it)
  * signal handlers are copied
  * pending signals and timers are **not** copied
  * threads are **not** copied \\ (but state of mutexes and values of semaphores are copied) \\ forking in a multithreaded application is dangerous

=== Learning one's own pid ===

To learn its own process identifier, the process can execute
<html><span style="float:right"><small>Needs header: <code>unistd.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpid.html"></html>
''pid_t **getpid**()''
<html></a></html>
\\
To learn the process identifier of its parent, the process can execute
<html><span style="float:right"><small>Needs header: <code>unistd.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/getppid.html"></html>
''pid_t **getppid**()''
<html></a></html>

=== Waiting for a child ===

The parent process shall care for its child processes once they terminate.
\\
The programmer may either:
1) wait for the child to terminate,
2) set up a signal handler for SIGCHILD (it suffices to ignore the signal),
<small>3) force the child out of the parent processes session (by using
''setsid()'' or double ''fork''). </small>

To wait for the termination of any child, one can call ''wait''. To wait for the
termination of a specific pid, one can call ''waitpid'':
\\
<html><span style="float:right"><small>Needs header:<br><code>sys/wait.h</code></small></span>
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/wait.html"></html>
''pid_t **wait**(int *//stat_loc//)'' \\
''pid_t **waitpid**(pid_t //pid//, int *//stat_loc//, int //options//)''
<html></a></html>
\\
These functions return the process identifier of the child process which
terminated.

The functions write the status of the termination to the memory pointed by
''//stat_loc//'' (provided it's not ''NULL'') .
The status provides information whether the process terminated normally (by
calling ''exit'' or returning from ''main'') and if it did, then which value
it returned.
See the documentation for a list of macros that extract the information.

If the ''//pid//'' in ''waitpid'' is positive, then it is considered the pid
of the child to wait for. Non-positive values have special meanings. Among
others, ''-1'' waits for any child.

The ''//options//'' argument of ''waitpid'' is a combination of flags.
The value of ''0'' simply waits until the pid terminates.
The flag ''WNOHANG'' makes ''waitpid'' return immediately (and the return value
indicates whether a child has terminated).

=== Exercises ===

~~Exercise.#~~ Write a program that:
\\     1. sleeps five seconds,
\\     2. prints a text with ''write'',
\\     3. forks,
\\     4. prints another text with ''write'',
\\     5. sleeps another five seconds.
\\
Run the program and observe it in a live process viewer. \\
<small> <html><a href="https://pubs.opengroup.org/onlinepubs/9699919799/functions/sleep.html"></html>
''sleep(int //sec//)''<html></a></html> sleeps with second resolution. (The other POSIX sleep function is
''[[https://pubs.opengroup.org/onlinepubs/9699919799/functions/nanosleep.html|nanosleep]]'';
C standard includes now the equivalent ''[[https://en.cppreference.com/w/c/thread/thrd_sleep|thrd_sleep]]'')
\\
To keep an eye on the application, either use ''htop'' / ''top'', or try ''watch -n 0.1 ps -lHC //executable_name//''.
</small>

~~Exercise.#~~ Fork and print the result of ''fork'', ''getpid'' and ''getppid''.

~~Exercise.#~~ Fork. Print ''child'' in the child process and ''parent'' in the
parent process.

~~Exercise.#~~ Fork. In the child process, exit immediately.  In the parent,
wait for input (e.g., do a ''read'' from 0 or invoke ''getchar''). \\
Run the program and observe the zombie using ''htop'' / ''top'' / ''ps''.


~~META:
language = en
~~
Jan Kończak

User Tools

Site Tools

Page Tools
