Context Navigation

source: trunk/hal/tsar_mips32/core/hal_uspace.c @ 657

Last change on this file since 657 was 657, checked in by alain, 4 years ago
Introduce remote_buf.c/.h & socket.c/.h files. Update dev_nic.c/.h files.
File size: 18.2 KB

Line
1	/*
2	* hal_uspace.c - implementation of Generic User Space Access API for MIPS32
3	*
4	* Author Alain Greiner (2016,2017,2018,2019,2020)
5	*
6	* Copyright (c) UPMC Sorbonne Universites
7	*
8	* This file is part of ALMOS-MKH..
9	*
10	* ALMOS-MKH. is free software; you can redistribute it and/or modify it
11	* under the terms of the GNU General Public License as published by
12	* the Free Software Foundation; version 2.0 of the License.
13	*
14	* ALMOS-MKH. is distributed in the hope that it will be useful, but
15	* WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17	* General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with ALMOS-MKH.; if not, write to the Free Software Foundation,
21	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22	*/
23
24	#include <hal_kernel_types.h>
25	#include <hal_uspace.h>
26	#include <hal_special.h>
27	#include <hal_irqmask.h>
28
29	#include <printk.h>
30	#include <thread.h>
31
32	///////////////////////////////////////////////////////////////////////////////////////
33	// This function moves <size> bytes from a source buffer in user virtual space,
34	// defined by the <u_src_ptr> argument, to a destination kernel buffer, defined by the
35	// <k_dst_xp> argument.
36	// It works in a critical section, as it modifies two CP2 registers:
37	// It activates briefly the DATA_MMU by writing into the CP2_MODE register to access the
38	// user buffer, and modifies the CP2_DEXT register to access the kernel buffer.
39	// If the two buffers are aligned on a word boundary, it moves the data word per word
40	// in a first loop, and moves byte per byte the remaining bytes in a second loop.
41	// If the buffers are not aligned, it moves all data byte per byte.
42	///////////////////////////////////////////////////////////////////////////////////////
43	// @ k_dst_xp : extended pointer on destination kernel buffer
44	// @ u_src_ptr : pointer on source user buffer
45	// @ size : number of bytes to move
46	///////////////////////////////////////////////////////////////////////////////////////
47	void hal_copy_from_uspace( xptr_t k_dst_xp,
48	void * u_src_ptr,
49	uint32_t size )
50	{
51	uint32_t save_sr;
52	uint32_t words; // number of words (if buffers aligned)
53	uint32_t src = (uint32_t)u_src_ptr;
54	uint32_t dst = (uint32_t)GET_PTR( k_dst_xp );
55	uint32_t cxy = (uint32_t)GET_CXY( k_dst_xp );
56
57	#if DEBUG_HAL_USPACE
58	thread_t * this = CURRENT_THREAD;
59	uint32_t cycle = (uint32_t)hal_get_cycles();
60	if( cycle > DEBUG_HAL_USPACE )
61	printk("\n[%s] thread[%x,%x] enter / %d bytes / u_buf(%x,%x) -> k_buf(%x,%x) / cycle %d\n",
62	__FUNCTION__, this->process->pid, this->trdid, size, local_cxy, src, cxy, dst, cycle );
63	#endif
64
65	if( (dst & 0x3) \|\| (src & 0x3) ) words = 0; // do it all in bytes
66	else words = size >> 2;
67
68	// enter critical section
69	hal_disable_irq( &save_sr );
70
71	asm volatile( ".set noreorder \n"
72
73	/* initialise registers */
74	"move $8, %0 \n" /* $8 <= src */
75	"move $9, %1 \n" /* $9 <= dst */
76	"move $10, %2 \n" /* $10 <= words */
77	"move $11, %3 \n" /* $11 <= size */
78	"mfc2 $12, $1 \n" /* $12 <= old MMU_MODE */
79	"ori $13, $12, 0x4 \n" /* $13 <= MMU_MODE with DTLB */
80
81	/* save MMU_DEXT register */
82	"mfc2 $16, $24 \n" /* $16 <= old MMU_DEXT */
83	"mtc2 %4, $24 \n" /* MMU_DEXT <= dst_cxy */
84
85	/* transfer one word per iteration in first loop if aligned */
86	"move $15, $10 \n" /* $15 <= words ($15 == i) */
87	"1: \n"
88	"beq $15, $0, 2f \n" /* exit loop if (i==0) */
89	"nop \n"
90	"mtc2 $13, $1 \n" /* MMU_MODE <= DTLB ON */
91	"lw $14, 0($8) \n" /* word from user space */
92	"mtc2 $12, $1 \n" /* restore old MMU_MODE */
93	"sw $14, 0($9) \n" /* word to kernel space */
94	"addi $15, $15, -1 \n" /* i-- */
95	"addi $8, $8, 4 \n" /* src += 4 bytes */
96	"j 1b \n"
97	"addi $9, $9, 4 \n" /* dst += 4 bytes */
98
99	/* transfer one byte per iteration in this second loop */
100	"2: \n"
101	"sll $15, $10, 2 \n" /* $15 <= words4 ($15 == i) /
102	"3: \n"
103	"beq $15, $11, 4f \n" /* exit loop if (i == size) */
104	"nop \n"
105	"mtc2 $13, $1 \n" /* MMU_MODE <= DTLB ON */
106	"lb $14, 0($8) \n" /* byte from user space */
107	"mtc2 $12, $1 \n" /* restore omd MMU_MODE */
108	"sb $14, 0($9) \n" /* byte to kernel space */
109	"addi $15, $15, 1 \n" /* i++ */
110	"addi $8, $8, 1 \n" /* src += 1 byte */
111	"j 3b \n"
112	"addi $9, $9, 1 \n" /* dst += 1 byte */
113
114	/* restore MMU_DEXT register */
115	"4: \n"
116	"mtc2 $16, $24 \n" /* MMU_DEXT <= $16 */
117	".set reorder \n"
118	:
119	: "r"(src) , "r"(dst) , "r"(words) , "r"(size) , "r"(cxy)
120	: "$8","$9","$10","$11","$12","$13","$14","$15","$16","memory" );
121
122	// exit critical section
123	hal_restore_irq( save_sr );
124
125	#if DEBUG_HAL_USPACE
126	cycle = (uint32_t)hal_get_cycles();
127	if( cycle > DEBUG_HAL_USPACE )
128	printk("\n[%s] thread[%x,%x] moved %d bytes / u_buf(%x,%x) -> k_buf(%x,%x) / cycle %d\n",
129	__FUNCTION__, this->process->pid, this->trdid, size, local_cxy, src, cxy, dst, cycle );
130	#endif
131
132	} // end hal_copy_from_uspace()
133
134	///////////////////////////////////////////////////////////////////////////////////////
135	// This function moves <size> bytes from a source kernel buffer, defined by the
136	// <k_src_xp> argument, to a destination buffer in user virtual space, defined by
137	// the <u_dst_ptr> argument.
138	// It works in a critical section, as it modifies two CP2 registers:
139	// It activates briefly the DATA_MMU by writing into the CP2_MODE register to access the
140	// user buffer, and modifies the CP2_DEXT register to access the kernel buffer.
141	// If the two buffers are aligned on a word boundary, it moves the data word per word
142	// in a first loop, and moves byte per byte the remaining bytes in a second loop.
143	// If the buffers are not word aligned, it moves all data byte per byte.
144	///////////////////////////////////////////////////////////////////////////////////////
145	// @ u_dst_ptr : pointer on destination user buffer
146	// @ k_src_xp : extended pointer on source kernel buffer
147	// @ size : number of bytes to move
148	///////////////////////////////////////////////////////////////////////////////////////
149	void hal_copy_to_uspace( void * u_dst_ptr,
150	xptr_t k_src_xp,
151	uint32_t size )
152	{
153	uint32_t save_sr;
154	uint32_t words; // number of words (if buffers aligned)
155	uint32_t dst = (uint32_t)u_dst_ptr;
156	uint32_t src = (uint32_t)GET_PTR( k_src_xp );
157	uint32_t cxy = (uint32_t)GET_CXY( k_src_xp );
158
159	#if DEBUG_HAL_USPACE
160	thread_t * this = CURRENT_THREAD;
161	uint32_t cycle = (uint32_t)hal_get_cycles();
162	if( cycle > DEBUG_HAL_USPACE )
163	printk("\n[%s] thread[%x,%x] enter / %d bytes / k_buf(%x,%x) -> u_buf(%x,%x) / cycle %d\n",
164	__FUNCTION__, this->process->pid, this->trdid, size, cxy, src, local_cxy, dst, cycle );
165	#endif
166
167	if( (dst & 0x3) \|\| (src & 0x3) ) words = 0; // not aligned
168	else words = size >> 2;
169
170	// enter critical section
171	hal_disable_irq( &save_sr );
172
173	asm volatile( ".set noreorder \n"
174
175	/* initialise registers */
176	"move $8, %0 \n" /* $8 <= k_src */
177	"move $9, %1 \n" /* $9 <= u_dst */
178	"move $10, %2 \n" /* $10 <= words */
179	"move $11, %3 \n" /* $11 <= size */
180	"mfc2 $12, $1 \n" /* $12 <= old MMU_MODE */
181	"ori $13, $12, 0x4 \n" /* $13 <= MMU_MODE with DTLB */
182
183	/* save MMU_DEXT register */
184	"mfc2 $16, $24 \n" /* $16 <= old MMU_DEXT */
185	"mtc2 %4, $24 \n" /* MMU_DEXT <= cxy */
186
187	/* transfer one word per iteration in first loop if aligned */
188	"move $15, $10 \n" /* $15 <= words ($15 == i) */
189	"1: \n"
190	"beq $15, $0, 2f \n" /* exit loop if (i==0) */
191	"nop \n"
192	"lw $14, 0($8) \n" /* load from kernel space */
193	"mtc2 $13, $1 \n" /* MMU_MODE <= DTLB ON */
194	"sw $14, 0($9) \n" /* store to user space */
195	"mtc2 $12, $1 \n" /* restore old MMU_MODE */
196	"addi $15, $15, -1 \n" /* i-- */
197	"addi $8, $8, 4 \n" /* src += 4 bytes */
198	"j 1b \n"
199	"addi $9, $9, 4 \n" /* dst += 4 bytes */
200
201	/* transfer one byte per iteration in this second loop */
202	"2: \n"
203	"sll $15, $10, 2 \n" /* $15 <= words4 ($15 == i) /
204	"3: \n"
205	"beq $15, $11, 4f \n" /* exit loop if (i == size) */
206	"nop \n"
207	"lb $14, 0($8) \n" /* byte from kernel space */
208	"mtc2 $13, $1 \n" /* MMU_MODE <= DTLB ON */
209	"sb $14, 0($9) \n" /* byte to user space */
210	"mtc2 $12, $1 \n" /* restore omd MMU_MODE */
211	"addi $15, $15, 1 \n" /* i++ */
212	"addi $8, $8, 1 \n" /* src += 1 byte */
213	"j 3b \n"
214	"addi $9, $9, 1 \n" /* dst += 1 byte */
215
216	/* restore MMU_DEXT register */
217	"4: \n"
218	"mtc2 $16, $24 \n" /* MMU_DEXT <= $16 */
219	".set reorder \n"
220	:
221	: "r"(src) , "r"(dst) , "r"(words) , "r"(size) , "r"(cxy)
222	: "$8","$9","$10","$11","$12","$13","$14","$15","$16","memory" );
223
224	// exit critical section
225	hal_restore_irq( save_sr );
226
227	#if DEBUG_HAL_USPACE
228	cycle = (uint32_t)hal_get_cycles();
229	if( cycle > DEBUG_HAL_USPACE )
230	printk("\n[%s] thread[%x,%x] moved %d bytes / k_buf(%x,%x) -> u_buf(%x,%x) / cycle %d\n",
231	__FUNCTION__, this->process->pid, this->trdid, size, cxy, src, local_cxy, dst, cycle );
232	#endif
233
234	} // end hal_copy_to_uspace()
235
236	/////////////////////////////////////////////////
237	void hal_strcpy_from_uspace( xptr_t k_dst_xp,
238	char * u_src_ptr,
239	uint32_t size )
240	{
241	uint32_t save_sr;
242	uint32_t src = (uint32_t)u_src_ptr;
243	uint32_t dst = (uint32_t)GET_PTR( k_dst_xp );
244	uint32_t cxy = (uint32_t)GET_CXY( k_dst_xp );
245
246	hal_disable_irq( &save_sr );
247
248	// loop on characters while ( (character != NUL) and (count < size ) )
249
250	asm volatile(
251	".set noreorder \n"
252
253	/* save old MMU_DEXT and set cxy in it */
254	"mfc2 $16, $24 \n" /* $16 <= old MMU_DEXT */
255	"mtc2 %3, $24 \n" /* MMU_DEXT <= cxy */
256
257	"move $11, %0 \n" /* $11 <= count == size */
258	"move $12, %1 \n" /* $12 <= u_src */
259	"move $13, %2 \n" /* $13 <= k_dst */
260	"mfc2 $15, $1 \n" /* $15 <= MMU_MODE */
261	"ori $14, $15, 0x4 \n" /* $14 <= MMU_MODE / DTLB ON */
262
263	"1: \n"
264	"mtc2 $14, $1 \n" /* MMU_MODE <= DTLB ON */
265	"lb $10, 0($12) \n" /* read char from user space */
266	"mtc2 $15, $1 \n" /* MMU_MODE <= DTLB OFF */
267	"sb $10, 0($13) \n" /* store char to kernel space */
268	"beq $10, $0, 2f \n" /* exit if char = 0 */
269	"addi $11, $11, -1 \n" /* decrement count */
270	"addi $12, $12, 1 \n" /* increment u_src pointer */
271	"beq $11, $0, 2f \n" /* exit if count == 0 */
272	"addi $13, $13, 1 \n" /* increment k_src pointer */
273	"j 1b \n" /* jump to next iteration */
274	"2: \n"
275	"nop \n"
276
277	/* restore old MMU_DEXT register */
278	"mtc2 $16, $24 \n" /* MMU_DEXT <= $16 */
279
280	".set reorder \n"
281	:
282	: "r"(size) , "r"(src) , "r"(dst) , "r"(cxy)
283	: "$10","$11","$12","$13","$14","$15","$16" );
284
285	hal_restore_irq( save_sr );
286
287	} // hal_strcpy_from_uspace()
288
289	////////////////////////////////////////////////
290	void hal_strcpy_to_uspace( char * u_dst_ptr,
291	xptr_t k_src_xp,
292	uint32_t size )
293	{
294	uint32_t save_sr;
295	uint32_t dst = (uint32_t)u_dst_ptr;
296	uint32_t src = (uint32_t)GET_PTR( k_src_xp );
297	uint32_t cxy = (uint32_t)GET_CXY( k_src_xp );
298
299	hal_disable_irq( &save_sr );
300
301	// loop on characters while ( (character != NUL) and (count < size) )
302
303	asm volatile(
304	".set noreorder \n"
305
306	/* save old MMU_DEXT and set cxy in it */
307	"mfc2 $16, $24 \n" /* $16 <= old MMU_DEXT */
308	"mtc2 %3, $24 \n" /* MMU_DEXT <= cxy */
309
310	"move $11, %0 \n" /* $11 <= count == size */
311	"move $12, %1 \n" /* $12 <= k_src */
312	"move $13, %2 \n" /* $13 <= u_dst */
313	"mfc2 $15, $1 \n" /* $15 <= MMU_MODE */
314	"ori $14, $15, 0x4 \n" /* $14 <= MMU_MODE modified */
315
316	"1: \n"
317	"lb $10, 0($12) \n" /* read char from kernel space */
318	"mtc2 $14, $1 \n" /* MMU_MODE <= DTLB ON */
319	"sb $10, 0($13) \n" /* store char to user space */
320	"mtc2 $15, $1 \n" /* MMU_MODE <= DTLB OFF */
321	"beq $10, $0, 2f \n" /* exit if char == 0 */
322	"addi $11, $11, -1 \n" /* decrement count */
323	"addi $12, $12, 1 \n" /* increment k_src pointer */
324	"beq $11, $0, 2f \n" /* exit if count == 0 */
325	"addi $13, $13, 1 \n" /* increment u_src pointer */
326	"j 1b \n" /* jump to next iteration */
327	"2: \n"
328	"nop \n"
329
330	/* restore old MMU_DEXT register */
331	"mtc2 $16, $24 \n" /* MMU_DEXT <= $16 */
332
333	".set reorder \n"
334	:
335	: "r"(size) , "r"(src) , "r"(dst) , "r"(cxy)
336	: "$10","$11","$12","$13","$14","$15","$16" );
337
338	hal_restore_irq( save_sr );
339
340	} // hal_strcpy_to_uspace()
341
342	///////////////////////////////////////////////
343	uint32_t hal_strlen_from_uspace( char * u_str )
344	{
345	uint32_t save_sr;
346	uint32_t count = 0;
347	uint32_t str = (uint32_t)u_str;
348
349	hal_disable_irq( &save_sr );
350
351	asm volatile(
352	".set noreorder \n"
353	"move $13, %1 \n" /* $13 <= str */
354	"mfc2 $15, $1 \n" /* $15 <= MMU_MODE (DTLB off) */
355	"ori $14, $15, 0x4 \n" /* $14 <= mode DTLB on */
356	"1: \n"
357	"mtc2 $14, $1 \n" /* set DTLB on */
358	"lb $12, 0($13) \n" /* $12 <= one byte from u_space */
359	"mtc2 $15, $1 \n" /* set DTLB off */
360	"addi $13, $13, 1 \n" /* increment address */
361	"bne $12, $0, 1b \n" /* loop until NUL found */
362	"addi %0, %0, 1 \n" /* increment count */
363	".set reorder \n"
364	: "+r"(count)
365	: "r"(str)
366	: "$12","$13","$14","$15" );
367
368	hal_restore_irq( save_sr );
369
370	return count;
371	}
372

Note: See TracBrowser for help on using the repository browser.

Download in other formats: