SO TP LAB Gua Unificada v1 8

Sistemas Operativos (3.4.
075)
2017 - Guía de Trabajos Prácticos
TRABAJO PRÁCTICO de LABORATORIO Nº1

Instalación de Linux en una máquina virtual
Objetivos:
Con la realización del siguiente trabajo práctico se busca:
 Familiarizar al alumno con herramientas esenciales para el conocimiento de SOs.

 Proveer a la base de conocimiento experimental que utilizará, en extenso, en los
siguientes trabajos prácticos.
 Introducir una metodología para la prueba y evaluación de SOs.
 Ayudar a entender los conceptos teóricos de la materia.
Introducción de contexto:
El grupo de alumnos deberá realizar la instalación y configuración de una plataforma operativa Linux, en
distribución y versión designada por el docente, pudiendo ser cualquiera que se justifique su instalación.
La instalación se desarrollará sobre una consola de máquina virtual, pudiendo ser remplazada por cualquier MV
(Máquina virtual) compatible con el SO (Sistema Operativo) anfitrión e invitado a usar. En este caso se usa y
ejemplifica sobre VMware Workstation, debido a su operatividad en múltiples plataformas de anfitriones, y la
posibilidad de operar con múltiples plataformas de invitados.
El TP constará de dos etapas, a saber:

1. Crear, reconocer el entorno de instalación y simultáneamente la recolección de la información que
pudiere ser necesaria para la resolución del cuestionario.
2. Realizar la instalación del SO invitado y simultáneamente la recolección de la información que pudiere
ser necesaria para la resolución del cuestionario.
Elementos Necesarios:
 Una computadora en condiciones de ejecutar la consola de máquina virtual VMware Workstation o similar.
 Conocer la instalación de una consola de máquina virtual y su operación.
 Acceso a Internet por parte del sistema anfitrión.
 Una distribución de un SO Linux en formato ISO, compatible con la máquina virtual a usar.
 Utilizar la bibliografía de la materia para realizar consultas.
1
Sistemas Operativos (3.4.075)
Desarrollo del Trabajo Práctico:
Parte 1 – Creación de la máquina virtual

1. Iniciar la consola de máquina virtual VMware, para ello seleccionar el ícono
“Inicio  Todos los Programas  VMware  VMware Workstation “
2. Iniciar la creación de una nueva máquina virtual, para ello seleccionar desde el menú “File  New 
Virtual Machine”, o “Create a New Virtual Machine”
3. Si aparece la pantalla anterior seleccionar la opción “Custom (advanced)”. Presionar “next”.
2
4. Presionar “next”.
5. Seleccionar “Instalar el Sistema Operativo más tarde”. Presionar “next”.
6. Seleccionar el “tipo de Sistema Operativo a instalar”, en este caso “Linux, Ubuntu”. Presionar “next”.
3
7. Completar los campos “Nombre y directorio de la máquina virtual” de la siguiente manera:
Virtual machine name: Ubuntu_SOXX

Donde XX se remplaza por: TM para turno mañana.
TT para turno tarde.
TN para turno noche.
Location: C:\Virtuales\Ubuntu_SOXX (respetando el remplazo predicho).

Luego presionar “next”.
8. Seleccionar la cantidad de procesadores que poseerá la máquina virtual. Para este caso: mantener las
“opciones por defecto”. Presionar “next”.
9. Seleccionar “tamaño de la memoria RAM de la máquina

virtual que requerirá el sistema operativo invitado”, en
este caso, será necesario 512MB. Presionar “next”.
4
10. Seleccionar “tipo de conexión a red que usará la máquina virtual”, en este caso se usará NAT. Presionar
“next”.
11. Seleccionar “tipo de controladora para el disco duro (HD)”, usar LSI Logic. Presionar “next”.
12. Seleccionar “Crear un nuevo disco duro virtual”. Presionar “next”.
5
13. Seleccionar “tipo de HD a usar”, en este caso un SCSI. Presionar “next”.
14. Ajustar el “tamaño máximo posible para el HD” a 10GB y la seleccionar “estructura del archivo asociado”.
Presionar “next”.
15. Mantener el “nombre del archivo por defecto”. Presionar “next”.

6
Ya creamos una máquina virtual y esta ventana, indica la configuración seleccionada. Mantener los valores
seleccionados para finalizar.
Cuestionario
1. ¿Cuál es el path donde se creó el HD virtual? En que paso se definió.
2. ¿Cuál es el nombre del archivo del HD primario? En que paso se definió.
3. ¿Sobre qué tipo de bus opera el HD primario? ¿Por qué se seleccionó dicho bus? En que paso se
definió.
4. ¿Qué tipos de buses puede operar el HD? Indicar en forma breve las características principales de
cada uno.
5. ¿Cuál es su tamaño final en bytes del HD virtual utilizado? ¿Por qué no es de 10,00 GB como se
definió? ¿Por qué se definió de este tamaño? ¿Qué tamaño mínimo de archivo quedó alocado? En que
paso se definió.
6. ¿Cuál es el tamaño de memoria base? ¿De qué depende la elección de ese tamaño? En que paso se
definió.
7. ¿Cuál es la cantidad de procesadores y de núcleos asignados? En que paso se definió.
8. ¿Cuál es el nombre del controlador de audio?
9. ¿Cuál es el nombre del adaptador de red? ¿Coincide con el de la máquina real?
10. ¿Está habilitada la virtualización por hardware? ¿Qué significa esto?
7
Parte 2 – Instalación del sistema operativo

1. Accediendo a la consola de máquinas virtuales seleccionar la MV recién creada e ingresar en “Virtual
Machine settings”
2. Seleccionar “CD/DVD (IDE) “e “ISO image file”. Seleccionar archivo ubuntu-12.04.3-desktop-i386.iso que
se encuentra en el disco V. Presionar “OK”.
3. Iniciar la máquina virtual arrancando de la imagen ISO del sistema operativo designado.
En la pantalla de arranque del Ubuntu:
8
4. Seleccionar el lenguaje con el cual se desea instalar “español” y presionar “Instalar Ubuntu”.
5. Deseleccionar “Descargar actualizaciones mientras instala”. Seleccionar “Continuar”.
6. Seleccionar “Algo más”. Presionar “Continuar”.
9
Una vez seleccionado “particionamiento manual” del disco duro (HD), se deben crear por lo menos
dos particiones (raíz y de intercambio), y proceder a montarlas.
1) Crear la partición raíz (/)

a) Seleccionar /dev/sda,
b) Y presionar “Nueva tabla de particiones”.
c) Luego seleccionar el “espacio libre“ y presionar “añadir”
d) Leer la advertencia. Presionar “Continuar”
10
Captura4
e) Proceder a crear la 1ª partición
f) Seleccionar “Tipo de partición”, “tamaño”, “ubicación de la partición”, tipo de “sistema de archivos a

usar” y “punto de montaje”. Completar os campos y presionar “Aceptar”.
Tipo de nueva partición: primaria

Tamaño: “9000MB”
Ubicación de la partición: “principio”
Tipo de sistemas de archivos a utilizar: “Ext4”
Punto de montaje (ruta):“/”
Nota: Anotar tipos de particiones disponibles y tipos de sistemas de archivos disponibles.
2) Crear la partición de intercambio ó área de intercambio(swap)

a) Seleccionar “espacio libre”, y presionar “Nueva tabla de particiones”. Presionar “Añadir”.
11
b) Seleccionar “espacio libre”, “Añadir “, “ubicación de la partición”, “tipo de sistema de archivos a usar”
y “punto de montaje”. Completar los campos y presionar “Aceptar”.
Tipo de nueva partición: “primaria”

Tamaño: espacio libre restante
Ubicación de la partición: “principio”
Tipo de sistemas de archivos a utilizar: “área de intercambio”
Nota: verificar que la partición de swap no está marcada para formatear.
7. Generar las particiones, para ello presionar “Instalar ahora”. En este momento se generan las particiones
en el HD y se formatean.
8. Generada las particiones necesarias continuar con el proceso de instalación del Sistema Operativo.
12
9. Seleccionar la ciudad. Presionar “Continuar”.
10. Seleccionar tipo de teclado. Presionar “Continuar”.

