WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/include/core.h


#define OS_BASE         0xE0000000
#define IMAGE_BASE      0xE0100000
#define LOAD_BASE       0x00100000
 
 
#define page_tabs       0xDD800000
 
#define master_tab      (page_tabs+(page_tabs>>10))
 
#define sel_tss         0x08
 
#define sel_os_stack    0x10
#define sel_os_code     0x18
 
#define sel_app_code    0x23
#define sel_app_data    0x2B
 
#define sel_srv_code    0x31
#define sel_srv_stack   0x39
 
 
 
#define __export __attribute__ ((dllexport))
 
 
void printf (const char *format, ...);
 
#define CALLER ((addr_t) __builtin_return_address(0))
 
extern void panic_printf(char *fmt, ...) __attribute__((noreturn));
 
#ifdef CONFIG_DEBUG
 
# define panic(format, ...) \
		panic_printf("Kernel panic in %s() at %s:%u: " format, __func__, \
		__FILE__, __LINE__, ##__VA_ARGS__);
 
#	define ASSERT(expr) \
		if (!(expr)) { \
			panic("assertion failed (%s), caller=%p\n", #expr, CALLER); \
		}
 
#define DBG(format,...) printf(format,##__VA_ARGS__)
 
#else
 
#	define panic(format, ...) \
		panic_printf("Kernel panic: " format, ##__VA_ARGS__);
 
# define ASSERT(expr)
 
# define DBG(format,...)
 
# define PANIC(expr)   \
      if (!(expr)) {   \
         panic_printf("Kernel panic in %s() at %s:%u: " \
                      "assertion failed (%s)",__func__ ,__FILE__,__LINE__, \
                       #expr); \
      };
 
#endif
 
 
static inline eflags_t safe_cli(void)
{
    eflags_t tmp;
	asm volatile (
    "pushfl\n\t"
    "popl %0\n\t"
    "cli\n"
    : "=r" (tmp));
    return tmp;
}
 
static inline void safe_sti(eflags_t efl)
{
	asm volatile (
    "pushl %0\n\t"
    "popfl\n"
    : : "r" (efl));
}
 
static inline index_t fnzb(u32_t arg)
{
    count_t n;
    asm volatile (
    "xorl %0, %0 \n\t"
    "bsr %1, %0"
    :"=&r"(n) :"r"(arg) );
	return n;
}
 
static inline index_t _bsf(u32_t arg)
{
    count_t n;
    asm volatile (
    "xorl %0, %0 \n\t"
    "bsf %1, %0"
    :"=&r" (n) :"r"(arg));
	return n;
}
 
static inline void _bts(u32_t *data, count_t val)
{
    asm volatile (
    "bts %0, %1 \n\t"
    ::"g"(data), "r"(val):"cc");
}
 
extern inline void _btr(u32_t *data, count_t val)
{
    asm volatile (
    "btr %0, %1 \n\t"
    ::"g"(data), "r"(val):"cc");
}
 
extern inline void* load_file(const char *path, size_t *size)
{
     void* retval;
     size_t tmp;
 
     __asm__ __volatile__ (
     "pushl %%eax           \n\t"
     "call _load_file@4     \n\t"
     :"=eax" (retval), "=ebx"(tmp)
     :"a" (path) );
 
     if(size)
        *size = tmp;
     return retval;
};
 
 
/*                            reemain part
  saved_box       BOX
  ipc_start       dd ?
  ipc_size    dd ?
  event_mask      dd ?
  debugger_slot   dd ?
          dd ?
  keyboard_mode   db ?
          db 3   dup(?)
  dir_table       dd ?
  dbg_event_mem   dd ?
  dbg_regs:
  dbg_regs.dr0    dd ?
  dbg_regs.dr1    dd ?
  dbg_regs.dr2    dd ?
  dbg_regs.dr3    dd ?
  dbg_regs.dr7    dd ?
  wnd_caption     dd ?
  wnd_clientbox   BOX
*/
 
//extern __fastcall void* load_file(const char *path, size_t *size);
 
 
typedef struct
{
    u32_t    edi;
    u32_t    esi;
    u32_t    ebp;
    u32_t    tmp;                    // esp
    u32_t    ebx;
    u32_t    edx;
    u32_t    ecx;
    u32_t    eax;
    addr_t   retaddr;
    addr_t   eip;
    u32_t    cs;
    u32_t    eflags;
    addr_t   esp;
    u32_t    ss;                    // 14*4
 
    u32_t    tid;                   // thread id
    u32_t    slot;                  // thread slot
 
    addr_t   pdir;                  //
 
    u32_t    thr_flags;             // process is runnable only if zero
 
    int      ticks_left;            // number of scheduling ticks left */
    int      quantum_size;          // quantum size in ticks */
 
    u32_t    user_time;             // user time in ticks
    u32_t    sys_time;              // sys time in ticks
 
}thr_t;
 
#define EFL_IF      0x0200
#define EFL_IOPL1   0x1000
#define EFL_IOPL2   0x2000
#define EFL_IOPL3   0x3000
 
typedef struct
{
  u32_t      handle;
  u32_t      io_code;
  void       *input;
  int        inp_size;
  void       *output;
  int        out_size;
}ioctl_t;
 
 
typedef struct __attribute__ ((packed))
{
    u32_t code;
    union
    {
        struct                          /* window event    */
        {
            u32_t  win;                 /* window handle   */
            u32_t  val1;
            u32_t  val2;
            u16_t  x;                   /* cursor x        */
            u16_t  y;                   /* cursor y        */
            u32_t  unused;
        };
 
        struct                          /* realtime io     */
        {
            u32_t  sender;              /* service handler */
            u32_t  stream;              /* io stream id, if present  */
            addr_t offset;
            size_t size;
        };
 
        struct                          /* ipc event       */
        {
            u32_t  sender;
            u32_t   io_code;
            addr_t *input;
            size_t  inp_size;
            addr_t *output;
            size_t  out_size;
        };
    };
}event_t;
 
 
void __fastcall dump_file(addr_t addr, size_t size);
 

Rev 1066	Rev 2971
-		1	#define OS_BASE 0xE0000000
1	#define OS_BASE 0xE0000000	2	#define IMAGE_BASE 0xE0100000
2	#define IMAGE_BASE 0xE0100000	3	#define LOAD_BASE 0x00100000
3	#define LOAD_BASE 0x00100000	4
4		5
5		6	#define page_tabs 0xDD800000
6	#define page_tabs 0xDD800000	7
7		8	#define master_tab (page_tabs+(page_tabs>>10))
8	#define master_tab (page_tabs+(page_tabs>>10))	9
9		10	#define sel_tss 0x08
10	#define sel_tss 0x08	11
11		12	#define sel_os_stack 0x10
12	#define sel_os_stack 0x10	13	#define sel_os_code 0x18
13	#define sel_os_code 0x18	14
14		15	#define sel_app_code 0x23
15	#define sel_app_code 0x23	16	#define sel_app_data 0x2B
16	#define sel_app_data 0x2B	17
17		18	#define sel_srv_code 0x31
18	#define sel_srv_code 0x31	19	#define sel_srv_stack 0x39
19	#define sel_srv_stack 0x39	20
20		21
21		22
22		23	#define __export __attribute__ ((dllexport))
23	#define __export __attribute__ ((dllexport))	24
24		25
25		26	void printf (const char *format, ...);
26	void printf (const char *format, ...);	27
27		28	#define CALLER ((addr_t) __builtin_return_address(0))
28	#define CALLER ((addr_t) __builtin_return_address(0))	29
29		30	extern void panic_printf(char *fmt, ...) __attribute__((noreturn));
30	extern void panic_printf(char *fmt, ...) __attribute__((noreturn));	31
31		32	#ifdef CONFIG_DEBUG
32	#ifdef CONFIG_DEBUG	33
33		34	# define panic(format, ...) \
34	# define panic(format, ...) \	35	panic_printf("Kernel panic in %s() at %s:%u: " format, __func__, \
35	panic_printf("Kernel panic in %s() at %s:%u: " format, __func__, \	36	__FILE__, __LINE__, ##__VA_ARGS__);
36	__FILE__, __LINE__, ##__VA_ARGS__);	37
37		38	# define ASSERT(expr) \
38	# define ASSERT(expr) \	39	if (!(expr)) { \
39	if (!(expr)) { \	40	panic("assertion failed (%s), caller=%p\n", #expr, CALLER); \
40	panic("assertion failed (%s), caller=%p\n", #expr, CALLER); \	41	}
41	}	42
42		43	#define DBG(format,...) printf(format,##__VA_ARGS__)
43	#define DBG(format,...) printf(format,##__VA_ARGS__)	44
44		45	#else
45	#else	46
46		47	# define panic(format, ...) \
47	# define panic(format, ...) \	48	panic_printf("Kernel panic: " format, ##__VA_ARGS__);
48	panic_printf("Kernel panic: " format, ##__VA_ARGS__);	49
49		50	# define ASSERT(expr)
50	# define ASSERT(expr)	51
51		52	# define DBG(format,...)
52	# define DBG(format,...)	53
53		54	# define PANIC(expr) \
54	# define PANIC(expr) \	55	if (!(expr)) { \
55	if (!(expr)) { \	56	panic_printf("Kernel panic in %s() at %s:%u: " \
56	panic_printf("Kernel panic in %s() at %s:%u: " \	57	"assertion failed (%s)",__func__ ,__FILE__,__LINE__, \
57	"assertion failed (%s)",__func__ ,__FILE__,__LINE__, \	58	#expr); \
58	#expr); \	59	};
59	};	60
60		61	#endif
61	#endif	62
62		63
63		64	static inline eflags_t safe_cli(void)
64	static inline eflags_t safe_cli(void)	65	{
65	{	66	eflags_t tmp;
66	eflags_t tmp;	67	asm volatile (
67	asm volatile (	68	"pushfl\n\t"
68	"pushfl\n\t"	69	"popl %0\n\t"
69	"popl %0\n\t"	70	"cli\n"
70	"cli\n"	71	: "=r" (tmp));
71	: "=r" (tmp));	72	return tmp;
72	return tmp;	73	}
73	}	74
74		75	static inline void safe_sti(eflags_t efl)
75	static inline void safe_sti(eflags_t efl)	76	{
76	{	77	asm volatile (
77	asm volatile (	78	"pushl %0\n\t"
78	"pushl %0\n\t"	79	"popfl\n"
79	"popfl\n"	80	: : "r" (efl));
80	: : "r" (efl));	81	}
81	}	82
82		83	static inline index_t fnzb(u32_t arg)
83	static inline index_t fnzb(u32_t arg)	84	{
84	{	85	count_t n;
85	count_t n;	86	asm volatile (
86	asm volatile (	87	"xorl %0, %0 \n\t"
87	"xorl %0, %0 \n\t"	88	"bsr %1, %0"
88	"bsr %1, %0"	89	:"=&r"(n) :"r"(arg) );
89	:"=&r"(n) :"r"(arg) );	90	return n;
90	return n;	91	}
91	}	92
92		93	static inline index_t _bsf(u32_t arg)
93	static inline index_t _bsf(u32_t arg)	94	{
94	{	95	count_t n;
95	count_t n;	96	asm volatile (
96	asm volatile (	97	"xorl %0, %0 \n\t"
97	"xorl %0, %0 \n\t"	98	"bsf %1, %0"
98	"bsf %1, %0"	99	:"=&r" (n) :"r"(arg));
99	:"=&r" (n) :"r"(arg));	100	return n;
100	return n;	101	}
101	}	102
102		103	static inline void _bts(u32_t *data, count_t val)
103	static inline void _bts(u32_t *data, count_t val)	104	{
104	{	105	asm volatile (
105	asm volatile (	106	"bts %0, %1 \n\t"
106	"bts %0, %1 \n\t"	107	::"g"(data), "r"(val):"cc");
107	::"g"(data), "r"(val):"cc");	108	}
108	}	109
109		110	extern inline void _btr(u32_t *data, count_t val)
110	extern inline void _btr(u32_t *data, count_t val)	111	{
111	{	112	asm volatile (
112	asm volatile (	113	"btr %0, %1 \n\t"
113	"btr %0, %1 \n\t"	114	::"g"(data), "r"(val):"cc");
114	::"g"(data), "r"(val):"cc");	115	}
115	}	116
116		117	extern inline void* load_file(const char path, size_t size)
117	extern inline void* load_file(const char path, size_t size)	118	{
118	{	119	void* retval;
119	void* retval;	120	size_t tmp;
120	size_t tmp;	121
121		122	__asm__ __volatile__ (
122	__asm__ __volatile__ (	123	"pushl %%eax \n\t"
123	"pushl %%eax \n\t"	124	"call _load_file@4 \n\t"
124	"call _load_file@4 \n\t"	125	:"=eax" (retval), "=ebx"(tmp)
125	:"=eax" (retval), "=ebx"(tmp)	126	:"a" (path) );
126	:"a" (path) );	127
127		128	if(size)
128	if(size)	129	*size = tmp;
129	*size = tmp;	130	return retval;
130	return retval;	131	};
131	};	132
132		133
133		134	/* reemain part
134	/* reemain part	135	saved_box BOX
135	saved_box BOX	136	ipc_start dd ?
136	ipc_start dd ?	137	ipc_size dd ?
137	ipc_size dd ?	138	event_mask dd ?
138	event_mask dd ?	139	debugger_slot dd ?
139	debugger_slot dd ?	140	dd ?
140	dd ?	141	keyboard_mode db ?
141	keyboard_mode db ?	142	db 3 dup(?)
142	db 3 dup(?)	143	dir_table dd ?
143	dir_table dd ?	144	dbg_event_mem dd ?
144	dbg_event_mem dd ?	145	dbg_regs:
145	dbg_regs:	146	dbg_regs.dr0 dd ?
146	dbg_regs.dr0 dd ?	147	dbg_regs.dr1 dd ?
147	dbg_regs.dr1 dd ?	148	dbg_regs.dr2 dd ?
148	dbg_regs.dr2 dd ?	149	dbg_regs.dr3 dd ?
149	dbg_regs.dr3 dd ?	150	dbg_regs.dr7 dd ?
150	dbg_regs.dr7 dd ?	151	wnd_caption dd ?
151	wnd_caption dd ?	152	wnd_clientbox BOX
152	wnd_clientbox BOX	153	*/
153	*/	154
154		155	//extern __fastcall void* load_file(const char path, size_t size);
155	//extern __fastcall void* load_file(const char path, size_t size);	156
156		157
157		158	typedef struct
158	typedef struct	159	{
159	{	160	u32_t edi;
160	u32_t edi;	161	u32_t esi;
161	u32_t esi;	162	u32_t ebp;
162	u32_t ebp;	163	u32_t tmp; // esp
163	u32_t tmp; // esp	164	u32_t ebx;
164	u32_t ebx;	165	u32_t edx;
165	u32_t edx;	166	u32_t ecx;
166	u32_t ecx;	167	u32_t eax;
167	u32_t eax;	168	addr_t retaddr;
168	addr_t retaddr;	169	addr_t eip;
169	addr_t eip;	170	u32_t cs;
170	u32_t cs;	171	u32_t eflags;
171	u32_t eflags;	172	addr_t esp;
172	addr_t esp;	173	u32_t ss; // 14*4
173	u32_t ss; // 14*4	174
174		175	u32_t tid; // thread id
175	u32_t tid; // thread id	176	u32_t slot; // thread slot
176	u32_t slot; // thread slot	177
177		178	addr_t pdir; //
178	addr_t pdir; //	179
179		180	u32_t thr_flags; // process is runnable only if zero
180	u32_t thr_flags; // process is runnable only if zero	181
181		182	int ticks_left; // number of scheduling ticks left */
182	int ticks_left; // number of scheduling ticks left */	183	int quantum_size; // quantum size in ticks */
183	int quantum_size; // quantum size in ticks */	184
184		185	u32_t user_time; // user time in ticks
185	u32_t user_time; // user time in ticks	186	u32_t sys_time; // sys time in ticks
186	u32_t sys_time; // sys time in ticks	187
187		188	}thr_t;
188	}thr_t;	189
189		190	#define EFL_IF 0x0200
190	#define EFL_IF 0x0200	191	#define EFL_IOPL1 0x1000
191	#define EFL_IOPL1 0x1000	192	#define EFL_IOPL2 0x2000
192	#define EFL_IOPL2 0x2000	193	#define EFL_IOPL3 0x3000
193	#define EFL_IOPL3 0x3000	194
194		195	typedef struct
195	typedef struct	196	{
196	{	197	u32_t handle;
197	u32_t handle;	198	u32_t io_code;
198	u32_t io_code;	199	void *input;
199	void *input;	200	int inp_size;
200	int inp_size;	201	void *output;
201	void *output;	202	int out_size;
202	int out_size;	203	}ioctl_t;
203	}ioctl_t;	204
204		205
205		206	typedef struct __attribute__ ((packed))
206	typedef struct __attribute__ ((packed))	207	{
207	{	208	u32_t code;
208	u32_t code;	209	union
209	union	210	{
210	{	211	struct /* window event */
211	struct /* window event */	212	{
212	{	213	u32_t win; /* window handle */
213	u32_t win; /* window handle */	214	u32_t val1;
214	u32_t val1;	215	u32_t val2;
215	u32_t val2;	216	u16_t x; /* cursor x */
216	u16_t x; /* cursor x */	217	u16_t y; /* cursor y */
217	u16_t y; /* cursor y */	218	u32_t unused;
218	u32_t unused;	219	};
219	};	220
220		221	struct /* realtime io */
221	struct /* realtime io */	222	{
222	{	223	u32_t sender; /* service handler */
223	u32_t sender; /* service handler */	224	u32_t stream; /* io stream id, if present */
224	u32_t stream; /* io stream id, if present */	225	addr_t offset;
225	addr_t offset;	226	size_t size;
226	size_t size;	227	};
227	};	228
228		229	struct /* ipc event */
229	struct /* ipc event */	230	{
230	{	231	u32_t sender;
231	u32_t sender;	232	u32_t io_code;
232	u32_t io_code;	233	addr_t *input;
233	addr_t *input;	234	size_t inp_size;
234	size_t inp_size;	235	addr_t *output;
235	addr_t *output;	236	size_t out_size;
236	size_t out_size;	237	};
237	};	238	};
238	};	239	}event_t;
239	}event_t;	240
240		241
241		242	void __fastcall dump_file(addr_t addr, size_t size);
242	void __fastcall dump_file(addr_t addr, size_t size);	-

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/include/core.h @ 859 – Rev 1066 → 2971