---
# System prepended metadata

title: Systemy operacyjne Lista 5

---

# Systemy operacyjne Lista 5
## Zadanie 1 kasia
![](https://i.imgur.com/ePnBD2k.png)
(koniec wykladu 5 do posluchania)


_Co robi operacja read(2) i write(2), jeśli bufor rury jest odpowiednio pusty albo pełny?_

Każda rura ma skończony cykliczny bufor w jądrze rozmiaru kilku stron pamięci. Jeśli bufor rury jest pełny / pusty to odpowiednio zapis do / odczyt z rury zablokują proces.

_Jakie gwarancje daje nam operacja write na rurze, do której pisze wiele procesów – każdy z nich wiersze tekstu nie dłuższe niż «PIPE_BUF»?_

Zapis do pipe'a jest atomowy pod warunkiem, że zapisujemy nie więcej niż bufor, to znaczy, że jeśli próbujemy wrzucić do rury dwie rzeczy naraz to nie zostaną pocięte na kawałki, nie wiadomo w jakiej kolejności, ale oba wyjdą w całości.

_Weźmy potok utworzony poleceniem «ps -ef | grep sh | wc -l». Czemu wszystkie procesy należące do potoku zakończą się bez interwencji powłoki, jeśli co najmniej jeden z nich umrze?_

Jeśli zostanie zamknięty koniec do:
● zapisu, to konsument ostatecznie opróżni bufor rury po czym dostanie EOF (read zwróci 0) 
● odczytu, to producent przy zapisie dostanie SIGPIPE, którego domyślną akcją jest zakończenie procesu
Exit code całego zadania to exit code ostatniego procesu

_Kiedy operacje read i write na rurze zwracają „short count”?_
→ short count tylko, jeśli nie ma więcej danych. 

_Jak można połączyć rodzica i dziecko rurą, która została utworzona po uruchomieniu dziecka?_
Nieskojarzone  ze sobą procesy można skomunikować Nazwaną rurą (FIFO)

## Zadanie 2 Marcin
![](https://i.imgur.com/nKogmrI.png)
ogólnie nie polecam tego zadanka bo przy interpretacji kodu można się łatwo wyj**** ale przeczytać : [Dlaczego unixy śmierdzą](http://www.catb.org/~esr/writings/taoup/html/ch20s03.html). Bardzo ciekawe krytyki.

**urządzenia znakowe** -  (ang. character device) – służy do odczytywania/zapisywania danych z/do urządzenia znak po znaku; w większości przypadków pojęcie znak jest równoznaczne z pojęciem bajt.

Urządzenia znakowe z zasady nie są buforowane i służą do komunikacji o charakterze strumieniowym.
**urządzenia blokowe** - (ang. block device) – pozwala na odczytywanie/zapisywanie danych blokami, czyli większymi grupami bajtów mającymi postać: sektorów, kilobajtów czy klastrów. W większości przypadków konieczność operowania na blokach wymuszona jest logiczną budową urządzenia.

Urządzenia blokowe różnią się od znakowych tym, że w większości są buforowane i pozwalają na swobodny dostęp do danych na nich zgromadzonych (lseek)
![](https://i.imgur.com/RPIRfJD.png)

:::    spoiler `iccom.h`
```=C
      #ifndef	_SYS_IOCCOM_H_
      #define	_SYS_IOCCOM_H_
      
      /*
       * Ioctl's have the command encoded in the lower word, and the size of
       * any in or out parameters in the upper word.  The high 3 bits of the
       * upper word are used to encode the in/out status of the parameter.
       *
       *	 31 29 28                     16 15            8 7             0
       *	+---------------------------------------------------------------+
       *	| I/O | Parameter Length        | Command Group | Command       |
       *	+---------------------------------------------------------------+
       */
      #define	IOCPARM_MASK	0x1fff		/* parameter length, at most 13 bits */
      #define	IOCPARM_SHIFT	16
      #define	IOCGROUP_SHIFT	8
      #define	IOCPARM_LEN(x)	(((x) >> IOCPARM_SHIFT) & IOCPARM_MASK)
      #define	IOCBASECMD(x)	((x) & ~(IOCPARM_MASK << IOCPARM_SHIFT))
      #define	IOCGROUP(x)	(((x) >> IOCGROUP_SHIFT) & 0xff)
      
      #define	IOCPARM_MAX	NBPG	/* max size of ioctl args, mult. of NBPG */
      				/* no parameters */
      #define	IOC_VOID	(unsigned long)0x20000000
      				/* copy parameters out */
      #define	IOC_OUT		(unsigned long)0x40000000
      				/* copy parameters in */
      #define	IOC_IN		(unsigned long)0x80000000
      				/* copy parameters in and out */
      #define	IOC_INOUT	(IOC_IN|IOC_OUT)
      				/* mask for IN/OUT/VOID */
      #define	IOC_DIRMASK	(unsigned long)0xe0000000
      
      #define	_IOC(inout, group, num, len) \
          ((inout) | (((len) & IOCPARM_MASK) << IOCPARM_SHIFT) | \
          ((group) << IOCGROUP_SHIFT) | (num))
      #define	_IO(g,n)	_IOC(IOC_VOID,	(g), (n), 0)
      #define	_IOR(g,n,t)	_IOC(IOC_OUT,	(g), (n), sizeof(t))
      #define	_IOW(g,n,t)	_IOC(IOC_IN,	(g), (n), sizeof(t))
      /* this should be _IORW, but stdio got there first */
      #define	_IOWR(g,n,t)	_IOC(IOC_INOUT,	(g), (n), sizeof(t))
      
      #define IOCSNPRINTF(buf, len, cmd) \
          snprintf((buf), (len), "_IO%s%s('%c', %hhu)", \
      	(((cmd) >> 30) & 1) ? "R" : "", \
      	(((cmd) >> 30) & 2) ? "W" : "", \
      	(char)IOCGROUP(cmd), (unsigned char)(cmd))
      
      
      #endif /* !_SYS_IOCCOM_H_ */
```
:::
::: info
Polesiuk skipnął opis krytyki unixsów "Bo chair by chciał to zrobić, a my sobie powiemy tylko  o rzeczach wytłuszczonych. Ale wspomniał, że warto przeczytac."
:::

## Zadanie 3 Olek
![](https://i.imgur.com/yU0OwJk.png)
> Rysunek 32-10 reprezentacja katalogu

![](https://i.imgur.com/rd3UzEZ.png)

* **Nieużytki** - nieużywane fragmenty reprezentacji katalogu. Rozmiar wpisu, po którym występuje nieużytek jest większy niż nazwa pliku.
* **Kompaktowanie** - operacja, która zmniejsza rozmiar katalogu, usuwane są nieużytki. Opłaca się ją robić, gdy wiadomo, że w danym katalogu jest dużo nieużytków, czyli zyskamy na tej operacji dużo miejsca.
* **Dodawanie pliku** - trzeba przejrzeć cały katalog, żeby wiedzieć czy ten plik już istnieje. Jeśli nie ma miejsca wykonywane jest kompaktowanie.
* **Usuwanie pliku** - przegląda się cały katalog, żeby wiedzieć czy plik istnieje. Po usunięciu pliku, miejsce gdzie był ten plik staje się nieużytkiem, pliki nie są od razu przesuwane, lecz przestawiany jest wskaźnik przy poprzednim pliku (entry size). 

Kiedy usuwamy plik musimy zadbać aby w odpowiedni sposób przepiąć wskaźniki `entry size`



## Zadanie 4 Kornelia
![](https://i.imgur.com/RNtKzQX.png)

:::spoiler i-node
![](https://i.imgur.com/JHmNli3.png)
:::

:::info
- ścieżka bezwzględna - zaczyna się od korzenia `/`
- i-węzeł - struktura w systemie plików przechowująca informacje o zasobie na dysku (zawiera atrybuty, wskaźniki na bloki danych i bloki pośrednie - dla większych plików)
:::


_Jak jądro systemu trawersuje ścieżkę bezwzględną?_ `/usr/bin/cc`
System plików dysponuje tablicą wszystkich i-węzłów. Przechodzenie ścieżki zaczyna się od i-węzła o numerze 2 (katalog główny `/`). Jądro wczytuje go i sprawdza, czy mamy uprawnienia do czytania i wchodzenia do tego katalogu. Jeśli tak, czyta blok po bloku zawartość katalogu i szuka w nim rekordu `usr`. W rekordzie oprócz nazwy znajduje się też numeryczny identyfikator i-węzła odpowiadającego tej nazwie.  Teraz zostanie wczytany i-node katalogu `usr`. Dalej algorytm jest analogiczny.


:::spoiler wydruk poleceń
- ls -i - wypisuje numeryczny indeks każdego pliku  (numer i-węzła)

![](https://i.imgur.com/yvk8xwg.png)

 Co wypisuje `ls -lia` na przykładzie `/usr/bin/cc` : 
- 2630359 - numeryczny indeks pliku / katalogu
- lrwxrwxrwx - uprawnienia dostępu (l informuje nas, że jest to dowiązanie a nie plik regularny)
- 1 - liczba dowiązań do pliku
- root - użytkownik
- root - grupa
- 20 - liczba bajtów
- mar  1  2022 - data ostatniej modyfikacji
- /usr/bin/cc -> /etc/alternatives/cc - nazwa pliku

Trawersowanie ścieżki
![](https://i.imgur.com/2QVLe76.png)

Na co wskazuje ścieżka `/usr/bin/cc` : 
![](https://i.imgur.com/LjbjbXk.png)
![](https://i.imgur.com/ZJYhkKK.png)
:::

_Skąd sterownik uniksowego systemu plików wie, gdzie na dysku znajduje się i-ty bajt pliku?_

I-node przechowuje wskaźniki na kolejne bloki pliku. Wszystkie bloki mają równe, ustalone rozmiary.

_Dlaczego nie możemy tworzyć dowiązań do plików znajdujących się w obrębie innych zamontowanych systemów plików?_

Dowiązania są tworzone do i-node’a, który nie jest dzielony między różnymi systemami plików. Chcemy, żeby licznik referencji zawierał informacje o dowiązaniach w obrębie jednego systemu plików. Pozwoli to uniknąć sytuacji, w której po utworzeniu dowiązania przez inny system plików zostanie on odłączony i nawet po zniszczeniu wszystkich lokalnych dowiązań licznik będzie nadal większy od 1, więc dane z pliku nie zostaną usunięte.

---
![](https://i.imgur.com/jKDRZPU.png)

## Zadanie 5 Kuba
![](https://i.imgur.com/0s2VU6H.png)

**Fstatat** - return information about a file, in the buffer pointed to by statbuf.  No permissions are required on the file itself. f the pathname given in pathname is relative, then it is interpreted relative to the directory referred to by the file descriptor dirfd (rather than relative to the current working directory of the calling process, as is done by stat(2) for a relative pathname). 

    AT_EMPTY_PATH (since Linux 2.6.39)
              If pathname is an empty string, operate on the file
              referred to by dirfd (which may have been obtained using
              the open(2) O_PATH flag).  In this case, dirfd can refer
              to any type of file, not just a directory, and the
              behavior of fstatat() is similar to that of fstat().  If
              dirfd is AT_FDCWD, the call operates on the current
              working directory.  This flag is Linux-specific; define
              _GNU_SOURCE to obtain its definition.

       AT_NO_AUTOMOUNT (since Linux 2.6.38)
              Don't automount the terminal ("basename") component of
              pathname if it is a directory that is an automount point.
              This allows the caller to gather attributes of an
              automount point (rather than the location it would mount).
              Since Linux 4.14, also don't instantiate a nonexistent
              name in an on-demand directory such as used for
              automounter indirect maps.  This flag has no effect if the
              mount point has already been mounted over.

              Both stat() and lstat() act as though AT_NO_AUTOMOUNT was
              set.

              The AT_NO_AUTOMOUNT can be used in tools that scan
              directories to prevent mass-automounting of a directory of
              automount points.

              This flag is Linux-specific; define _GNU_SOURCE to obtain
              its definition.

       AT_SYMLINK_NOFOLLOW
              If pathname is a symbolic link, do not dereference it:
              instead return information about the link itself, like
              lstat().  (By default, fstatat() dereferences symbolic
              links, like stat().)

**Major, minor** - The major() and minor() functions perform the converse task: given a device ID, they return, respectively, the major and minor components.  These macros can be useful to, for example, decompose the device IDs in the structure returned by stat(2). 
1. **główny numer urządzenia (ang. major number)**-liczba z zakresu od 1 do 255 (0-Unnamed devices) identyfikująca numer urządzenia; zazwyczaj wszystkie urządzenia o tym samym numerze głównym i tym samym typie współdzielą ten sam zestaw operacji, ponieważ są obsługiwane przez ten sam sterownik urządzenia
1. **podrzędny numer urządzenia (ang. minor number)**-liczba z zakresu od 0 do 250 dzięki, niemu identyfikujemy urządzenie wśród urządzeń o tym samym numerze głównym

**Readlinkat** - readlink() places the contents of the symbolic link pathname in the buffer buf, which has size bufsiz.  readlink() does not append a terminating null byte to buf.  It will (silently) truncate the contents (to a length of bufsiz characters), in case the buffer is too small to hold all of the contents.

**Getdents** - The system call getdents() reads several linux_dirent structures from the directory referred to by the open file descriptor fd into the buffer pointed to by dirp.  The argument count specifies the size of that buffer.

Aby sprawdzić, czy zadanie jest dobrze rozwiązane, przygotowałem katalog permission_bits zawierający pliki podobne do tych z zadania, są to kolejno executable.py, file1.txt, link, local oraz tmp z ustawionymi odpowiednimi bitami. local oraz tmp to katalogi. Bity zostały ustawione następującymi poleceniami:

```bash
$ chmod o+t tmp
$ chmod g+s local
$ chmod u+s executable.py
$ link -s file1.txt link
```

Uzupełniony kod zadania:

```cpp
#include "csapp.h"

#define DIRBUFSZ 256

static void print_mode(mode_t m) {
    char t;

    if (S_ISDIR(m))
        t = 'd';
    else if (S_ISCHR(m))
        t = 'c';
    else if (S_ISBLK(m))
        t = 'b';
    else if (S_ISREG(m))
        t = '-';
    else if (S_ISFIFO(m))
        t = 'f';
    else if (S_ISLNK(m))
        t = 'l';
    else if (S_ISSOCK(m))
        t = 's';
    else
        t = '?';

    char ur = (m & S_IRUSR) ? 'r' : '-';
    char uw = (m & S_IWUSR) ? 'w' : '-';
    char ux = (m & S_IXUSR) ? 'x' : '-';
    char gr = (m & S_IRGRP) ? 'r' : '-';
    char gw = (m & S_IWGRP) ? 'w' : '-';
    char gx = (m & S_IXGRP) ? 'x' : '-';
    char or = (m & S_IROTH) ? 'r' : '-';
    char ow = (m & S_IWOTH) ? 'w' : '-';
    char ox = (m & S_IXOTH) ? 'x' : '-';

    /* TODO: Fix code to report set-uid/set-gid/sticky bit as 'ls' does. */
    // 'setuid' bit can be identified easily when there is 's' in place of
    // 'x' of the executable bit. The 's' implies that te executable bit is
    // set, otherwise it would be set to 'S'. 'setgid' bit is similar to 
    // 'setuid' bit, but in this case 's' is present in group sector (there
    // are three sectors: owner, group, other, before them there is one bit
    // saying if it is regular file). The 'sticky' bit is meant to forbid
    // modifying files in that directory by users who are not owners. It is
    // identifiable by a 't' in the place of 'x', also 'T' applies that the
    // executable bit is not present.

    // If m has set 'setuid'/'setgid'/'sticky', check if m is executable,
    // then set the bit accordingly, otherwise permissions are not changed.
    ux = (m & S_ISUID) ? ((m & S_IXUSR) ? 's' : 'S') : ux;
    gx = (m & S_ISGID) ? ((m & S_IXGRP) ? 's' : 'S') : gx;
    ox = (m & S_ISVTX) ? ((m & S_IXOTH) ? 't' : 'T') : ox;

    printf("%c%c%c%c%c%c%c%c%c%c", t, ur, uw, ux, gr, gw, gx, or, ow, ox);
}

static void print_uid(uid_t uid) {
    struct passwd *pw = getpwuid(uid);
    if (pw)
        printf(" %10s", pw->pw_name);
    else
        printf(" %10d", uid);
}

static void print_gid(gid_t gid) {
    struct group *gr = getgrgid(gid);
    if (gr)
        printf(" %10s", gr->gr_name);
    else
        printf(" %10d", gid);
}

static void file_info(int dirfd, const char *name) {
    struct stat sb[1];

    /* TODO: Read file metadata. */
    // int fstatat(int dirfd, const char *pathname, 
    //             struct stat *statbuf, int flags);
    // AT_SYMLINK_NOFOLLOW flag means that if pathname (name) is a symbolic
    // link, it should not be dereferenced.
    fstatat(dirfd, name, sb, AT_SYMLINK_NOFOLLOW);

    print_mode(sb->st_mode);
    printf("%4ld", sb->st_nlink);
    print_uid(sb->st_uid);
    print_gid(sb->st_gid);
    
    /* TODO: For devices: print major/minor pair; for other files: size. */
    // Device ID consists of two parts: major ID (class of the device) and
    // minor ID (specific instance of a device in that class).
    // unsigned int major(dev_t dev);
    // unsigned int minor(dev_t dev);
    // S_ISCHR returns non-zero if the file is a character special file
    // (a device like a terminal) and S_ISBLK returns non-zero if the file
    // is a block special file (a device like a disk).
    if (S_ISCHR(sb->st_mode) || S_ISBLK(sb->st_mode))
        printf("%2u, %2u", major(sb->st_rdev), minor(sb->st_rdev));
    else
        printf("%6lu", (size_t)sb->st_size);

    char *now = ctime(&sb->st_mtime);
    now[strlen(now) - 1] = '\0';
    printf("%26s", now);

    printf("    %s", name);

    if (S_ISLNK(sb->st_mode)) {
    /* TODO: Read where symlink points to and print '-> destination' string. */
        const size_t bufsize = 255;
        char path[bufsize + 1];

        // readlinkat(2) places the contents of the symbolic link name in the
        // buffer buf, which has size bufsize, but it does not append null byte
        // to buf, thus we have to do it.
        const ssize_t len = readlinkat(dirfd, name, path, bufsize);
        path[len] = '\0';
        printf(" -> %s", path);
    }

    putchar('\n');
}

int main(int argc, char *argv[]) {
    if (!argv[1])
        argv[1] = ".";

    int dirfd = Open(argv[1], O_RDONLY | O_DIRECTORY, 0);
    char buf[DIRBUFSZ];
    int n;

    while ((n = Getdents(dirfd, (void *)buf, DIRBUFSZ))) {
        struct linux_dirent *d;
        /* TODO: Iterate over directory entries and call file_info on them. */
        // int getdents(unsigned int fd, struct linux_dirent *dirp
        //              unsigned int count);
        // getdents(2) returns directory entries, it reads several linux_dirent
        // structures from the directory reffered to by the open file descriptor
        // fd into the buffer pointed to by dirp. The argument count specifies
        // the size of that buffer.
        const void* end = buf + n;
        void* it = buf;
        while (it < end) {
            d = (struct linux_dirent*)it;
            file_info(dirfd, d->d_name);
            it += d->d_reclen; // d_reclen is length of this linux_dirent
        }
    }

    Close(dirfd);
    return EXIT_SUCCESS;
}
```



## Zadanie 6
![](https://i.imgur.com/s8f0MWl.png)

## Zadanie 7
![](https://i.imgur.com/SzpOhyP.png)
