Implementaciones de Servicios del Sistema Operativo

De Departamento de Informatica
Saltar a: navegación, buscar

Contenido

Gestión y planificación de recursos

Entre las tareas claves de un sistema operativo está la de gestionar los diferentes recursos que disponga el sistema y planificar la utilización de los mismos de la forma más eficiente para los procesos de ejecución.

La política de planificación o de asignación de recursos tiene que ser justa y eficiente. Esto supone que todos los procesos que compiten por la utilización de un determinado recurso deben disponer de él de una forma equitativa y se debe cumplir sobretodo en trabajos de la misma clase que posean igual prioridad.

Por otro lado hay situaciones en las que es necesario distinguir las diferentes clases de trabajos con sus propias exigencias de servicios.

El sistema operativo debe intentar hacer la planificación y la asignación considerando el total de los requerimientos. Estas decisiones se hacen dinámicamente, por ejemplo: si un proceso esta esperando para utilizar un periférico, el sistema operativo debe planificar su ejecución de forma que lo libere lo antes posible, para poder satisfacer peticiones posteriores de otros procesos.


Ejemplo de implementación de asignación de recursos del sistema operativo

Algoritmo del Banquero

Este algoritmo determina si un pedido de recursos puede ser satisfecho de forma segura. Es ejecutado por el sistema cada vez que llega una petición de recursos por parte de un proceso.

Fue creado a partir del siguiente enunciado: Existe un banco que tiene fondos limitados de dinero para prestar y también clientes a los cuales les otorga créditos. Un cliente solicita un préstamo al banco y éste puede otorgar o rechazar el préstamo si existe algún riesgo de que se quede sin fondos para prestar a otros clientes.

En analogía con los Sistemas Operativos, los clientes representan a los procesos, el dinero a los recursos y el banquero al Sistema Operativo.

Los pasos del procedimiento son:

1.Buscar un proceso cuya suma recAsig + recDisp >= recMax

2.Sumamos sus recursos al vector recDisp y añadimos el proceso a la lista de finalizados.Suponiendo que se asignan dichos recursos y el proceso termina su ejecución.

3.Repetir primer paso hasta terminar todos los procesos (siendo un estado estable) o bien hasta el punto en el que no sea posible ninguna asignación de recursos.

Ejemplo

AlgoritmodelBanquero1.png

AlgoritmodelBanquero2.png



Debilidades del Algoritmo del Banquero

Requiere que el S.O garantice que todas las peticiones serán concedidas en un tiempo finito, pero en realidad se requieren mayores garantías.

Requiere que los procesos indiquen sus necesidades máximas de recursos por adelantado, lo cual generalmente no ocurre.

Requiere que exista un número fijo de recursos asignables, pero generalmente no se puede contar con que el número de recursos se mantenga siempre constante.


Algoritmo en Python
   def comprueba_configuracion(asignados, maximos, disponibles):
   finalizados = []
   i = 0
   while(i < len(asignados)):
       if not i in finalizados and puede_progresar(asignados[i], disponibles, maximos[i]):
           print('Finaliza P%s\nDisponibles: %s' % (i,disponibles))
           libera_recursos(asignados[i], disponibles)
           finalizados.append(i)   # Marca el proceso Pi como finalizado
           i = 0
       else:
           i += 1

   if(len(asignados) == len(finalizados)):     # Si todos los procesos finalizan
       print('\nEstado seguro para la configuracion de procesos-recursos dada')
   else:
       print('\nSe produce un interbloqueo')

  #Incrementamos la lista de disponibles con los que tenia asignados
   def libera_recursos(asignados, disponibles):
   for i in range(len(disponibles)):
       disponibles[i] += asignados[i]

  # Devuelve True si el nº de elementos asignados mas los disponibles son mayores o iguales a los requeridos para continuar
   def puede_progresar(asignados, disponibles, maximos):
   resultado = True
   for i in range(len(maximos)):
       if(asignados[i] + disponibles[i] < maximos[i]):
           resultado = False
           break
   return resultado

   asignados = [
   [1,0,2,1,1],
   [2,0,1,1,0],
   [1,1,0,1,0],
   [1,1,1,1,0]
   ]
   maximos = [
   [1,2,2,1,2],
   [2,2,2,1,0],
   [2,1,3,1,0],
   [1,1,2,2,1]
   ]
  disponibles = [0,0,2,1,1]
  
  Para este ejemplo la salida sería: 
  >>> comprueba_configuracion(asignados, maximos, disponibles)
  Finaliza P3
  Disponibles: [0, 0, 2, 1, 1]
  Finaliza P2
  Disponibles: [1, 1, 3, 2, 1]
  Finaliza P0
  Disponibles: [2, 2, 3, 3, 1]
  Finaliza P1
  Disponibles: [3, 2, 5, 4, 2]

  Estado seguro para la configuración de procesos-recursos dada.


