LINUX AVANZATO 2007

Scusate lo sfogo,ma quando ce vò ce vò :

Aritorniamo a studià va...

Allora per quanto riguarda l'esercizio postato sopra da shogun c'era qualche errore ma è molto buono.
Aa un problema di segmentation fault, e stavolta non mi pare che è roba da allocare, e non riesco a capire perchè lo fa.

Una domanda più importante come funziona strace?? Dovrebbe aiutare a debbuggare?? Perchè a me non aiuta affatto...

/*
Autore: Shogun <Questo indirizzo email è protetto dagli spambots. È necessario abilitare JavaScript per vederlo.>
Rilasciato sotto GPL 2.0
*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sched.h>

char *filename = NULL;
off_t positions[2] = {0,0};

void lock(){
int fd;

while(1){
fd = creat("LA.lock", 0500);
if(fd > 0){
close(fd);
return;
}
}
}

void unlock(){
unlink("LA.lock");
}

int replace_function(void *data){
//Dichiarazione variabili
int fd = 0, index = (int) data, byte;
char buf = 0;
off_t cur = 0;

//Apriamo il file
if((fd = open(filename, O_RDWR)) < 0) return -1;

//Iniziamo la lettura del file
if(index == 1){
lock();
lseek(fd, -1, SEEK_END);
unlock();
}

while(1){
lock();
byte = read(fd, &buf, 1);
if(byte < 0){
perror("Impossibile leggere dal file");
unlock();
return 1;
}else if(byte == 0){
unlock();
return 0;
}
//printf("letto %c\n", buf);
if(buf == 'a'){ //Abbiamo trovato il byte da sostituire
lseek(fd, -1, SEEK_CUR); //Torniamo indietro
if(index==0) buf='b'; else buf='c';
write(fd, &buf, 1);
}

// Adesso aggiorniamo la posizione attuale e verifichiamo se è il caso di uscire
cur = lseek(fd, 0, SEEK_CUR);
//printf("index = %d, cur = %d , positions[0] = %d, positions[1] = %d\n", index, cur, positions[0], positions[1]);
usleep(200);

if(index == 0){
if(cur > positions[1]){
unlock();
break;
}
}else{
if(cur > positions[0]){
unlock();
break;
}
}

// Non dobbiamo uscire, posizioniamo correttamente se andiamo all'indietro

if(index == 1){ cur = lseek(fd, -2, SEEK_CUR);}

positions[index] = cur;
unlock();
}


//Chiudiamo il file
close(fd);

//Ritorniamo
return 0;
}

int main(int argn, char** args){
//Dichiarazione variabili
int i = 0, pids[2] = {0,0}, stacks[2][2048], rc = 0;

//Verifica argomenti
if(argn != 2){
printf("Uso: %s nome_file\n", args[0]);
exit(1);
}else
filename = strdup(args[1]); //duplica la stringa la memoria &#65533;allocata con malloc, &#65533;possibile usare free

//Verifichiamo la disponibilità del file
if(access(args[1], R_OK) < 0){ //testa l'esisstenza del file e se si hanno i permessi di lettura scrittura e esecuzione F_OK solo esistenza
perror("Impossibile aprire il file in scrittura:\n");
exit(1);
}

//Inizializzo positions[1]
int fd;
if((fd = open(filename, O_RDWR)) < 0) return -1;
positions[1] = lseek(fd, 0, SEEK_END);
close(fd);


//Creiamo i due cloni che eseguiranno la modifica.
for(i = 0; i < 2; i++){
pids = clone(&replace_function, stacks, CLONE_VM, (void*) i);
if(pids < 0){
perror("Impossibile creare il clone:");
exit(1);
}else{
printf("Creato il clone %d che ha il PID %d\n", i + 1, pids);
}
}

//Aspettiamo la terminazione dei cloni
waitpid(pids[0], &rc, __WCLONE); printf("Il clone 1 e' uscito con stato %d.\n", rc);
waitpid(pids[1], &rc, __WCLONE); printf("Il clone 1 e' uscito con stato %d.\n", rc);

//Usciamo
return 0;
}

Ragazzi scusate il disturbo ma vi sarei grato se qualcuno desse uno sguardo a questo programmino:

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <sched.h>

int pid[3];
int pidpadre;

int run(){
int mypid=getpid();
fprintf(stderr, "Processo %d in esecuzione\n",mypid);

int j=0;
int ismax=1;
for(j=0;j<3;j++){
if(mypid<pid[j]) ismax=0;
}
if(ismax==0) {
while(1) {
fprintf(stderr, "Processo %d in attesa di essere ucciso\n",mypid);
sleep(1);
}
}
else{
printf("Processo %d dormirà tre secondi\n",mypid);
sleep(3);
fprintf(stderr, "Processo %d sta per uccidere gli altri due\n",mypid);
for(j=0;j<3;j++){
if(mypid!=pid[j]) kill(pid[j],SIGKILL);
}
kill(pidpadre,SIGUSR1);
}
return 0;
}

void stampa(){
fprintf(stderr, "Processo padre ha ricevuto il segnale della strage!!\n");
sleep(2);
}

int main(){

pidpadre=getpid();
char stack[3][1024];
int i=0;
for(i=0;i<3;i++){
if((pid=clone(run,&stack[1023],CLONE_VM,NULL))<0){
fprintf(stderr, "Clone %d non creato!\n",i);
}
}
signal(SIGUSR1,stampa);
sleep(5);
return 0;
}

Funziona, ma non credo che il professore lo darebbe per buono con un bel SEGMENTATION FAULT finale..

Grazie in anticipo..

Per MrEnrick

Ho provato il tuo programma ed a me dava un bel segmentation fault iniziale.
Ecco la mia soluzione:

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <sched.h>
#include <stdlib.h>


int pid[3];
int pidpadre;

int run(){
sleep(3);
int mypid=getpid();
printf("Processo %d in esecuzione\n",mypid);

int j=0;
int ismax=1;
for(j=0;j<3;j++){
if(mypid<pid[j]) ismax=0;
}
printf("Processo %d in esecuzione\n", mypid);
if(ismax==0) {
while(1) {
printf("Processo %d in attesa di essere ucciso\n",mypid);
sleep(1);
}
}
else{
printf("Processo %d dorme tre secondi\n",mypid);
sleep(3);
printf("Processo %d sta per uccidere gli altri due\n",mypid);
for(j=0;j<3;j++){
if(mypid!=pid[j]) kill(pid[j],SIGKILL);
}
kill(pidpadre,SIGUSR1);
}
sleep(1);
return 0;
}

void stampa(){
printf("Processo padre ha ricevuto il segnale della strage!!\n");
sleep(2);
}

int main(){

char stack[3][1024];
int i=0;
signal(SIGUSR1,stampa);
pidpadre = getpid();

for(i=0;i<3;i++){
if((pid=clone(run,&stack[1023],CLONE_VM|CLONE_SIGHAND,NULL))<0){
printf("Clone %d non creato!\n",i);
}
sleep(1);
}
pause();
return 0;
}

Se hai dubbi chiedi pure!!

Allora innanzitutto grazie mille!
Poi... a parte che non si sa perchè sul mio compilatore il mio programma da segmentation fault alla fine e sul tuo all'inizio..e vabbè trascuriamo questo dettaglio.
Seconda cosa ho provato il tuo e mi da segmentation fault quasi subito:

marco@marco-laptop:~/Università/LinuxA/Programmi$ gcc -Wall lionel.c -o leo
marco@marco-laptop:~/Università/LinuxA/Programmi$ ./leo
Processo 4768 in esecuzione
Processo 4768 in esecuzione
Processo 4768 in attesa di essere ucciso
Segmentation fault
marco@marco-laptop:~/Università/LinuxA/Programmi$

poi ho provato a mettere la "pause" sul mio al posto della sleep(5) alla terzultima riga e non mi da più segmentation fault, ma se gli faccio stampare qualcosa dopo fa una cosa un pò strana:

Processo padre ha ricevuto il segnale della strage!! // l'ultima istruzione prima della "pause"
marco@marco-laptop:~/Università/LinuxA/Programmi$ grammi$ // scrive "grammi$ " il cui numero di lettere corrisponde al numero di lettere che gli faccio stampare dopo la pause!!!!

Ho provato a mettere sleep da tutte le parti ma l'esito è lo stesso.

I misteri del C..

hai provato a mettere uno \n dopo l'ultima printf?????