Context Navigation

← Previous Change
Next Change →

x86_64

Timestamp:

Jun 26, 2017, 12:08:02 PM (7 years ago)

Author:

max@…

Message:

Put panics everywhere

Location:

trunk/hal/x86_64

Files:

: 14 edited

hal_arch.c (modified) (8 diffs)
hal_arch.h (modified) (8 diffs)
hal_atomic.c (modified) (5 diffs)
hal_context.c (modified) (4 diffs)
hal_do_exceptions.c (modified) (3 diffs)
hal_do_interrupt.c (modified) (2 diffs)
hal_do_syscall.c (modified) (2 diffs)
hal_exception.c (modified) (2 diffs)
hal_gpt.c (modified) (9 diffs)
hal_interrupt.c (modified) (1 diff)
hal_irqmask.c (modified) (1 diff)
hal_remote.c (modified) (14 diffs)
hal_syscall.c (modified) (1 diff)
hal_uspace.c (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed

trunk/hal/x86_64/hal_arch.c

r25	r48
34	34	#include <arch.h>
35	35
	36	#include <hal_internal.h>
	37
36	38	static void cpu_default_irq_handler(struct irq_action_s *action)
37	39	{
38
	40	x86_panic((char *)__func__);
39	41	}
40	42
41	43	error_t arch_cpu_init( core_t * core )
42	44	{
	45	x86_panic((char *)__func__);
43	46	return 0;
44	47	}
…	…
48	51	struct irq_action_s *action )
49	52	{
	53	x86_panic((char *)__func__);
50	54	return 0;
51	55	}
…	…
55	59	struct irq_action_s **action)
56	60	{
	61	x86_panic((char *)__func__);
57	62	return 0;
58	63	}
…	…
61	66	arch_power_state_t state)
62	67	{
	68	x86_panic((char *)__func__);
63	69	return 0;
64	70	}
…	…
66	72	sint_t arch_barrier_init(struct cluster_s cluster, struct event_s event, uint_t count)
67	73	{
	74	x86_panic((char *)__func__);
68	75	return 0;
69	76	}
…	…
71	78	sint_t arch_barrier_wait(struct cluster_s *cluster, uint_t barrier_id)
72	79	{
	80	x86_panic((char *)__func__);
73	81	return 0;
74	82	}
…	…
76	84	error_t arch_barrier_destroy(struct cluster_s *cluster, uint_t barrier_id)
77	85	{
	86	x86_panic((char *)__func__);
78	87	return 0;
79	88	}
…	…
83	92	uint32_t val )
84	93	{
	94	x86_panic((char *)__func__);
85	95	return 0;
86	96	}

trunk/hal/x86_64/hal_arch.h

r25	r48
24	24	#include <hal_types.h>
25	25	#include <soclib_xicu.h>
	26	#include <hal_internal.h>
