<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="es">
		<id>https://1984.lsi.us.es/wiki-ssoo/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Juablafer</id>
		<title>Wiki de Sistemas Operativos - Contribuciones del usuario [es]</title>
		<link rel="self" type="application/atom+xml" href="https://1984.lsi.us.es/wiki-ssoo/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Juablafer"/>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php/Especial:Contribuciones/Juablafer"/>
		<updated>2026-05-07T11:21:51Z</updated>
		<subtitle>Contribuciones del usuario</subtitle>
		<generator>MediaWiki 1.29.0</generator>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estados_de_los_procesos&amp;diff=3359</id>
		<title>Estados de los procesos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estados_de_los_procesos&amp;diff=3359"/>
				<updated>2016-10-24T15:18:19Z</updated>
		
		<summary type="html">&lt;p&gt;Juablafer: /* Diagrama de Estados Ampliado */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= 3.2 Estados de los procesos =&lt;br /&gt;
&lt;br /&gt;
Todo proceso en un sistema operativo presenta un estado que indica la situación de la ejecución en que se encuentra. El número de posibles estados varía de un sistema operativo a otro.&lt;br /&gt;
&lt;br /&gt;
== Diagrama de estados simplificado ==&lt;br /&gt;
&lt;br /&gt;
Consideramos que todo proceso puede estar, como mínimo, en uno de los siguientes tres estados:&lt;br /&gt;
&lt;br /&gt;
* '''Activo''': el proceso está empleando la CPU, por tanto, está ejecutándose. Pueden haber tantos procesos activos como procesadores haya disponibles. Por tanto, si el sistema dispone de un único procesador, únicamente puede haber un proceso activo a la vez.&lt;br /&gt;
* '''Preparado''': el proceso no está ejecutándose pero es candidato a pasar a estado activo. Es el planificador el que, en base a un criterio de planificación, decide qué proceso selecciona de la lista de procesos preparados para pasar a estado activo.&lt;br /&gt;
* '''Bloqueado''': el proceso está pendiente de un evento externo que le ha hecho bloquear, tales como una operación de lectura/escritura, la espera de finalización de un proceso hijo, una señal o una operación sobre un semáforo. El dispositivo/hecho externo &amp;quot;avisa&amp;quot; al S.O. cuando ha terminado la acción que realizaba mediante una INTERRUPCIÓN, dejando el S.O. lo que está haciendo para atender a esta última. Tras esto, el S.O. comprueba cuales son los procesos que fueron bloqueados por ese evento externo, cambiándolos al estado de preparado.&lt;br /&gt;
&lt;br /&gt;
La transición de activo a preparado y viceversa depende de decisiones tomadas por el '''planificador del sistema operativo''' en base a un cierto criterio. La transición de activo a bloqueado, y de bloqueado a preparado puede inducirlas el programador mediante llamadas al sistema.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
                                            [[Archivo:SSOO2.jpg]] &lt;br /&gt;
