Sistemi Operativi - User contributions [en]

Grep piramidale (non tanto grep) esame 2.7.2003

2015-04-22T06:21:00Z

Eddy: /* Soluzione di Eddy */

=Traccia=
Scrivere uno script che prende in input (da linea di comando) una stringa e una lista di file; lo script deve
riportare il numero di occorrenze della stringa e di tutte i suoi prefissi nei file specificati. Ad esempio, se la
stringa cercata è linux, lo script deve riportare un output del tipo:
<source lang="text">
l 512
li 324
lin 300
linu 30
linux 30
</source>

== Soluzione di Eddy ==
In bash sarebbe stato molto piu` corto, ma volevo provare a fare qualcosa in python.

<source lang="python">
#!/usr/bin/env python3
import argparse
import os
import sys

def main():
# parsing degli argomenti
parser = argparse.ArgumentParser()
parser.add_argument("string", help="string to be matched")
parser.add_argument("files", nargs='+', help="source files")
args = parser.parse_args()

# leggo tutti i file e metto le parole in data
data = list()
try:
for fname in args.files:
with open(fname) as f:
data += f.read().split()
except FileNotFoundError:
print ('file \'%s\' not found' % fname)
sys.exit(0)

# faccio lo string matching per ogni prefisso
for i in range(len(args.string)+1)[1:]: # ogni prefisso
currStrn = args.string[:i]
count = 0
newData = list()

for strn in data: # string matching
n = strn.count(currStrn)
if n>0:
count += n
newData.append(strn)
print (currStrn,count)
data = newData

if __name__ == "__main__":
main()
</source>

Soluzione in bash
<source lang="bash">
#!/usr/bin/env bash

cat ${@:2} >> /tmp/tmp$$
string=$1
for (( i=1; i<=${#string}; i++ ))
do
curr=$(echo ${string} | cut -c1-$i)
occ=$(grep -o "$curr" /tmp/tmp$$ | wc -w)
echo "$curr $occ"
done
</source>

2015-03-24T12:54:25Z

Eddy: /* Soluzione di Eddy */

<source lang="text">
Scrivere un programma testeventfd che faccia uso della system call eventfd.
In particolare il programma deve eseguire una fork, quando l'utente digita un numero letto dal processo padre, il processo
figlio deve stampare un numero uguale di x.
</source>
==Soluzione di Pierg==
<source lang="c">
#include <sys/eventfd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

int main (int argc, char *argv[]) {

int efd, i;
long long unsigned int val;
ssize_t s;

/* Check for eventfd error */
efd = eventfd(0, 0);
if (efd == -1) {
perror("Eventfd Error");
}

/* Use fork to move eventfd form parent to child */
switch (fork()) {

case 0:
/* Read parent event */
s = read(efd, &val, sizeof(long long unsigned int));

if (s != sizeof(long long unsigned int)) {
perror("Read Error");
exit(EXIT_FAILURE);
}

/* For is used to print the 'x' of the argument passed by terminal */
for (i = (int)val; i > 0; i--) {
printf ("x\n");
}

exit(EXIT_SUCCESS);

/* Check for error */
case -1:
perror("Fork Error");
exit(EXIT_FAILURE);

default:
/* Wait for number */
printf ("Inserisci un intero diverso da 0: \n");
scanf ("%llu", &val);

/* Write parent event */
s = write(efd, &val, sizeof(long long unsigned int));

if (s != sizeof(long long unsigned int)) {
perror("Write Error");
exit(EXIT_FAILURE);
}

exit(EXIT_SUCCESS);
}
}
</source>

==Soluzione di Maldus==
<source lang="c">
#include <stdio.h>
#include <sys/eventfd.h>
#include <inttypes.h>
#include <sys/types.h>
#include <signal.h>
#include <semaphore.h>

int main(){
sem_t empty , full ;
pid_t son ;
int ed , status, i;
uint64_t x = 1;
ed = eventfd(0,0) ;
sem_init( &full , 1 , 0) ;
sem_init( &empty , 1 , 1 ) ;
switch( son = fork() ){
case 0:
while( x){
scanf("%" PRIu64 , &x) ;
sem_wait(&empty) ;
write(ed , &x , 8 ) ;
sem_post(&full) ;
}
kill(son ,SIGTERM);
return 0 ;
default:
while( 1 ){
sem_wait(&full);
read( ed , &x , 8) ;
for( i = x ; i > 0 ; i--) printf( "x\n" ) ;
sem_post(&empty) ;
}
return 1;
}
}
</source>
Siccome la write su di un event descriptor somma il valore dal buffer, se questa viene effettuata prima della lettura (che lo riporta a 0) il risultato ottenuto non è quello richiesto. Benchè sia altamente improbabile che una situazione del genere si verifichi in questo programma, ho cercato di evitarla usando i semafori (si tratta di un problema produttore/consumatore), senza successo: non riesco a capire perchè, ma sembra che le sem_post non incrementino il valore del semaforo.
Togliendo sem_wait e sem_post il programma funziona correttamente.

Esercizio 1, prova pratica 29.05.2013

2015-03-24T11:58:04Z

Eddy: /* Soluzione di Eddy */

Esercizio 1, prova pratica 29.05.2013

2015-03-24T10:05:47Z

Eddy:

Wifi daemon

2015-03-02T08:45:49Z

Eddy: Created page with "==Intro== Dato che ogni mattina mentre sono in laboratorio la connessione con ALMAWIFI viene persa ogni 10 minuti, ho deciso di scrivere un demone che me la riattivi ogni volt..."

==Intro==
Dato che ogni mattina mentre sono in laboratorio la connessione con ALMAWIFI viene persa ogni 10 minuti, ho deciso di scrivere un demone che me la riattivi ogni volta.
PROBLEMA: durante la wpa_supplicant ho ioctl[SIOCSIWAP]: Operation not permitted

===daemon.c===
<source lang="C">
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

void daemonFunction (char * argv[]);
void usage (int argc, char *argv[]);

int main (int argc, char *argv[])
{
pid_t child;
pid_t gChild;
int status;

usage (argc, argv);
child = fork ();
switch (child)
{
case -1:
perror ("child");
exit (1);
case 0:
gChild = fork ();
switch (gChild)
{
case -1:
perror ("gChild");
exit (1);

case 0:
daemonFunction(argv);

default:
//parent gChild
return 0;

}
default:

//parent
waitpid (child, &status, 0);
return 0;

}

return 0;
}

void daemonFunction (char *argv[])
{
argv[0] = "./connect.sh";
while (1)
{
pid_t child;
child = fork ();
int status;

switch (child)
{
case -1:
perror ("child");
exit (1);
case 0:
execv("./connect.sh", argv);

perror ("execv");
exit (1);

default:
//parent
waitpid (child, &status, 0);
break;

}
}
}

void usage (int argc, char *argv[])
{
if (argc != 2)
{
char *iface= "iface";
printf ("Usage: %s [%s]\n",
argv[0],
iface);
exit (1);
}
}
</source>

===connect.sh===
<source lang="bash">
#!/bin/bash

main ()
{
ping -q -c5 google.com >> ./.log

if [ $? -eq 0 ]
then
echo "internet ok" >> ./.log
sleep 10
else
connect "$@"

fi

}

connect ()
{
iface=$1

sudo killall wpa_supplicant
sudo ifconfig $iface down
sudo iwconfig $iface mode Managed
sudo ifconfig $iface up
sudo wpa_supplicant -B -Dwext -i $iface -c ./wireless-wpa-enterprise.conf -dd
sudo dhclient $iface
sleep 10
}

main "$@"

</source>
===wireless-wpa-enterprise.conf===
<source lang="text">
ctrl_interface=/var/run/wpa_supplicant

network={
ssid="ALMAWIFI"
scan_ssid=0
key_mgmt=WPA-EAP
eap=PEAP
phase2="auth=MSCHAPV2"
identity="blabla@studio.unibo.it"
password="psw"
}
</source>
[[User:Eddy|Eddy]] ([[User talk:Eddy|talk]]) 10.20 Mon, 02 Mar 2015 (CET)

Main Page

2015-03-02T08:20:34Z

Eddy:

Questo è il Wiki del Corso di Sistemi Operativi

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Listx.h commentato + esempio su container of

2015-01-30T10:43:04Z

Eddy: /* Intro */

==Intro==
Siccome mi e` stato chiesto, per chiunque ne avesse bisogno, qui c'e` il file listx.h con i commenti presi dal file originale list.h, ho aggiunto in piu un esempio su come usare la macro container_of
<source lang="C">
* subset of the Linux Kernel source file: "include/linux/list.h"
CPLv2 */
#ifndef _LISTX_H
#define _LISTX_H

typedef unsigned int size_t;

/**
* example:
*
* struct container
* {
* int some_data;
* struct list_head list;
* };
*
* *list_ptr is a pointer to the list member
*
* struct container *container_ptr;
* container_ptr = container_of(list_ptr, struct container, list);
*/
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})

#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

struct list_head {
struct list_head *next, *prev;
};

#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \
struct list_head name = LIST_HEAD_INIT(name)

static inline void INIT_LIST_HEAD(struct list_head *list)
{
list->next = list;
list->prev = list;
}

/**
* Insert a new entry between two known consecutive entries.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __list_add(struct list_head *new,
struct list_head *prev,
struct list_head *next)
{
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;
}
/**
* list_add - add a new entry
* @new: new entry to be added
* @head: list head to add it after
*
* Insert a new entry after the specified head.
* This is good for implementing stacks.
*/
static inline void list_add(struct list_head *new, struct list_head *head)
{
__list_add(new, head, head->next);
}
/**
* list_add_tail - add a new entry
* @new: new entry to be added
* @head: list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
__list_add(new, head->prev, head);
}
/**
* Delete a list entry by making the prev/next entries
* point to each other.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
prev->next = next;
}
/**
* list_del - deletes entry from list.
* @entry: the element to delete from the list.
* Note: list_empty on entry does not return true after this, the entry is in an undefined state.
*/
static inline void list_del(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
}
static inline int list_is_last(const struct list_head *list,
const struct list_head *head)
{
return list->next == head;
}
/**
* list_empty - tests whether a list is empty
* @head: the list to test.
*/
static inline int list_empty(const struct list_head *head)
{
return head->next == head;
}
static inline struct list_head *list_next(const struct list_head *current)
{
if (list_empty(current))
return NULL;
else
return current->next;
}
static inline struct list_head *list_prev(const struct list_head *current)
{
if (list_empty(current))
return NULL;
else
return current->prev;
}
/**
* list_for_each - iterate over a list
* @pos: the &struct list_head to use as a loop counter.
* @head: the head for your list.
*/
#define list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/**
* list_for_each_prev - iterate over a list backwards
* @pos: the &struct list_head to use as a loop counter.
* @head: the head for your list.
*/
#define list_for_each_prev(pos, head) \
for (pos = (head)->prev; pos != (head); pos = pos->prev)
/**
* list_for_each_entry - iterate over list of given type
* @pos: the type * to use as a loop counter.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
#define list_for_each_entry(pos, head, member) \
for (pos = container_of((head)->next, typeof(*pos), member); \
&pos->member != (head); \
pos = container_of(pos->member.next, typeof(*pos), member))

#define list_for_each_entry_reverse(pos, head, member) \
for (pos = container_of((head)->prev, typeof(*pos), member); \
&pos->member != (head); \
pos = container_of(pos->member.prev, typeof(*pos), member))

#endif
</source>
[[User:Eddy|Eddy]] ([[User talk:Eddy|talk]]) 12.20 FRI, 30 Gen 2014 (CET)

2014-11-02T22:13:23Z

Eddy: /* Paradigma OOP in C */

