Vserbu: Pagină nouă: In the last lab, we gave one process several threads. In this lab, we will look at how the kernel decides what a task is allowed to do. It compares...

2026-11-13T14:14:22Z

Pagină nouă: In the last lab, we gave one process several threads. In this lab, we will look at how the kernel decides what a task is allowed to do. It compares...

Pagină nouă

In [[OS_Lab_5_-_Threads._Mutexes|the last lab]], we gave one process several threads. In this lab, we will look at how the kernel decides what a task is allowed to do. It compares the numbers of the task, its '''credentials''', with the owner, group and mode of the file. We will read these numbers, turn them into names, and change the permissions of our own files. As an application, we will write our own <code>ls -l</code>, and a tool which finds and repairs dangerous permissions.

<div class="regula">'''Note:''' Everything in this lab works as a normal user, and you will not need <code>sudo</code>. Some of the commands below fail with a permission error on purpose.</div>

== Learning objectives ==

By the end of this lab you should be able to:

# read the user and group IDs of a task, and turn them into names;
# read the owner, group and mode of a file with [https://man7.org/linux/man-pages/man2/statx.2.html <code>statx(2)</code>], and change the mode with [https://man7.org/linux/man-pages/man2/chmod.2.html <code>chmod(2)</code>];
# say which class of permission bits applies when a task uses a file;
# explain what read, write and execute mean for files and for directories;
# recognize the set-user-ID, set-group-ID and sticky bits.

== The credentials of a task ==

Every task has a set of numbers, which the kernel uses for every permission check. First, it has three user IDs:

{| class="wikitable"
! ID !! Meaning
|-
| Real UID || Who started the task
|-
| Effective UID || Whose rights the task uses
|-
| Saved set-user-ID || One more value the task can go back to
|}

It also has a real GID, an effective GID and a saved set-group-ID, which work in the same way, and a list of '''supplementary groups'''. All of them are copied to the child by [https://man7.org/linux/man-pages/man2/fork.2.html <code>fork(2)</code>], and kept across <code>exec</code>, so everything started from a shell normally has the same credentials as the shell.

=== getresuid(2) and getresgid(2) ===

<syntaxhighlight lang="c">
// In: <unistd.h>
int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);

uid_t getuid(void); // The real UID
uid_t geteuid(void); // The effective UID
gid_t getgid(void); // The real GID
gid_t getegid(void); // The effective GID
</syntaxhighlight>

