linux.hhf

High Level assembly language(HLA)软件

	pf_memalloc 	:= $00000800;
	pf_usedfpu 		:= $00100000;
	pf_atomicalloc 	:= $00400000;
	pt_ptraced 		:= $00000001;
	pt_tracesys 	:= $00000002;
	pt_dtrace 		:= $00000004;
	pt_tracesysgood := $00000008;
	
	// process priority constants
	
	prio_min		:= -20;
	prio_max		:= 20;
	
	prio_process	:= 0;
	prio_pgrp		:= 1;
	prio_user		:= 2;


  	
  	// Misc constants:
  	
  	nr_open_default	:= 32;
  	numGroups_c		:= 32;
  	rlim_nlimits	:= 11;
  	default_max_map_count	:= 65536;
  	
  	

/*
 * These are the constant used to fake the fixed-point load-average
 * counting. Some notes:
 *  - 11 bit fractions expand to 22 bits by the multiplies: this gives
 *    a load-average precision of 10 bits integer + 11 bits fractional
 *  - if you want to count load-averages more often, you need more
 *    precision, or rounding will get you. With 2-second counting freq,
 *    the EXP_n values would be 1981, 2034 and 2043 if still using only
 *    11 bit fractions.
 */

	fshift		:= 11;
	fixed_1		:= (1 << fshift);
	load_freq	:= (5*hz);
	exp_1		:= 1884;
	exp_5		:= 2014;
	exp_15		:= 2037;
	
	#macro calc_load( __load, __exp, __n );
		returns
		({
			push( ebx );
			mov( linux.fixed_1, ebx );
			sub( __exp, ebx );
			intmul( __n, ebx );
			mov( __load, eax );
			intmul( __exp, eax );
			add( ebx, eax );
			shr( linux.fshift, eax );
			pop( ebx );
		}, "eax" )
	#endmacro
	
	#macro ct_to_secs(__x);
		returns
		({
			push( edx );
			mov( __x, eax );
			cdq();
			div( linux.hz, edx:eax );
			pop( edx );
		},"eax" )
	#endmacro
	
	#macro ct_to_usecs(__x);
		returns
		({
			push( edx );
			mov( __x, eax );
			cdq();
			div( linux.hz, edx:eax );
			intmul( 1_000_000, edx );
			mov( edx, eax );
			pop( edx );
		},"eax" )
	#endmacro
	
	
type
	sched_param_t: record
		sched_priority	:int32;
	endrecord;

  	
  	files_struct:record
  		count				:atomic_t;
  		file_lock			:rw_lock_t;
  		max_fds				:dword;
  		max_fdset			:dword;
  		next_fd				:dword;
  		fd					:dword;	// ptr to fd array;
  		close_on_exec		:fd_set_ptr;
  		open_fds			:fd_set_ptr;
  		close_on_exec_unit	:fd_set;
  		open_fds_init		:fd_set;
  		fd_array			:dword[ bits_per_long ];
  	endrecord;
  		

static
	avenrun			:dword; @external;
	nr_running		:dword;	@external;
	nr_threads		:dword; @external;
	last_pid		:dword; @external;
	max_map_count	:dword;	@external;
	

#if( @defined( __kernel__ ))