&lt;br /&gt;
== Diagrama de Estados Ampliado ==&lt;br /&gt;
* '''En espera / Preparación''': Estado por el que pasan los procesos antes de pasar a estar preparados por primera vez. Los procesos, cuando comienzan a existir, no están preparados para comenzar a ejecutar instrucciones hasta que el sistema no ha llevado a cabo una serie de actividades. Una vez que el proceso está completamente cargado, ya se puede producir la primera transición al estado preparado. &lt;br /&gt;
* '''Terminado''': La transición de activo a este estado ocurre cuando el proceso realiza una llamada al sistema solicitando su propia terminación. En estas circunstancias, hay estructuras de datos correspondientes al proceso que no pueden ser liberadas hasta que el proceso padre del que está terminando recoja el código de terminación del mismo. Hasta que esto ocurra, estas estructuras se mantendrán y el proceso seguirá existiendo en estado terminado. &lt;br /&gt;
* '''Transición''': cuando la operación que mantiene a un proceso en estado bloqueado termina, el proceso puede haber perdido parte de los recursos que necesita para proseguir su ejecución. Este es por ejemplo el caso de un sistema con memoria virtual, en el que parte de las páginas de memoria del proceso han sido descargadas a disco. En dicho caso, el proceso tendría que pasar por un estado intermedio transición mientras recupera dichos recursos, y una vez que todos sus recursos vuelven a estar disponibles, volvería al estado preparado.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
[[Archivo:SSOOProc.jpg]]&lt;br /&gt;
&lt;br /&gt;
Hay tres posibles situaciones en las que se ejecutará el planificador del sistema operativo:&lt;br /&gt;
* El proceso que se encuentra en el estado activo hace una llamada al sistema que, por su naturaleza, resulta en una transición al estado bloqueado. Este es el caso de las llamadas read(), write(), wait(), pause(), entre muchas otras. Al pasar a estado bloqueado, se invoca al planificador para que decida que otro proceso se asignará al procesador.&lt;br /&gt;
* Si el proceso que se encuentra en el estado activo excede el tiempo máximo de asignación, en caso de que lo hubiere.&lt;br /&gt;
* Si el proceso que hasta ese momento se encontraba en estado activo termina de ejecutar su código.&lt;br /&gt;
&lt;br /&gt;
Además, algunos sistemas operativos disponen de un estado terminado en el que los procesos pasan antes de terminar su ejecución.&lt;br /&gt;
&lt;br /&gt;
En el caso del núcleo de Linux, existen tres tipos de estados bloqueado y dos estados terminado: http://www.ibm.com/developerworks/linux/library/l-task-killable/&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
4.3.[[Planificador de procesos| El planificador de procesos]]&lt;/div&gt;</summary>
		<author><name>Juablafer</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Llamadas_al_sistema&amp;diff=3312</id>
		<title>Llamadas al sistema</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Llamadas_al_sistema&amp;diff=3312"/>
				<updated>2016-09-27T11:38:23Z</updated>
		
		<summary type="html">&lt;p&gt;Juablafer: /* Implementación de llamadas al sistema */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= 2.7. Llamadas al sistema =&lt;br /&gt;