=Paradigma OOP in C=

Quando in classe abbiamo parlato di [[puntatori a funzione]] mi e` subito venuto in mente una cosa del genere:

<source lang="c">
#include <stdio.h>

int foo1 (int x);

typedef struct classe
{
int data;
int (*foo) (int x);
} classe;

int main (void)
{
classe *ptr;
ptr = (classe*) malloc (sizeof (classe));
ptr->foo = &foo1;
printf ("%d", ptr->foo(4));
free(ptr);
return 0;
}

int foo1 (int x)
{
return x;
}
</source>

'''ptr->foo()''' assomiglia molto ad un metodo!

===Primi problemi===

* se l'utente mi cambia l'indirizzo a cui punta foo?
* come rendo privati eventuali campi che voglio nascondere all'utente? [[Incapsulamento]]
* come derivo nuove classi a partire da quelle gia` definite? [[Ereditarietà]]
* come implemento il [[Polimorfismo]]?

===La mia soluzione (incapsulamento)===

* Scrivere una "classe" per modulo, nel relativo header dichiarare solo "i metodi che dovranno essere public":

<source lang="c">
#ifndef H__CLASS_H__H
#define H__CLASS_H__H

/* la "classe" classe contiene una parola che puo`:
* -essere cambiata
* -essere stampata
*/
struct classe;
typedef struct classe classe;

