ficheros

#include

#include

#include

#include

#include

#include

#define MAXLON 1000

void*cuenta(void*dato){

int pos, cont=0, leidos;

char*nombre=(char*)dato,cadena,MAXLON))!=0)

int fd;

while((leidos=read(fd,cadena,MAXLON))!=0)

for(pos=0; pos

if((cadena[pos]=='a') ||(cadena[pos]=='A'))

cont++;

printf("fichero %s:%d caracteres 'a' o 'A' encontramos" nombre,cont);

close(fd);

pthread_exit(NULL);

}

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

pthread_t hilo;

printf("indica el nombre de un fichero.");

exit(0);

}

pthread_create(&hilo,NULL,cuenta,(void*) argv[1]);

pthread_join(hilo,NULL);

return 0;

}

practica policia

55. Disponemos de un disco duro de 20 GB de capacidad. Hay establecida sobre él, una única partición que contiene un sistema de ficheros del tipo FAT32 en el que cada agrupamiento (cluster) consta de 16 sectores de 512 bytes cada uno. ¿Cuántos sectores del disco se necesitarán para almacenar cada copia la FAT? Razona tu respuesta.

En primer lugar se calcula lo que ocupa la FAT, que es el tama˜no del enlace

(32 bits) por el n´umero de entradas de la tabla que, a su vez, es el tama˜no del

disco dividido por el tama˜no del agrupamiento y que en este problema son

20GB/(16 ∗ 512bytes) = 20 ∗ 217 entradas. Luego la tabla ocupa 20 ∗ 217 ∗ 32bits = 20 ∗ 219bytes.

Si se divide lo que ocupa la tabla por el tama˜no del agrupamiento se obtiene

el n´umero de agrupamientos que ocupa la tabla: 20 ∗ 219/(16 ∗ 512) = 20 ∗26 = 1280agrupamientos, que multiplicado por 16, que es el n´umero de

sectores por agrupamiento, se obtiene el n´umero total de sectores que es

20480.

56. La policía ha arrestado al sospechoso de un delito. Al analizar el contenido de su ordenador piensan que pueden inculparle pues el contenido del mismo

es el siguiente:

En un sistema de archivos FAT, los bloques se asignan como una lista enlazada

que finaliza con la posici´on fin de lista EOF. Es posible recuperar

datos utilizando los enlaces partiendo desde esa posici´on EOF hacia atr´as.

La reconstrucci´on de la lista de bloques ser´a:

14 → 15 → 12 → 13 → 10 → 11 → EOF

La informaci´on de esa lista de bloques ser´a:

sigan → buscando → yo → no → he → sido → EOF

Número De bloque de datos	Contenido
10	he
11	sido
12	yo
13	no
14	sigan
15	buscando

Como experto informático, pides consultar el contenido de la FAT, que es el siguiente:

Número de entrada en la FAT	Contenido
10	11
11	EOF
12	13
13	10
14	15
15	12

¿Apoyarías la opinión de la policía? Razona tu respuesta.

No estoy deacuerdo

Respuestas

#include

#include

#include

#include

#include

#include

#define MAX 10

#define FIN -1

int buffer[MAX];

sem t huecos, elementos;

int generar dato (void) { return random() %256;} int numero aleatorio(void) { return random() %100;}

void ∗productor (void ∗p) {

int pos productor= 0;

int num, dato, n;

n= numero aleatorio();

printf ("Productor con %d datos\n", n);

for(num= 0; num< n; num++) { dato= generar dato();

sem wait (&huecos);

buffer[pos productor]= dato;

pos productor= (pos productor+ 1) %MAX;

sem post (&elementos);

}sem wait (&huecos);

buffer[pos productor]= FIN;

sem post (&elementos);

pthread exit (NULL);

}