Nota: Si se desconoce el tipo al que pertenece la distribución del teclado, usar “Determinar la distribución
de teclado”.
11. Crear usuario. Completar los campos y presionar “Continuar”.
13
Nombre de usuario: “uade”

Nombre del equipo: “uadeXX-desktop”, donde XX es el nº del puesto de trabajo.
Contraseña (password): “123456”
ADVERTENCIA a diferencia de Windows Linux distingue entre mayúsculas y minúsculas, en nombre de

usuarios y de archivos. No ingresar las comillas.
El sistema comenzará su instalación, mostrándonos un indicador visual del avance. Este proceso demora un
tiempo determinado que depende del tipo de máquina física y de la velocidad de conexión a internet. Este
proceso puede durar aproximadamente 30’.
12. Una vez finalizada la instalación: Presionar “Reiniciar ahora”, con lo que generaremos el primer
arranque del equipo virtual para dar por finalizada la instalación.
Cuestionario
1. En una máquina real: ¿Cuál sería el equivalente de la acción realizada en la parte 2 paso 2?
2. Enumerar los diversos tipos de conexión de HD que puede tener instalados una computadora (IDE, SATA,
etc.) y realice una breve descripción de los mismos.
¿Cuál es la denominación lógica que el SO Linux da a sus particiones? Estas fueron anotadas cuando se
realizó el paso 6. 1) c). ¿Cuántas particiones son necesarias como mínimo para instalar Linux?, ¿Cuáles
son? ¿Por qué se utiliza este sistema? ¿Conoce algún otro? En que paso se definió.
3. Describir la función de cada una de las particiones creadas, cuál es su punto de montaje y cuál es el sistema
de archivos (File System) seleccionado en cada caso. Justificando el porqué.
4. ¿Por qué no es necesario formatear la partición de swap?
5. ¿Por qué el SO en el paso 6 reporta la existencia de un HD de 10,7GB y no de 10GB como se definió al
crearlo?
14
6. ¿Por qué el tamaño de la partición sda1 definida no es de 9000MB como se pidió? (justifique la respuesta).
7. Durante la creación de una partición se puede elegir ubicarla al principio o al final del espacio libre del
disco, ¿cuál es la razón de esto?
8. ¿Qué cantidad de memoria de video está asignada?
9. ¿Cuál es el nombre del controlador de audio? ¿Coincide con el reportado por la consola? ¿Cuál es el
comando utilizado en Linux para obtener la información?
10. ¿Cuál es el nombre del adaptador de red? ¿Coincide con el de la máquina real? ¿Cuál es el comando
utilizado en Linux para obtener la información?
11. ¿Qué es el Kernel?
12. ¿Cuáles son las funciones del Kernel?
13. Mencione distintas versiones de Kernel Linux. ¿Cómo se las clasifica?
14. ¿Es posible tener instalado más de un Kernel en una instalación de Linux?, ¿cuál es su sentido?
15. ¿Dónde se encuentra ubicado el Kernel dentro del File System de Linux?
16. Describa qué función cumple el comando sudo, y que es “root”.
17. Explique el significado de los símbolos “#” y “$” al final del prompt.
15

Proceso de compilación, Intercomunicación de procesos y uso de memoria
Objetivos:
 Comprender mejor el proceso de compilación y enlace.

 Comprender el mecanismo de comunicación entre procesos.
 Aprender cómo utilizar desde la programación los sistemas de IPC provistos por el
Kernel del SO.
 Aprender a usar la memoria para realizar el intercambio de información entre procesos
que operan en espacios de memoria distintos.
El TP constará de dos partes, a saber:
a) Conocer las diversas formas de uso del compilador GCC (http://www.gnu.org/software/gcc/),
con la finalidad de obtener resultados intermedios durante el proceso de compilación.
b) Aprender a controlar desde el programa el uso de los diversos mecanismos de IPC, y ver como
se utiliza la memoria para el intercambio de información
Al finalizar cada una de las partes se deberá responder un cuestionario relacionado con la tarea
realizada.
Parte 1 - El uso del compilador GCC:
 Una computadora en condiciones de ejecutar alguna distribución del SO Linux, puede ser en modo anfitrión
o modo virtual.
 Disponer de un editor de texto compatible con el compilador gcc.
 Disponer del compilador gcc.
 Acceso a Internet.
Parte 2 - Comunicación entre procesos:
o modo virtual.
 Disponer de un editor de texto compatible con el compilador gcc.
 Disponer del compilador gcc.
 Como alternativa se puede disponer de un IDE (entorno de desarrollo integrado) para lenguaje “C”. (Geany
o similar).
 Acceso a Internet.
16
Parte 1 – El uso del compilador GCC

Introducción teórica
Introducción
El GNU Compiler Collection (gcc), es un conjunto de programas que comprenden el compilador del proyecto
GNU para diversos lenguajes, ej.: ANSI C, C++, Fortran, Java, etc.
El gcc le da al programador un amplio control sobre el proceso de compilación, el cuál comprende cuatro
etapas:
 Pre procesado.
 Compilación.
 Ensamblaje.
 Vinculación.
Uno puede detener después de cualquiera de dichas etapas para examinar el rendimiento del compilador.
El gcc es también un compilador cruzado, de modo que se puede desarrollar el código en una arquitectura de
procesador y correrlo en otra.
La compilación cruzada es importante porque Linux corre en diferentes tipos de sistemas, tales como los x86
de Intel, las PowerPC, etc.
Cada chip de procesador tiene una arquitectura física diferente, de modo que la manera de construir un binario
varía para cada sistema.
Invocación del gcc:
Para utilizar gcc, hay que suministrar un nombre de archivo fuente de C y utilizar la opción -o para especificar el
nombre del archivo de salida.
Gcc pre procesará, compilará, ensamblará y vinculará (link) el programa, generando un archivo ejecutable, a
menudo denominado binario.
La sintaxis más simple es la siguiente:
gcc archivo_entrada.c [-o archivo_salida]
NOTA: gcc se basa en las extensiones de los archivos para determinar cómo procesar correctamente cada
archivo.
Las extensiones más comunes y sus interpretaciones se listan en la siguiente tabla:
Extensión Tipo de archivo

.c Código fuente de lenguaje c
.C, .cc Código fuente de lenguaje c++
.i Código fuente de C pre procesado
.ii Código fuente de C++ pre procesado
.S, .s Código fuente de lenguaje ensamblador
17
.o Código objeto compilado
Uso del gcc paso a paso:
En el primer ejercicio, habrá muchas cosas que estarán de manera encubierta, a saber:
 gcc primero correrá primerGcc.c por el preprocesador, cpp, para expandir cualquier macro que pudiese
haber, e insertar los contenidos de los archivos incluidos mediante #include.
 Luego compilará el código fuente pre procesado, convirtiéndolo en el código objeto.
 Finalmente, el linker, ld, creará el archivo binario primerGcc.
Ejecución manual del paso a paso:
Uno puede recrear estas etapas manualmente, avanzando por el proceso de compilación un paso por vez.
1. Para indicarle a gcc que detenga la compilación luego del pre procesado hay que utilizar la opción -E de gcc,
como se indica a continuación:
gcc -E archivo_entrada.c -o archivo_salida.cpp
2. El siguiente paso es el de compilación:
gcc -S archivo_entrada.c
3. El ensamblado transforma el programa escrito en lenguaje ensamblador a código objeto, de esta manera:
as -o archivo_salida.o archivo_entrada.s
18
4. Enlazando (Linkeando) el archivo objeto, finalmente se obtiene su imagen binaria.

