/*I'd suggest people also take a look at the (beta) pthreads library that 
somebody wrote on top of clone() (the announcement is probably still in 
comp.os.linux.announce if you have a reasonable news spool). That is 
probably actually useful, unlike my minimal example.

		Linus

----*/
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>

#include <linux/unistd.h>

#define STACKSIZE 16384

#define CSIGNAL         0x000000ff      /* signal mask to be sent at exit */
#define CLONE_VM        0x00000100      /* set if VM shared between processes */
#define CLONE_FS        0x00000200      /* set if fs info shared between processes */
#define CLONE_FILES     0x00000400      /* set if open files shared between processes */
#define CLONE_SIGHAND   0x00000800      /* set if signal handlers shared */

int start_thread(void (*fn)(void *), void *data)
{
	long retval;
	void **newstack;

	/*
	 * allocate new stack for subthread
	 */
	newstack = (void **) malloc(STACKSIZE);
	if (!newstack)
		return -1;

	/*
	 * Set up the stack for child function, put the (void *)
	 * argument on the stack.
	 */
	newstack = (void **) (STACKSIZE + (char *) newstack);
	*--newstack = data;

	/*
	 * Do clone() system call. We need to do the low-level stuff
	 * entirely in assembly as we're returning with a different
	 * stack in the child process and we couldn't otherwise guarantee
	 * that the program doesn't use the old stack incorrectly.
	 *
	 * Parameters to clone() system call:
	 *	%eax - __NR_clone, clone system call number
	 *	%ebx - clone_flags, bitmap of cloned data
	 *	%ecx - new stack pointer for cloned child
	 *
	 * In this example %ebx is CLONE_VM | CLONE_FS | CLONE_FILES |
	 * CLONE_SIGHAND which shares as much as possible between parent
	 * and child. (We or in the signal to be sent on child termination
	 * into clone_flags: SIGCHLD makes the cloned process work like
	 * a "normal" unix child process)
	 *
	 * The clone() system call returns (in %eax) the pid of the newly
	 * cloned process to the parent, and 0 to the cloned process. If
	 * an error occurs, the return value will be the negative errno.
	 *
	 * In the child process, we will do a "jsr" to the requested function
	 * and then do a "exit()" system call which will terminate the child.
	 */
	__asm__ __volatile__(
		"int $0x80\n\t"		/* Linux/i386 system call */
		"testl %0,%0\n\t"	/* check return value */
		"jne 1f\n\t"		/* jump if parent */
		"call *%3\n\t"		/* start subthread function */
		"movl %2,%0\n\t"
		"int $0x80\n"		/* exit system call: exit subthread */
		"1:\t"
		:"=a" (retval)
		:"0" (__NR_clone),"i" (__NR_exit),
		 "r" (fn),
		 "b" (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | SIGCHLD),
		 "c" (newstack));

	if (retval < 0) {
		errno = -retval;
		retval = -1;
	}
	return retval;
}

int show_same_vm;

void cloned_process_starts_here(void * data)
{
	printf("child:\t got argument %d as fd\n", (int) data);
	show_same_vm = 5;
	printf("child:\t vm = %d\n", show_same_vm);
	close((int) data);
}

int main()
{
	int fd, pid;

	fd = open("/dev/null", O_RDWR);
	if (fd < 0) {
		perror("/dev/null");
		exit(1);
	}
	printf("mother:\t fd = %d\n", fd);

	show_same_vm = 10;
	printf("mother:\t vm = %d\n", show_same_vm);

	pid = start_thread(cloned_process_starts_here, (void *) fd);
	if (pid < 0) {
		perror("start_thread");
		exit(1);
	}

	sleep(1);
	printf("mother:\t vm = %d\n", show_same_vm);
	if (write(fd, "c", 1) < 0)
		printf("mother:\t child closed our file descriptor\n");
}