[https://man7.org/linux/man-pages/man2/getresuid.2.html <code>getresuid(2)</code>] and [https://man7.org/linux/man-pages/man2/getresgid.2.html <code>getresgid(2)</code>] store the three IDs at the given addresses. The four shorter functions return a single ID, and cannot fail.

=== getgroups(2) ===

<syntaxhighlight lang="c">
// In: <unistd.h>
int getgroups(int size, gid_t list[]);
</syntaxhighlight>

{| class="wikitable"
! Parameter !! Description
|-
| <code>size</code> || How many elements <code>list</code> can hold
|-
| <code>list</code> || Where to store the supplementary groups
|}

It returns the number of groups, or -1 on error. If <code>size</code> is 0, <code>list</code> is not touched, and the call only returns the number of groups. This lets us first ask how many groups there are, and then declare an array of exactly that size: a '''variable-length array''' (VLA), whose size is only known at run time.

<div class="regula">'''Note:''' A VLA must have at least one element. A task may have no supplementary groups at all, so the programs below make room for one more group than needed.</div>

The following program prints all the credentials of the task running it:

<syntaxhighlight lang="c" line>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

static void print_error(const char *what)
{
char msg[256];
snprintf(msg, sizeof msg, "%s: %s\n", what, strerror(errno));
write(STDERR_FILENO, msg, strlen(msg));
}

int main(void)
{
uid_t ruid, euid, suid;
gid_t rgid, egid, sgid;

getresuid(&ruid, &euid, &suid);
getresgid(&rgid, &egid, &sgid);

int n = getgroups(0, nullptr);
if (n == -1) {
print_error("getgroups");
return EXIT_FAILURE;
}
gid_t groups[n + 1]; // + 1: a VLA cannot be empty
n = getgroups(n, groups);
if (n == -1) {
print_error("getgroups");
return EXIT_FAILURE;
}

char msg[256];
snprintf(msg, sizeof msg, "UID: real %u, effective %u, saved %u\n", ruid, euid, suid);
write(STDOUT_FILENO, msg, strlen(msg));
snprintf(msg, sizeof msg, "GID: real %u, effective %u, saved %u\n", rgid, egid, sgid);
write(STDOUT_FILENO, msg, strlen(msg));

write(STDOUT_FILENO, "Groups:", 7);
for (int i = 0; i < n; i++) {
snprintf(msg, sizeof msg, " %u", groups[i]);
write(STDOUT_FILENO, msg, strlen(msg));
}
write(STDOUT_FILENO, "\n", 1);
return EXIT_SUCCESS;
}
</syntaxhighlight>

<syntaxhighlight lang="bash">
$ ./build/debug/app
UID: real 1000, effective 1000, saved 1000
GID: real 1000, effective 1000, saved 1000
Groups: 1000
</syntaxhighlight>

Your numbers may be different. The three IDs are the same for almost every task, and only differ while special programs run, as we will see below.

== From numbers to names ==

The kernel does not know what users are called. Names are looked up in user space, by the C library:

<syntaxhighlight lang="c">
// In: <pwd.h>
struct passwd *getpwuid(uid_t uid);

// In: <grp.h>
struct group *getgrgid(gid_t gid);
</syntaxhighlight>

They return a structure describing the user or group, or <code>nullptr</code> if nothing is known about that number. For example, a file can still belong to a user who has been deleted. A program must be ready to print the number instead.

<syntaxhighlight lang="c">
// In: <pwd.h> (simplified)
struct passwd {
char *pw_name; // The name of the user
uid_t pw_uid; // Its UID
gid_t pw_gid; // Its primary group
char *pw_dir; // Its home directory
char *pw_shell; // Its shell
};

// In: <grp.h> (simplified)
struct group {
char *gr_name; // The name of the group
gid_t gr_gid; // Its GID
};
</syntaxhighlight>

<div class="regula">'''Note:''' The returned structure is kept in a static buffer, which the next call to the same function overwrites. If you need a name after another lookup, copy it first.</div>

The following program prints the same line as the <code>id</code> command:

<syntaxhighlight lang="c" line>
#include <errno.h>
#include <grp.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

static void print_error(const char *what)
{
char msg[256];
snprintf(msg, sizeof msg, "%s: %s\n", what, strerror(errno));
write(STDERR_FILENO, msg, strlen(msg));
}

static void print_group(gid_t gid)
{
const struct group *gr = getgrgid(gid);
char msg[256];
snprintf(msg, sizeof msg, "%u(%s)", gid, gr != nullptr ? gr->gr_name : "?");
write(STDOUT_FILENO, msg, strlen(msg));
}

int main(void)
{
int n = getgroups(0, nullptr);
if (n == -1) {
print_error("getgroups");
return EXIT_FAILURE;
}
gid_t groups[n + 1]; // + 1: a VLA cannot be empty
n = getgroups(n, groups);
if (n == -1) {
print_error("getgroups");
return EXIT_FAILURE;
}

uid_t uid = getuid();
const struct passwd *pw = getpwuid(uid);

char msg[256];
snprintf(msg, sizeof msg, "uid=%u(%s) gid=", uid, pw != nullptr ? pw->pw_name : "?");
write(STDOUT_FILENO, msg, strlen(msg));
print_group(getgid());

write(STDOUT_FILENO, " groups=", 8);
for (int i = 0; i < n; i++) {
if (i > 0) {
write(STDOUT_FILENO, ",", 1);
}
print_group(groups[i]);
}
write(STDOUT_FILENO, "\n", 1);
return EXIT_SUCCESS;
}
</syntaxhighlight>

<syntaxhighlight lang="bash">
$ ./build/debug/app
uid=1000(john) gid=1000(john) groups=1000(john)
$ id
uid=1000(john) gid=1000(john) groups=1000(john)
</syntaxhighlight>

== The permissions of a file ==

Every file has an '''owner''' (a UID), a '''group''' (a GID) and a '''mode''' of 16 bits. The mode holds the type of the file, 3 special bits, and 9 permission bits: read, write and execute, for each of the three classes.

[[File:OS_Lab_6_-_mode_bits.png|center|thumb|500px|The owner, group and mode of a file. The mode is usually written in octal: each digit is one group of 3 bits. The file here is <code>rwxr-x---</code>, or 0750.]]

When a task uses a file, the kernel picks '''exactly one''' class, and only checks that one:

[[File:OS_Lab_6_-_open_check.png|center|thumb|500px|The first match decides. An owner with <code>---</code> cannot read the file, even if the others can.]]

The checks use the effective IDs. A task with effective UID 0, the superuser, skips them. In addition, every directory on the path needs the execute permission.

The mode bits have names, defined in <code><sys/stat.h></code>:

{| class="wikitable"
! Class !! Read !! Write !! Execute
|-
| Owner || <code>S_IRUSR</code> (0400) || <code>S_IWUSR</code> (0200) || <code>S_IXUSR</code> (0100)
|-
| Group || <code>S_IRGRP</code> (0040) || <code>S_IWGRP</code> (0020) || <code>S_IXGRP</code> (0010)
|-
| Others || <code>S_IROTH</code> (0004) || <code>S_IWOTH</code> (0002) || <code>S_IXOTH</code> (0001)
|}

The three special bits are:

{| class="wikitable"
! Bit !! Value !! Shown as !! Meaning
|-
| Set-user-ID, <code>S_ISUID</code> || 04000 || <code>s</code> instead of the owner's <code>x</code> || The program runs with the effective UID of the owner of the file
|-
| Set-group-ID, <code>S_ISGID</code> || 02000 || <code>s</code> instead of the group's <code>x</code> || The program runs with the effective GID of the group of the file. On a directory: new files get the group of the directory
|-
| Sticky, <code>S_ISVTX</code> || 01000 || <code>t</code> instead of the others' <code>x</code> || On a directory: an entry can only be deleted or renamed by its owner, the owner of the directory, or root
|}

If the <code>x</code> underneath is not set, the letter is uppercase: <code>S</code> or <code>T</code>.

=== statx(2) ===

<syntaxhighlight lang="c">
// In: <fcntl.h> and <sys/stat.h>
int statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf);
</syntaxhighlight>