El comando que llevaría a cabo la etapa de vinculación sería el siguiente:
gcc archivo_entrada.o -o archivo_salida
19
Parte práctica
Ejercicio 1: Compilar el archivo fuente denominado primerGcc.c y ejecutarlo.
Nota: Para ejecutar el archivo se debe tipear ./primerGcc seguido de Enter.
/* primerGcc.c */
#include <stdio.h>
int main(void)
{
printf("Hola mundo.\n");
return 0;
}
Ejercicio 2: Compilar el archivo fuente denominado primerGcc.c en la forma manual paso a paso.
Obtener todos los archivos intermedios. Ejecutar el archivo final obtenido luego del proceso completo.
Cuestionario
1. Describir qué función realiza el programa primerGcc ejecutado.
2. ¿Cuáles son los archivos intermedios obtenidos al realizar el ejercicio 2? Visualizar cada uno de los
archivos intermedios y describir sus características.
a) ¿Cuál es la función específica del preprocesador?
b) ¿Cuál es la función específica del compilador?
c) ¿Cuál es la función específica del enlazador?
3. Mencione por lo menos dos circunstancias donde es necesario realizar el proceso de compilación paso a
paso.
4. Escriba la línea de comando que usaría para compilar múltiples archivos de código fuente.
Archivo 1: “segundoGcc.c”
/* segundoGcc.c */
#include <stdio.h>
int suma(int, int);
int main(void){
int a, b;
printf("Ingrese a: ");
scanf("%d", &a);
printf("Ingrese b: ");
scanf("%d", &b);
printf("La suma de %d y %d es: %d\n", a, b, suma(a,b));
return 0;
}
Archivo 2: “sumar.c”
/* sumar.c */
int suma(int a, int b){
return a + b ;
}
5. Escriba la línea de comando que usaría para compilar un archivo de código fuente cuyas bibliotecas o
inclusiones no se hallan en la ubicación estándar.
6. Por defecto el gcc vincula bibliotecas en forma dinámica y no estática,
 ¿qué diferencia hay entre las bibliotecas dinámicas y las estáticas?
 ¿cuándo conviene usar una o la otra?
 ¿cuál es la diferencia visible en el archivo ejecutable final?
20
Parte 2 – Comunicación entre procesos (IPC)

Introducción teórica
Introducción
Las estructuras de IPC (segmentos de memoria compartidos, colas de mensajes y semáforos), existen en el
kernel como si fuesen pipes, en lugar de estar presentes en el file system, como los FIFO’s. Las estructuras IPC
son denominadas a veces en conjuntos de objetos IPC.
Los objetos de IPC permiten que puedan intercambiar datos dos procesos no relacionados entre sí.
Visualización de los mecanismos IPC activos:

El comando estándar IPCS facilita información sobre los mecanismos utilizados por nuestro sistema,
informando de a quién están asignados, permisos, información estadística, etc.
Ej.: $ipcs -parámetro
Si no se especifica ninguna opción, el comando muestra un resumen de la información administrativa que se
almacena para memoria compartida, colas de mensajes y semáforos.
Las informaciones que suministra son:
t: tipo de mecanismo (q: cola de mensajes, m: segmento de memoria y s: semáforo).
id: identificación del mecanismo.
key: clave del mecanismo.
mode: derechos de acceso al mecanismo.
owner: propietario del mecanismo.
group: grupo propietario del mecanismo.
Segmentos de memoria compartidos (shared memory).

La memoria compartida es una región (segmento) de memoria destinada por el Kernel para el propósito del
intercambio de información entre procesos.
Siempre y cuando un proceso cuente con los permisos de acceso al
segmento adecuados, el mismo puede acceder a dicho segmento
mapeándolo a su propio espacio privado de memoria.
21
Los procesos mapean los segmentos de memoria compartida a su propio espacio de memoria.
Archivos de
Función Descripción Prototipo
encabezado
shmget Permite crear de un int shmget(key_t key, int size, int flags)
segmento
shmat Permite utilizar un segmento, char *shmat(int shmid, char *shmaddr, int flags)
una vez creado
sys/types.h
shmdt Permite cancelar el uso del int shmdt(char *shmaddr); sys/ipc.h
segmento. Elimina el vínculo
sys/shm.h
entre el segmento adosado
en shmaddr y espacio en
memoria del proceso que
efectúo la llamada.
 key: Puede ser ya sea IPC_PRIVATE o una clave retornada por la función ftok.
 size: tamaño del segmento.
 flags
IPC_CREATE: Indica que si aún no existe ningún segmento asociado con key deberá ser creado uno nuevo.
 shmid: identificador del segmento que el proceso desea adosar. Este es retornado por la función shmget.
 shmaddr: dirección de memoria la cual deberá mapear el kernel el segmento de memoria compartida. Si
shmaddr es 0, el Kernel mapeará el segmento hacia el espacio en memoria correspondiente al proceso que
efectuó la respectiva llamada.
Colas de mensajes (message queue).

Una cola de mensajes es una lista vinculada de mensajes almacenada dentro del Kernel e identificada a los
procesos de usuario por un identificador de cola de mensajes.
Si bien los mensajes se agregan al final de la cola de mensajes, estos pueden ser recuperados no
necesariamente en el mismo orden que fueron ingresados.
Archivos de
encabezado
msgget Permite crear una cola nueva int msgget(key_t key, int flags)
o abre una ya existente
msgsnd Permite añadir un nuevo int msgsend(int msqid, const void *ptr, size_t
mensaje al final de una cola nbytes, int flags) sys/msg.h
sys/types.h
msgrcv Permite extraer un mensaje de int msgrcv(int msqid, void *ptr, size_t nbytes,
sys/ipc.h
una cola long type, int flags)
msgctl Permite proveer de un cierto int msgctl(int msqid, int cmd, struct msqid_ds
grado de control sobre las *buf)
colas de mensajes
22
 msqid: identificador de la cola Si la llamada resulta exitosa de msgget, retorna el nueva o existente que
corresponda al valor contenido en key.
 nbytes: tamaño del mensaje
 ptr: mensaje
 cmd: acción. Puede adoptar uno de los siguientes valores:
IPC_RMID: Elimina la cola msquid_ds a la cola identificada como msqid.
IPC_STAT: Permite desplazarse por los mensajes contenidos en una cola sin eliminar ninguno de ellos.
IPC_SET: Permite modificar los siguientes parámetros de una cola: UID, GID, modo de acceso y el máximo
número de bytes que se permite almacenar en la misma.
Los errores de las funciones son colocados en la variable errno.
Semáforos (semaphore).
Vamos a analizar sólo la modalidad más simple de un semáforo, el semáforo binario.
Un semáforo binario puede adoptar sólo uno de dos valores: 0 cuando un recurso se encuentra bloqueado y no
debe ser accedido por otros procesos, y 1 cuando el recurso queda desbloqueado.
Los semáforos funcionan de una manera muy similar a señales de tránsito de sólo dos luces (roja y verde)
ubicadas en un cruce transitado.
Cuando un proceso necesita acceder a un recurso controlado, tal como un archivo, primero verifica el valor del
semáforo pertinente, lo mismo que un conductor verifica que una luz de tránsito este en verde.
Si un semáforo tiene un valor positivo, lo cual equivale a una luz verde para dicho acceso, el recurso asociado al
mismo se encuentra disponible, de modo que el semáforo procede a disminuir el semáforo (enciende la luz
roja), lleva a cabo sus operaciones con el recurso y luego vuelve a encender la luz verde, es decir incrementa el
valor del semáforo a fin de liberar su “bloqueo”.
Naturalmente, antes de que un proceso esté en condiciones de incrementar o disminuir un semáforo, y
suponiendo que le proceso cuente con los permisos adecuados, el semáforo debe existir.
Archivos de
encabezado
semget Permite crear un semáforo o int semget(key_t key, int nsems, int flags)
acceder a uno existente
semct Permite controlar y eliminar int semctl(int semid, int semnum, int cmd, union sys/sem.h
semáforos semun arg)
 semid: identifica el conjunto de semáforos que se desea manipular.
 semnum: especifica el semáforo específico que uno se encuentra interesado, en nuestro caso que siempre
será cero.
 cmd: acción. Puede ser uno de los valores de la lista siguiente:
GETVAL: Retorna el estado corriente del semáforo (bloqueado o desbloqueado).
SETVAL: Establece el estado corriente del semáforo.
GETPID: Retorna el PID del último proceso que llamó a semop.
GETNCNT: permite retornar el número de procesos aguardando que el semáforo se incremente.
GETNCNT: permite retornar el número de procesos que están aguardando para que el valor del sem
sea 0.
GETALL: Retorna los valores corrientes a todos los semáforos presentes en el conjunto asociado con
semid.
IPC_RMID: Elimina el conjunto de semáforos con identificador semid.
23
Parte práctica
Visualización de los mecanismos IPC activos.

1. Usando el comando ipcs con los parámetros adecuados, ver la tabla de los IPC que el Kernel tiene en uso.
a) ¿Cuál es la sintaxis del comando?
b) ¿Cuál es la tabla que genera como resultado de su ejecución?
c) Detallar el significado de cada una de las columnas.
Segmentos de memoria compartidos (shared memory).