26	27
27	28	/*****************************************************************************************
…	…
39	40	static void cpu_default_irq_handler(struct irq_action_s *action)
40	41	{
41
	42	x86_panic((char *)__func__);
42	43	}
43	44
44	45	error_t hal_arch_init(struct cpu_s *cpu)
45	46	{
46
	47	x86_panic((char *)__func__);
47	48	return 0;
48	49	}
…	…
50	51	error_t arch_cpu_set_irq_entry(struct cpu_s cpu, int irq_nr, struct irq_action_s action)
51	52	{
	53	x86_panic((char *)__func__);
52	54	return 0;
53	55	}
…	…
55	57	error_t arch_cpu_get_irq_entry(struct cpu_s cpu, int irq_nr, struct irq_action_s *action)
56	58	{
	59	x86_panic((char *)__func__);
57	60	return 0;
58	61	}
…	…
60	63	error_t arch_set_power_state(struct cpu_s *cpu, arch_power_state_t state)
61	64	{
	65	x86_panic((char *)__func__);
62	66	return 0;
63	67	}
…	…
65	69	sint_t arch_barrier_init(struct cluster_s cluster, struct event_s event, uint_t count)
66	70	{
	71	x86_panic((char *)__func__);
67	72	return 0;
68	73	}
…	…
70	75	sint_t arch_barrier_wait(struct cluster_s *cluster, uint_t barrier_id)
71	76	{
	77	x86_panic((char *)__func__);
72	78	return 0;
73	79	}
…	…
75	81	error_t arch_barrier_destroy(struct cluster_s *cluster, uint_t barrier_id)
76	82	{
	83	x86_panic((char *)__func__);
77	84	return 0;
78	85	}

trunk/hal/x86_64/hal_atomic.c

r25	r48
23	23
24	24	#include <hal_types.h>
	25	#include <hal_internal.h>
25	26
26	27	void hal_atomic_and( uint32_t * ptr,
27	28	int32_t val )
28	29	{
29
	30	x86_panic((char *)__func__);
30	31	}
31	32
…	…
33	34	int32_t val )
34	35	{
35
	36	x86_panic((char *)__func__);
36	37	}
37	38
…	…
39	40	int32_t val )
40	41	{
	42	x86_panic((char *)__func__);
41	43	return 0;
42	44	}
…	…
46	48	uint32_t new )
47	49	{
	50	x86_panic((char *)__func__);
48	51	return 0;
49	52	}
…	…
52	55	int32_t val )
53	56	{
	57	x86_panic((char *)__func__);
54	58	return 0;
55	59	}

trunk/hal/x86_64/hal_context.c

r25	r48
34	34	#include <hal_context.h>
35	35
	36	#include <hal_internal.h>
	37
36	38	error_t hal_cpu_context_create( struct thread_s * thread )
37	39	{
38		return 0;
	40	x86_panic((char *)__func__);
	41	return 0;
39	42	}
40	43
…	…
42	45	thread_t * src )
43	46	{
44		return 0;
	47	x86_panic((char *)__func__);
	48	return 0;
45	49	}
46	50
47	51	void hal_cpu_context_destroy( thread_t * thread )
48	52	{
49
50
	53	x86_panic((char *)__func__);
51	54	}
52	55
53	56	error_t hal_fpu_context_create( thread_t * thread )
54	57	{
55		return 0;
	58	x86_panic((char *)__func__);
	59	return 0;
56	60	}
57	61
…	…
59	63	thread_t * src )
60	64	{
61		return 0;
	65	x86_panic((char *)__func__);
	66	return 0;
62	67	}
63	68
64	69	void hal_fpu_context_destroy( thread_t * thread )
65	70	{
66
	71	x86_panic((char *)__func__);
67	72	}
68	73
69	74	void hal_cpu_context_save( thread_t * thread )
70	75	{
	76	x86_panic((char *)__func__);
	77	}
71	78
72		}
73
74	79	void hal_cpu_context_restore( thread_t * thread )
75	80	{
76
	81	x86_panic((char *)__func__);
77	82	}
78	83
79	84	void hal_cpu_context_load( thread_t * thread )
80	85	{
81
	86	x86_panic((char *)__func__);
82	87	}
83	88
84	89	void hal_fpu_context_save( thread_t * thread )
85	90	{
86
	91	x86_panic((char *)__func__);
87	92	}
88	93
89	94	void hal_fpu_context_restore( thread_t * thread )
90	95	{
91
	96	x86_panic((char *)__func__);
92	97	}
93	98
…	…
95	100	xptr_t src )
96	101	{
97
	102	x86_panic((char *)__func__);
98	103	}
99	104

trunk/hal/x86_64/hal_do_exceptions.c

r25	r48
23	23	*/
24	24
	25	#include <hal_internal.h>
	26
25	27	#include <types.h>
26	28	#include <task.h>
…	…
39	41	static error_t fpu_exception_handler( reg_t * regs_tbl )
40	42	{
	43	x86_panic((char *)__func__);
41	44	return 0;
42	45	}
43
44	46
45	47	static error_t mmu_exception_handler( uint32_t excp_code,
46	48	uint32_t bad_vaddr )
47	49	{
	50	x86_panic((char *)__func__);
48	51	return 0;
49	52	}
…	…
53	56	reg_t * regs_tbl )
54	57	{
55
	58	x86_panic((char *)__func__);
56	59	}