{| class="wikitable"
! Parameter !! Description
|-
| <code>dirfd</code> || A directory to which a relative <code>pathname</code> is relative, or <code>AT_FDCWD</code> for the current directory
|-
| <code>pathname</code> || The file
|-
| <code>flags</code> || 0 to follow a symbolic link and describe its target, or <code>AT_SYMLINK_NOFOLLOW</code> to describe the link itself
|-
| <code>mask</code> || Which fields we want. <code>STATX_BASIC_STATS</code> asks for the usual ones
|-
| <code>statxbuf</code> || Where to store the result
|}

<syntaxhighlight lang="c">
// In: <sys/stat.h> (simplified)
struct statx {
uint16_t stx_mode; // The type, special bits and permission bits
uint32_t stx_uid; // The owner
uint32_t stx_gid; // The group
uint32_t stx_nlink; // The number of hard links
uint64_t stx_size; // The size in bytes
struct statx_timestamp stx_atime; // Last access
struct statx_timestamp stx_mtime; // Last modification
};

struct statx_timestamp {
int64_t tv_sec; /* Seconds since the Epoch (00:00 1st Jan 1970 UTC) */
uint32_t tv_nsec; /* Nanoseconds since tv_sec */
};
</syntaxhighlight>

The type is tested with macros: <code>S_ISREG(mode)</code> (regular file), <code>S_ISDIR</code> (directory), <code>S_ISLNK</code> (symbolic link), <code>S_ISCHR</code> (character device), <code>S_ISBLK</code> (block device), <code>S_ISFIFO</code> (pipe) and <code>S_ISSOCK</code> (socket).