&lt;br /&gt;
== Definición de llamada al sistema ==&lt;br /&gt;
&lt;br /&gt;
Una llamada al sistema es un método o función que puede invocar un proceso para solicitar un cierto servicio al sistema operativo. Dado que el acceso a ciertos recursos del sistema requieren la ejecución de código en modo privilegiado, el sistema operativo ofrece un conjunto de métodos o funciones que el programa puede emplear para acceder a dichos recursos. En otras palabras, el sistema operativo actúa como intermediario, ofreciendo una interfaz de programación (API) que el programa puede usar en cualquier momento para solicitar recursos gestionados por el sistema operativo.&lt;br /&gt;
&lt;br /&gt;
Algunos ejemplos de llamadas al sistema son las siguientes:&lt;br /&gt;
&lt;br /&gt;
* '''time''', que permite obtener la fecha y hora del sistema.&lt;br /&gt;
* '''write''', que se emplea para escribir un dato en un cierto dispositivo de salida, tales como una pantalla o un disco magnético.&lt;br /&gt;
* '''read''', que es usada para leer de un dispositivo de entrada, tales como un teclado o un disco magnético.&lt;br /&gt;
* '''open''', que es usada para obtener un descriptor de un fichero del sistema, ese fichero suele pasarse a write.&lt;br /&gt;
&lt;br /&gt;
Todo sistema operativo ofrece un conjunto de llamadas al sistema. En el caso de Linux 3.0, se ofrecen un total de 345 llamadas al sistema.&lt;br /&gt;
&lt;br /&gt;
Toda llamada al sistema se identifica de manera unívoca mediante un valor numérico que no debe ser modificado a lo largo de la vida del sistema operativo para evitar que se rompa la compatibilidad hacia atrás.&lt;br /&gt;
&lt;br /&gt;
El siguiente ejemplo muestra en un ejemplo en C la invocación de las llamadas al sistema '''time''' y '''write'''.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#include &amp;lt;stdio.h&amp;gt;&lt;br /&gt;
#include &amp;lt;time.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
int main(void)&lt;br /&gt;
{&lt;br /&gt;
      uint64_t segundos;&lt;br /&gt;
&lt;br /&gt;
      segundos = time(NULL);&lt;br /&gt;
      write(stdout, &amp;quot;Segundos desde 1970: %d&amp;quot;, segundos);1&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Familias de llamadas al sistemas operativo: POSIX y WIN32/64 ===&lt;br /&gt;
&lt;br /&gt;
Las dos familias de APIs estandarizas más importantes son:&lt;br /&gt;
&lt;br /&gt;
* [http://es.wikipedia.org/wiki/POSIX POSIX].&lt;br /&gt;
* WIN32/64, empleada en los sistemas operativos de tipo-Windows. Además, existen emuladores como '''Wine''' que también las implementan.&lt;br /&gt;
&lt;br /&gt;
== Implementación de llamadas al sistema ==&lt;br /&gt;
&lt;br /&gt;
El siguiente ejemplo muestra el código en ensamblador de x86 para invocar a la llamada al sistema '''write''' que permite escribir un dato en cualquier dispositivo. En concreto, se va a escribir una cadena por el dispositivo de salida '''pantalla''', que se identifica mediante el descriptor de fichero número 1.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;asm&amp;quot;&amp;gt;&lt;br /&gt;
section .text&lt;br /&gt;
    global _start&lt;br /&gt;
_start:&lt;br /&gt;
    mov eax, 4         ;cargamos el número de la llamada al sistema en el regitro eax&lt;br /&gt;
    mov ebx, 1         ;cargamos el descriptor de fichero sobre el que queremos escribir&lt;br /&gt;
    mov ecx, string    ;cargamos en ecx la dirección de la cadena a imprimir&lt;br /&gt;
    mov edx, lenght    ;cargamos en edx el tamaño de la cadena a imprimir&lt;br /&gt;
    int 80h            ;se invoca al de&lt;br /&gt;
&lt;br /&gt;
    mov eax, 1&lt;br /&gt;
    mov ebx, 0&lt;br /&gt;
    int 80h&lt;br /&gt;
&lt;br /&gt;
section .data&lt;br /&gt;
    string: db &amp;quot;Hola Mundo&amp;quot;, 0x0A&lt;br /&gt;
    lenght: equ 13&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
La instrucción ''int'' forma parte del conjunto de instrucciones de procesadores x86. Esta instrucción emite una [[Gestión_de_Entrada/Salida|interrupción]] por software cuyo tratamiento es realizado por la rutina ''dispatcher''. Dicha rutina se encarga del tratamiento de la interrupción por software número 80.&lt;br /&gt;
&lt;br /&gt;
'''Ejemplo de llamadas al sistema de Linux (64 bits):''' http://blog.rchapman.org/posts/Linux_System_Call_Table_for_x86_64/&lt;br /&gt;
&lt;br /&gt;
== El ''dispatcher'' ==&lt;br /&gt;
&lt;br /&gt;
El dispatcher, que forma parte del SO, se ejecuta cuando se invoca una llamada al sistema. &lt;br /&gt;
Cuando un proceso hace una llamada al sistema, el dispatcher, se encarga de invocar la llamada que el proceso ha solicitado.&lt;br /&gt;
 &lt;br /&gt;
Tiene un comportamiento sincronizado, cuando recibe una llamada y se la pasa al sistema operativo hasta que no recibe respuesta no atiende otra llamada. &lt;br /&gt;
&lt;br /&gt;
En el caso de x86, el dispatcher consulta el registro eax e invoca a la llamada al sistema identificada con dicha numeración.&lt;br /&gt;
&lt;br /&gt;
== El punto de entrada == &lt;br /&gt;
&lt;br /&gt;
Es la posición de memoria desde la cual es posible solicitarle servicios al sistema operativo. Normalmente hay un único punto de entrada.&lt;br /&gt;
En algunos SO se realiza mediante llamadas a subprogramas. La dirección de memoria del punto de entrada puede cambiar si se modifica el SO. En algunos SO éste problema lo solucionan usando una dirección fija, mientras en otros han preferido usar una referencia a dicha dirección.&lt;br /&gt;
&lt;br /&gt;
Lo ideal es que sean compatibles a lo largo del tiempo (aunque Windows normalmente no lo respeta).&lt;/div&gt;</summary>
		<author><name>Juablafer</name></author>	</entry>

	</feed>