type

  	pgprot_t: record
  		pgprot	:dword;
  	endrecord;
  	
  		
  		
  		
	exception_table_entry: record
		insn	:dword;
		fixup	:dword;
	endrecord;


  	task_struct:record
  		state			:dword;	// -1 unrunnable, 0 runable, >0 stopped.
  		flags			:dword;	// per process flags
  		sigpending		:int32;
  		addr_limit		:dword;	// BFFF_FFFF for users,
  								// FFFF_FFFF for kernel.
  		exec_domain		:dword;	// Pointer to struct exec_domain
  		need_resched	:dword;
  		ptrace			:dword;
  		lock_depth		:dword;
  		
  		counter			:dword;
  		nice			:dword;
  		policy			:dword;
  		mm				:pointer to mm_struct;
  		has_cpu			:dword;
  		processor		:dword;
  		cpus_allowed	:dword;
  		run_list		:list_head;
  		sleep_time		:dword;
  		next_task		:pointer to task_struct;
  		prev_task		:pointer to task_struct;
  		active_mm		:pointer to mm_struct;
  		
  		binfmt			:dword;	//pointer to linux_binfmt
  		exit_code		:int32;
  		exit_signal		:int32;
  		pdeath_signal	:int32;
  		personality		:dword;
  		did_exec		:dword;
  		pid				:pid_t;
  		pgrp			:pid_t;
  		tty_old_pgrp	:pid_t;
  		session			:pid_t;
  		tgid			:pid_t;
  		leader			:dword;
  		
  		p_opptr			:pointer to task_struct;
  		p_pptr			:pointer to task_struct;
  		p_cptr			:pointer to task_struct;
  		p_ysptr			:pointer to task_struct;
  		p_osptr			:pointer to task_struct;
  		thread_group	:list_head;
  		pidhash_next	:pointer to task_struct;
  		pid_has_pprev	:dword;	//pointer to pointer to task_struct
  		
  		wait_chldexit	:wait_queue_head_t;
  		vfork_done		:dword;	//pointer to completion
  		rt_priority		:dword;
  		it_real_value	:dword;
  		it_prof_value	:dword;
  		it_virt_value	:dword;
  		it_real_incr	:dword;
  		it_prof_incr	:dword;
  		it_virt_incr	:dword;
  		real_timer		:timer_list;
  		times			:tms;
  		start_time		:dword;
  		#if( @defined( __smp__ ))
  		
  			per_cpu_utime	:dword[32];
  			per_cpu_stime	:dword[32];
  			
  		#else
  		
			per_cpu_utime	:dword[1];
			per_cpu_stime	:dword[1];
			
		#endif
  		min_flt			:dword;
  		maj_flt			:dword;
  		nswap			:dword;
  		cmin_flt		:dword;
  		cmaj_flt		:dword;
  		cnswap			:dword;
  		swappable		:dword;
  		
  		uid				:dword;
  		euid			:dword;
  		suid			:dword;
  		fsuid			:dword;
  		gid				:dword;
  		egid			:dword;
  		sgid			:dword;
  		fsgid			:dword;
  		
  		ngroups			:dword;
  		groups			:dword[ numGroups_c ];
  		cap_effective	:kernel_cap_t;
  		cap_inheritable	:kernel_cap_t;
  		cap_permitted	:kernel_cap_t;
  		keep_capabilities	:dword;
  		user			:dword;		// pointer to user_struct.
  		rlim			:rlimit_t[rlim_nlimits];
  		used_math		:word;
  		comm			:char[16];
  		align(4);
  		link_count		:dword;
  		tty				:dword;	// pointer to tty_struct
  		locks			:dword;
  		semundo			:dword;	//pointer to sem_undo
  		semsleeping		:dword; //pointer to sem_queue

		align(8);
  		thread			:thread_struct;
  		_fs				:dword;	// pointer to fs_struct
  		files			:dword; // pointer to files_struct
  		sigmask_lock	:spinlock_t;
  		sig				:pointer to signal_struct;
  		blocked			:sigset_t;
  		pending			:sigpending_t;
  		sas_ss_sp		:dword;
  		sas_ss_size		:size_t;
  		notifier		:procedure( var priv:var );
  		notifier_data	:dword;
  		notifier_mask	:pointer to sigset_t;
  		
  		tux_info		:dword;
  		tux_exit		:procedure;
  		
  		parent_exec_id	:dword;
  		self_exec_id	:dword;
  		alloc_lock		:spinlock_t;
  		journal_info	:dword[4]; //?????
  	endrecord;
  	
  	vm_area_struct: record
  		vm_mm			:dword;		//pointer to mm_struct
  		vm_start		:dword;
  		vm_end			:dword;
  		vm_next			:pointer to vm_area_struct;
  		vm_page_prot	:pgprot_t;
  		vm_flags		:dword;
  		
  		vm_avl_height	:word;
  		vm_avl_left		:pointer to vm_area_struct;
  		vm_avl_right	:pointer to vm_area_struct;
  		vm_next_share	:pointer to vm_area_struct;
  		vm_pprev_share	:pointer to vm_area_struct;
  		
  		vm_pgoff		:dword;
  		vm_file			:dword;		//pointer to file
  		fm_raend		:dword;
  		vm_private_data	:dword;
  	endrecord;

  	mm_context_t:record
  		segments	:dword;
  		cpuvalid	:dword;
  	endrecord;


  	mm_struct:record
  		mmap		:pointer to vm_area_struct;
  		mmap_avl	:pointer to vm_area_struct;
  		mmap_cache	:pointer to vm_area_struct;
  		pgd			:dword;	// page ptr.
  		mm_users	:atomic_t;
  		mm_count	:atomic_t;
  		map_count	:dword;	// # of VMAs.
  		mmap_sem	:rw_semaphore;
  		page_table_lock	:spinlock_t;
  		mmlist		:list_head;
  		
  		start_code	:dword;
  		end_code	:dword;
  		start_data	:dword;
  		end_data	:dword;
  		start_brk	:dword;
  		brk			:dword;
  		start_stack	:dword;
  		arg_start	:dword;
  		arg_end		:dword;
  		env_start	:dword;
  		env_end		:dword;
  		rss			:dword;
  		total_vm	:dword;
  		locked_vm	:dword;
  		def_flags	:dword;
  		cpu_vm_mask	:dword;
  		swap_address:dword;
  		dumpable	:dword;
  		
  		context		:mm_context_t;
  		
  	endrecord;
			