Visualizar el código del programa fuente: crear_sgtomemcomp.c, con la finalidad de ver como se aplica la
función para crear un segmento de memoria compartido.
/*
============================================================================
Name : crear_sgtomemcomp.c
Author : Julian Rousselot
Referencia : "Programacion en Linux con Ejemplos de Prentice Hall, Kurt Wall"
Version :
Copyright : GPL V3
Description : Crea e inicializa un segmento de memoria compartida, Ansi-style
============================================================================
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#define TAMANO_BUF 4096
int main(void){
int identificadorSegmento;
if((identificadorSegmento = shmget(IPC_PRIVATE,TAMANO_BUF,0666)) < 0){
perror("shmget");
return 1;
}
printf("Identificador del segmento creado: %d\n", identificadorSegmento);
return 0;
}
Compilar el código fuente y ejecutarlo.

a) ¿Cuál es la sintaxis del comando para visualizar los segmentos de memoria compartida por el Kernel?
¿Cuál es la tabla que genera el programa como resultado de su ejecución? Detallar en la tabla anterior
la nueva entrada, indicando la información requerida para la generación de un segmento de memoria
compartida.
b) ¿Cuáles son los permisos asociados al segmento de memoria creado y cuál es su significado? Describa
que significa el término “perms” en la tabla generada por el comando ipcs, y describa el significado de
este número que tiene (666).
2. Visualizar el código del programa fuente: adosar_sgtomemcomp.c , con la finalidad de ver como se aplica
la función para adosar un segmento de memoria compartido y usarlo.
/* ============================================================================
Name : adosar_sgtomemcomp.c
Reference : "Programacion en Linux con Ejemplos de Prentice Hall, Kurt Wall"
Copyright : GPL V3
Description : Adosar y elimina el segmento de memoria compartida, Ansi-style
24
============================================================================ */
#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>
int main(int argc,char *argv[]){
int identificadorSegmento; //Identificador del segmento
char *buf_sgtomemcomp; //Punt. a dir. en espacio de mem. del proceso
if(argc != 2){ //En la linea de comandos se espera un identificador de segmento
puts("MODO DE EMPLEO: atshm <identificador>");
return 1;
}
identificadorSegmento = atoi(argv[1]);
if((buf_sgtomemcomp = shmat(identificadorSegmento, 0, 0))<(char *)0){ //Adosar segm.

perror("shmat");
return 1;
}
//En que direccion ha sido adosado el segmento?
printf("El segmento ha sido adosado en %p\n", buf_sgtomemcomp);
system("ipcs -m");//Comprobacion de que efectivamente el segmento ha sido adosado
if((shmdt(buf_sgtomemcomp))<0){ //Eliminar el vinculo (desacoplar)
perror("shmdt");
return 1;
}
puts("Segmento desacoplado\n");
system("ipcs -m");//Verificar que efectivamente el segmento haya sido desacoplado
return 0;
}

a) Describir en detalle el funcionamiento del programa relacionándolo con el resultado obtenido de la
corrida. ¿Cuál es la sintaxis del comando para visualizar los segmentos de memoria compartida por
el Kernel? ¿Cómo determina que un segmento de memoria tiene procesos adosados? ¿Cuál es el
elemento que utiliza el SO para vincular los procesos con el segmento de memoria compartida? ¿Cuál
es el significado de “key” y “shmid”?
b) ¿Cómo se asocia el proceso con una zona de memoria compartida?
c) Si un proceso coloca información en un segmento de memoria compartida, acto siguiente se mata a
este proceso:
 ¿Qué sucede con la información colocada en el segmento?
 ¿Puede ser usada por otros procesos?
 ¿Qué condición deben cumplir estos otros procesos?
25
Colas de mensajes (message queue)

1. ¿Cuál es la sintaxis del comando para visualizar las colas de mensajes que el Kernel tiene en uso? ¿Cuál es
la tabla que genera como resultado de su ejecución? ¿Cuál es la información que por defecto proporciona
el comando ipcs sobre las colas?
2. Visualizar el código del programa fuente: crear_cola.c, con la finalidad de ver como se aplica la función de
crear una cola y usarlo.
/* ============================================================================
Name : creaCola.c
Copyright : GPL V3
Description : Crea una cola de mensajes de IPC, Ansi-style
============================================================================ */
#include <sys/msg.h>
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {

int identificador_cola;
key_t clave=1234; //Clave de la cola
//Crear la cola de mensajes
if((identificador_cola == msgget(clave, IPC_CREAT | 0666)) < 0){
perror("msgget|create");
exit(EXIT_FAILURE);
}
printf("Creada la cola de identificador = %d\n", identificador_cola);
//Abrir la cola de mensajes nuevamente
if((identificador_cola == msgget(clave, 0)) < 0){
perror("msgget:open");
exit(EXIT_FAILURE);
}
printf("Abierta cola de identificador = %d\n", identificador_cola);
return EXIT_SUCCESS;
}

Describir en detalle el funcionamiento del programa relacionándolo con el resultado obtenido de la
corrida. Verificar la creación de la cola. Observar y describir sus valores relevantes.
3. Visualizar el código del programa fuente: enviar_a_cola.c, con la finalidad de ver como se aplica la función
de enviar un mensaje una cola y usarlo.
/* ============================================================================
Name : enviar_a_cola.c
Version :
Copyright : GPL V3
Description : Envia un mensaje a una cola ya abierta con anterioridad, Ansi-style
============================================================================ */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
struct mensaje {
long tipo_mensaje;
char texto_mensaje[TAMANO_BUF];
};
int main(int argc, char *argv[]) {
int identificador_cola;
int tamano_texto; //Longitud del mensaje a ser enviado
struct mensaje buffer_mensaje; //Estructura de patron mensaje
26
//Obtenemos el identificador de cola transferido en la linea de comandos

if(argc != 2){
puts("MODO DE EMPLEO: enviar_a_cola <identificador de la cola de mensaje>");
exit(EXIT_FAILURE);
}
identificador_cola = atoi(argv[1]);
//Obtener el mensaje que sera agregado a la cola

puts("Ingrese un mensaje para publicar: ");
if((fgets((&buffer_mensaje)->texto_mensaje, TAMANO_BUF, stdin)) == NULL){
puts("No hay mensaje para ser publicado");
exit(EXIT_SUCCESS);
}
//Asociar el mensaje ingresado con este proceso

buffer_mensaje.tipo_mensaje = getpid();
//Anadir el mensaje al final de la cola

tamano_texto = strlen(buffer_mensaje.texto_mensaje);
if((msgsnd(identificador_cola, &buffer_mensaje, tamano_texto, 0)) < 0){
perror("msgsnd");
exit(EXIT_FAILURE);
}
puts("Mensaje Publicado");
}

Describir en detalle el funcionamiento del programa relacionándolo con el resultado obtenido de la
corrida. Nuevamente utilizar el comando ipcs para verificar que sucedió en la cola observando y
describiendo sus valores relevantes.
4. Visualizar el código del programa fuente: colaMensaje, con la finalidad de ver como se aplica la función de
enviar un mensaje una cola y usarlo por otro proceso.
/* ============================================================================
Name : colaMensaje.c
Author : Patricia Mazzitelli
Description : Envia un mensaje a una cola y recuperar mensaje por otro proceso
============================================================================ */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
struct mimjebuffr {
long int tipo;
int nro;
};
struct mensaje {
long tipo_mensaje;
char texto_mensaje[TAMANO_BUF];
};
int main(void) {
int qid; // identificador_cola
key_t mjekey;
struct mimjebuffr buffer;
int longitud;
pid_t pid;
int i;
27
longitud = sizeof(struct mimjebuffr) - sizeof (longitud) ;

mjekey = ftok(".", 'm');
qid = msgget(mjekey, IPC_CREAT | 0660);
printf("Se creo la cola %d\n", qid);

system ("ipcs -m");
puts("Generacion de mensajes...");
if (!(pid = fork())){
printf("Hijo - qid = %d\n", qid);
for (i=0; i<10; i++) {

sleep(rand()%4);
buffer.tipo=1;
buffer.nro= rand() % 100;
if (msgsnd(qid, &buffer, longitud, 0)<0){
puts("No pudo publicarse el mensaje");
return 1;
}
printf("Hijo - nro mensaje %d: %d - Mensaje Publicado\n",
i+1, buffer.nro);
}
return 0;
}
//Obtener el mensajes
system ("ipcs -m");
printf("Padre - qid = %d\n", qid);
puts("Lectura de mensajes...");
for (i=0; i<10; i++) {
sleep(rand()%4);
if (msgrcv(qid, &buffer, longitud, 1,0)<0)
printf("Padre - nro de mensaje no leido: %2d\n", i+1);
else
printf("Padre - nro mensaje %2d: %d\n", i+1, buffer.nro);
}
}
Compilar el código fuente y ejecutarlo. Describir en detalle el funcionamiento del programa

