Implementación APIs en SO

POSIX & SUS

Miguel Pajares Hernández Antonio Pérez Morales

Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Francisco de Vitoria Universidad Francisco de Vitoria
Pozuelo de Alarcón, Madrid Pozuelo de Alarcón, Madrid
miguel.pajares@outlook.com antonio.pemo@hotmail.com

Abstract—Para poder profundizar en como los conjunto de controladores que proporcionan

sistemas operativos basados en el kernel de Linux, vamos comunicación entre el hardware y la capa
a hacer una introducción a cómo funciona la API y ABI
software que se asienta por encima de él.
de Linux, y como el estándar de C y POSIX han
posibilitado el soporte de programas en muchos sistemas
operativos suficientemente diferentes sin ningún tipo de
incompatibilidad de programas.

Keywords—kernel; Linux; UNIX; POSIX;

programming; API; ABI; C; C++; shell.

I. DEFINICIÓN Y ALCANCE DEL PROYECTO

Ilustración 1: En el anexo podrá encontrar un

En este trabajo, vamos a comenzar introduciendo los diagrama más completo)
conceptos de API, ABI y como Linux gestiona estos
sistemas con el estándar de la IEEE POSIX del que
hablaremos más adelante. • API: Application Programming Interface.
Para comenzar vamos a definir algunos términos que Como su nombre indica, se trata de una
son importantes: interfaz de Programación. Esto es lo que
proporciona unas formas de comunicación
• LINUX: Linux hace referencia generalmente
entre el kernel y el SO previamente definidas,
a los sistemas operativos que se construyen
que permite la programación de una forma
encima del kernel, que es lo que se llama
mucho más rápida, puesto que no hace falta
realmente Linux. Este kernel, o núcleo,
crear esa comunicación cada vez que se
explicándolo de forma simplificada, es un
 intenta acceder a características de niveles
más bajos del SW. Un ejemplo puede ser la
API que dibuja en pantalla, pues abstrae una
información y la dibuja en pantalla o la más
conocida Standard I/O conocida como
<stdio.h> en C.
• ABI: Application Binary Interface: Al igual
que la API permite el acceso desde el propio
código de alto nivel, la ABI permite el acceso
a rutinas y a estructuras de datos desde un
código de tan bajo nivel como es el binario.
Un código compilado en API asegura
compatibilidad, mientras que uno en ABI
puede ser compatible directamente sin tener
que ser recompilado con otro sistema que
comparta ABI y librerías.
Ilustración 2: Diferencias API vs ABI En el anexo
podrá encontrar un diagrama más completo)
En Linux se encuentran tres componentes
principales: “System calls”, “Librerias C” y
“Compilador C”
Las llamadas al sistema dan una forma al código del
usuario de ejecutarse en el modo de kernel a través de
fragmentos o llamadas cortas, pues todo el código por
seguridad no se puede ejecutar en el kernel. Cada
arquitectura define una forma de acceso diferente,
pero el i386 se hace mediante la instrucción int con el
valor 0x80, que es un wrapper para la función de
system call.
Las librerías de C, como ‘stdio’ son una de las partes
principales en la programación en kernel de Linux
que dan acceso a servicios de núcleo. La más
conocida es glibc, que aparte de implementar la
librería estándar de C, también proporciona wrappers
para llamadas del sistema, soporte para acceso a hilos
y acceso a memorias.
El compilador de C, en Linux conocido como GNU
Compiler Collection, gcc, que ayuda a implementar
los estándares de C y las ABIs del sistema
II. HISTORIA
En los años 80, la gran variedad de sistemas Unix
quería ser estandarizado por Richard Stallman,
fundador del movimiento Free Software y parte del
IEEE (Instituto de Ingenieros Eléctricos y
Electrónicos), sugiriendo que se llamara POSIX,
Portable Operating System Interface.
Desde entonces se ha ido evolucionando el estándar,
quedando dividido en diferentes versiones: POSIX.1,
POSIX.1b, POSIX.1c, POSIX.2. De acuerdo con
Wikipedia [1], cada uno incluyen lo siguiente:
• POSIX.1: Servicios de núcleo, implementa
llamadas de C estándar, como señales,
creación y control de procesos, excepciones,
operaciones de ficheros y directorios, tuberías
y operaciones i/o.
 • POSIX.1b: Extensiones para tiempo real,
