[Risolto] dubbio system call write C

[gian2991]

ciao a tutti, volevo sapere se ci fosse un modo per stampare a video dei valori con la write, tipo come si fa con la pritnf, printf("valore %i",val), una cosa del genere

[Actarus5]

ciao a tutti, volevo sapere se ci fosse un modo per stampare a video dei valori con la write, tipo come si fa con la pritnf, printf("valore %i",val), una cosa del genere

Questo è il prototipo della write():

ssize_t write(int fildes, const void *buf, size_t nbyte);

Praticamente ti scrive su fildes nbytes byte del buffer puntato da buf.
Puoi usare la write() per scrivere su stdin passando come primo parametro STDIN_FILENO ( è una macro definita in unistd.h) ma non credo sia davvero utile utilizzarla in questo modo

[gian2991]

sto provando cercando di usare una sprintf() per scrivere su file e poi cerco di stamparlo con la write()

[gian2991]

tipo questa cosa

char stamp[1];
snprintf(stamp, sizeof(stamp), "%i",5));
write(1,stamp,sizeof(char));

non mi stampa niente

[cortinico]

Codice: Seleziona tutto

#include <unistd.h>
int main() {
	write(STDOUT_FILENO, "hello\n", 6);
	return 0;
}

Cosi scrivi su standard output hello.

[gian2991]

è ma io la stampa ce l'ho dentro a un ciclo, e ogni giro le variabili cambiano, e non so come fare per stamparle, con la printf sarebbe una stupidata, ma non posso usarla, solo system calls

[cortinico]

Posti il codice per favore?

[gian2991]

Codice: Seleziona tutto

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/types.h>
#include <string.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <errno.h>

#ifndef KEY
#define KEY 2 /*dimensione per il buffer di lettura/scrittura*/
#endif

int charToInt(char u){
	int a=u-'0';
	return a;
}

int numeroNodi(){
	char buffer[50];
    	int nodesNumber;
    	memset(buffer,'\0',50);                // Azzera la memoria in modo che non ci siano problemi quando si va a leggere del buffer
    	write(1,"inserisci i nodi da simulare: ",sizeof(char)*29);
    	read(0,buffer,50);
    	nodesNumber=atoi(buffer);
    	return nodesNumber;
}

void wait_sem(int id_sem, int numsem){
	struct sembuf sem_buf;
	sem_buf.sem_num=numsem;
	sem_buf.sem_flg=0;
	sem_buf.sem_op=-1;
	semop(id_sem,&sem_buf,1); //semaforo rosso
}

void signal_sem(int id_sem,int numsem){
	struct sembuf sem_buf;
	sem_buf.sem_num=numsem;
	sem_buf.sem_flg=0;
	sem_buf.sem_op=1;
	semop(id_sem,&sem_buf,1); //semaforo verde
}

union semun{ 
 	int val;                  	/* value for SETVAL */       
	struct semid_ds *buf;     	/* buffer for IPC_STAT, IPC_SET */ 
      	unsigned short *array;    	/* array for GETALL, SETALL */ 
                                 	/* Linux specific part: */       
	struct seminfo *__buf;    	/* buffer for IPC_INFO */ 
};