static
	tasklist_lock	:rwlock_t;		@external;
	runqueue_lock	:spinlock_t;	@external;
	mmlist_lock		:spinlock_t;	@external;
	mmlist_nr		:dword;			@external;
	jiffies			:dword;			@external;
	itimer_ticks	:dword;			@external;
	itimer_next		:dword;			@external;
	xtime			:timeval;		@external;
	prof_buffer		:dword;			@external;
	prof_len		:dword;			@external;
	prof_shift		:dword;			@external;
	prof_pid		:pid_t;			@external;
	
	
	
	procedure schedule;		@external;
	procedure sched_init; 	@external;
	procedure init_idle;	@external;
	procedure show_state;	@external;
	procedure cpu_init;		@external;
	procedure trap_init;	@external;
	procedure update_process_times( user:dword ); @cdecl; @external;
	
	procedure update_one_process
	(
		var	p		:task_struct;
			user	:dword;
			system	:dword;
			cpu		:dword
	);
		@cdecl;
		@external;
		
	procedure schedule_task( var task: tq_struct );
		@use eax;
		@cdecl;
		@returns( "eax" );
		@external;
		
		
	procedure flush_scheduled_tasks; @external;
	procedure start_context_thread; @external;
	procedure current_is_keventd; @external;
	
	procedure __wake_up
	( 
		var	q		:wait_queue_head_t in eax; 
			mode	:dword in edx; 
			nr		:dword in ecx
	);	@external;
		
	#macro wake_up( __q );
		returns
		(
			{
				push( eax );
				push( ecx );
				push( edx );
				linux.__wake_up
				( 
					__q, 
						linux.task_interruptible 
					|	linux.task_uninterruptible, 
					1 
				);
				pop( edx );
				pop( ecx );
				pop( eax );
			}, ""
		)
	#endmacro
	
		
	#macro wake_up_interruptible( __q );
		returns
		(
			{
				push( eax );
				push( ecx );
				push( edx );
				linux.__wake_up
				( 
					__q, 
						linux.task_interruptible, 
					1 
				);
				pop( edx );
				pop( ecx );
				pop( eax );
			}, ""
		)
	#endmacro
	
	procedure __wake_up_sync
	( 
		var	q		:wait_queue_head_t in eax; 
			mode	:dword in edx; 
			nr		:dword in ecx
	);	@external;
		
		
	#macro wake_up_sync( __q );
		returns
		(
			{
				push( eax );
				push( ecx );
				push( edx );
				linux.__wake_up_sync
				( 
					__q, 
						linux.task_interruptible 
					|	linux.task_uninterruptible, 
					1 
				);
				pop( edx );
				pop( ecx );
				pop( eax );
			}, ""
		)
	#endmacro
	

		
		
	#macro wake_up_sync_interruptible( __q );
		returns
		(
			{
				push( eax );
				push( ecx );
				push( edx );
				linux.__wake_up_sync
				( 
					__q, 
						linux.task_interruptible, 
					1 
				);
				pop( edx );
				pop( ecx );
				pop( eax );
			}, ""
		)
	#endmacro
	

		

	procedure __sleep_on
	( 
		var	q		:wait_queue_head_t in eax
	);	@external( "sleep_on" );
		
		
	#macro sleep_on( __q );
		returns
		(
			{
				push( eax );
				push( ecx );
				push( edx );
				linux.__sleep_on( __q );
				pop( edx );
				pop( ecx );
				pop( eax );
			}, ""
		)
	#endmacro
	

		

	procedure __sleep_on_timeout
	( 
		var	q		:wait_queue_head_t in eax;
			timeout	:dword in edx
	);	@external( "sleep_on_timeout" );
		
		
	#macro sleep_on_timeout( __q, __t );
		returns
		(
			{
				push( eax );
				push( ecx );
				push( edx );
				linux.__sleep_on( __q, __t );
				pop( edx );
				pop( ecx );
				pop( eax );
			}, ""
		)
	#endmacro
	

		

	

		

	procedure __interruptible_sleep_on
	( 
		var	q		:wait_queue_head_t in eax
	);	@external( "interruptible_sleep_on" );
		
		
	#macro interruptible_sleep_on( __q );
		returns
		(
			{
				push( eax );
				push( ecx );
				push( edx );
				linux.__interruptible_sleep_on( __q );
				pop( edx );
				pop( ecx );
				pop( eax );
			}, ""
		)
	#endmacro
	

		

	procedure __interruptible_sleep_on_timeout
	( 
		var	q		:wait_queue_head_t in eax;
			timeout	:dword in edx
	);	@external( "interruptible_sleep_on_timeout" );
		
		
	#macro interruptible_sleep_on_timeout( __q, __t );
		returns
		(
			{
				push( eax );
				push( ecx );
				push( edx );
				linux.__interruptible_sleep_on( __q, __t );
				pop( edx );
				pop( ecx );
				pop( eax );
			}, ""
		)
	#endmacro
	

		

