Espacio de tecnologia, software libre y sus derivados. Una horda de monos entrenados escriben de vez en cuando por aqui algunas noticias, opiniones e incluso alguna que otra cosa fuera del tema. Maqueros, favor de abstenerse que no somos lo suficientemente guapos.
November 16, 2009 a las 5:44 pm por Edwin Plauchu · Archivado en FreeBSD
La organizacion del kernel de FreeBSD puede ser vista como un proveedor de servicios a los procesos de los usuarios. Procesos usualmente accesaran a esos servicios mediante las llamadas al sistema (system calls). Algunos servicios, tales como planeacion y administracion de memoria, son implementados como procesos que se ejecutaran en modo kernel o como subrutinas que se ejecutan periodicamente dentro del kernel.
Existen procesos de kernel, y ellos funcionan enteramente dentro del kernel. (Los procesos de kernel executan codigo que es compilado dentro de la imagen cargada y opera con el modo de ejecucion privilegiada del kernel).
Nombre del Proceso
Funcion
idle
Corre cuando no hay mas nada por hacer
swapper
Programa la carga de procesos proveenientes de la memoria secundaria hacia en memoria principal, cuando los recursos del sistema empiezan a estar disponibles
vmdaemon
Programa la transferencia de procesos enteros hacia la memoria secundaria, cuando los recursos del sistema son bajos
ramdon
Colecta datos para la produccion de semillas aleatorias para el kernel y el dispositivo /dev/ramdon
vnrlu
Mantiene una fuente de vnodes libres, esto lo logra limpiando los vnodes cuya fecha de uso fue la menos reciente
pagedaemon
Escribe partes de el espacio de direcciones de un proceso hacia un sistema de almacenamiento secundario, a razon de soportar las facilidades de paginacion , de un sistema de memoria virtual.
ktrace
Escribe los registros de seguimiento a las llamadas al sistema (system calls) a sus archivos de salida.
bufdaemon
Mantiene un suministro de buffers limpios, producto de buffers sucios cuando el suministro de buffers limpios esta abajo del nivel optimo.
syncer
Asegura que los datos de archivo sucio estan escritos despues de 30 segundos.
pagezero
Mantiene un suministro de paginas Cero.
g_up
Toma los datos que van llegando de los dispositivos manejadores y los entrega a los procesos.
g_down
Toma los datos que van llegando de los procesos y los entrega a los dispositivos manejadores.
g_event
Toma tareas de configuracion, inclullendo en esto el descubrimiento de nuevos dispositivos y la remocion de estos cuando ellos ya han desaparecido.
Despues de que los procesos de kernel son creados, el kernel crea el primer proceso a ejecuta en modo usuario. Este sirve como el proceso padre para todos los subsecuentes procesos. El primer proceso en modo usuario es el programa init. Este metodo realizara tareas administrativas, tales como ejecutar procesos getty para cada terminal sobre la maquina, etc. El proceso init es un proceso de modo usuario y corre fuera del kernel.
November 11, 2009 a las 1:00 pm por Edwin Plauchu · Archivado en FreeBSD
# cd /usr/ports/databases/mysql51-server
# make && make install
Agregar al fichero /etc/rc.conf lo siguiente para que mysql server arranque junto con el sistema operativo
# echo ‘mysql_enable=”YES”’ >> /etc/rc.conf
Ahora reinicie el equipo
# reboot
MySQL ya se encuentra instalado.. ahora creamos una base de datos llamada uno… asignada al usuario user con el password “password”…. Esta sera accesible desde cualquier direccion ip… gracias al comodin %
mysql> create database uno;
mysql> grant all on uno.* to user@’%’ identified by “password”;
August 13, 2009 a las 4:25 pm por Edwin Plauchu · Archivado en Programacion, FreeBSD
Se pueden tener apuntadores a cualquier tipo de variable.
Para entender perfectamente este desmadre de los apuntadores… aprendete estas reglas magicas:
1.- Un apuntador es una variable que contiene la dirección en memoria de otra variable.
main()
{
int x = 1;
int *ap; //Apuntador que permite
//ser usado con variables enteras
ap = &x; //Se le asigna la direccion
//de memoria que alverga el valor 1
printf("Direccion de el apuntador ap:%x",ap);
}
La consola termina imprimiendonos esto: Imprime la direccion de el apuntador ap:bf9ed410
2.- Un apuntador puede ser desreferenciado, para accesar a el valor que contiene (a esto se le llama acceso indirecto) esto se logra agregando el * al identificador del apuntador:
main()
{
int x = 1;
int *ap; //Apuntador que permite
//ser usado con variables enteras
ap = &x; //La direccion de memoria de x
//se asigna a la direccion de
// memoria que alberga el apunt
// ador ap
printf("Valor de el apuntador ap:%d",*ap);
}
La consola termina imprimiendonos esto: Valor de el apuntador ap :1
3.- C no es muy estricto en la asignación de valores de diferente tipo (entero a apuntador - apuntador a entero). Así que es perfectamente legal (aunque el compilador genera un aviso de cuidado).
main()
{
int x;
int y;
int *ap;
y = 3;
ap = y; //Ahora se apunta
// a la localidad de
// memoria 3
x = ap; //Aqui x recibe el valor
//3
printf("Localidad de memoria:%d",x);
}
La consola termina imprimiendonos esto: Localidad de memoria x :3
4.- No se puede usar un apuntador, si no esta este previamente inicializado
Por lo que:
main()
{
int *ap;
*ap = 100;
}
puede generar un error en tiempo de ejecución o presentar un comportamiento errático.
El uso correcto será:
main()
{
int *ap;
int x;
ap = &x;
*ap = 100;
}
5.- En los apuntadores a estructuras: Se usa la notación p->member
main()
{
typedef struct {
char member_1;
int member_2;
} s_type;
s_type x={'U',2}, *p = &x;
p->member_1 = 'R'; // Equivale a (*p).member_1 = 'R';
//Observece como sacamos el contenido de uno de
// los elementos de la estructura de forma indirecta
printf("Caracter encontrado:%c",(*p).member_1);
}
Imprime en consola Caracter encontrado:R
Con estas reglas basica ahora podras comprender la fabulosa Aritmetica de punteros
Me pidieron un programita hecho en C residente en memoria. Un demonio pues!…
Aqui les dejo el codigo base del daemon unix tradicional.
El daemon lo hice para un IBM AIX 5.3 sobre arquitectura power pc.
Y poco despues lo compile en linux, y no hubo nada de problema.. codigo 2000% porciento guapo y portable.
/**********************************
* UNIX Daemon Server Programming *
* Written by Edwin Plauchu *
* mailto:pianodaemon@gmail.com *
**********************************/
#include stdio.h
#include stdlib.h
#include fcntl.h
#include signal.h
#include unistd.h
#include string.h
#define RUNNING_DIR "/tmp"
#define LOCK_FILE "cacherd.lock"
#define LOG_FILE "cacherd.log"
void log_message(filename,message)
char *filename;
char *message;
{
FILE *logfile;
logfile=fopen(filename,"a");
if(!logfile) return;
fprintf(logfile,"%sn",message);
fclose(logfile);
}
void signal_handler(sig)
int sig;
{
switch(sig) {
case SIGHUP:
log_message(LOG_FILE,"Senal de hangup cachada");
break;
case SIGTERM:
log_message(LOG_FILE,"Senal de Terminacion cachada");
exit(0);
break;
}
}
void daemonize(){
int i,lfp;
char str[10];
// Primero obtenemos el indentificador de Proceso
if( getppid() == 1 ) return;
// Ahora generamos un proceso hijo y obtenemos su PID
// mediante la variable i
i=fork();
// Comprobamos que el proceso hijo este lanzado de manera correcta
// Verificando los posibles ERRORES de lanzamiento
// En caso de existir un error de lanzamiento en el proceso hijo
// procedemos a la finalizacion del proceso padre
if (i<0) { exit(1); } // fork error, el proceso hijo no pudo ser creado
if (i>0) { exit(0); } /* Padre existe */
// Proceso hijo (Demonio) continua
setsid(); // Crea una sesión y define el ID de grupo del proceso
/* Cerrar todos los descriptores de archivo
OJO: Esto evita que el hijo use los mismos decriptores de fichero que el padre*/
for (i=getdtablesize();i>=0;–i) close(i);
i=open(”/dev/null”,O_RDWR); dup(i); dup(i); /* handle standart I/O */
umask(027); /* Establece los permisos que le seran dados a los nuevos archivos a crear */
chdir(RUNNING_DIR); /* Cambia el directorio de ejecucion */
/* Abre el archivo de bloqueo en modo lectura/escritura, pero
si el archivo no existiece, lo crea con el permiso 640 */
lfp=open(LOCK_FILE,O_RDWR|O_CREAT,0640);
if (lfp<0) { exit(1); } /* No puede ser abierto */
if (lockf(lfp,F_TLOCK,0)<0) exit(0); /* No puede ser bloqueado el fichero para este proceso*/
/* Primera instancia continua */
sprintf(str,"%dn",getpid());
// Escribimos el PID al fichero de bloqueo
write(lfp,str,strlen(str));
signal(SIGCHLD,SIG_IGN); /* Ignora hijo */
signal(SIGTSTP,SIG_IGN); /* Ignora Senales tty */
signal(SIGTTOU,SIG_IGN);
signal(SIGTTIN,SIG_IGN);
signal(SIGHUP,signal_handler); /* Cacha Senal hangup (kill -1 PID)*/
signal(SIGTERM,signal_handler); /* Cacha Senal de Terminacion (kill -15 PID)*/
}
int main(){ daemonize(); while(1) sleep(1); }
July 8, 2009 a las 9:27 am por Edwin Plauchu · Archivado en Microsoft, FreeBSD, Linux
Navegando hace unos instantes, encontré este “humor gráfico” en el cual podemos apreciar los distintos puntos de vista de los diferentes sistemas operativos, unos contra otros, como por ejemplo; como ve un “maquero” a un “linuxero” y viceversa. Espero que les guste.