Algoritmo en C
           int nRecursos;
           int nProcesos;
           List<List<int>> asignados = new List<List<int>>();
           List<List<int>> maximos = new List<List<int>>();
           List<int> disponibles = new List<int>();

           Random r = new Random();

           //Generamos las matrices aleatoriamente
           for (int j1 = 0; j1 < nRecursos;j1++)
           {
               disponibles.Add(r.Next(0, nRecursos));                
           }
           for (int i = 0; i < nProcesos; i++)
           {
               asignados.Add(new List<int>());
               maximos.Add(new List<int>());
               for (int j = 0; j < nRecursos; j++)
               {
                   asignados[i].Add(r.Next(0, nRecursos));
                   maximos[i].Add(r.Next(0, nRecursos));
               }
           }

           bool aux = true;
           for (int proc = 0; proc < nProcesos; proc++)
           {
               aux = true;
               for (int recur = 0; recur < nRecursos; recur++)
               {
                   // comprobamos que haya recursos suficientes
                   aux = (maximos[proc][recur] - asignados[proc][recur] - disponibles[recur]) <= 0;
                   if (!aux)
                   {
                       break;
                   }
               }
               if (aux)
               {
                   añadirYeliminar(ref disponibles, ref asignados, proc);
                   maximos.RemoveAt(proc);
                   nProcesos--;
                   proc = -1;
                   if (nProcesos == 0)
                   {
                       Console.WriteLine("Es estado seguro");
                       Console.ReadLine();
                       return;
                   }
               }
           }
           Console.WriteLine("Es interbloqueo");
           Console.ReadLine();

       }

       private static void añadirYeliminar(ref List<int> disponibles, ref List<List<int>> asignados, int proc)
       {
           for (int k = 0; k < asignados[proc].Count; k++)
           {
               disponibles[k] += asignados[proc][k];
           }
           asignados.RemoveAt(proc);
       }
      Faltaría solamente leer por consola el numero de procesos y de recursos que queremos testear, o agregarlos manualmente.

Implementaciones de seguridad en el sistema operativo

Si hablamos de seguridad, es claramente una expresión muy amplia. En el contexto de la informática podemos decir que se resume principalmente en estos ámbitos:

Consistencia: Que el sistema no muestre cambios inesperados.

Servicio: Todos los servicios deben ser presentados constante, consistente y confiablemente.

Funcionamiento: Si en un programa ocurre un problema, el sistema deberá seguir funcionando con el resto de las funcionalidades y estas no deben verse afectadas por lo primero.

Control de acceso: Los datos que mantiene o genera un usuario no deben ser vistos por otro, o bien, deben tener las limitaciones claras para el uso compartido de estos.

Autenticación: Asegurar que cada usuario sea quien dice ser, y no se pueda intervenir en las sesiones que no corresponden.


Cada uno de estos puntos se extiende de maneras muy diversas a partir de las especificaciones que se le den al SO, sin embargo a pesar de todos los detalles que tratemos de cubrir, siempre habrá espacios abiertos que no se pueden preveer. Incluso para el creador del sistema siempre existirán nuevas aplicaciones que traten de burlar de manera diferente la seguridad.

A pesar de esto, no se debe pensar que la seguridad es poco importante, sino que siempre hay que darle una trascendencia fundamental en la creación y utilización de nuestro sistema, recordando siempre que la inversión en seguridad es inversamente proporcional a la usabilidad.

Para los sitemas UNIX, podemos generalizar la instalación del sistema operativo (en el aspecto de la seguridad) en 2 bloques:

Seguridad básica

Parte con la instalación del sistema, recordando la configuración de red (en el caso de estar conectado a una), instalar solo los servicios requeridos y hacerlo con el mínimo de servicios pensando en ir aumentándolos, no hacer una instalación muy pesada para después intentar alivianarla. Con esta visión, nuestro sistema estará preparado para trabajar de manera básica sin mayores complicaciones.

Seguridad avanzada

Para tener esto, debemos poner atención en muchos puntos importantes. Algunos de los principales son:

Filtrado de paquetes: gran parte de los sistemas UNIX traen paquetes para el filtrado, y dependiendo de la versión esta su comando (ipfwadm, ipchains, iptables). También esta el IPFilter y el FreeBSD.

Montaje (mount): revisar los atributos de montaje permite una mejor protección para el sistema. Por ejemplo para Linux y *BSD usando -o: async/sync (escritura asincrónica/sincrónica); noexec (no permitir ejecutables); nosuid (no permite archivos SUID).

En este contexto, Linux tiene otras instancias con el programa mount (-o): nouser (no deja a cierto usuario montar partición); ro/rw (montar la partición en solo lectura o lectura/escritura).

Para *BSD estan los siguientes comandos (también con mount -o): rdonly (montar la partición solo en modo lectura); update (actualizar los parámetros del montaje de la partición).

Cabe destacar que aún con esto, es posible que nuestro sistema sea vulnerado. Lo realmente importante es interiorizarse en el aspecto de seguridad para cubrir la mayor parte de los espacios por donde podamos recibir algún tipo de ataque a nuestro sistema.

Referencias

http://es.wikipedia.org/wiki/Algoritmo_del_banquero

http://es.scribd.com/doc/2511443/Sistemas-Operativos-Martinez

http://www.hacienda.go.cr/centro/datos/Articulo/Implementaci%C3%B3n%20de%20seguridad.pdf

Herramientas personales
Espacios de nombres
Variantes
Acciones
Navegación
Herramientas