relacionándolo con el resultado obtenido de la corrida. Verificar que sucedió en la cola. Observar y
describir sus valores relevantes. ¿Cuál fue el mensaje que envió a la cola y cuántos bytes ocupó?
5. Realizar un programa, en lenguaje de programación C, que permita eliminar una cola de mensajes.
/* ============================================================================
Name : eliminarCola.c
Author : Patricia Mazzitelli
Description : Elimina una cola de mensajes
============================================================================ */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
int id;
system("ipcs -q ");
printf("Ingrese identificador de la cola: ");
scanf("%d", &id);
msgctl(id, IPC_RMID, 0);
printf("Cola eliminada. . ,\n ");
system("ipcs -q ");
}
28
a) Describir en detalle el funcionamiento del programa relacionándolo con el resultado obtenido de la

corrida. Verificar que sucedió en la cola. Observar y describir sus valores relevantes.
b) Si un proceso coloca información en una cola, acto siguiente se mata a este proceso. Para cada una de
las preguntas acompañar la salida del proceso correspondiente.
 ¿Qué sucede con la información colocada en la cola?
 ¿Puede ser usada por otros procesos? ¿Qué condición deben cumplir estos otros procesos?
6. ¿Cuánto tiempo perdura el mensaje dentro de la cola?
7. ¿Qué diferencia hay entre colas de mensajes y las colas FIFO?
29
Semáforos (semaphore).
1. ¿Cuál es la sintaxis del comando para visualizar los semáforos que el Kernel tiene en uso? ¿Cuál es la tabla
que genera como resultado de su ejecución? ¿Cuál es la información que por defecto proporciona el
comando ipcs sobre los semáforos?
2. Visualizar el código del programa fuente: semaforo.c, con la finalidad de ver como se aplica la función de
crear, usar y eliminar un semáforo.
/* ============================================================================
Name : semaforo.c
Version :
Copyright : GPL V3
Description : Crea y decrementa un semaforo, Ansi-style
============================================================================ */
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int identificador_semaforo;
int total_semaforos = 1; //Cuantos semaforos crear
int indicadores = 0666; //Derechos de lectura y modificacion para todos los usuarios
struct sembuf buf;
//Crea el semaforo con derechos de lectura/modificacion para todos los usuarios

identificador_semaforo = semget(IPC_PRIVATE, total_semaforos, indicadores);
if(identificador_semaforo < 0){
perror("semget");
exit(EXIT_FAILURE);
}
Else {
printf("Semaforo creado %d\n", identificador_semaforo);
system("ipcs -s");
}
//Asignar valores a la estructura de patron sembuf para semop

buf.sem_num = 0; //Un solo semaforo
buf.sem_op = 1; //Incrementar el semaforo, permitir acceso
buf.sem_flg = IPC_NOWAIT; //Bloquear si se llega a maximo valor permitido
if((semop(identificador_semaforo,&buf, total_semaforos)) < 0){

perror("semop");
exit(EXIT_FAILURE);
}
else{
puts("Asignación del semáforo…");
system("ipcs -s");
}
printf("Ingrese id del semaforo al eliminar: ");

scanf("%d", &identificador_semaforo ) ;
//Elimina el semaforo
if((semctl(identificador_semaforo,0,IPC_RMID)) < 0){
perror("semctl IPC_RMID");
exit(EXIT_FAILURE);
}
else{
puts("Semaforo eliminado");
system("ipcs -s");
}
exit(EXIT_SUCCESS);
}
Compilar el código fuente y ejecutarlo. Describir en detalle el funcionamiento del programa relacionándolo
con el resultado obtenido de la corrida.
30
Permite crear, asignar valores al semáforo y eliminar un semáforo.

Verificar que sucedió con los semáforos observando y describiendo sus valores relevantes.
El ejemplo utiliza IPC_PRIVATE para asegurarse de que el semáforo sea creado tal como se lo requiere, y
luego exhibe el valor retornado por semget, o sea el identificador de ese semáforo.
IPC_SET: Establece el modo (bits de permiso) en el semáforo.
3. Realizar un programa, en lenguaje de programación C, que permita que dos procesos distintos utilicen un
semáforo para acceder a un recurso. Indicar lo que realizan e informar su salida.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/sem.h>
void Imprimir_por_pantalla (int semaforo,struct sembuf *P,struct sembuf *V );
int main (void)

{
int semaforo;
struct sembuf P,V; //Estructura para las operaciones de incr/decr
key_t key=ftok("/bin/ls",1); //Crea la clave
//Se crea un semáforo para controlar el acceso exclusivo al recurso compartido

semaforo = semget(key, 1, IPC_CREAT | 0666);
printf("Se creo el semáforo: %d\n", key);
//Se inicializa el semáforo a 1.

semctl(semaforo,0,SETVAL,1);
//P decrementa el semaforo en 1 para cerrarlo y V lo incrementa para abrirlo.

//El flag SEM_UNDO hace que si un proceso termina inesperadamente
//deshace las operaciones que ha realizado sobre el semaforo.
P.sem_num = 0;
P.sem_op = -1;
P.sem_flg = SEM_UNDO;
V.sem_num = 0;
V.sem_op = 1;
V.sem_flg = SEM_UNDO;
Imprimir_por_pantalla(semaforo, &P, &V);
Imprimir_por_pantalla(semaforo, &P, &V);

return 0;
}
void Imprimir_por_pantalla (int semaforo,struct sembuf *P,struct sembuf *V )

{
pid_t pid;
/*Creamos un proceso hijo que imprime en pantalla*/

pid = fork();
// Comprobamos que ha sido posible crear el proceso hijo

if (pid != -1)
{
if (pid == 0)
{
sleep(3);
printf("Proceso hijo adquiere - SID: %d\n", semaforo);
// El proceso hijo adquiere el semáforo para acceder al recurso
// compartido (pantalla) antes de imprimir el texto por pantalla.
semop(semaforo,P,1);
sleep(1);
//Libera el semáforo
31
printf("---- Proceso hijo, libera semáforo...\n\n", semaforo);

semop(semaforo,V,1);
system("ipcs -s");
}
else
{
sleep(4);
printf("Proceso padre adquiere - SID: %d\n", semaforo);
// El proceso padre adquiere el semáforo para acceder al recurso
// compartido (pantalla)antes de imprimir el texto por pantalla.
semop(semaforo,P,1);
system("ipcs -s");
//Libera el semáforo
printf("---- Proceso padre, libera semáforo...\n\n", semaforo);
semop(semaforo,V,1);
}
}
else
{
printf("No se pudo crear hijo\n");
exit(-1);
}
}
4. ¿Cuáles son los estados de un semáforo binario?

5. ¿Qué otros tipos de semáforos?
6. ¿Cómo se denomina al identificador del semáforo?
7. ¿En qué estado se halla un semáforo recién creado?
32

Uso de comandos y herramientas relacionadas con el sistema de archivos y el de
E/S
Objetivos:
 Utilizando aplicaciones propietarias del SO trabajar sobre el subsistema de archivos.

 Reconocer las principales operaciones con archivos desde el SO.
 Familiarizarse con el uso del modo comando (consola).
 Aprender a usar los comandos básicos del SO Linux/Windows para el manejo del sistema
de archivos.
 Reconocer desde el SO MS Windows la estructura de E/S.
Elementos necesarios:
o modo virtual.
 Una computadora en condiciones de ejecutar el SO MS Windows XP, puede ser en modo anfitrión o modo
virtual.
 Disponer de la posibilidad de poder visualizar archivos PDF.
 Disponer de una copia del archivo comandos_linux.pdf.
 Disponer de conexión con acceso a Internet para la búsqueda de información adicional.