/* constructor */
classe* classeCreate(void);

/* destructor */
void classeDestroy(classe *classe_ptr);

/* public methods */
void cambiaParola (classe *classe_ptr, char *hello);
void stampa(classe *classe_ptr);

#endif
</source>

Da notare che non ho definito la struttura, in questo modo l'utente che andra` ad utilizzarla non potra`
accedere ai campi, sara` costretto ad utilizzare "i metodi" dichiarati.

* Implementare la relativa "classe":

<source lang = "c">
#include "class.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

struct classe
{
/* i campi sono privati!! */
char *hello;
};

/* constructor implementation */

classe* classeCreate(void)
{
classe *classe_ptr = NULL;

classe_ptr = (classe* ) malloc (sizeof (classe));
if(classe_ptr == NULL)
return NULL;
memset (classe_ptr, 0, sizeof (classe));

classe_ptr->hello = (char *) malloc (9*sizeof (char));
strcpy (classe_ptr->hello, "default");

return classe_ptr;
}

/* destructor implementation */

void classeDestroy (classe *classe_ptr)
{
if (classe_ptr == NULL)
{
fprintf( stderr, "Null pointer error, classe_ptr is NULL\n");
exit (-4);
}

/* sono sicuro che hello != null, poiche` l'utente
* non puo` gestirla al di fuori dei public methods
*/
free (classe_ptr->hello);
free (classe_ptr);
}

/* public methods implementation */

void cambiaParola (classe *classe_ptr, char *src)
{
/* dealloco *hello e creo spazio per *src */
free (classe_ptr->hello);

classe_ptr->hello = (char *) malloc
( (strlen(src) +1)*sizeof(char));
strcpy (classe_ptr->hello, src);
}

void stampa (classe *classe_ptr)
{
printf ("%s\n", classe_ptr->hello);
}

/* private methods */

static void foo (void)
{
/* something */
}
</source>

* Per finire importare la "classe" ed utilizzarla:

<source lang = "c">
#include "class.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main (int argc, char *argv)
{
classe *saluto;

/* creo la "classe" saluto */
saluto = classeCreate ();

/* provo a stampare, N.B. non ho la minima
* idea di come sia fatta la struttura.
* NON posso fare:
* printf ("%s", stampa->hello);
*/

//printf ("%s", stampa->hello);
stampa (saluto);

/* cambio la parola, N.B. non ho la minima
* idea di come sia fatta la struttura.
* NON posso fare:
* strcpy (stampa->hello, "ciao");
*/

//strcpy (stampa->hello, "ciao");
cambiaParola (saluto, "ciao");

stampa (saluto);

classeDestroy (saluto);

return 0;
}
</source>

=Conclusione=

Non so se il modo in cui ho affrontato il problema sia corretto o errato, sono aperto a qualunque suggerimento (anche uno stravolgimento della mia idea e` ben accetto).
Rimangono ancora "aperti" i problemi:
# [[Ereditarietà]]
# [[Polimorfismo]]

Sarei felice di ricevere suggerimenti in proposito!

PS. Non ho scritto questo Topic per utilizzare il paradigma OOP in C, ero solo curioso di vedere se fossi riuscito o meno ad implementare qualcosa di simile al concetto di classe.

=Download File=