void ∗consumidor(void ∗p){

int pos consumidor= 0, dato;

bool continuar= true;

while (continuar) { sem wait (&elementos);

dato= buffer[pos consumidor];

sem post (&huecos);

if (dato== FIN)

continuar= false;

else { printf ("Numero aleatorio: %d\n", dato);

pos consumidor= (pos consumidor+1) %MAX;

}

}

pthread exit (NULL);

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

pthread t hiloproductor, hiloconsumidor;

sem init (&elementos, 0, 0);

sem init (&huecos, 0, MAX);

pthread create (&hiloproductor, NULL, productor, NULL);

pthread create (&hiloconsumidor, NULL, consumidor, NULL);

pthread join (hiloproductor, NULL);

pthread join (hiloconsumidor, NULL);

sem destroy (&huecos);

sem destroy (&elementos);

return 0;

}

Practica 2

Practica 2:

//Estudia el siguiente codigo y escribe la jerarquia de procesos resultante. Despues, compila y ejecuta el codigo para comprobarlo (deberas añadir llamadas al sistema getpid, getppid y wait para conseguirlo).

#include

#include

#include

#include

#include

#include

#define L1 2

#define L2 3

int main ()

{

int cont1, cont2;

pid_t pid;

system("clear");

for (cont2 = 0; cont2

{

for (cont1 = 0; cont1 < L1; cont1++)

{

pid = fork();

if (pid== 0)

break;

}

if (pid!= 0)

break;

}

printf("Soy el proceso %d y mi padre es % d\n",getpid(),getppid());

return 0;

}

En esta primera corrida y compilacion del programa, se obtienen un padre para muchos hijos en este caso 15.

Y en este caso si se le agrega la funcion sleep(); los procesos se anidan y se forman como en zigzag.

Ejercicio 1

Dibuja la jerarquía de procesos que resulta de la ejecución del siguiente código. Introduce las llamadas al sistema wait para que una vez generado el árbol de procesos los hijos sean esperados por sus respectivos padres. Ademas, haz que se informe de los tiempos de ejecución de las aplicaciones xload y kcalc que se generen así como del tiempo total de ejecución. Para calcular el tiempo transcurrido, puedes utilizar la función´ time() de la librería estándar time.h. La llamada time(NULL) devuelve los segundos transcurridos desde las 00:00:00 del 1/1/1970 hasta el instante de la llamada.Código:

#include

#include

#include

#include

#include

#include

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

int i, j;

pid_t pid, nuevo, nuevo1;

time_t ini, fin;

ini = rand()%25+1;

for (i= 0; i< 2; i++)

{ pid= getpid();

for (j= 0; j< i+2; j++)

{ nuevo= fork();

if(nuevo== 0){ break;

nuevo1= fork();

if(nuevo1== 0)

execlp ("xload", "xload", NULL);

}

}

if (pid!= getpid())

execlp ("kcalc", "kcalc", NULL);

}

for (i= 0; i< 2; i++)

for (j= 0; j< i+2; j++){ wait(NULL);

printf ("Tiempo en ejecucion de kcalc: %ld\n", (rand()%50+1)-ini);

}

Practicas matando proceso

Practica 1 Matando un proceso en modo grafico

Practica 2 Matando un proceso por línea de comandos

Practica 3 Matando un proceso por medio de scripts

Practica 4 Ver los procesos de usuario desde línea de comandos

Practica 5 Mostrando los porcentajes de uso de memoria de los procesos

Practica 6 Ejecución de procesos de manera concurrente

Prac7 Uso del comando jobs (viendo estado de procesos)

Practica 8 Pausar tareas y 9 Muestra de reinicio de procesos

Practica 10 Crear una lista FIFO

Practica 11 Agregando un proceso a una lista FIFO




Practica 12 Creado listas con mknod

PRACTICA 13 Observar listas de procesos creadas hasta ahora

PRACTICA 14 Eliminando una lista

Practica15

Practica 15 Ver árbol de procesos

practica semaforos

lock_lp (tipo_flag flag)
{
BOOL entrar= 0;
while (!entrar) {
lock(cerrojo_flags);
if (flag) {
unlock(cerrojo_flags);
dormir(flag);
}
else {
entrar= 1;
flag= 1;
unlock(cerrojo_flags);
}
}
}
unlock_lp (tipo_flag flag)
{
lock(cerrojo_flags);
flag= 0;
despertar(flag);
unlock(cerrojo_flags);
}

a) Analizar la estructura de las secciones criticas que contiene.
El código es de acceso exclusivo y se protege con una sección crítica de corto plazo mediante un cerrojo de exclusión mutua único común, que llamamos (de mutual exclusión). Pero un proceso no puede quedarse dormido dentro de la sección crítica de corto plazo en lock_lp, ya que no permitiría la ejecución de despertar por otro proceso.
b) Siguiendo esta misma idea, dados los algoritmos de bajar y subir sobre semáforos.
Subir () puede encargarse de liberar los cerrojos de los procesos, y bajar() de restaurarlos. En otras palabras, los procesos en estado bloqueado se consideran fuera de toda sección crítica. Un problema del esquema subir/bajar es que bajar desbloquea a todos los procesos subidos en el flag y sólo uno de ellos accederá a la sección crítica. Esto es especialmente preocupante en multiprocesadores, ya que producirían contención en el acceso al cerrojo. Sin embargo, la limitación fundamental del manejo de eventos con este mecanismo deriva de que la primitiva de bajar no almacena el evento; lo que introduce la posibilidad de condiciones de carrera en una secuencia de subir y bajar sobre un flag (importa el orden en que se ejecutan).