El TP constará de tres partes, a saber:

1. Utilizar los comandos básicos de consola para el manejo de archivos en SO Linux.
2. Obtención de información de recursos y dispositivos desde la consola del SO Windows XP.
3. Comparación de información obtenida a través de interfaz gráfica y modo consola en el SO de Windows
(nombres de archivos, directorios y atributos).
33
Generalidades del Linux

Estructura del Kernel
Figura 1
El KERNEL está directamente en contacto con el hardware y permite las interacciones con los dispositivos de
E/S y la unidad de administración de la memoria; además controla el acceso de la CPU a estos dispositivos.
Como se muestra en la figura 1 Existen tres niveles que son:
1. Bajo: contiene manejadores de interrupciones, los cuales son la forma principal de interactuar con los
dispositivos, y el mecanismo de despacho de bajo nivel.
2. Alto: contiene la comunicación con las llamadas al sistema (call systems).
3. Componentes principales:
a. Componente de E/S: es el responsable de interactuar con los dispositivos y realizar operaciones de
E/S de red y almacenamiento.
b. Administración de la memoria incluyen el mantenimiento de las asignaciones entre la memoria
virtual y la memoria física, el mantenimiento de una caché de páginas de acceso reciente y la
implementación de una buena directiva de reemplazo de páginas, y el proceso de traer a la memoria
nuevas páginas de código y datos necesarias, según la demanda
c. Administración de procesos es la creación y terminación de los procesos. También incluye el
planificador de procesos, que selecciona cuál proceso o hilo debe ejecutar a continuación.
Generalidades del Windows

Configuración de consola
Abrir una consola de comandos: InicioejecutarcmdIntro
34
Se recomienda configurar una instancia de terminal de comandos para usarla como regla, se recomienda
cambiar el tamaño de la ventana y del buffer de pantalla a 50 caracteres., para ello hacer “clic” derecho sobre
encabezado de ventana  propiedades Diseño
Hacer clic en el control de tamaño de ventana para acceder a la nueva configuración.
Referencia: Sistemas operativos modernos. Andrew S. Tanenbaum
35
Parte 1 - Comandos básicos del S.O Linux

Iniciar el equipo en el SO del anfitrión (Windows o Linux), y arrancar la máquina virtual en el SO invitado (Linux
o Windows).
Comandos básicos de apertura y cierre de consola del S.O Linux

Abrir una terminal de consola, teniendo en cuenta que para ello se puede usar la combinación de teclas:
Ctrl + Alt + F1 a F6
NOTA: Cada tecla de función abre una terminal distinta, por lo que se sugiere anotar cual es el nro. de la
terminal abierta a fin de volver a la misma.
Cerrar la terminal de consola definitivamente se debe usar el comando: exit
Retornar al entorno gráfico se debe usar las teclas: Alt + F7
Cuestionario
1. Relacionado al modelo conceptual básico de un SO ¿indique sobre que partes del mismo operan las
terminales de consola y tty?
2. ¿Cuál es el equivalente a la terminal de consola de Linux en el SO Windows?
3. Enumere la secuencia de comandos para la invocación en un SO Windows.
4. Operando con el SO Linux, ¿Se puede trabajar con el intérprete de comandos desde el entorno gráfico? De
ser posible, indique la secuencia para realizar dicha acción.
Comandos para manejo de Archivos y Directorios:

Realizar una lectura previa del archivo comandos_linux.pdf a fin de familiarizarse con su contenido. Basándose
en los comandos que figuran en el PDF, y ampliando el conocimiento de su uso mediante la ayuda del comando
de consola man, realizar:
Identificación de configuración sistema de archivo y estructura de directorios

1. Indicar sintaxis del comando para identificar el sistema de archivos que está en uso. Mostrar resultado de
aplicarlo.
2. Indicar sintaxis del comando para obtener un esquema del 1er y 2do nivel de la estructura de directorios
del Linux. Mostrar resultado de aplicarlo.
3. Describir en forma breve cual es el uso típico de cada uno de los directorios que se hallan en el 2° nivel.
4. Determine en qué directorio se encuentran los archivos de configuración del sistema.
Ubicación, creación, permisos y eliminación de directorios

1. Indique cuál es el significado de los parámetros “/”, “.” y “..”
2. ¿Qué comando usar para ubicarse en el directorio etc?
3. Si está en el directorio etc, indique qué comando que utilizaría para volver al directorio home (directorio
del usuario), tipiando la mínima cantidad de caracteres.
4. Posicionado en el home del usuario, cree un directorio denominado prueba. Copie el archivo gzip del
directorio /bin al directorio prueba recién creado. Indique en ambos casos la secuencia de comandos
utilizada.
5. Cree un duplicado del archivo gzip, recién copiado y cámbiele el nombre a gzip2. Indique la secuencia de
comandos utilizada.
6. Cambie el nombre al directorio prueba por el de prueba2. Cree el directorio prueba3 en el mismo nivel
que prueba2, utilizando un solo comando mueva todos los archivos de prueba2 a prueba3, por último
elimine el directorio prueba2. Indique la secuencia de comandos utilizada.
36
7. Cree el directorio dir2 y dir3 dentro del directorio prueba3. Determine cuáles son los actuales permisos del
directorio dir2, indique la secuencia de comandos utilizada.
8. Utilice la notación simbólica, elimine todos los permisos de escritura (propietario, grupo, otros) del
directorio dir2. Indique cuál es la nueva estructura de permisos y la secuencia de comandos utilizada.
9. Explique cómo realizaría la misma acción utilizando notación octal e indique como sería el comando
correspondiente.
10. Cree bajo dir2, un directorio llamado dir21. Indique la secuencia de comandos utilizada. Concédase a sí
mismo permiso de escritura en el directorio dir2 e intente de nuevo el paso anterior. Indique la secuencia
de comandos utilizada.
11. Proceda a eliminar todos los archivos/directorios creados, y deje la máquina en las condiciones originales
en la que la recibió. Indique comandos usados para poder eliminar el directorio prueba3.
Búsqueda de archivos con su información

Ubicarse en el directorio etc.
1. Indique qué comando utilizaría para ver su contenido. Muestre y describa su resultado.
2. Indique cómo utilizar el comando anterior para determinar cuántos nombres de archivos/directorios hay
que comiencen con las letras “app” en el directorio etc.
3. ¿Qué comando utilizaría y cómo, para determinar cuántos nombres de archivos/directorios finalizan con
la letra n contiene el directorio etc.?
4. ¿Qué comando utilizaría y cómo, para determinar cuántos nombres de archivos/directorios del directorio
etc. comienzan con la letra “o” y su tercera letra es “e”?
5. ¿Qué comando utilizaría y cómo, para mostrar todos los archivos del directorio etc., incluyendo los
archivos ocultos, con toda la información de cada uno (permisos, tamaño, etc.)?
Accesos
1. Utilizar el comando less para ver el contenido del archivo passwd, de la siguiente manera: less passwd.
¿Analice su contenido?
2. Utilizar el comando less para ver el contenido del archivo shadow, de la siguiente manera: sudo less
shadow. Analice su contenido e indique cuál es la función del comando sudo.
Enlaces
1. Cree un enlace simbólico a la aplicación nano que está en el directorio /usr/bin. Pruebe su correcto
funcionamiento e indique la secuencia de comandos utilizada. ¿Cuál sería el equivalente en MS Windows?
2. Cree un enlace duro a la aplicación nano que está en el directorio /usr/bin. Pruebe su correcto
funcionamiento e indique la secuencia de comandos utilizada. ¿Cuál sería el equivalente en MS Windows?
37
Parte 2 - Obtención de información de recursos y dispositivos desde la consola del

SO Windows.
Iniciar una máquina virtual que posea instalado el SO MS Windows XP.
1. Enumere la secuencia de pasos para su invocación.
2. Mediante el comando msinfo32, y el Panel de Control obtener la siguiente información. Complete las
siguientes tablas e indique los pasos que realizó para obtener la información de cada tabla
Incluya en las conclusiones de comparar la información obtenida con msinfo32 con las opciones de pantalla
provistas por el Panel de Control, para los dispositivos asociados con los canales de acceso directo a
memoria (DMA) ¿Que otra información arroja la comparación de direcciones obtenidas de puertos,
memoria y DMA? Tener en cuenta que el valor de H puede remplazarse por pistas por cilindro en el cálculo
por tratarse de un formato virtual Normalmente 255 pistas por cilindro. Se asume que hay una cabeza por
cada pista posible en el mismo cilindro. Otro aspecto a tener en cuenta es que los sectores por pista llegan
a 63, numerados de 1 a 63.
PARTICIONES POR UNIDAD DISCOS RÍGIDOS (ESTRUC.VIRTUAL)

