clone

CLONE(2)                 Manual del Programador de Linux                CLONE(2)



NOMBRE
       clone - crea un proceso hijo

SINOPSIS
       #include <sched.h>

       int clone(int (*fn)(void *), void *child_stack, int flags, void *arg);

       _syscall2(int, clone, int, flags, void *, child_stack)


DESCRIPCIÓN
       clone crea un nuevo proceso como lo hace fork(2).  clone es una función
       de biblioteca situada encima de la llamada al sistema subyacente clone ,
       de aquí en adelante referida como sys_clone.  Una descripción de
       sys_clone se da hacia el final de esta página.

       A diferencia de fork(2), estas llamadas permiten al proceso hijo
       compartir partes de su contexto de ejecución con el proceso invocador,
       tales como el espacio de memoria, la tabla de descriptores de fichero y
       la tabla de manejadores de señal.  (Observe que en esta página de manual,
       "proceso invocador" normalmente se corresponde con "proceso padre". Vea
       la descripción de CLONE_PARENT más abajo.)

       El principal uso de clone es para implementar los hilos: múltiples hilos
       de control en un programa que se ejecutan concurrentemente en un espacio
       de memoria compartido.

       Cuando se crea el proceso hijo con clone, éste ejecuta la función
       fn(arg).  (Eso difiere de fork(2), en donde la ejecución continúa en el
       hijo desde el punto en el que se encuentra la llamada fork(2) El
       argumento fn es un puntero a una función que es ejecutada por el proceso
       hijo al comienzo de su ejecución.  El argumento arg se pasa a la función
       fn.

       Cuando la función fn(arg) regresa, el proceso hijo termina. El entero
       devuelto por fn es el código de salida del proceso hijo. El proceso hijo
       también puede terminar explícitamente ejecutando exit(2) o después de
       recibir una señal fatal.

       El argumento child_stack indica la posición de la pila utilizada por el
       proceso hijo. Puesto que los procesos hijo e invocador pueden compartir
       la memoria, no es posible, en general, para el proceso hijo ejecutarse
       usando la misma pila que el proceso invocador. Por tanto, el proceso
       invocador debe preparar un área de memoria para la pila del hijo y pasar
       un puntero a dicha área a clone.  Las pilas crecen hacia abajo en todos
       los procesadores en los que se ejecuta Linux (excepto en el procesador HP
       PA), por lo que child_stack apunta normalmente a la dirección más alta de
       la zona de memoria preparada para la pila del hijo.

       El byte bajo de flags contiene el número de la señal enviada al padre
       cuando el hijo muere.  Si la señal especificada es cualquiera distinta de
       SIGCHLD, el proceso padre debe especificar las opciones __WALL o __WCLONE
       cuando espera al hijo con wait(2).  Si no se indica ninguna señal, el
       proceso padre no es notificado cuando el hijo termina.

       flags puede también ser operado con un OR a nivel de bits (bitwise or)
       con una o varias de las siguientes constantes, para así especificar qué
       van a compartir los procesos invocador e hijo:


       CLONE_PARENT
              (Linux 2.4 en adelante) Si CLONE_PARENT está presente, el padre
              del nuevo hijo (valor devuelto por getppid(2)) será el mismo que
              el del proceso invocador.

              Si CLONE_PARENT no está presente, (al igual que ocurre con
              fork(2)) el padre del hijo es el proceso invocador.

              Observe que es el proceso padre, tal como informa getppid(2), el
              que es notificado cuando el hijo termina, así que si se especifica
              la opción CLONE_PARENT , será notificado el padre del proceso
              invocador, en lugar del propio proceso invocador.


       CLONE_FS
              Si se pone CLONE_FS, los procesos invocador e hijo comparten la
              misma información del sistema de ficheros. Ésta incluye la raíz
              del sistema de ficheros, el directorio de trabajo actual y el
              valor de umask. Cualquier llamada a chroot(2), chdir(2) o umask(2)
              realizada por el proceso invocador o hijo también afecta al otro
              proceso.

              Si no se pone CLONE_FS, el proceso hijo trabaja con una copia de
              la información del sistema de ficheros del proceso invocador en el
              momento de ejecutar la llamada clone.  Las llamadas a chroot(2),
              chdir(2) o umask(2) realizadas después por uno de los procesos no
              afectan al otro.


       CLONE_FILES
              Si se pone CLONE_FILES, los procesos invocador e hijo comparten la
              misma tabla de descriptores de fichero. Los descriptores de
              fichero siempre se refieren a los mismos ficheros en el invocador
              y en el proceso hijo. Cualquier descriptor de fichero creado por
              el proceso invocador o por el proceso hijo también es válido en el
              otro proceso. De igual forma, si uno de los procesos cierra un
              descriptor de fichero o cambia sus banderas (flags) asociadas, el
              otro proceso también se verá afectado.

              Si no se pone CLONE_FILES, el proceso hijo hereda una copia de
              todos los descriptores de fichero abiertos en el proceso invocador
              en el momento de ejecutar clone.  Las operaciones sobre los
              descriptores de fichero realizadas después por uno de los procesos
              invocador o hijo no afectan al otro.


       CLONE_NEWNS
              (Linux 2.4.19 en adelante) Comienza el hijo en un nuevo espacio de
              nombres.

              Cada proceso vive en un espacio de nombres. El espacio de nombres
              de un proceso viene dado por los datos (el conjunto de montajes)
              que describen la jerarquía de ficheros tal como la ve ese proceso.
              Después de una llamada a fork(2) o clone(2) con la bandera
              CLONE_NEWNS desactivada, el hijo vive en el mismo espacio de
              nombres que el padre.  Las llamadas al sistema mount(2) y
              umount(2) cambian el espacio de nombres del proceso invocador, y
              por tanto afectan a todos los procesos que viven en el mismo
              espacio de nombres, pero no a los que están en un espacio de
              nombres diferente.

              Tras una llamada a clone(2) con la bandera CLONE_NEWNS activada,
              el hijo clonado comienza su ejecución en un nuevo espacio de
              nombres, inicializado con una copia del espacio de nombres del
              padre.

              Solamente un proceso privilegiado puede indicar la bandera
              CLONE_NEWNS.  No está permitido especificar CLONE_NEWNS y CLONE_FS
              en la misma llamada a clone.


       CLONE_SIGHAND
              Si se pone CLONE_SIGHAND, los procesos invocador e hijo comparten
              la misma tabla de manejadores de señal.  Si el proceso invocador o
              hijo llama a sigaction(2) para cambiar el comportamiento asociado
              a una señal, el comportamiento también se cambia en el otro
              proceso. Sin embargo, los procesos invocador e hijo todavía tienen
              diferentes máscaras de señales y conjuntos de señales pendientes.
              Por tanto, uno de ellos puede bloquear o desbloquear algunas
              señales usando sigprocmask(2) sin afectar al otro proceso.

              Si no se pone CLONE_SIGHAND, el proceso hijo hereda una copia de
              los manejadores de señal del proceso invocador en el momento de
              ejecutar clone.  Las llamadas a sigaction(2) realizadas después
              por uno de los procesos no tendrán efecto sobre el otro proceso.


       CLONE_PTRACE
              Si se especifica la opción CLONE_PTRACE , y el proceso invocador
              está siendo rastreado, también se rastrea al hijo (vea ptrace(2)).


       CLONE_VFORK
              Si la opción CLONE_VFORK está presente, la ejecución del proceso
              invocador se suspende hasta que el hijo libere sus recursos de
              memoria virtual mediante una llamada a execve(2) o _exit(2) (al
              igual que con vfork(2)).

              Si CLONE_VFORK no está presente tanto el proceso invocador como el
              hijo son planificables tras la llamada, y una aplicación no
              debería confiar en que se ejecuten en un determinado orden.


       CLONE_VM
              Si CLONE_VM está presente, el proceso invocador y el proceso hijo
              se ejecutan en el mismo espacio de memoria. En particular, las
              escrituras en memoria realizadas por el proceso invocador o el
              hijo son visibles también en el otro proceso.  Además, cualquier
              ubicación o eliminación de memoria realizada con mmap(2) o
              munmap(2) por el proceso hijo o invocador también afecta al otro
              proceso.

              Si CLONE_VM no está presente, el proceso hijo se ejecuta en una
              copia separada del espacio de memoria del proceso invocador en el
              momento de la llamada a clone.  Las escrituras en memoria o las
              ubicaciones/eliminaciones de ficheros realizadas por uno de los
              procesos no afecta al otro, al igual que con fork(2).


       CLONE_PID
              Si se pone CLONE_PID, se crea el proceso hijo con el mismo
              identificador de proceso que el proceso invocador.

              Si no se pone CLONE_PID, el proceso hijo posee un identificador de
              proceso único, distinto del identificador del invocador.

              Esta bandera sólo puede ser especificada por el proceso de
              arranque del sistema (PID 0).


       CLONE_THREAD
              (Linux 2.4 en adelante) Si CLONE_THREAD está presente, el proceso
              hijo se pone en el mismo grupo de hilos que el proceso invocador.

              Si CLONE_THREAD no está presente, el proceso hijo se pone en su
              propio (nuevo) grupo de hilos, cuyo identificador es el mismo que
              el identificador de proceso.

              (Los grupos de hilos son una característica añadida en Linux 2.4
              para soportar la noción de un conjunto de hilos compartiendo un
              solo PID impuesta por los hilos POSIX. En Linux 2.4, las llamadas
              a getpid(2) devuelven el identificador de grupo de hilos del
              invocador.)


       La llamada al sistema sys_clone se corresponde más estrechamente con
       fork(2) en el hecho de que la ejecución en el proceso hijo continúa desde
       el punto de la llamada. Así, sys_clone solamente requiere los argumentos
       flags y child_stack , que tienen el mismo significado que para clone.
       (Observe que el orden de estos argumentos difiere de clone.)

       Otra diferencia de sys_clone es que el argumento child_stack puede ser
       cero, en cuyo caso la semántica de copia-en-escritura (copy-on-write)
       asegura que el proceso hijo obtendrá copias de las páginas de pila cuando
       cualquiera de los dos procesos modifique la pila. En este caso, para una
       operación correcta, debería especificarse la opción CLONE_VM.


VALOR DEVUELTO
       En caso de éxito, se devuelve el PID del hijo en el hilo de ejecución del
       invocador. En caso de fallo, se devuelve -1 en el contexto del invocador,
       no se creará ningún proceso hijo y se asignará a la variable errno un
       valor apropiado.

ERRORES
       EAGAIN Se están ejecutando ya demasiados procesos.

       ENOMEM __clone no puede reservar suficiente memoria para obtener una
              estructura de tarea (task structure) para el hijo o para copiar
              aquellas partes del contexto del padre que necesitan ser copiadas.

       EINVAL Devuelto por clone cuando se especifica un valor cero para
              child_stack.

       EINVAL Se especificaron ambas opciones CLONE_FS y CLONE_NEWNS en flags.

       EINVAL Se especificó CLONE_THREAD , pero no CLONE_SIGHAND.  (Desde Linux
              2.5.35.)

       EPERM  Se especificó CLONE_PID por un proceso cuyo PID es distinto de
              cero.


FALLOS
       Desde la versión 2.1.97 del núcleo, no se debe usar la bandera CLONE_PID
       ya que otras partes del núcleo y la mayoría del software del sistema
       todavía asumen que los identificadores de proceso son únicos.

       No hay una entrada para clone en la versión 5 de libc. libc 6 (o sea,
       glibc 2) proporciona una llamada clone tal como la que se ha descrito en
       esta página de manual.


OBSERVACIONES
       Para las versiones del núcleo 2.4.7-2.4.18 la bandera CLONE_THREAD
       implica la bandera CLONE_PARENT.


CONFORME A
       Las llamadas clone y sys_clone son específicas de Linux y no deberían
       usarse en aquellos programas que pretendan se portables. Para programar
       aplicaciones con hilos (múltiples hilos de control en el mismo espacio de
       memoria) es mejor usar una biblioteca que implemente la API de hilos
       POSIX 1003.1c, como la biblioteca LinuxThreads (incluida en glibc2). Vea
       pthread_create(3).

       Esta página de manual se corresponde con los núcleos 2.0.x, 2.1.x, 2.2.x,
       2.4.x, y con las versiones 2.0.x y 2.1.x de glibc.


VÉASE TAMBIÉN
       fork(2), wait(2), pthread_create(3)



Linux 2.4                       31 diciembre 2001                       CLONE(2)