FIFO Y LIFO

FIFO: Guarda analogía con las personas que esperan en una cola y van siendo atendidas en el orden en que llegaron, es decir, que la primera persona que entra es la primera persona que sale.

También se lo llama first come first served o FCFS (en español "primero en llegar, primero en ser atendido").



En hardware, un FIFO se usa para propósitos de sincronización. Comportándose como una cola circular y, por lo tanto, contiene dos punteros:

1.Puntero de Lectura / Registro de Dirección de Lectura
2.Puntero de Escritura / Registro de Dirección de Escritura
Las direcciones de lectura y escritura están ambas inicialmente en la primera ubicación de la memoria y la cola FIFO está Vacía.

FIFO Vacía
Cuando el registro de dirección de lectura alcanza al registro de dirección de escritura, la cola FIFO dispara la señal o bandera Vacío.
FIFO Llena
Cuando el registro de dirección de escritura alcanza al registro de dirección de lectura, la cola FIFO dispara la señal o bandera

LIFO

El término LIFO es el acrónimo inglés de Last In First Out (último en entrar, primero en salir). elementos almacenados en forma de algunos tipos de estructuras de datos se procesan. Por definición, en una lista estructurada LIFO lineales, los elementos pueden ser añadidos o retirados de un solo extremo, llamado el "top". [1] Una estructura LIFO se puede ilustrar con el ejemplo de una pila de bandejas. La última bandeja para ser colocado en la parte superior es también el primero en tomar la parte superior.

Examen

