Kernel

Kernel APP

	kernel.erl

	kernel_config.erl

	kernel.appup.src

	kernel.app.src

application管理

	application_controller.erl

	application_starter.erl

	application_master.hrl

	application_master.erl

	application.erl

	heart.erl

HIPE

	hipe_ext_format.hrl

	hipe_unified_loader.erl

调试& 日志

	日志

		disk_log.erl

		disk_log_sup.erl

		disk_log_server.erl

		disk_log_1.erl

		disk_log.hrl

		error_logger.erl

		wrap_log_reader.erl

	调试

		error_handler.erl

		erts_debug.erl

		standard_error.erl

		seq_trace.erl

IO

	文件IO

		file.erl

		file_server.erl

		file_io_server.erl

		ram_file.erl

	网络IO

		gen_sctp.erl

		gen_udp.erl

		gen_tcp.erl

		inet.erl

		inet_config.hrl

		inet_config.erl

		inet_boot.hrl

		inet6_udp.erl

		inet6_tcp_dist.erl

		inet6_tcp.erl

		inet6_sctp.erl

		inet_db.erl

		inet_dns.hrl

		inet_dns.erl

		inet_gethost_native.erl

		inet_udp.erl

		inet_tcp_dist.erl

		inet_tcp.erl

		inet_sctp.erl

		inet_res.hrl

		inet_res.erl

		inet_parse.erl

		inet_int.hrl

		inet_hosts.erl

		inet_dns_record_adts.pl

		erl_reply.erl

		net_kernel.erl

		net_adm.erl

		net.erl

	IO Request

		user_drv.erl

		user.erl

		user_sup.erl

		group.erl

Code生命周期管理

	code.erl

	code_server.erl

	erl_boot_server.erl

	erl_ddll.erl

distribute管理

	dist_util.erl

	dist_ac.erl

	Distributed Applications Controller

	erl_distribution.erl

	erl_epmd.erl

	rpc.erl

	pg2.erl

	global_search.erl

	global_group.erl

	global.erl

	auth.erl

OS

	os.erl

/*

** Data types:

**

** Eterm: A tagged erlang term (possibly 64 bits)

** BeamInstr: A beam code instruction unit, possibly larger than Eterm, not smaller.

** UInt:  An unsigned integer exactly as large as an Eterm.

** SInt:  A signed integer exactly as large as an eterm and therefor large

**        enough to hold the return value of the signed_val() macro.

** UWord: An unsigned integer at least as large as a void * and also as large

**          or larger than an Eterm

** SWord: A signed integer at least as large as a void * and also as large

**          or larger than an Eterm

** Uint32: An unsigned integer of 32 bits exactly

** Sint32: A signed integer of 32 bits exactly

** Uint16: An unsigned integer of 16 bits exactly

** Sint16: A signed integer of 16 bits exactly.

*/

     copy = last = CONS(hp, CAR(list_val(list)), make_list(hp + 2));

     list = CDR(list_val(list));

#define CONS(hp, car, cdr) \

        (CAR(hp)=(car), CDR(hp)=(cdr), make_list(hp))

#define CAR(x)  ((x)[0])

#define CDR(x)  ((x)[1])

struct process {

    ErtsPTabElementCommon common; /* *Need* to be first in struct */

    /* All fields in the PCB that differs between different heap

     * architectures, have been moved to the end of this struct to

     * make sure that as few offsets as possible differ. Different

     * offsets between memory architectures in this struct, means that

     * native code have to use functions instead of constants.

     */

    Eterm* htop;		/* Heap top */

    Eterm* stop;		/* Stack top */

    Eterm* heap;		/* Heap start */

    Eterm* hend;		/* Heap end */

    Uint heap_sz;		/* Size of heap in words */

    Uint min_heap_size;         /* Minimum size of heap (in words). */

    Uint min_vheap_size;        /* Minimum size of virtual heap (in words). */

#if !defined(NO_FPE_SIGNALS) || defined(HIPE)

    volatile unsigned long fp_exception;

#endif

#ifdef HIPE

    /* HiPE-specific process fields. Put it early in struct process,

       to enable smaller & faster addressing modes on the x86. */

    struct hipe_process_state hipe;

#endif

    /*

     * Saved x registers.

     */

    Uint arity;			/* Number of live argument registers (only valid

				 * when process is *not* running).

				 */

    Eterm* arg_reg;		/* Pointer to argument registers. */

    unsigned max_arg_reg;	/* Maximum number of argument registers available. */

    Eterm def_arg_reg[6];	/* Default array for argument registers. */