señales, temporizadores, semáforos, shared
memory, bloqueos de memoria y i/o síncrona
y asíncrona.
• POSIX.1c: Exteniones para hilos o threads.
• POSIX.2: Shell y comandos.
Sin embargo, POSIX y la IEEE tenían un problema y
es que eran de pago. Por tanto, el Open Group
(consorcion de la industria en favor del software
libre) desarrolló la Single UNIX Specification,
conocida por sus siglas SUS, que se hizo rápidamente
famoso por ser libre. Hoy en día, POSIX se encuentra
incluido en SUS, cuya última versión data del año
2008.
III. ESTADO DEL ARTE
La relevancia de POSIX en la actualidad es total. La
capacidad que tiene de ofrecer una mayor facilidad
para el desarrollo y porteado de las aplicaciones. Las
interfaces son ampliamente implementadas y
referenciadas en otros intentos de estandarización,
pues es la norma que seguir. De hecho, en desarrollos
actuales de sistemas empotrados, dispositivos
móviles Android, dispositivos de red (routers),
servidores y Workstation, hasta supercomputadores.
A. POSIX 4.2 define:
1. C API
Amplía enormemente ANSI C con cosas como:
- obtención de más operaciones sobre
archivos como: mkdir, dirname, symlink,
readlink, hardlinks, poll, sync
- procesos e hilos nuevos como: fork, execl,
pipe, emáforos, memoria compartida, kill y
parámetros de programación
- networking
- regular expressions
- Gestión avanzada de memoria: mmap,
mlock, mprotect y madvise
Estas APIs tamién determinan los conceptos
subyacentes del sistema del que dependen. Hay
muchas llamadas a Linux para implementar alguna
función API Posix C específica y cumplir con los
procesos Linux como sys_write, sys_read,...
2. Utilidades CLI
Como por ejemplo los comandos: cd, ls, echo, etc.
Muchas de estas utilidades son interfaces directas del
shell para una función de la API C correspondiente.
También tenemos importantes implementaciones
sobre lo que es el escritorio en Linux, como GNU
Coreutils para proyectos pequeños y la
implementación de utilidades CLI integradas con el
Bash.
3. Lenguaje Shell
Introducciones principal del GNU Bash.

4. Variables del entorno
Nuevas rutas como: HOME y PATH
5. Estado de las salidas del programa
ANSI C nos devolverá EXIT_SUCCESS para los
éxitos, EXIT_FAILURE en caso de fracaco y la
definición del resto de la implementación la dejará
definida añadiendo:
126: comando encontrado pero no puede ser
ejecutado
127: comando no encontrado
128: comando terminado por una señal
6. Expresiones regulares
Tenemos dos tipos: BRE(Básico) y ERE(extendido).
La primera actualmente se encuentra en desuso y
solo es mantenida dentro de la API.
Estas expresiones son implementadas por funciones
de la API C y usadas por medio de las utilidades de
CLI como grep
7. Estructura de directorios
POSIX es ampliado enormemente por medio de
Linux FHS.
Por ejemplo: /dev, /tmp, /null, etc
8. Nombres de archivos
- '/' lo utilizaremos como el separador de ruta
- NUL no podrá ser utilizado
- '.' será cwd y '..' su padre
- Para el nombre de los archivos que puedan ser
portales tenemos:
- solo podrán utilizar 14 caracteres como máximo
y 256 para la ruta completa.
- solo podrá contener caracteres como: a-zA-Z0-
9 ._-
9. Utilidades de la línea de comandos usadas de
forma convencional por la API
Por ejemplo, podemos destacar:
- '-' significa donde se debe esperar un
archivo.
- '--' usado como fin de los flags.
Esto se encuentra implementado en los sistemas
actuales basados en Unix, donde gran parte de las
funciones aquí mencionadas son parte esencial del
comportamiento básico del sistema, sobre todo del
Shell de comandos, herramienta principal para
cualquier programador y desarrollador de la
plataforma para los que las APIs del sistema son
esenciales pues les facilitan el empleo de estas
herramientas.
 UnixWare SkyOS
Compatibilidad de POSIX en distintos SSOO

Syllable
VelOSity
Mayoritariamente
Totalmente compatibles
compatibles (no
(de forma oficial) VxWorks Windows
certificados oficialmente)

A/AUX BeOS

AIX FreeBSD

BSD/OS GNU/Linux

HP-UX Contiki

INTEGRITY NetBSD

IRIX Nucleus RTOS

LynxOS OpenBSD

MAC OS X OpenSolaris

MINIX PikeOS

MPE/iXa RTOS

Solaris RTEMS

Unison RTOS Sanos

 IV. EJEMPLO DESARROLLO PRÁCTICO

