Iván Gordón P1 #!/bin/bash if test !

Iván Gordón
P1
#!/bin/bash
if test ! -d $1
then
echo "El argumento NO es un directorio"
exit
fi
rm -f $(find $1 -iname '*.class') /* el problema es que rm verá espacios y los toma como separador de nombre de
archivos*/
rm -f $(find $1 -iname '*.o')
15/25
P2
No contestada
0/25
P3
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
//fork(), waitpid(), open()
//fork(), execlp(), dup2(), sleep()
//exit()
//fdopen()
//open()
//open()
int main(void)
{
pid_t pid;
int pfd_bc[2],pfd_re[2];// decriptor
char operacion[200];
FILE *sd;
int n;
if (pipe(pfd_bc) < 0) {
perror("pipe");
exit(1);
}
// hijo que invoca bc
// operacion: Arreglo para almacenamiento de expresiones a calcular.
// Send Data para escribir en la pipa de matlab
// pipa que ejecuta el comando bc La pipa no ejecuta el comando
if (pipe(pfd_re) < 0) {
// pipa que recibe la respuesta de bc, no la use, una idea que no llevo a nada :
( (en el momento de la prueba, puede que si despues).
perror("pipe");
exit(1);
}
if ((pid = fork()) < 0) {
perror("fork");
exit(1);
}
if (pid == 0)
{
// Fork crea primer hijo
//HIJO 1
dup2(pfd_bc[0], 0);
// Pipa du: Hijo 1 escribe a la pipa
close(pfd_bc[1]);
// Pipa du: Hijo 1 no escribe de la pipa, por lo tanto cierra lado de escrittura
//dup2(pfd_re[1], 1); //esta pipa iba a recibir la respuesta del comando bc, pero sería mucho depurar la salida.
//close(pfd_re[0]);
execl("/usr/bin/bc","bc", 0); // Ejecuta el comando bc requerido y termina.
perror("exec");
_exit(127);
}else{
dup2(pfd_bc[1], 1);
sd = fdopen(pfd_bc[1], "w");
// Permite escribir a la pipa con fprintf mediante sd
while ((n = read(0, operacion, sizeof(operacion))) > 0)
write(sd, operacion, n);
// debió usar write (pfd_bc[1], operación,n);
fflush(sd);
/*getchar();*/
//fprintf(sd, "\n quit\n"); fflush(sd); //en caso de que ya no se quiera continuar.
close(pfd_bc[0]); //cierro el lado de lectura del proceso padre, el solo escribe en la pipa.
waitpid(pid, NULL, 0); //espero la muerte del proceso hijo.
exit(0);
}
}
/* No termina con quit.
Usa descriptor errado en write */
22/25
P4
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
int contador;
pthread_t ntid;
pthread_mutex_t candado = PTHREAD_MUTEX_INITIALIZER; //este es mi candado.
void *incrementa(void *arg){ //esta funcion incrementa sin exclsuion
int i;
printids("Incrementadora");
for ( i=0;i<2000000;i++){
contador++;
}
printf("El valor maximo adquirido por invrementadora es:%d\n",contador); // no es el máximo
return((void *)0);
}
void *incrementamutex(void *arg){//esta funcion incrementa con exclusion
int i;
printids("Incrementadora-mutex");
for ( i=0;i<2000000;i++){
pthread_mutex_lock(&candado);
contador++;
pthread_mutex_unlock(&candado);
}
printf("El valor maximo adquirido por invrementadoramutex es:%d\n",contador); // no es el máximo
return((void *)0);
}
//esta funcion la copie de los ejemplos y la uso para verificar que estoy creando hebras distintas.
printids(const char *s)
{
pid_t pid;
pthread_t
tid;
pid = getpid();
tid = pthread_self();
printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int)pid,
(unsigned int)tid, (unsigned int)tid);
}
main(int argc, char *argv[]){
if (argc != 2) { /* verifico si me estan pasando los parametros*/
printf("Debe indicar en que modo opera:\n 0 -sin exclusion,\n 1 -con exclusion");
exit(0);
}
int err,i;
contador=0; //variable a incrementar
int minimo=0;//variable con el minimo
int modo; //variable que guarda el modo de operación.
modo = atoi(argv[1]);
if(modo==0){
err = pthread_create(&ntid, NULL, incrementa, NULL); //creo hebra de la funcion incrementa
if (err != 0){
printf("error al crear hebra.");
exit(0);
}
printids("Decrementadora"); //la hebra del programa principal decrementa
for (i=0;i<2000000;i++){
contador--;
if(contador < minimo)
minimo=contador;
}
pthread_join(ntid,NULL);
}else if(modo==1){
err = pthread_create(&ntid, NULL, incrementamutex, NULL);
if (err != 0){
//la hebra, y los argumentos de esta son NULL
printf("error al crear hebra.");
exit(0);
}
printids("Decrementadoramutex");
for (i=0;i<2000000;i++){
pthread_mutex_lock(&candado);
contador--;
if(contador < minimo)
minimo=contador;
pthread_mutex_unlock(&candado);
}
pthread_join(ntid,NULL); //la hebra decrementa se duerme hasta que termine la que incrementa.
}else{
printf("Error en modo, debe se 0 ó 1");
exit(0);
}
printf("El valor minimo de contador es:%d\n",minimo);
printf("El valor final de contador es:%d\n",contador);
}
24/25