#include "rshmem.h"
#include
#include
#include
#include
#define N 5
typedef int semaphore;
int state[N];
semaphore mutex=1;
semaphore s[N];
viod philosopher(int i)
{
incrementa (int *mem, int k){
int i;
i=*mem;
TP ; TP ; TP TP ;
TP ; TP TP ; TP ;
TP TP ; TP ; TP
i=i+k;
TP ; TP ; TP TP ;
TP ; TP TP ; TP ;
TP TP ; TP ; TP
*mem=i;

}

filosofo(FILE *pf, key_t *sclave, int *sfilo, int i, int *comer, int *fin, int *fc){
while (true){
think();
take_forks(i);
eat();
put_forks(i);
}
}
void take_forks(int i)
{
down(&mutex);
state[i] = HUNGRY;
test(i);
up(&mutex);
down(&s[i]);
}
void put_forks(i)
{
down(&mutex);
state[i] = THINKING;
test(LEFT);
test(RIGHT);
up(&mutex);
}
void test(i)
{
if(state[i] == HUNGRY && state [LEFT]!= EATING && state [RIGHT]!=EATING){
state[i]=EATING;
up(&s[i]);
}
}

Practica num Aleatorios y procesos

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define lectura 0
#define escritura 1


int aleatorio(void)
{
int semilla = (int)time(NULL);
srand(semilla);
}

int hijo(int tube1[2], int tube2[2]){
int ret;
int minumero;

int numbytes;
char buf[256]={};

ret = fork();

if (ret == 0){
/*Tratamiento del nieto*/
//minumero = aleatorio();
minumero= 10;

printf("%d\n",minumero);
sprintf(buf,"%d",minumero);

if( write (tube1[escritura],buf, sizeof(buf)) == -1){
perror("Fallo write nieto");
exit(EXIT_FAILURE);
}

numbytes = read(tube2[lectura],buf,sizeof(buf));

if (numbytes == -1){
perror("Fallo read nieto");
exit(EXIT_FAILURE);
}



close(tube1[escritura]);
close(tube2[lectura]);

printf("Soy hijo2 con PID=%d, mi número aleatorio es %d y el del otro proceso es %s\n",getpid(),minumero,buf);


}

else if (ret > 0){
/*Tratamiento del padre*/

//minumero = aleatorio();
minumero=32;

printf("%d\n",minumero);
sprintf(buf,"%d",minumero);

if( write (tube2[escritura],buf, sizeof(buf)) == -1){
perror("Fallo write padre");
exit(EXIT_FAILURE);
}

numbytes = read(tube1[lectura],buf,sizeof(buf));

if (numbytes == -1){
perror("Fallo read padre");
exit(EXIT_FAILURE);
}




close(tube1[lectura]);
close(tube2[escritura]);

printf("Soy hijo1 con PID=%d, mi número aleatorio es %d y el del otro proceso es %s\n",getpid(),minumero,buf);
}

else if (ret == -1){
/*Error*/
perror("Fallo en el segundo fork");
exit(EXIT_FAILURE);
}
}

int main (void){
int ret;
int ret2;
int tube1[2];
int tube2[2];
int temp;
int e;
char buf[256]={};

if (pipe(tube1) == -1){
perror("Fallo pipe1");
exit(EXIT_FAILURE);
}

if (pipe(tube2) == -1){
perror("Fallo pipe2");
exit(EXIT_FAILURE);
}

ret = fork();

if (ret == 0){
/*tratamiento del hijo*/
hijo(tube1,tube2);

}

else if( ret > 0){
/*tratamiento del abuelo*/


}

else if (ret == -1){
/*error*/
perror("Fallo en fork");
exit(EXIT_FAILURE);
}

ret = wait (NULL);

while (ret > 0){
ret = wait(NULL);
}

if (ret == -1 && errno != ECHILD){
perror("Fallo en wait");
exit (EXIT_FAILURE);
}

}

Numero

escojo el numero 10

Posix

¿Que son?

El POSIX es un grupo de estándares en evolución. Cada uno de los estándares que lo

componen cubre diferentes aspectos de los sistemas operativos. Algunos de ellos ya han

sido aprobados, mientras que otros están aún en fase de desarrollo. Los estándares POSIX

se pueden agrupar en tres categorías diferentes

1) Estándares Base: Definen interfases del sistema relacionadas con diferentes

Tabla I. Lista de estándares base del POSIX

POSIX.1 Interfases del sistema (estándar básico)

a,b

POSIX.2 Shell y utilidades

a

POSIX.3 Métodos para medir la conformidad con POSIX

a

POSIX.4 Extensiones de tiempo real

POSIX.4a Extensión de threads, o múltiples flujos de control

POSIX.4b Extensiones adicionales de tiempo real

POSIX.6 Extensiones de seguridad

POSIX.7 Administración del sistema