int main(int argc, char *argv[]){
	int nodesNumber=numeroNodi();
	int fd_in=-1,cont=0;  
	pid_t nodi[nodesNumber];
	int a,i,j,nread[nodesNumber],maxRead=0;
	pid_t pid;
	key_t key_mem;
	key_t key_sem;
	key_t key_sem2;
	int *mem;
	int contatore=0,h;
	int fine[nodesNumber];
  	int *memoria;
	int *media;
	char *c;
	int curr_cont = 0;
	char filename[9];
   	char operazioni[nodesNumber][256];

	for(i=0;i<nodesNumber;i++){
		for(j=0;j<256;j++){
			operazioni[i][j]='-';
		}
	}

	key_mem = ftok("elab2.c", 'a');
	key_sem = ftok("elab2.c", 'b');
	key_sem2 = ftok("elab2.c", 'c');
    	

	/////////////////////////////////////////// LETTURA DA FILE ////////////////////////////////////////////////////
	
	for(i=0;i<nodesNumber;i++){
            sprintf(filename,"file%d.txt",i+1);
            if((fd_in=open(filename,O_RDONLY,0644))==-1)
         	write(2,"OPEN: -1",sizeof(char)*8);
            nread[i]=read(fd_in,operazioni[i],256);
            close(fd_in);
      	}
	for(i=0;i<nodesNumber;i++){
		if(nread[i]>=maxRead){
			maxRead=nread[i];
		}
	}
	maxRead++;
	maxRead++;
	for(j=0;j<nodesNumber;j++){	
		for(i=0;i<maxRead;i++){
			if(operazioni[j][i]=='\n')
				operazioni[j][i]=' ';
	      	}
	}
	
	/////////////////////////////////////////// MEMORIA CONDIVISA //////////////////////////////////////////////////

	int size_mem=(((sizeof(int)*2)*2)*nodesNumber)+sizeof(int);
	int shmid=shmget(key_mem,size_mem,IPC_CREAT | 0666);
  	if(shmid==-1){
	    	write(2,"SHMGET: -1",sizeof(char)*10);
	    	exit(1);
  	}
  	mem=(int*)(shmat(shmid,0,0));
  	if(mem==(void*)-1){
    		write(2,"SHMAT: -1",sizeof(char)*9);
    		exit(1);
  	}
  	memoria=mem;
  	media=mem;
	memoria[size_mem-1]=0;
	char operazione1;
	int z=0;
	
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	////////////////////////////////////////// SEMAFORI ////////////////////////////////////////////////////////////

	int semNumber=nodesNumber+1;
	struct sembuf oper;
  	int idSem=semget(key_sem,semNumber,IPC_CREAT | 0666);	// creo i semafori
	if(idSem==-1){
    		write(2,"SEMGET: -1",sizeof(char)*10);
    		exit(1);
  	}
	for(i=0;i<semNumber;i++){
		if((semctl(idSem,i,SETVAL,0))==-1){
			write(2,"SEMCTL: -1",sizeof(char)*10);
    			exit(1);
		}
	}
	int idSemEnd=semget(key_sem2,1,IPC_CREAT | 0666);
	if(idSemEnd==-1){
		write(2,"SEMGET altro: -1",sizeof(char)*10);
    		exit(1);
	}
	if((semctl(idSemEnd,0,SETVAL,0))==-1){
			write(2,"SEMCTL: -1",sizeof(char)*10);
    			exit(1);
	}

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	/////////////////////////////////////////// CREAZIONE PROCESSI /////////////////////////////////////////////////

	int flag=1;
	char operazione;
	int stamp;
	for(i=1;i<=nodesNumber;i++){	
		j=0;
		operazione=operazioni[i-1][j];	
		pid=fork();
		if(pid==0)
	   	{	// operazioni in comune per ogni processo
			do{
				switch(operazione){
					case 'E':
						//sprintf(stamp,"\nesecuzione processo %i\n sleep[%i]\n",i,charToInt(operazioni[i-1][j+2]));
						write(1,&stamp,sizeof(stamp));
						/*printf("esecuzione processo %i\n sleep[%i]\n",i,charToInt(operazioni[i-1][j+2]));*/
						sleep(charToInt(operazioni[i-1][j+2]));						
						j+=4;
						operazione=operazioni[i-1][j];
					break;
					case 'R':
						if(memoria[(i*4)-1]==0 && memoria[(i*4)-2]==0){
							printf("ricezione processo %i fallita\n",i);
						}
						else{
							memoria[(i*4)-1]=0;
							memoria[(i*4)-2]=0;
							printf("svuoto memoria ricezione del processo %i [%i][%i]\n",i,memoria[(i*4)-1],memoria[(i*4)-2]);
						}
						j+=2;
						operazione=operazioni[i-1][j];
					break;
					case 'S':
						if(memoria[(i*4)-4]!=0 && memoria[(i*4)-3]!=0){
							printf("impossibile scrivere in invio processo %i",i);
						}
						else{	
							printf("scrivo nella zona di invio di %i [%i][%i]\n",i,charToInt(operazioni[i-1][j+2]),charToInt(operazioni[i-1][j+4]));
							memoria[(i*4)-4]=charToInt(operazioni[i-1][j+2]);
							memoria[(i*4)-3]=charToInt(operazioni[i-1][j+4]);
							signal_sem(idSem,i-1);
						}
						j+=6;
						operazione=operazioni[i-1][j];
					break;	
					case ' ':
						j+=1;
						operazione=operazioni[i-1][j];
					break;
					case '-':
						flag=0;
						memoria[size_mem-1]+=1;
						signal_sem(idSemEnd,0);			
						exit(0);
					break;
					default:
						write(1,"operazione non conosciuta\n",sizeof(char)*26);
						exit(1);
						return 0;
					break;
				}
			}while(flag!=0);
			//exit(0);	     	 	
	   	}
		else 
	   	{
			if(pid>0){
				wait_sem(idSemEnd,0);
				while(1){
					if(memoria[size_mem-1]==nodesNumber){
						exit(0);
						return 0;
					}
					break;	
				}
				wait_sem(idSem,i-1);
				//printf("sono qui");
				int nodoR=memoria[(i*4)-4]; // nodo a cui inviare il msg
				int valR=memoria[(i*4)-3]; // valore da scrivere nel nodo
				memoria[(i*4)-4]=0; //libero la zona di invio
				memoria[(i*4)-3]=0;
				printf("libero la zona di invio del processo %i",i);
				if(memoria[(nodoR*4)-2]==0 && memoria[(nodoR*4)-1]==0){		
					memoria[(nodoR*4)-2]=i;
					memoria[(nodoR*4)-1]=valR;
					printf("scrivo nella zona di ivnio del processo %i [%i][%i]\n",nodoR,memoria[(nodoR*4)-2],memoria[(nodoR*4)-1]);
				}
				else{
					printf("il processo %i ha la zona di ricezione occupata",valR);;
				}
	   		}
	   		else
	   		{   
	      			fprintf(stderr, "Errore nel fork");
	      			exit(1);
				return 0;
	   		}
		}
	}
	exit(0);
}

tutti i printf vanno sostituiti con system calls, quelli che mi danno problemi sono tipo questi

Codice: Seleziona tutto

printf("svuoto memoria ricezione del processo %i [%i][%i]\n",i,memoria[(i*4)-1],memoria[(i*4)-2]);

[cortinico]

Puoi utilizzare le sprintf cosi:

Codice: Seleziona tutto

#include <string.h>
#include <unistd.h>
#include <stdio.h>

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

	char buffer[200];
	memset(buffer, '\0', 200);
	sprintf(buffer, "svuoto memoria ricezione del processo %i [%i][%i]\n",1,2,3);
	write(STDOUT_FILENO, buffer, strlen(buffer));
	return 0;
}