POSIX

POSIX

POSIX es el acrónimo de Portable Operating System Interface; la X viene de UNIX como seña de identidad de la API.

El término fue sugerido por Richard Stallman en respuesta a la demanda de la IEEE, que buscaba un nombre fácil de recordar. Una traducción aproximada del acrónimo podría ser "Interfaz de sistema operativo portable". ".

INTRODUCCION

Son una familia de estándares de llamadas al sistema operativo definidos por el IEEE y especificados formalmente en el IEEE 1003. Persiguen generalizar las interfaces de los sistemas operativos para que una misma aplicación pueda ejecutarse en distintas plataformas. Estos estándares surgieron de un proyecto de normalización de las API y describen un conjunto de interfaces de aplicación adaptables a una gran variedad de implementaciones de sistemas operativos.

Especifica las interfaces de usuario y software al sistema operativo en 15 documentos diferentes. La línea de comandos estándar y las interfaces de scripting se basaron en Korn Shell. Otros programas a nivel de usuario (user-level), servicios y utilidades incluyen AWK, echo, ed y cientos de otras. Los servicios a nivel de programa requeridos incluyen definición de estándares básicos de I/O, (file, terminal, y servicios de red). También especifican una API para las bibliotecas de threading, que es muy utilizada en una gran variedad de sistemas operativos.

Una serie de pruebas acompañan al estándar POSIX. Son llamadas "PCTS" en alusión al acrónimo "Posix Conformance Test Suite". Desde que la IEEE empezó a cobrar altos precios por la documentación de POSIX y se ha negado a publicar los estándares, ha aumentado el uso del modelo Single Unix Specification. Este modelo es abierto, acepta entradas de todo el mundo y está libremente disponible en Internet. Fue creado por The Open Group.

• POSIX.1, Core Services (implementa las llamadas del ANSI C estándar). Incluye:
  • Creación y control de procesos.
  • Señales.
  • Excepciones de punto flotante.
  • Excepciones por violación de segmento.
  • Excepciones por instrucción ilegal.
  • Errores del bus
  • Temporizadores.
  • Operaciones de ficheros y directorios (sobre cualquier fs montado).
  • Tuberias(Pipes).
  • Biblioteca C (Standard C).
  • Instrucciones de entrada/salida y de control de dispositivo (ioctl).

• POSIX.1b, extensiones para tiempo real:
  • Planificación (scheduling) con prioridad.
  • Señales de tiempo real.
  • Temporalizadores
  • semaforos
  • Intercambio de mensajes (message passing).
  • Memoria compartida.
  • Entrada/salida síncrona y asíncrona.
  • Bloqueos de memoria.

• POSIX.1c, extensiones para hilos (threads):
  • Creación, control y limpieza de hilos.
  • Planificación (scheduling).
  • Sincronización.
  • Manejo de señales.

• POSIX.2, Shell y Utilidades (IEEE Std 1003.2-1992)
  • Intérprete de Comandos
  • Programas de Utilidad

Luego de 1997 el Grupo Austin realizó modificaciones a POSIX. Las especificaciones tienen el nombre de Single Unix Specification (Especificación Única de Unix)

• POSIX:2001 o IEEE Std 1003.1-2001 equivale a la versión 3 de Single UNIX Specification.
  • Las base de definiciones, Tema 6.
  • Las interfaces y encabezamientos del sistema, Tema 6.
  • Los comandos y utilidades, Tema 6.

• POSIX:2004 o IEEE Std 1003.1-2004 implica una pequeña actualización de POSIX:2001. Tiene dos correcciones técnicas de errores. Para más información sobre este estándar visitar:

A partir de 2009 POSIX:2008 o IEEE Std 1003.1-2008 representa la versión actual.

• La base de definiciones, Tema 7,
• Las interfaces encabezamientos del sistema, Tema 7.
• Los comandos y utilidades, Tema 7.

EJEMPLO:

sistema productor-consumidor con búfer circular utilizando hilos, semáforos POSIX binarios y semáforos POSIX genéricos:

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <semaphore.h>
#define TAMBUF 8     // Tamaño del búfer circular
#define NUMDATOS 100 // Número de datos a enviar
//
// El buffer circular y los correspondientes punteros
int buffer[TAMBUF];
int bufin = 0;
int bufout = 0;
//
// Semaforo binario
pthread_mutex_t buffer_lock = PTHREAD_MUTEX_INITIALIZER;
//
// Variable suma
unsigned long sum = 0;
//
// Semaforos generales
sem_t hay_datos;
sem_t hay_sitio;
//
// Funciones de escritura y lectura del buffer circular
void obten_dato(int *itemp)
{
  pthread_mutex_lock(&buffer_lock);
  *itemp = buffer[bufout];
  bufout = (bufout + 1) % TAMBUF;
  pthread_mutex_unlock(&buffer_lock);
  return;
}
void pon_dato(int item)
{
  pthread_mutex_lock(&buffer_lock);
  buffer[bufin] = item;
  bufin = (bufin + 1) % TAMBUF;
  pthread_mutex_unlock(&buffer_lock);
  return;
}
 
//
// Funciones productor-consumidor
void *productor(void *arg1)
{
  int i;
  for (i = 1; i <= NUMDATOS; i++) {
    sem_wait(&hay_sitio);
    pon_dato(i*i);
    sem_post(&hay_datos);
  }
  pthread_exit( NULL );
}
void *consumidor(void *arg2)
{
  int i, midato;
  for (i = 1; i<= NUMDATOS; i++) {
    sem_wait(&hay_datos);
    obten_dato(&midato);
    sem_post(&hay_sitio);
    sum += midato;
  }
  pthread_exit( NULL );
}
 
//
// Funcion principal
main()
{
  pthread_t tidprod, tidcons;
  unsigned long i, total;
 
  total = 0;
  for (i = 1; i <= NUMDATOS; i++)
    total += i*i;
  printf("El resultado deberia ser %u\n", total);
//
// Inicializacion de semaforos
  sem_init(&hay_datos, 0, 0);
  sem_init(&hay_sitio, 0, TAMBUF);
//
// Se crean los hilos
  pthread_create(&tidprod, NULL, productor, NULL);
  pthread_create(&tidcons, NULL, consumidor, NULL);
//
// Se espera a que los hilos terminen
  pthread_join(tidprod, NULL);
  pthread_join(tidcons, NULL);
  printf("Los hilos produjeron el valor %u\n", sum);
 
}