    BeamInstr* cp;		/* (untagged) Continuation pointer (for threaded code). */

    BeamInstr* i;		/* Program counter for threaded code. */

    Sint catches;		/* Number of catches on stack */

    Sint fcalls;		/*

				 * Number of reductions left to execute.

				 * Only valid for the current process.

				 */

    Uint32 rcount;		/* suspend count */

    int  schedule_count;	/* Times left to reschedule a low prio process */

    Uint reds;			/* No of reductions for this process  */

    Eterm group_leader;		/* Pid in charge

				   (can be boxed) */

    Uint flags;			/* Trap exit, etc (no trace flags anymore) */

    Eterm fvalue;		/* Exit & Throw value (failure reason) */

    Uint freason;		/* Reason for detected failure */

    Eterm ftrace;		/* Latest exception stack trace dump */

    Process *next;		/* Pointer to next process in run queue */

    struct ErtsNodesMonitor_ *nodes_monitors;

    ErtsSuspendMonitor *suspend_monitors; /* Processes suspended by

					     this process via

					     erlang:suspend_process/1 */

    ErlMessageQueue msg;	/* Message queue */

    union {

	ErtsBifTimer *bif_timers;	/* Bif timers aiming at this process */

	void *terminate;

    } u;

    ProcDict  *dictionary;       /* Process dictionary, may be NULL */

    Uint seq_trace_clock;

    Uint seq_trace_lastcnt;

    Eterm seq_trace_token;	/* Sequential trace token (tuple size 5 see below) */

#ifdef USE_VM_PROBES

    Eterm dt_utag;              /* Place to store the dynamc trace user tag */

    Uint dt_utag_flags;         /* flag field for the dt_utag */

#endif

    BeamInstr initial[3];	/* Initial module(0), function(1), arity(2), often used instead

				   of pointer to funcinfo instruction, hence the BeamInstr datatype */

    BeamInstr* current;		/* Current Erlang function, part of the funcinfo:

				 * module(0), function(1), arity(2)

				 * (module and functions are tagged atoms;

				 * arity an untagged integer). BeamInstr * because it references code

				 */

    /*

     * Information mainly for post-mortem use (erl crash dump).

     */

    Eterm parent;		/* Pid of process that created this process. */

    erts_approx_time_t approx_started; /* Time when started. */

    /* This is the place, where all fields that differs between memory

     * architectures, have gone to.

     */

    Eterm *high_water;

    Eterm *old_hend;            /* Heap pointers for generational GC. */

    Eterm *old_htop;

    Eterm *old_heap;

    Uint16 gen_gcs;		/* Number of (minor) generational GCs. */

    Uint16 max_gen_gcs;		/* Max minor gen GCs before fullsweep. */

    ErlOffHeap off_heap;	/* Off-heap data updated by copy_struct(). */

    ErlHeapFragment* mbuf;	/* Pointer to message buffer list */

    Uint mbuf_sz;		/* Size of all message buffers */

    ErtsPSD *psd;		/* Rarely used process specific data */

    Uint64 bin_vheap_sz;	/* Virtual heap block size for binaries */

    Uint64 bin_vheap_mature;	/* Virtual heap block size for binaries */

    Uint64 bin_old_vheap_sz;	/* Virtual old heap block size for binaries */

    Uint64 bin_old_vheap;	/* Virtual old heap size for binaries */

    ErtsProcSysTaskQs *sys_task_qs;

    erts_smp_atomic32_t state;  /* Process state flags (see ERTS_PSFLG_*) */

#ifdef ERTS_SMP

    ErlMessageInQueue msg_inq;

    ErtsPendExit pending_exit;

    erts_proc_lock_t lock;

    ErtsSchedulerData *scheduler_data;

    Eterm suspendee;

    ErtsPendingSuspend *pending_suspenders;

    erts_smp_atomic_t run_queue;

#ifdef HIPE

    struct hipe_process_state_smp hipe_smp;

#endif

#endif

#ifdef CHECK_FOR_HOLES

    Eterm* last_htop;		/* No need to scan the heap below this point. */

    ErlHeapFragment* last_mbuf;	/* No need to scan beyond this mbuf. */

#endif

#ifdef DEBUG

    Eterm* last_old_htop;	/*

				 * No need to scan the old heap below this point

				 * when looking for invalid pointers into the new heap or

				 * heap fragments.

				 */

#endif

#ifdef FORCE_HEAP_FRAGS

    Uint space_verified;        /* Avoid HAlloc forcing heap fragments when */

    Eterm* space_verified_from; /* we rely on available heap space (TestHeap) */

#endif

};