Tam. Sect. Tam.
Sist. de Tam. Libre Cant. Cab. Sect.
Unid. TIPO Sector por Part.
archivo [GB] [GB] Cyl. Pist./Cyl Tot.
[B] pista [GB]
msinfo32
Panel de control
3. Mediante el comando msinfo32, y el panel de control obtener la siguiente información. Determinar los
recursos asociados a las operaciones entrada/salida por categoría, y dentro de la misma según dispositivo
para comunicarse con la CPU. Indicar la siguiente información según corresponda
 Puertos, canales DMA.
 Interrupciones.
 Espacios de memoria y variables asociadas con registro de datos, estado y control.
 Archivos ejecutables de comandos asociados con operaciones de I/O.
Recurso Memoria Dirección de puerto IRQ
NRO. DE IRQ TOTAL

NRO. DE IRQ ASIGNADAS
NRO. DE IRQ CON ASIGNACIÓN MULTIPLE
NRO. DE IRQ FALTANTES
38
4. Otros dispositivos de E/S. Mediante la opción “Componentes” obtener la siguiente información de los
siguientes dispositivos:
a) Teclado (entrada  teclado).
Descripción
b) Mouse (entrada  mouse).

Tipo de hardware
c) Pantalla y placa gráfica.

Nombre
5. Error y conflictos
a) Verificar utilizando: (recursos de hardware  conflictos/recursos compartidos). ¿De haberlos,
mencione cuáles?
b) Verificar utilizando: (componentes  recursos con problemas). ¿De haberlos, mencione cuáles?
39
Parte 3 - Comparación de información obtenida a través de interfaz gráfica y modo

consola en el SO de Windows (atributos de archivos y directorios)
Utilizar <comando>/?, como ayuda interna del comando o help <comando> para manual de comandos, y el
tabulador para completar los comandos o los nombres.
Iniciar una máquina virtual que posea instalado el SO MS Windows XP.

 Seleccionar la utilidad gráfica, interfaz con el sistema de archivos, en este caso “Explorador de Windows ->
Mis Documentos”. Ajustar la vista a “detalles” y agregar la columna de para visualización de “atributos”.
Generar en él, un juego de archivos creados por distintas aplicaciones, ej.: WORD, Bock de notas, EXCEL,
etc.
Utilizar los comandos “cd” y “dir” para acceder a la carpeta “Mis Documentos\<dir. de trabajo>”
 Ordenar los archivos según los distintos atributos como tamaño, fecha de creación en ambos casos.
Explorador y comando.
 Establecer y quitar los flags de oculto y lectura solamente, mediante el explorador y el comando
“attrib”.
Cuestionario
1. Enumerar los datos informados para cada archivo informado por la interfaz gráfica y mediante el comando
de consola
2. Indicar que tamaño informa para cada archivo la columna tamaña del explorador y comando dir.
Especificar la línea de comando usado. Justificar la razón de la diferencia de valores obtenidos si la hubiera
entre la columna del explorador y el comando.
3. Indicar que propiedad del archivo informa para cada archivo la columna atributo del explorador y el
comando attrib. Especificar la línea de comando usado. Justificar la razón de la diferencia de valores
obtenidos si la hubiera entre la columna del explorador y el comando.
4. Indicar que fechas informa para cada archivo la columna de fecha del explorador y el comando dir.
Especificar la línea de comando usado. Justificar la razón de la diferencia de valores obtenidos si la hubiera
entre las columnas del explorador y el comando.
5. Medir la cantidad de caracteres que acepta el atributo nombre del archivo.
6. Renombrar un archivo de los existentes mediante el comando ren, intentando usar una cadena de 100
caracteres para el nuevo nombre. Visualizar el nombre desde el explorador, el comando dir y el que
aparece si se selecciona propiedades del archivo desde el ícono. Justificar la razón de la diferencia de
valores obtenidos si la hubiera.
Nota: Recuerde que cada línea de la terminal tiene 50 caracteres.
7. Repetir el proceso usando una cadena de 200 y 300 caracteres para el nuevo nombre. Visualizar el nombre
desde el explorador, el comando dir y el que aparece si se selecciona propiedades del archivo desde el
ícono. Justificar la razón de la diferencia de valores obtenidos si la hubiera. Mediante que parámetro del
comando dir puede observarse los nombres cortos (MSDOS formato 8.3). Cual son las reglas para
generación de nombres cortos a partir de los nombres largos.
Nota: Se recomienda buscar en la bibliografía de base como se relaciona este formato con el nuevo
extendido para nombre.
Conclusiones
En base a los elementos investigados en cada sistema operativo, indicar las diferencias
(Funcionalidades/nombres).
40
Ejercicios propuestos
Uso disquete virtual

1. De formato a un disquete virtual (archivo diskette.flp) desde consola con el comando format, y verificar lo
informado.
2. Crear un archivo de 10 bytes y copiarlo al diskette virtual, ejecutar el comando chkdsk sobre el diskette.
Determine espacio total, cantidad de bloques libres y usados, tamaño de la unidad de asignación (bloque) y
cuánto es el desperdicio por fragmentación.
3. Calcular el valor del número de serie del volumen en decimal.
4. Considerar FAT 12 y 512 bytes por sector averiguar una organización posible de sistema de archivo.
5. Dimensionar cantidad máxima de archivos y bytes utilizados para administrar el volumen.
Otros comandos
6. Investigar el uso del comando fsutil sobre un volumen NTFS. (se requieren privilegios de administrador).
7. Utilizar aplicaciones propietarias para determinar los recursos asociados a las operaciones entrada salida:
 Puertos, interrupciones, canales DMA.
 Archivos ejecutables de comandos asociados con operaciones de I/O.
 Espacios de memoria y variables asociadas con registro de datos, estado y control.
8. Indicar y describir comandos del Shell que suministren información de dispositivos y permitan su
configuración, ejemplo comando mode.
9. Crear un archivo de comandos que almacene en un archivo el estado de los puertos de comunicaciones, la
configuración del puerto de impresora y la pantalla, fecha y hora.
41

Administración y Comandos Linux/Windows
Objetivos:
 Conocer herramientas y comandos para la administración y manejo de los SO.

 Familiarizarse con herramientas esenciales para la administración básica de un SO.
 Familiarizarse con el uso del entorno de comandos de los SO.
 Proveer a la base de conocimiento experimental que utilizará para su tarea profesional.
 Una computadora en condiciones de ejecutar la consola de máquina virtual VMware o similar.

 Tener instalado MS Windows XP o Linux en la computadora como SO anfitrión y su contrapartida en la
máquina virtual como SO invitado.
 Conocer el uso de los comandos utilizados en el TP N°3.
 Acceso a Internet por parte del sistema anfitrión.
 Tutorial Shell Scripts.
(http://recursostic.educacion.es/observatorio/web/es/software/programacion/573-javier-
martinez-avedillo).

Los comandos internos se encuentran incluidos o compilados con un programa del sistema operativo que ya
está en proceso, generalmente el “Shell”, los externos por el contrario necesitan cargar un programa al
invocarlos.
Sistema operativo Windows
Iniciar una instancia del “Shell” de comandos cmd, en el sistema operativo MS Windows.
1. Determinar cuál es el directorio de apertura por defecto y establecer el camino para llegar a él desde el
dispositivo que lo contiene.
2. Ejecutar el comando set y verificar el valor de las variables de entorno HOMEDRIVE y HOMEPATH.
3. ¿Qué valores del punto 1 y 2 variarán si el comando lo ejecuta, en el mismo equipo, otro usuario declarado,
luego de abrir su sesión? (verificarlo en alguna máquina vecina).
4. Indicar el comando para detectar si es un comando interno o externo. Indicar las rutas que se encuentran
los comandos internos y externos.
5. Indicar los comandos “internos” del sistema operativo.
6. Indicar alguno de los comandos “externo” del sistema operativo.
Uso de comandos de procesos