Aquí podemos apreciar un ejemplo en pseudocódigo de una API de Linux la cual es una rutina que se encarga
de realizar manipulaciones de cadenas de strings. Es una implementación de los estándares de C en la librería
string.h:

Description:
Here are some standard string manipulation functions:

{To determine if the character is a digit.}

function IsDigit(ch: char): boolean;
begin
Result := ch in ['0'..'9'];
end;

{To determine if the character is an uppercase letter.}

function IsUpper(ch: char): boolean;
begin
Result := ch in ['A'..'Z'];
end;

{To determine if the character is an lowercase letter.}

function IsLower(ch: char): boolean;
begin
Result := ch in ['a'..'z'];
end;

{Changes a character to an uppercase letter.}

function ToUpper(ch: char): char;
begin
Result := chr(ord(ch) and $DF);
end;

{Changes a character to a lowercase letter.}

function ToLower(ch: char): char;
begin
Result := chr(ord(ch) or $20);
end;

{ Capitalizes first letter of every word in s }

function Proper(const s: string): string;
var
i: Integer;
CapitalizeNextLetter: Boolean;
begin
Result := LowerCase(s);
CapitalizeNextLetter := True;
for i := 1 to Length(Result) do
begin
if CapitalizeNextLetter and IsLower(Result[i]) then
Result[i] := ToUpper(Result[i]);
CapitalizeNextLetter := Result[i] = ' ';
end;
end;

{ NOTE: The following functions are available in Delphi 2.0,

but not in Delphi 1.0. }

{Supresses trailing blanks in a string.}

function TrimRight(const s: string): string;
var
i: integer;
begin
i := Length(s);
while (I > 0) and (s[i] <= ' ') do Dec(i);
Result := Copy(s, 1, i);
end;

{Removes the leading spaces from a string.}

function TrimLeft(const S: string): string;
var
I, L: Integer;
begin
L := Length(S);
I := 1;
 while (I <= L) and (S[I] <= ' ') do Inc(I);
Result := Copy(S, I, Maxint);
end;

{ Removes leading and trailing whitespace from s);

function Trim(const S: string): string;
var
I, L: Integer;
begin
L := Length(S);
I := 1;
while (I <= L) and (S[I] <= ' ') do Inc(I);
if I > L then Result := '' else
begin
while S[L] <= ' ' do Dec(L);
Result := Copy(S, I, L - I + 1);
end;
end;
 V. CONCLUSIONES VI. BIBLIOGRAFÍA

El desarrollo actual de software para Sistemas Operativos le

debe en gran medida su tamaño a Linux y la cantidad de
innovaciones que ha puesto sobre la mesa y sobre las que se
han construido estos sólidos cimientos. Una vez más
podemos observar la importancia de estandarizar procesos a
la hora de extender el empleo generalizado de tus
herramientas, y el estándar POSIX de la IEEE y el SUS de
la Open Group son dos grandes ejemplos de ello.
En la investigación que hemos llevado a cabo hemos
comprendido muchos de los procesos que se nos enseñaron
en la asignatura de Sistemas Operativos I, en los que a
primera vista la consola parecía algo del pasado, pero como
hemos podido comprobar el empleo que hace de las
herramientas disponibles en materia de APIs y ABIs es
importante, proporcionando no solo ejemplo para otros
sistemas, sino que la extensa documentación y la facilidad
para introducirse en este mundo ha facilitado que se pueda
llegar a comprender este tipo de conceptos abstractos de una
forma mucho mas accesible al público en general.
[1] Anónimo, «WIkipedia POSIX,» [En línea]. Available:
https://es.wikipedia.org/wiki/POSIX.
[2] C. Santilini, «stackexchange,» [En línea]. Available:
https://unix.stackexchange.com/questions/11983/what-
exactly-is-posix/220877.
[3] A. Josey, «opengroup,» [En línea]. Available:
https://www.opengroup.org/austin/papers/posix-
paper1.txt .
[4] R. Lerner, «Linux Journal,» [En línea]. Available:
https://www.linuxjournal.com/content/apis .
[5] Anónimo, «Kernel,» [En línea]. Available:
https://www.kernel.org/doc/htmldocs/kernel-api/ .
[6] Anónimo, «Wikipedia,» [En línea]. Available:
https://en.wikipedia.org/wiki/Linux_kernel_interfaces .
[7] R. Love, System Programming, O'Reilly.

Para terminar, nos gustaría recalcar las facilidades que

proporcionan las interfaces de programación. Pues la época
de programación en ensamblador y mucho menos en binario,
y las APIs, no solo de SO, sino de gran cantidad de software
actual en todos los ámbitos de la informática.
VII. ANEXOS