#endif //__kernel__
	
	
end linux;
#endif // sched_hhf
#if( !@defined( stat_hhf ))
?stat_hhf := true;

namespace linux; //@fast;

const
	
	// Protection bit values:
	
	usr_r 	:= %100_000_000;
	usr_w	:= %010_000_000;
	usr_x	:= %001_000_000;
	
	grp_r	:= %000_100_000;
	grp_w	:= %000_010_000;
	grp_x	:= %000_001_000;
	
	all_r	:= %000_000_100;
	all_w	:= %000_000_010;
	all_x	:= %000_000_001;
	
	
	// More protection bits:
	
	s_isuid	:= %100_000_000_000;
	s_isgid	:= %010_000_000_000;
	s_isvtx	:= %001_000_000_000;
	s_iread	:= usr_r;
	s_iwrite:= usr_w;
	s_iexec	:= usr_x;
	s_irgrp	:= grp_r;
	s_iwgrp	:= grp_w;
	s_ixgrp	:= grp_x;
	s_iroth	:= all_r;
	s_iwoth	:= all_w;
	s_ixoth	:= all_x;
	
	s_irwxu	:= usr_r | usr_w | usr_x;
	s_irwxg	:= grp_r | grp_w | grp_x;
	s_irwxo	:= all_r | all_w | all_x;
	
	
	
	// File types:
	
	s_ifmt	:= %001_111_000_000_000_000;
	s_ifreg	:= %001_000_000_000_000_000;
	s_ifdir	:= %000_100_000_000_000_000;
	s_ifchr	:= %000_010_000_000_000_000;
	s_ifblk	:= %000_110_000_000_000_000;
	s_ififo	:= %000_001_000_000_000_000;
	s_iflnk	:= %001_010_000_000_000_000;
	s_ifsock:= %001_100_000_000_000_000;

	
type
	stat_t:	record
		st_dev		:word;
		__pad1		:word;
		st_ino		:dword;
		st_mode		:word;
		st_nlink	:word;
		st_uid		:word;
		st_gid		:word;
		st_rdev		:word;
		__pad2		:word;
		st_size		:dword;
		st_blksze	:dword;
		st_blocks	:dword;
		st_atime	:dword;
		__unused1	:dword;
		st_mtime	:dword;
		__unused2	:dword;
		st_ctime	:dword;
		__unused3	:dword;
		__unused4	:dword;
		__unused5	:dword;
	endrecord;
	
	stat64_t:	record
		st_dev		:qword;
		__pad1		:dword;
		st_ino32	:dword;
		st_mode		:dword;
		st_nlink	:dword;
		st_uid		:dword;
		st_gid		:dword;
		st_rdev		:qword;
		__pad2		:dword;
		st_size		:qword;
		st_blksze	:dword;
		st_blocks	:qword;
		st_atime	:qword;
		st_mtime	:qword;
		st_ctime	:qword;
		st_ino		:qword;
	endrecord;
	
end linux;
#endif
#if( !@defined( fcntl_hhf ))
?fcntl_hhf := true;

namespace linux; //@fast;

const
	
	// Constants for the flock calls:
	
	lock_sh		:= 1;
	lock_ex		:= 2;
	lock_un		:= 8;
	lock_nb		:= 4;
	lock_mand	:= 32;
	lock_read	:= 64;
	lock_write	:= 128;
	lock_rw		:= 192;
	
	// constants for the open calls:
	
	o_rdonly	:= 0;
	o_wronly	:= 1;
	o_rdwr		:= 2;
	o_accmode	:= 3;
	o_creat		:= $40;
	o_excl		:= $80;
	o_noctty	:= $100;
	o_trunc		:= $200;
	o_append	:= $400;
	o_noblock	:= $800;
	o_ndelay	:= o_noblock;
	o_sync		:= $1000;
	o_fsync		:= o_sync;
	o_async		:= $2000;
	
	o_direct	:= $4000;
	o_largefile	:= $8000;
	o_directory	:= $1_0000;
	o_nofollow	:= $2_0000;
	o_atomiclookup	:= $20_0000;