Convertir fichero .nrg a .iso

Para convertir un fichero .nrg al formato .iso en linux sin necesidad de ningún programa adicional tan solo hay que ejecutar el siguiente comando.

dd bs=1k if=imagen.nrg of=imagen.iso skip=300

La explicación, con este comando lo que hacemos es copiar el fichero quitando los primeros 300kB (skip indica el número de bloques que no queremos copiar y bs es el block size).

En realidad un fichero .nrg y uno .iso se diferencian simplemente en eso, nero añade esa cabecera con información propia.

Hay un programa que hace esta misma conversión en linux, nrg2iso.
Este programa está hecho en c, la conversión la realiza de esta manera.

fseek (nrgFile, 307200, SEEK_SET);

El resto del programa es básicamente una copia de ficheros, al igual que hace el comando dd, en este caso salta 307200 bytes, que en realidad corresponde a los 300kB mencionados arriba (300*1024).

Ficheros abiertos por un proceso

Para localizar los procesos que están usando un fichero en linux tenemos el comando fuser. En concreto ejecutando lo siguiente.

fuser -va fichero (fichero también puede ser un directorio).

fuser -km fichero (mata todos los procesos que acceden al fichero).

Una funcionalidad similar se puede obtener con lsof, además lsof también permite ver los sockets abiertos.

lsof fichero

Ejecutando simplemente lsof se muestran todos los fichero abiertos así que podemos filtrar mejor con grep.

lsof | grep fichero
lsof | grep UDP (sockets udp abiertos).

Hacer copia de seguridad del MBR

Si instalamos y reinstalamos frecuentemente distintos sistemas operativos en el mismo disco duro es frecuente perder el MBR (Master Boot Record).

Cuando ya tenemos un MBR que nos sirve y no lo queremos perder en ninguna reinstalación podemos hacer una copia de seguridad, para ello hay que ejecutar el siguiente comando.

dd if=/dev/sda of=/mbr.bak bs=512 count=1

Donde /dev/sda es el disco duro y /mbr.bak la copia de seguridad, para reestablecer la copia de seguridad tan solo hay que hacer.

dd if=/mbr.bak of=/dev/sda bs=512 count=1

El problema al hacerlo así es que también estamos sobreescribiendo la tabla de particiones, para no afectar a la tabla de particiones sobreescribiendo el gestor de arranque hay que escribir solo los primeros 446 bytes.

dd if=/dev/sda of=/mbr.bak bs=446 count=1
dd if=/mbr.bak of=/dev/sda bs=446 count=1

Matar procesos selectivamente en linux

Para terminar (matar) procesos en linux se suele usar la orden kill pid o killall programa pero hay otra forma de hacerlo más potente.

El comando en cuestión es pkill, dejo una guía rápida de las opciones que permite, siempre se pueden combinar varias.

pkill -u usuario mata todos los procesos de un usuario.

pkill patron mata todos los procesos en los que el patrón esté incluído en el nombre.

pkill -n patron mata al proceso más nuevo de los que coinciden con el patrón.

pkill -o patron mata al proceso más antiguo de los que coinciden con el patrón.

pkill -x patron mata los procesos en los que el nombre coincide exactamente con el patrón.

pkill -v -u usuario mata todos los procesos que no son del usuario (-v invierte el efecto de la acción).

Hay algunas opciones más, para verlas todas man pkill.

Número de argumentos variables en C

Para crear un método que acepte un número de argumentos variables en C hay que incluir la cabecera stdarg, una vez incluída podremos acceder a las macros va_start, va_arg y va_end.

va_start acepta como parámetro el último parámetro antes de la lista variable.
va_arg necesita el tipo del parámetro que hay que devolver.
va_end libera los recursos usados para la lectura de parámetros.

#include <stdio.h>
#include <stdarg.h>

int sumatorio(int howmany, ...){ 
 int i;
 int total = 0;
 va_list ap;

 va_start(ap, howmany);
 
 for (i=0; i<howmany; i++)
  total+=va_arg(ap, int);
 
 va_end(ap);

 return total;
}

int main(){
 printf("%d\n", sumatorio(4, 1,2,3,4));
}

Comprobaciones numéricas en C

Es conocido que C es un lenguaje muy potente pero a muy bajo nivel, esto tiene algunas consecuencias al trabajar con valores numéricos que con otros lenguajes ni nos plantearíamos.

En primer lugar, ¿qué devuelven las funciones matemáticas en caso de que no exista un resultado a su operación?

Hay algunas funciones matemáticas como la raíz cuadrada y el logaritmo que no siempre tienen solución, en estos casos se devuelve nan (Not A Number) y se puede comprobar con la función isnan.

Otra situación posible es llegar a un valor infinito, ¿qué ocurre entonces? pues se devuelve inf y se puede comprobar con isinf.

Aquí un ejemplo de como se puede llegar a estas situaciones, para compilar gcc prog.c -o prog -lm.

#include <stdio.h>
#include <math.h>

int main(){
 float dividendo=999999999;
 float divisor=0.000000000000000000000000000000001;
 float num=dividendo/divisor;

 if(isinf(num)) printf("Infinito\n");
 printf("%f\n",num);

 num=sqrt(-num);
 if(isnan(num)) printf("Not a number\n");

 printf("%f\n",num);
}

Threads en ruby

El manejo de threads en ruby es muy sencillo, la creación de threads se basa en pasar un bloque a la creación de un objeto de la clase thread.

#!/usr/bin/ruby

t1 = Thread.new do
 10.times do
  puts "hello from thread 1"
  sleep(0.2)
 end
end

t2 = Thread.new do 
 10.times do
  puts "hello from thread 2"
  sleep(0.2)
 end
end

t1.join
t2.join

Para pasar parámetros se hace de la siguiente forma.

#!/usr/bin/ruby

t1 = Thread.new(1) do |id|
 10.times do
  puts "hello from thread #{id}"
  sleep(0.2)
 end
end

t2 = Thread.new(2) do |id|
 10.times do
  puts "hello from thread #{id}"
  sleep(0.2)
 end
end

t1.join
t2.join

Para controlar las secciones criticas tan solo hay que cambiar la variable de clase critical a true.

#!/usr/bin/ruby

counter = 0;

t1 = Thread.new do
 100000.times do
  Thread.critical = true
  counter += 1
  Thread.critical = false 
 end
end

t2 = Thread.new do
 100000.times do
  Thread.critical = true
  counter -= 1
  Thread.critical = false
 end
end

t1.join
t2.join

puts counter

Se pueden consultar los demás métodos de la clase Thread en la documentación oficial.