7. Indicar y describir cuál es el comando que usaría para ver los procesos que se están ejecutando con sus
respectivas prioridades.
8. Probar y describir cuál es el comando que usaría para cambiar la prioridad de un proceso que se halla en
ejecución. Mencione cuales son las prioridades disponibles.
9. Probar y describir cuál es el comando que usaría para eliminar un proceso que se halla en ejecución.
42
Uso de variables de entorno

10. Describir las variables de entorno declaradas por defecto. Mediante el uso de los comandos set.
11. Realizar un archivo por lotes o script que genere un alias de comandos llamado “instalar”, el cuál realice la
copia un conjunto de archivos desde un directorio de origen a un directorio destino (previamente creados).
La sintaxis del nuevo comando debe ser:
instalar <origen destino>, donde origen es %1 y destino %2
A qué elementos se denominan %1, %2, %3, … dentro del archivo.
12. ¿Qué modificaciones debería hacer para contemplar el caso en que el directorio de origen o destino no
existieran?
13. ¿Cómo se asegura que en el caso que el directorio de origen sea multinivel copie la estructura en destino?
14. En caso de tener que tomar una decisión de ejecución, programa “A” o programa “B” desde un archivo por
lotes o script. (Estructura de menú con decisión del operador). ¿Cómo lo haría?
15. ¿Cómo declararía una variable de entorno automáticamente cuando abre un Shell?
16. ¿Cómo agregaría dinámicamente un nuevo valor para búsqueda de la variable de entorno PATH y la
volvería a su estado anterior antes de ejecutar un programa y al finalizar el mismo respectivamente?
17. Mediante que variable de entorno se obtiene un valor producido por algún comando.
Sistema operativo LINUX

Iniciar una instancia del “Shell”, en el sistema operativo Linux.
1. Determinar cuál es el directorio de apertura por defecto y establecer el camino para llegar a él desde el
dispositivo que lo contiene.
2. Ejecutar el comando env y verificar el valor de la variable de entorno HOME.
3. ¿Qué valores del punto 1 y 2 variarán si el comando lo ejecuta, en el mismo equipo, otro usuario declarado,
luego de abrir su sesión? (verificarlo en alguna máquina vecina).
4. Indicar el comando para detectar si es un comando interno o externo. Indicar las rutas que se encuentran
los comandos internos y externos.
5. Indicar los comandos en el sistema operativo que respondan a la clasificación de “internos/externos”.
43
Uso de comandos de procesos

6. Indicar y describir cuál es el comando que usaría en para ver los procesos que se están ejecutando con
sus respectivas prioridades.
7. Indicar y describir cuál es el comando que usaría para cambiar la prioridad de un proceso que se halla
en ejecución. Mencione cuales son las prioridades disponibles.
8. Indicar y describir cuál es el comando que usaría para eliminar un proceso que se halla en ejecución.
Uso de variables de entorno

9. Describir las variables de entorno declaradas por defecto. Mediante el uso de los comandos env/set.
10. Realizar un archivo por lotes o script que genere un alias de comandos llamado “instalar”, el cuál
realice la copia un conjunto de archivos desde un directorio de origen a un directorio destino
(previamente creados). La sintaxis del nuevo comando debe ser:
instalar <origen destino>, donde origen es $1 y destino $2
A qué elementos se denominan $1, $2, $3, … dentro del archivo.
11. ¿Qué modificaciones debería hacer para contemplar el caso en que el directorio de origen o destino no
existieran?
12. ¿Cómo se asegura que en el caso que el directorio de origen sea multinivel copie la estructura en
destino?
13. Si desde un archivo por lotes o script se desea tomar una decisión de ejecución del programa “A” o
programa “B” qué estructura de menú con decisión del operador debería usarse. ¿Cómo lo haría?
14. ¿Cómo declararía una variable de entorno automáticamente cuando abre un Shell?
15. ¿Cómo agregaría dinámicamente un nuevo valor para búsqueda de la variable de entorno PATH y la
volvería a su estado anterior antes de ejecutar un programa y al finalizar el mismo respectivamente?
16. ¿Qué significa errorlevel?
17. ¿Para qué sirve el comando test?
Conclusiones
En base a los elementos investigados en cada sistema operativo, indicar las diferencias
(Funcionalidades/nombres).
44

SO TP LAB Gua Unificada v1 8

Cargado por

Copyright:

Formatos disponibles

SO TP LAB Gua Unificada v1 8

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

SO TP LAB Gua Unificada v1 8

Cargado por

Copyright:

Formatos disponibles

Sistemas Operativos (3.4.

TRABAJO PRÁCTICO de LABORATORIO Nº1

 Familiarizar al alumno con herramientas esenciales para el conocimiento de SOs.

El TP constará de dos etapas, a saber:

Desarrollo del Trabajo Práctico:

Parte 1 – Creación de la máquina virtual

“Inicio  Todos los Programas  VMware  VMware Workstation “

3. Si aparece la pantalla anterior seleccionar la opción “Custom (advanced)”. Presionar “next”.

5. Seleccionar “Instalar el Sistema Operativo más tarde”. Presionar “next”.

7. Completar los campos “Nombre y directorio de la máquina virtual” de la siguiente manera:

Virtual machine name: Ubuntu_SOXX

Location: C:\Virtuales\Ubuntu_SOXX (respetando el remplazo predicho).

9. Seleccionar “tamaño de la memoria RAM de la máquina

12. Seleccionar “Crear un nuevo disco duro virtual”. Presionar “next”.

13. Seleccionar “tipo de HD a usar”, en este caso un SCSI. Presionar “next”.

15. Mantener el “nombre del archivo por defecto”. Presionar “next”.

Parte 2 – Instalación del sistema operativo

5. Deseleccionar “Descargar actualizaciones mientras instala”. Seleccionar “Continuar”.

6. Seleccionar “Algo más”. Presionar “Continuar”.

1) Crear la partición raíz (/)

b) Y presionar “Nueva tabla de particiones”.

c) Luego seleccionar el “espacio libre“ y presionar “añadir”

d) Leer la advertencia. Presionar “Continuar”

e) Proceder a crear la 1ª partición

f) Seleccionar “Tipo de partición”, “tamaño”, “ubicación de la partición”, tipo de “sistema de archivos a

Tipo de nueva partición: primaria

Nota: Anotar tipos de particiones disponibles y tipos de sistemas de archivos disponibles.

2) Crear la partición de intercambio ó área de intercambio(swap)

Tipo de nueva partición: “primaria”

Nota: verificar que la partición de swap no está marcada para formatear.

9. Seleccionar la ciudad. Presionar “Continuar”.

10. Seleccionar tipo de teclado. Presionar “Continuar”.

11. Crear usuario. Completar los campos y presionar “Continuar”.

Nombre de usuario: “uade”

ADVERTENCIA a diferencia de Windows Linux distingue entre mayúsculas y minúsculas, en nombre de

TRABAJO PRÁCTICO de LABORATORIO Nº2

 Comprender mejor el proceso de compilación y enlace.

Parte 1 - El uso del compilador GCC:

Parte 2 - Comunicación entre procesos:

Desarrollo del Trabajo Práctico:

Parte 1 – El uso del compilador GCC

Invocación del gcc:

Extensión Tipo de archivo

.C, .cc Código fuente de lenguaje c++

.i Código fuente de C pre procesado

.ii Código fuente de C++ pre procesado

.S, .s Código fuente de lenguaje ensamblador

.o Código objeto compilado

Uso del gcc paso a paso:

Ejecución manual del paso a paso:

4. Enlazando (Linkeando) el archivo objeto, finalmente se obtiene su imagen binaria.

Parte 2 – Comunicación entre procesos (IPC)

Visualización de los mecanismos IPC activos:

Segmentos de memoria compartidos (shared memory).

Colas de mensajes (message queue).

Visualización de los mecanismos IPC activos.

Segmentos de memoria compartidos (shared memory).

#define TAMANO_BUF 4096

Compilar el código fuente y ejecutarlo.

void Imprimir_por_pantalla (int semaforo,struct sembuf P,struct sembuf V );

void Imprimir_por_pantalla (int semaforo,struct sembuf P,struct sembuf V )

/Creamos un proceso hijo que imprime en pantalla/