POSIX.8 Acceso a ficheros transparente a la red

POSIX.12 Interfases de red independientes del protocolo

POSIX.15 Extensiones de colas batch

POSIX.17 Servicios de directorios

a

Estándares IEEE ya aprobados

b

Estándar ISO/IEC ya aprobado

aspectos del sistema operativo. El estándar especifica la sintaxis y la semántica de

estos servicios del sistema operativo, de modo que los programas de aplicación

puedan invocarlos directamente. El estándar no especifica cómo se implementan

estos servicios; de este modo, los implementadores de sistemas pueden elegir la

implementación que crean más conveniente—y así competir entre ellos—, siempre

que cumplan la especificación de la interfase. Todos los estándares base

desarrollados hasta el momento lo han sido para lenguaje C. En el momento de

escribir este artículo está abierto el debate sobre si los estándares base deben

desarrollarse de forma independiente del lenguaje, y luego especificar interfases

concretas para los diferentes lenguajes de programación. La Tabla I y la Tabla II

muestran los estándares base que están siendo desarrollados por los grupos de

trabajo del POSIX.

Tabla II. Estándares base POSIX adicionales

P1224 Servicios de mensajería electrónica (X.400)

P1224.1 Interfase para portabilidad de aplicaciones X.400

P1238 Interfase de comunicaciones OSI

P1238.1 Interfase OSI de transferencia de ficheros

P1201.1 Interfase gráfica a usuario (ventanas)

2) Interfases en diferentes lenguajes de programación: Son estándares secundarios que

traducen a un lenguaje de programación concreto los estándares base. Los

lenguajes utilizados hasta el momento son Ada, Fortran 77, y Fortran 90, además

del lenguaje C, en el que se han especificado hasta el momento los estándares base.

La Tabla III muestra las interfases POSIX que están actualmente en desarrollo

para diferentes lenguajes de programación.

3) Entorno de Sistemas Abiertos. Estos estándares incluyen una guía al entorno

Tabla III. Lista de interfases POSIX para diferentes lenguajes de programación

POSIX.5 Interfases Ada

a

POSIX.9 Interfases Fortran 77

a

POSIX.19 Interfases Fortran 90

POSIX.20 Interfases Ada para las extensiones de tiempo real

a

Estándares IEEE ya aprobados

POSIX y los perfiles de entornos de aplicación. Un perfil de aplicación es una lista

de los estándares POSIX, con especificación de las opciones y parámetros

necesarios, que se requieren para un cierto entorno de aplicación. El objetivo

principal de los perfiles de aplicación es conseguir un conjunto pequeño de clases

de implementaciones de sistemas operativos bien definidas y que sean apropiadas

para entornos particulares de aplicaciones. La Tabla IV muestra la lista de

estándares que están siendo desarrollados en este grupo.

La necesidad del desarrollo de un estándar de sistema operativo se deriva del hecho de

Tabla IV. Lista de estándares POSIX de entornos de aplicaciones

POSIX.0 Guía al entorno POSIX de sistemas abiertos

POSIX.10 Perfil de entorno de aplicaciones de supercomputación

POSIX.11 Perfil de entorno de aplicaciones de procesado de

transacciones

POSIX.13 Perfiles de entornos de aplicaciones de tiempo real

POSIX.14 Perfil de entorno de aplicaciones multiprocesadoras

POSIX.18 Perfil de entorno de aplicación de plataforma POSIX

que, aunque el UNIX es un estándar de facto, hay suficientes diferencias entre las

diferentes implementaciones para que las aplicaciones no sean completamente portables.

Más aún, si una aplicación UNIX puede necesitar ciertos cambios para ser portada a una

plataforma diferente, la portabilidad de las aplicaciones de tiempo real es muchísimo más

difícil, ya que existe una gran diversidad de sistemas operativos de tiempo real. El UNIX

no es un sistema operativo de tiempo real, y no existe un estándar de facto para estas

aplicaciones.