[https://man7.org/linux/man-pages/man2/statx.2.html <code>statx(2)</code>] only needs the execute permission on the directories of the path, and no permission on the file itself. The following program describes any file we can reach:

<syntaxhighlight lang="c" line>
#include <errno.h>
#include <fcntl.h>
#include <grp.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

static void print_error(const char *what)
{
char msg[256];
snprintf(msg, sizeof msg, "%s: %s\n", what, strerror(errno));
write(STDERR_FILENO, msg, strlen(msg));
}

int main(int argc, char *argv[])
{
if (argc != 2) {
const char *usage = "usage: app <path>\n";
write(STDERR_FILENO, usage, strlen(usage));
return EXIT_FAILURE;
}

struct statx st;
if (statx(AT_FDCWD, argv[1], 0, STATX_BASIC_STATS, &st) == -1) {
print_error(argv[1]);
return EXIT_FAILURE;
}

const char *type = "other";
if (S_ISREG(st.stx_mode)) {
type = "regular file";
} else if (S_ISDIR(st.stx_mode)) {
type = "directory";
}

const struct passwd *pw = getpwuid(st.stx_uid);
const struct group *gr = getgrgid(st.stx_gid);

char msg[512];
snprintf(msg, sizeof msg, "%s, owner %u (%s), group %u (%s), mode %04o\n", type,
st.stx_uid, pw != nullptr ? pw->pw_name : "?",
st.stx_gid, gr != nullptr ? gr->gr_name : "?",
st.stx_mode & 07777);
write(STDOUT_FILENO, msg, strlen(msg));
return EXIT_SUCCESS;
}
</syntaxhighlight>

<syntaxhighlight lang="bash">
$ ./build/debug/app /etc/shadow
regular file, owner 0 (root), group 42 (shadow), mode 0640
$ ./build/debug/app /tmp
directory, owner 0 (root), group 0 (root), mode 1777
$ ./build/debug/app /usr/bin/passwd
regular file, owner 0 (root), group 0 (root), mode 4755
$ ./build/debug/app /nope
/nope: No such file or directory
</syntaxhighlight>

<code>stx_mode</code> also holds the type of the file, and <code>& 07777</code> keeps only the special and permission bits. In the examples above:

* <code>/etc/shadow</code> holds the password hashes, and the others class has no permissions at all.
* <code>/tmp</code> can be written by anyone, but the sticky bit (the leading 1) stops users from deleting each other's files.
* <code>/usr/bin/passwd</code> is set-user-ID (the leading 4) and belongs to root. This is how a normal user can change their own password: the program runs with effective UID 0, and it knows who started it from the real UID.

=== chmod(2) ===

<syntaxhighlight lang="c">
// In: <sys/stat.h>
int chmod(const char *pathname, mode_t mode);
</syntaxhighlight>

[https://man7.org/linux/man-pages/man2/chmod.2.html <code>chmod(2)</code>] replaces the permission and special bits of a file. Only the owner of the file, or root, may call it. The permission bits themselves do not matter: an owner with <code>---</code> can still give itself <code>rw-</code>. Since it replaces all the bits, changing just some of them means starting from the old mode, which [https://man7.org/linux/man-pages/man2/statx.2.html <code>statx(2)</code>] gives us. For example, to remove the write permission of the group and of the others:

<syntaxhighlight lang="c">
mode_t new_mode = (st.stx_mode & 07777) & ~(S_IWGRP | S_IWOTH);
chmod(path, new_mode);
</syntaxhighlight>

<div class="regula">'''Note:''' [https://man7.org/linux/man-pages/man2/chmod.2.html <code>chmod(2)</code>] follows symbolic links: called on a link, it changes the file the link points to.</div>

=== Trying it out ===

The <code>chmod</code> command takes the same octal numbers. Try the following on your own files:

<syntaxhighlight lang="bash">
$ echo hello > notes.txt
$ chmod 044 notes.txt
$ cat notes.txt
cat: notes.txt: Permission denied
$ chmod 644 notes.txt
$ cat notes.txt
hello
</syntaxhighlight>

With mode 044, everybody else can read the file, but its owner cannot: only the owner class is checked. On a directory, the three permissions mean something else:

{| class="wikitable"
! Permission !! For a directory
|-
| Read || List the names
|-
| Write || Create, delete and rename entries
|-
| Execute || Go through it, to use the names inside
|}

<syntaxhighlight lang="bash">
$ mkdir box
$ echo hi > box/a.txt
$ chmod 600 box
$ ls box
a.txt
$ cat box/a.txt
cat: box/a.txt: Permission denied
$ chmod 300 box
$ ls box
ls: cannot open directory 'box': Permission denied
$ cat box/a.txt
hi
$ chmod 500 box
$ touch box/b.txt
touch: cannot touch 'box/b.txt': Permission denied
$ rm box/a.txt
rm: cannot remove 'box/a.txt': Permission denied
$ chmod 700 box
</syntaxhighlight>

Without execute, we can see the names, but we cannot use them. Without read, we can use a name, if we already know it. Deleting a file needs write permission on its '''directory'''. The permissions of the file itself are not checked. Depending on its version, <code>ls box</code> may also complain about each name in the first case.

== Exercises ==

Write each program in its own copy of the project template. As a reminder from [[OS_Lab_1_-_Linux_setup._Bash_primer._C_primer#getting-the-template|the first lab]]:

<syntaxhighlight lang="bash">
mkdir -p ~/oslab/lab06 && cd ~/oslab/lab06
curl -OL https://wiki.dcae.pub.ro/images/9/93/Os_lab_skeleton.zip
unzip -d ls Os_lab_skeleton.zip
unzip -d doctor Os_lab_skeleton.zip
</syntaxhighlight>

For this lab:

* As in the last labs, do not use the standard I/O library for output: build the text with [https://man7.org/linux/man-pages/man3/snprintf.3.html <code>snprintf(3)</code>] and [https://man7.org/linux/man-pages/man2/write.2.html <code>write(2)</code>] it.
* Do not run other programs: make the system calls yourself.
* If a file cannot be reached, print the error on standard error, and continue with the next one.

=== A. Your own ls -l ===

Write a command which lists a directory like <code>ls -la</code>. It takes the directory as an optional parameter, and uses the current directory if there is none. Build it in these steps:

# '''Names and sizes.''' Read the directory with [https://man7.org/linux/man-pages/man3/readdir.3.html <code>readdir(3)</code>], as in [[OS_Lab_3_-_Files._Memory_mapping#readdir()|Lab 3]], and call [https://man7.org/linux/man-pages/man2/statx.2.html <code>statx(2)</code>] for each entry. Print the size and the name.
# '''The mode.''' Print the mode as 10 characters: the type (<code>-</code>, <code>d</code>, <code>l</code>, <code>c</code>, <code>b</code>, <code>p</code> or <code>s</code>), then the 9 permission bits. Write a function which fills in a string.
# '''The other columns.''' Add the number of hard links, the owner, the group and the date. If a number has no name, print the number. For a symbolic link, also print <code>-> target</code>.
# '''The special bits.''' Show <code>s</code> and <code>S</code> for the set-user-ID and set-group-ID bits, as described [[#The permissions of a file|above]]. You can ignore the sticky bit.
# '''What can I do?''' Add a first column with your own rights over the file, such as <code>r-x</code>, by picking the class as the kernel does: compare with your effective UID, then with your effective GID and supplementary groups, or else use the others class.

<syntaxhighlight lang="bash">
$ ./build/debug/app
rwx drwxr-xr-x 1 john john 44 2026-11-09 15:54 .
rwx drwxr-xr-x 1 john john 50 2026-11-09 15:54 ..
rw- -rw-r-S--- 1 john john 6 2026-11-09 15:54 notes.txt
rwx lrwxrwxrwx 1 john john 9 2026-11-09 15:54 link -> notes.txt
rwx drwxr-x--x 1 john john 0 2026-11-09 15:54 sub
rwx -rwsr-xr-x 1 john john 68064 2026-11-09 15:54 tool
$ ./build/debug/app /etc | grep shadow
--- -rw-r----- 1 root shadow 840 2026-11-09 15:54 shadow
</syntaxhighlight>

The names do not have to be sorted. The widths of the columns are up to you.

* You do not need to build a path for each entry: give [https://man7.org/linux/man-pages/man2/statx.2.html <code>statx(2)</code>] the directory through <code>dirfd(dir)</code>, which returns the file descriptor of an open <code>DIR</code>, and the name of the entry as <code>pathname</code>.
* Use <code>AT_SYMLINK_NOFOLLOW</code>, so that links are listed as links.
* <code>readlinkat(dirfd(dir), name, buffer, size)</code> reads the target of a link. It returns the length, and does not add a <code>'\0'</code>.
* For the date: <code>time_t when = st.stx_mtime.tv_sec;</code>, then <code>localtime_r(&when, &tm)</code>, and <code>strftime(date, sizeof date, "%Y-%m-%d %H:%M", &tm)</code>, from <code><time.h></code>.
* [https://man7.org/linux/man-pages/man3/getpwuid.3.html <code>getpwuid(3)</code>] and [https://man7.org/linux/man-pages/man3/getgrgid.3.html <code>getgrgid(3)</code>] use different buffers, but copy the names anyway if you want to look up anything else before printing them.

After step 4, compare your output with the real <code>ls</code>.

=== B. Permission doctor ===

Write a command which walks a directory and everything below it, and reports dangerous permissions. With <code>--fix</code>, it also repairs them.

<syntaxhighlight lang="bash">
./build/debug/app [--fix] <directory>
</syntaxhighlight>

It checks only regular files and directories, including the starting directory, against three rules:

{| class="wikitable"
! Applies to !! Problem !! Repair
|-
| Regular files and directories || Writable by others, except for directories with the sticky bit || Remove the write permission of the others
|-
| Regular files whose name ends in <code>.key</code> || Any permission for the group or the others || Remove all of them
|-
| Regular files || Set-user-ID or set-group-ID || Remove those bits
|}

Create a test directory inside the project:

<syntaxhighlight lang="bash">
mkdir -p demo/sub demo/locked
echo hello > demo/notes.txt
echo hello > demo/shared.txt && chmod 666 demo/shared.txt
echo secret > demo/sub/server.key && chmod 644 demo/sub/server.key
cp /bin/true demo/sub/tool && chmod 4755 demo/sub/tool
chmod 777 demo/sub
ln -s /etc/shadow demo/link
chmod 000 demo/locked
</syntaxhighlight>

<syntaxhighlight lang="bash">
$ ./build/debug/app demo
demo/sub: writable by others (0777)
demo/sub/server.key: private key open to group or others (0644)
demo/sub/tool: runs with the rights of its owner or group (4755)
demo/locked: Permission denied
demo/shared.txt: writable by others (0666)
problems found: 4, fixed: 0
$ ./build/debug/app --fix demo
demo/sub: writable by others (0777)
fixed: 0777 -> 0775
demo/sub/server.key: private key open to group or others (0644)
fixed: 0644 -> 0600
demo/sub/tool: runs with the rights of its owner or group (4755)
fixed: 4755 -> 0755
demo/locked: Permission denied
demo/shared.txt: writable by others (0666)
fixed: 0666 -> 0664
problems found: 4, fixed: 4
$ ./build/debug/app demo
demo/locked: Permission denied
problems found: 0, fixed: 0
</syntaxhighlight>

The lines may come in a different order. The exit status is 0 if every problem found was fixed, and 1 otherwise.

* Write a recursive function which takes the path of a directory. Build the path of each entry with [https://man7.org/linux/man-pages/man3/snprintf.3.html <code>snprintf(3)</code>], into a buffer of <code>PATH_MAX</code> bytes (from <code><limits.h></code>).
* Skip <code>.</code> and <code>..</code>, or the walk will never end.
* Use <code>AT_SYMLINK_NOFOLLOW</code>, and leave symbolic links alone.
* Set <code>errno</code> to 0 before '''each''' call to [https://man7.org/linux/man-pages/man3/readdir.3.html <code>readdir(3)</code>]. The recursive calls change it.
* A file can break several rules. Work out the new mode from all of them, and call [https://man7.org/linux/man-pages/man2/chmod.2.html <code>chmod(2)</code>] once.

<div class="regula">'''Note:''' The set-user-ID bit on <code>demo/sub/tool</code> is harmless here, because that program is a copy of <code>true</code>. Never set it on a shell or on anything which runs commands: whoever starts the program would get your rights.</div>

Some things to look at:

* Run <code>./build/debug/app --fix /usr/bin</code>. Why does it fail for every file?
* Why is <code>/tmp</code> not reported, even though everybody can write to it?
* <code>demo/link</code> has mode 0777. What would <code>--fix</code> try to do if the program treated it like a regular file? Why would that fail here, and what would happen if the link pointed to a file of yours?

OS Lab 6 - Users. Permissions - Revizia istoricului

Vserbu: Pagină nouă: In the last lab, we gave one process several threads. In this lab, we will look at how the kernel decides what a task is allowed to do. It compares...