[https://drive.google.com/file/d/0B0FK1WI24sl6a3oyYUlvQVlrN0k/view?usp=sharing Download: classi.tgz]

"classi" in C

2014-11-02T22:08:18Z

Eddy: Come scrivere una "classe" in C?

=Paradigma OOP in C=

Quando in classe abbiamo parlato di [[puntatori a funzione]] mi e` subito venuto in mente una cosa del genere:

<source lang="c">
#include <stdio.h>

int foo1 (int x);

typedef struct classe
{
int data;
int (*foo) (int x);
} classe;

int main (void)
{
classe *ptr;
ptr = (classe*) malloc (sizeof (classe));
ptr->foo = &foo1;
printf ("%d", ptr->foo(4));
return 0;
}

int foo1 (int x)
{
return x;
}
</source>

'''ptr->foo()''' assomiglia molto ad un metodo!

===Primi problemi===

* se l'utente mi cambia l'indirizzo a cui punta foo?
* come rendo privati eventuali campi che voglio nascondere all'utente? [[Incapsulamento]]
* come derivo nuove classi a partire da quelle gia` definite? [[Ereditarietà]]
* come implemento il [[Polimorfismo]]?

===La mia soluzione (incapsulamento)===

* Scrivere una "classe" per modulo, nel relativo header dichiarare solo "i metodi che dovranno essere public":

<source lang="c">
#ifndef H__CLASS_H__H
#define H__CLASS_H__H

/* la "classe" classe contiene una parola che puo`:
* -essere cambiata
* -essere stampata
*/
struct classe;
typedef struct classe classe;

/* constructor */
classe* classeCreate(void);

/* destructor */
void classeDestroy(classe *classe_ptr);

/* public methods */
void cambiaParola (classe *classe_ptr, char *hello);
void stampa(classe *classe_ptr);

#endif
</source>

Da notare che non ho definito la struttura, in questo modo l'utente che andra` ad utilizzarla non potra`
accedere ai campi, sara` costretto ad utilizzare "i metodi" dichiarati.

* Implementare la relativa "classe":

<source lang = "c">
#include "class.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

struct classe
{
/* i campi sono privati!! */
char *hello;
};

/* constructor implementation */

classe* classeCreate(void)
{
classe *classe_ptr = NULL;

classe_ptr = (classe* ) malloc (sizeof (classe));
if(classe_ptr == NULL)
return NULL;
memset (classe_ptr, 0, sizeof (classe));

classe_ptr->hello = (char *) malloc (9*sizeof (char));
strcpy (classe_ptr->hello, "default");

return classe_ptr;
}

/* destructor implementation */

void classeDestroy (classe *classe_ptr)
{
if (classe_ptr == NULL)
{
fprintf( stderr, "Null pointer error, classe_ptr is NULL\n");
exit (-4);
}

/* sono sicuro che hello != null, poiche` l'utente
* non puo` gestirla al di fuori dei public methods
*/
free (classe_ptr->hello);
free (classe_ptr);
}

/* public methods implementation */

void cambiaParola (classe *classe_ptr, char *src)
{
/* dealloco *hello e creo spazio per *src */
free (classe_ptr->hello);

classe_ptr->hello = (char *) malloc
( (strlen(src) +1)*sizeof(char));
strcpy (classe_ptr->hello, src);
}

void stampa (classe *classe_ptr)
{
printf ("%s\n", classe_ptr->hello);
}

/* private methods */

static void foo (void)
{
/* something */
}
</source>

* Per finire importare la "classe" ed utilizzarla:

<source lang = "c">
#include "class.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main (int argc, char *argv)
{
classe *saluto;

/* creo la "classe" saluto */
saluto = classeCreate ();

/* provo a stampare, N.B. non ho la minima
* idea di come sia fatta la struttura.
* NON posso fare:
* printf ("%s", stampa->hello);
*/

//printf ("%s", stampa->hello);
stampa (saluto);

/* cambio la parola, N.B. non ho la minima
* idea di come sia fatta la struttura.
* NON posso fare:
* strcpy (stampa->hello, "ciao");
*/

//strcpy (stampa->hello, "ciao");
cambiaParola (saluto, "ciao");

stampa (saluto);

classeDestroy (saluto);

return 0;
}
</source>

=Conclusione=

Non so se il modo in cui ho affrontato il problema sia corretto o errato, sono aperto a qualunque suggerimento (anche uno stravolgimento della mia idea e` ben accetto).
Rimangono ancora "aperti" i problemi:
# [[Ereditarietà]]
# [[Polimorfismo]]

Sarei felice di ricevere suggerimenti in proposito!

PS. Non ho scritto questo Topic per utilizzare il paradigma OOP in C, ero solo curioso di vedere se fossi riuscito o meno ad implementare qualcosa di simile al concetto di classe.

=Download File=

[https://drive.google.com/file/d/0B0FK1WI24sl6a3oyYUlvQVlrN0k/view?usp=sharing Download: classi.tgz]