trunk/hal/x86_64/hal_do_interrupt.c

-                      r25
+                      r48
 #include <cpu-regs.h>
+#include <hal_internal.h>
 void hal_do_interrupt( thread_t * this,
                        reg_t      cpu_id,
 …
                                reg_t      irq_state )
+{
+        x86_panic((char *)__func__);
+}

trunk/hal/x86_64/hal_do_syscall.c

r25	r48
32	32	#include <cpu-regs.h>
33	33
	34	#include <hal_internal.h>
	35
34	36	extern reg_t do_syscall( reg_t arg0,
35	37	reg_t arg1,
…	…
40	42	static void sys_sigreturn()
41	43	{
42
	44	x86_panic((char *)__func__);
43	45	}
44	46
45	47	thread_t * hal_do_syscall( reg_t * regs_tbl )
46	48	{
	49	x86_panic((char *)__func__);
47	50	return NULL;
48	51	}

trunk/hal/x86_64/hal_exception.c

r25	r48
36	36	#include <remote_spinlock.h>
37	37
	38	#include <hal_internal.h>
	39
38	40	void hal_do_exception( thread_t * this,
39	41	reg_t * regs_tbl )
40	42	{
41
	43	x86_panic((char *)__func__);
42	44	}
43	45
…	…
45	47	reg_t * regs_tbl )
46	48	{
47
	49	x86_panic((char *)__func__);
48	50	}
49	51

trunk/hal/x86_64/hal_gpt.c

r47	r48
74	74	hal_gpt_leave_range(CLUSTER_MIN_VA(0) + KERNEL_VA_SIZE, npages);
75	75	}
76
77	76
78	77	void hal_gpt_enter(vaddr_t va, paddr_t pa)
…	…
246	245	error_t hal_gpt_create( gpt_t * gpt )
247	246	{
	247	x86_panic((char *)__func__);
248	248	return 0;
249	249	}
…	…
251	251	void hal_gpt_destroy( gpt_t * gpt )
252	252	{
253
	253	x86_panic((char *)__func__);
254	254	}
255	255
256	256	void hal_gpt_print( gpt_t * gpt )
257	257	{
258
	258	x86_panic((char *)__func__);
259	259	}
260	260
…	…
264	264	uint32_t attr )
265	265	{
	266	x86_panic((char *)__func__);
266	267	return 0;
267	268	}
…	…
272	273	ppn_t * ppn )
273	274	{
274
	275	x86_panic((char *)__func__);
275	276	}
276	277
…	…
278	279	vpn_t vpn )
279	280	{
280
	281	x86_panic((char *)__func__);
281	282	}
282	283
…	…
284	285	vpn_t vpn )
285	286	{
	287	x86_panic((char *)__func__);
286	288	return 0;
287	289	}
…	…
290	292	vpn_t vpn )
291	293	{
	294	x86_panic((char *)__func__);
292	295	return 0;
293	296	}
…	…
297	300	bool_t cow )
298	301	{
	302	x86_panic((char *)__func__);
299	303	return 0;
300	304	}

trunk/hal/x86_64/hal_interrupt.c

r25	r48
28	28	#include <hal_interrupt.h>
29	29
	30	#include <hal_internal.h>
	31
30	32	void hal_do_interrupt( thread_t * this,
31	33	reg_t * regs_tbl )
32	34	{
33
	35	x86_panic((char *)__func__);
34	36	}

trunk/hal/x86_64/hal_irqmask.c

r25	r48
24	24
25	25	#include <hal_types.h>
	26	#include <hal_internal.h>
