Added 17,21,res,rlimit

processes/17.c

@@ -0,0 +1,66 @@
+/*
+Wspolpraca z kalkulatorem bc z wykorzystaniem potoków. Przykładowe wywolanie programu a.out 4+7 lub a.out "5 +
+7". Aby wyliczyc wartosc funkcji sinus mozna uzyc polecenia a.out "s(7)".
+*/
+#include <stdio.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+int main(int argc, char *argv[])
+{
+    int pid, fd1[2], fd2[2];
+    if (argc != 2)
+    {
+        perror("Bledna liczba argumentow.\n");
+        return -1;
+    }
+    else
+    {
+        if (pipe(fd1) == -1 || pipe(fd2) == -1)
+        {
+            perror("Otwarcie laczy nie jest mozliwe.\n");
+            return -1;
+        }
+        else
+        {
+            if ((pid = fork()) == -1)
+            {
+                perror("Pomyslne zakonczenie funkcji fork nie jest mozliwe.\n");
+                return -1;
+            }
+            else
+            {
+                if (pid == 0)
+                {
+                    char **pomoc = malloc(2 * sizeof(char *));
+                    pomoc[0] = strdup("bc");
+                    pomoc[1] = strdup("-l");
+                    pomoc[2] = NULL;
+                    close(fd2[0]);
+                    close(fd1[1]);
+                    dup2(fd1[0], 0);
+                    dup2(fd2[1], 1);
+                    execvp(pomoc[0], pomoc);
+                }
+                else
+                {
+                    FILE *f1, *f2;
+                    char *bufor;
+                    int l = 0;
+                    close(fd1[0]);
+                    close(fd2[1]);
+                    f1 = fdopen(fd1[1], "w");
+                    f2 = fdopen(fd2[0], "r");
+                    fprintf(f1, "%s\nquit\n", argv[1]);
+                    fflush(f1);
+                    bufor = (char *)malloc(1000 * sizeof(char));
+                    fgets(bufor, 1000, f2);
+                    printf("Wynik %s", bufor);
+                    free(bufor);
+                }
+            }
+            return 0;
+        }
+    }
+}

processes/21.c

@@ -0,0 +1,71 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+struct dane
+{
+    double *tab, *maksimum;
+    int dlugosc;
+    pthread_mutex_t *rygiel;
+};
+typedef struct dane Dane;
+void *obsluga(void *x)
+{
+    Dane *a = (Dane *)x;
+    int i;
+    double *wynik = (double *)malloc(sizeof(double));
+    *wynik = a->tab[0];
+    for (i = 1; i < a->dlugosc; i++)
+        if (*wynik < a->tab[i])
+            *wynik = a->tab[i];
+    pthread_mutex_lock(a->rygiel);
+    if (*(a->maksimum) < *wynik)
+        *(a->maksimum) = *wynik;
+    pthread_mutex_unlock(a->rygiel);
+    free(a);
+    return (void *)wynik;
+}
+int main(int argc, char **argv)
+{
+    int m = atoi(argv[1]), n, i, j;
+    double **tablica, *pomoc, wynik;
+    pthread_t *watki;
+    pthread_mutex_t kontrola = PTHREAD_MUTEX_INITIALIZER;
+    Dane *y;
+    sscanf(argv[2], "%d", &n);
+    tablica = (double **)malloc(sizeof(double *) * m);
+    watki = (pthread_t *)malloc(sizeof(pthread_t) * m);
+    tablica[0] = (double *)malloc(sizeof(double) * m * n);
+    for (i = 1; i < m; i++)
+        tablica[i] = &(tablica[0][i * n]);
+    srand(time(NULL));
+    for (i = 0; i < m; i++)
+    {
+        for (j = 0; j < n; j++)
+        {
+            tablica[i][j] = (rand() % 1000) / 77;
+            printf("[%d][%d]=%lf ", i, j, tablica[i][j]);
+        }
+        printf("\n");
+    }
+    wynik = tablica[0][0];
+    for (i = 0; i < m; i++)
+    {
+        y = (Dane *)malloc(sizeof(Dane));
+        y->dlugosc = n;
+        y->tab = tablica[i];
+        y->maksimum = &wynik;
+        y->rygiel = &kontrola;
+        pthread_create(&(watki[i]), NULL, obsluga, (void *)y);
+    }
+    for (i = 0; i < m; i++)
+    {
+        pthread_join(watki[i], (void **)&pomoc);
+        free(pomoc);
+    }
+    printf("Wynik %lf.\n", wynik);
+    free(tablica[0]);
+    free(watki);
+    free(tablica);
+    return 0;
+}

processes/resources.c

@@ -0,0 +1,11 @@
+/*
+Program wypisuje informacje o efektywnym biezacym uzytkowniku. Program ma problemy z poprawna praca na wszelkich emulatorach systemow typu uniksowego.
+*/
+
+#include<unistd.h>
+#include<pwd.h>
+#include<stdio.h>
+
+int main() {
+    printf("Uzytkownik: %s.\n", getpwuid(geteuid())->pw_dir);
+}

processes/rlimit.c

@@ -0,0 +1,33 @@
+/*
+Pobranie i ustawienie wielkosci segmentu danych dla procesu. Polecenia getrlimit i setrlimit sluza do pobrania i ustawiania roznych limitow w systemie operacyjnym. Nie na wszystkich systemach operacyjnych program powoduje blad z powodu przekrocenia limitu segmentu danych dla procesu, efekt działania programu zalezy od konfiguracji systemu operacyjnego. Program ma problemy z poprawna praca na wszelkich emulatorach systemow typu uniksowego.
+*/
+
+#include<stdio.h>
+#include<sys/resource.h>
+#include<stdlib.h>
+
+int main(int argc) {
+    struct rlimit pomoc;
+    char *p1, *p2;
+
+    getrlimit(RLIMIT_AS, &pomoc);
+    printf("soft: %llu, hard: %llu\n", pomoc.rlim_cur, pomoc.rlim_max);
+    pomoc.rlim_cur = 100;
+    if (argc == 1) {
+        setrlimit(RLIMIT_AS, &pomoc);
+    }
+    getrlimit(RLIMIT_AS, &pomoc);
+    printf("soft: %llu, hard: %llu\n", pomoc.rlim_cur, pomoc.rlim_max);
+    printf("Przydzielam pamiec dla zmiennej p1.\n");
+    if (!(p1 = (char *) malloc(5000))) {
+        perror("Brak pamieci dla zmiennej p1.\n");
+        return -1;
+    }
+    printf("Przydzielam pamiec dla zmiennej p2.\n");
+    if (!(p2 = (char *) malloc(7000))) {
+        perror("Brak pamieci dla zmiennej p2.\n");
+        return -1;
+    }
+    printf("Poprawnie zakonczylem przydzial pamieci.\n");
+    return 0;
+}