Llamadas al Sistema en Linux

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

Linux provee mas de 300 llamadas al sistema diferentes las que permiten al usuario que los procesos y el sistema operativo puedan comunicarse, transfiriendo el control al kernel. A continuación se ejemplificaran algunas de estas llamadas.

Contenido

Ejemplos

Código 1

Muestra la fecha y la hora actual por pantalla.

#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
void print_time () 
{
    struct timeval tv;
    struct tm* ptm;
    char time_string[40];
    /*Obtenemos la fecha y hora del día y la transformamos en un estructura tm.
      Para  conseguir  la  fecha  y  hora  actual, la llamada al sistema gettimeofday se encarga de obtenerlo 
      a través del kernel quien consulta a el RTC  (real time clock)  de  la  máquina.*/
    gettimeofday(&tv, NULL);
    ptm = localtime(&tv.tv_sec);
    /*Utilizando la estructura tm creamos un string con la informacion que deseamos*/
    strftime(time_string, sizeof(time_string),  "%d/%m/%Y %H:%M:%S" , ptm);
    printf( "%s\n" ,time_string);
}
int main() 
{
    print_time();
    return 0;
}

Código 2

Llamada al sistema read.

#include <unistd.h>
#include <stdio.h>

int main()
{
    char buf[32];
    int result;
    /*El valor 0 pasado como argumento a la función  read indica que lea de la entrada estándar (teclado o archivo).*/
    result = read(0,buf,sizeof(buf));
    printf("%d",result);
    return result;
}

Código 3

Muestra estadísticas del sistema respecto al uso de memoria y los procesos en ejecución.

#include <stdio.h>
#include <linux/kernel.h>
#include <linux/sys.h>
#include <sys/sysinfo.h>
int main ()
{
    const long minutos = 60;
    const long horas   = minutos * 60;
    const long dia    = horas * 24;
    const double megabyte = 1024 * 1024;
    struct sysinfo si;
    /* Obtenemos estadísticas del sistema */
    sysinfo(&si);
    /* Mostramos algunos valores interesantes contenidos en la estructura sysinfo. */
    printf("Tiempo que lleva el sist. en funcionamiento: %ld dia , %ld:%02ld:%02ld\n”,
        si.uptime/dia, 
        (si.uptime % dia) / horas,
        (si.uptime % horas) / minutos,
         si.uptime % minutos);
    printf("Memoria RAM total: %5.1f Mb\n" , si.totalram / megabyte);
    printf("Memoria RAM libre: %5.1f Mb\n" , si.freeram / megabyte);
    printf("Cantidad de procesos corriendo: %d\n" , si.procs);
    return 0;
}

Código 4

Chequear permisos de acceso a un archivo

#include <errno.h>
#include <stdio.h>
#include <unistd.h>

int main (int argc, char* argv[])
{
    /*El primer argumento se guarda en path*/
    char* path = argv[1];
    int rval;
    /* Chequear existencia del archivo.*/
    rval = access (path, F_OK);
    if (rval == 0) 
        printf ("%s existe\n", path);
    else {
        if (errno == ENOENT) 
            printf ("%s no existe\n", path);
        else if (errno == EACCES) 
            printf ("%s no es accesible\n", path);
        return 0;
    }
    /* Chequear permiso de lectura. */
    rval = access (path, R_OK);
    if (rval == 0)
        printf ("%s tiene permiso de lectura\n", path);
    else
        printf ("%s no tiene permiso de lectura (acceso denegado)\n", path);
    
    /* Chequear permiso de escritura. */
    rval = access (path, W_OK);
    if (rval == 0)
        printf ("%s tiene permiso de escritura\n", path);
    else if (errno == EACCES)
        printf ("%s no tiene permiso de escritura (acceso denegado)\n", path);
    else if (errno == EROFS)
        printf ("%s no tiene permiso de escritura (solo lectura)\n", path);
    return 0;
}

Código 5

Truncar archivos.

#include <stdio.h> 
int main(  ) 
{ 
       int ret; 
       /*Se truncara el archivo prueba.txt a 2 bites*/
       ret = truncate ("./prueba.txt", 2); 
       if (ret == -1) { 
               perror ("truncate"); 
               return -1; 
       } 
       return 0;
}

Código 6

Demostración de fork(), getpid(), sleep(), wait(), exit().

#include <unistd.h>     /* Constantes Simbolicas */
#include <sys/types.h>  
#include <errno.h>      /* Errors */
#include <stdio.h>      /* Input/Output */
#include <sys/wait.h>   /* Espera de terminacion de procesos */
#include <stdlib.h>   

int main()
{
   pid_t hijo; 	/* variable que almacena el Pid del hijo */
   int retval;     /* proceso del hijo: usuario proporciona codigo de retorn o*/
   int status;     /* proceso del padre: estado del termino del hijo */
     
   /* Creacion de un nuevo proceso */
   hijo = fork();
   
   if (hijo >= 0) /* fork realizado correctamente */
   {
       if (hijo == 0) /* fork() returna 0 al proceso hijo */
       {
           printf("HIJO: Soy el proceso hijo!\n");
           printf("HIJO: Este es mi PID: %d\n", getpid());
           printf("HIJO: El PID de mi padre es: %d\n", getppid());
           printf("HIJO: El valor del PID de mi hijo es: %d\n", hijo);
           printf("HIJO: Durmiendo por 3 segundos...\n");
           sleep(3); /* duerme por 3 segundos */
           printf("HIJO: Ingrese un valor de salida entre 0 y 255: ");
           scanf(" %d", &retval);
           printf("HIJO: Adios!\n");    
           exit(retval); /* el hijo termina con el codigo de retorno ingresado */
       }
       else /* fork() retorna el nuevo pid al proceso padre */
       {
           printf("PADRE: Soy el proceso padre!\n");
           printf("PADRE: Este es mi PID: %d\n", getpid());
           printf("PADRE: El valor del PID de mi hijo es: %d\n", hijo);
           printf("PADRE: Ahora esperare que mi hijo termine.\n");
           wait(&status); /* wait for child to exit, and store its status */
           printf("PADRE: El codigo de termino de mi hijo es: %d\n", WEXITSTATUS(status));
           printf("PADRE: Adios!\n");             
           exit(0);  /* Padre termino */       
       }
   }
   else /* fork returna -1 en error */
   {
       perror("fork"); /* muestra mensaje de error */
       exit(0); 
   }
}

Referencias

Enlaces Externos

Herramientas personales
Espacios de nombres
Variantes
Acciones
Navegación
Herramientas