• a) 3
• b) 3
• c) 2
• d) 1
• e) 4

Warum? gibts dafür ne Begründung? - Ich würde sagen wegen der Formulierung, es MUSS einfach nicht so sein, es reicht ja wenn die Echtzeitaufgaben erledigt sin bis zum Termin, ob da noch wer davor drankommt ist doch dann worschd? → Genau.

• f) 2
• g) 1
• h) 4
• i) 3
• j) 3
• k) 4

Ich wäre für 3: physikalische Betriebsmittel können nie entzogen werden… aber virtuelle schon - In der Übung wo man März 2006 gemacht hat kam auch die Frage, da wars meines Wissens das 4te? → Die virtuellen Betriebsmittel können nicht entzogen werden, weil dazu in den Prozeß eingegriffen werden müßte. Das System kann aber die physikalischen Mittel als Grundlage entziehen, um sie neu zu vergeben.

• l) 2
• m) 2

Folgende Aufgaben sind der Musterlösung entnommen:

• a)

/* includes */
 
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <signal.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/stat.h>
 
/* Funktionsdeklarationen, globale Variablen */
 
void sighup_handler();
void msgserver();
char *getconf(int *);
static char cfile[256];
static int reload_msg = 1;
 
int main(int argc, char *argv[]) {
 
    /* Argumente prüfen */
 
    if (argc == 1) {
	strcpy(cfile, "msgd.conf");
    }
    else if (argc == 2) {
	strcpy(cfile, argv[1]);
    }
    else {
	fprintf(stderr, "usage: msgd [cfile]\n");
	exit(EXIT_FAILURE);
    }
 
    /* Serverprozess starten */
 
    {
	pid_t pid;
	pid = fork();
 
	if (pid == -1) {
	    perror("fork msgd-server");
	    exit(EXIT_FAILURE);
	}
	else if (pid == 0) {
	    msgserver();
	}
	else {
	    printf("msgd startet: PID = %d\n", pid);
	}
	return 0;
    }
}
 
/* msgserver-Funktion */
 
void msgserver() {
 
    /* Variablendefintionen */
 
    char *message;
    int msg_size;
    int sock_accept;
    int sock_listen;
    struct sockaddr_in sa_listen;
    struct sockaddr_in sa_accept;
 
    /* Socken öffnen, binden, usw. */
 
    if ( (sock_listen = socket(PF_INET, SOCK_STREAM, 0)) < 0 ) {
	perror("socket");
	exit(1);
    }
 
    sa_listen.sin_addr.s_addr = INADDR_ANY;
    sa_listen.sin_family = AF_INET;
    sa_listen.sin_port = htons(9999);
 
    if ( bind(sock_listen, (struct sockaddr *) &sa_listen, sizeof(sa_listen)) < 0 ) {
	perror("bind");
	exit(1);
    }
 
    listen(sock_listen, 20);
 
    /* Signal-Handler für SIGHUP einrichten */
 
    {
	struct sigaction act;
	act.sa_handler = sigchld_handler;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	sigaction(SIGHUP, &act, NULL);
    }
 
    while (1) {
 
	if (reload_msg) {
	    if ( (message = getconf(&msg_size)) == NULL ) {
		fprintf(stderr, "getconf failed\n");
		exit(EXIT_FAILURE);
	    }
	    reload_msg = 0;
	}
 
	/* Verbindung annehmen */
 
	{
	    int addr_size = sizeof(sa_accept);
 
	    if ( (sock_accept = accept(sock_listen, (struct sockaddr *) &sa_accept, &addr_size)) < 0 ) {
		if (ERRNO = EINTR) {
		    continue;
		}
		perror("accept");
		exit(EXIT_FAILURE);
	    }
 
	}
 
	/* Text ausgeben */
 
	{
	    FILE *conn;
	    int i;
 
	    if ( (conn = fdopen(sock_accept, "w")) == NULL ) {
		perror("fdopen socket");
		exit(EXIT_FAILURE);
	    }
 
	    for (i = 0; i < msg_size; i++) {
		putc(message[i], conn);
	    }
 
	    fclose(conn);
	}
    }
}
 
char *getconf(int *s) {
 
    /* Variablendefinitionen */
 
    static char *buffer = NULL;
    struct stat statbuf;
    int i;
    FILE *cf;
 
    /* Groeße der Datei ermitteln */
 
    if ( stat(cfile, &statbuf) < 0) {
	perror("stat cfile");
	return NULL;
    }
 
    /* Speicher allokieren */
 
    if ( (buffer = realloc(buffer, statbuf.st_size)) == NULL ) {
	perror("realloc");
	return NULL;
    }
 
    /* Datei einlesen */
 
    if ( (cf = fopen(cfile, "r")) == NULL ) {
	perror("fopen cfile");
	return NULL;
    }
 
    if ( fread(buffer, 1, statbuf.st_size, cf) != statbuf.st_size ) {
	fprintf(stderr, "getconf: file too short???\n");
	return NULL;
    }
 
    fclose(cf);
 
    /* Ergebnis liefern */
 
    *s = statbuf.st_size;
    return buffer;
}
 
void sighup_handler() {
 
    reload_msg = 1;
}

• b)

msgd: msgd.c
    ($CC) -o msgd msgd.c

msgd.c:
    co msgd.c

clean:
    rm -f msgd

• a)
• b)
• c)