26	27
27	28	inline void hal_disable_irq( uint32_t * old )
28	29	{
29
	30	x86_panic((char *)__func__);
30	31	}
31	32
32	33	inline void hal_enable_irq( uint32_t * old )
33	34	{
34
	35	x86_panic((char *)__func__);
35	36	}
36	37
37	38	inline void hal_restore_irq( uint32_t old )
38	39	{
39
	40	x86_panic((char *)__func__);
40	41	}
41	42

trunk/hal/x86_64/hal_remote.c

r25	r48
24	24
25	25	#include <hal_types.h>
	26	#include <hal_internal.h>
26	27
27	28	void hal_remote_sb( xptr_t xp,
28	29	char data )
29	30	{
30
	31	x86_panic((char *)__func__);
31	32	}
32	33
…	…
34	35	uint32_t data )
35	36	{
36
	37	x86_panic((char *)__func__);
37	38	}
38	39
…	…
40	41	uint64_t data )
41	42	{
42
	43	x86_panic((char *)__func__);
43	44	}
44	45
…	…
46	47	void * pt )
47	48	{
48
	49	x86_panic((char *)__func__);
49	50	}
50	51
51	52	char hal_remote_lb( xptr_t xp )
52	53	{
	54	x86_panic((char *)__func__);
53	55	return 0;
54	56	}
…	…
56	58	uint32_t hal_remote_lw( xptr_t xp )
57	59	{
	60	x86_panic((char *)__func__);
58	61	return 0;
59	62	}
…	…
61	64	uint64_t hal_remote_lwd( xptr_t xp )
62	65	{
	66	x86_panic((char *)__func__);
63	67	return 0;
64	68	}
…	…
67	71	void * pt )
68	72	{
	73	x86_panic((char *)__func__);
69	74	return NULL;
70	75	}
…	…
72	77	uint32_t hal_remote_lw_unc( xptr_t xp )
73	78	{
	79	x86_panic((char *)__func__);
74	80	return 0;
75	81	}
…	…
79	85	uint32_t new )
80	86	{
	87	x86_panic((char *)__func__);
81	88	return 0;
82	89	}
…	…
84	91	uint32_t hal_remote_atomic_add( xptr_t xp,
85	92	uint32_t incr )
86		{
	93	{
	94	x86_panic((char *)__func__);
87	95	return 0;
88	96	}
…	…
90	98	uint32_t hal_remote_atomic_and( xptr_t xp,
91	99	uint32_t mask )
92		{
	100	{
	101	x86_panic((char *)__func__);
93	102	return 0;
94	103	}
…	…
96	105	uint32_t hal_remote_atomic_or( xptr_t xp,
97	106	uint32_t mask )
98		{
	107	{
	108	x86_panic((char *)__func__);
99	109	return 0;
100	110	}
…	…
104	114	uint32_t * old )
105	115	{
	116	x86_panic((char *)__func__);
106	117	return 0;
107	118	}
…	…
111	122	uint32_t size )
112	123	{
113
	124	x86_panic((char *)__func__);
114	125	}
115	126

trunk/hal/x86_64/hal_syscall.c

r25	r48
27	27	#include <thread.h>
28	28
	29	#include <hal_internal.h>
	30
29	31	void hal_do_syscall( thread_t * this,
30	32	reg_t * regs_tbl )
31	33	{
32
	34	x86_panic((char *)__func__);
33	35	}

trunk/hal/x86_64/hal_uspace.c

r25	r48
27	27	#include <hal_irqmask.h>
28	28
	29	#include <hal_internal.h>
	30
29	31	void hal_copy_from_uspace( void * k_dst,
30	32	void * u_src,
31	33	uint32_t size )
32	34	{
33
	35	x86_panic((char *)__func__);
34	36	}
35	37
…	…
38	40	uint32_t size )
39	41	{
40
	42	x86_panic((char *)__func__);
41	43	}
42	44
43	45	uint32_t hal_strlen_from_uspace( char * u_str )
44	46	{
	47	x86_panic((char *)__func__);
45	48	return 0;
46	49	}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 48 for trunk/hal/x86_64

Legend:

Download in other formats: