![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to movc.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / ppc|
Return to movc.s CVS log | Up to [Apple XNU] / XNU / osfmk / ppc |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25:
26: #include <debug.h>
27: #include <ppc/asm.h>
28: #include <ppc/proc_reg.h>
29: #include <mach/ppc/vm_param.h>
30: #include <assym.s>
31: #include <sys/errno.h>
32:
33: /*
34: * void pmap_zero_page(vm_offset_t pa)
35: *
36: * zero a page of physical memory.
37: */
38:
39: #if DEBUG
40: /* C debug stub in pmap.c calls this */
41: ENTRY(pmap_zero_page_assembler, TAG_NO_FRAME_USED)
42: #else
43: ENTRY(pmap_zero_page, TAG_NO_FRAME_USED)
44: #endif /* DEBUG */
45:
46: mfmsr r6 /* Get the MSR */
47: rlwinm r7, r6, 0, MSR_DR_BIT+1, MSR_DR_BIT-1 /* Turn off DR */
48: rlwinm r7,r7,0,MSR_EE_BIT+1,MSR_EE_BIT-1 ; Disable interruptions
49: li r4,PPC_PGBYTES-CACHE_LINE_SIZE /* Point to the end of the page */
50: mtmsr r7 /* Set MSR to DR off */
51: isync /* Ensure data translations are off */
52:
53:
54: .L_phys_zero_loop:
55: subic. r5,r4,CACHE_LINE_SIZE /* Point to the next one */
56: dcbz r4, r3 /* Clear the whole thing to 0s */
57: subi r4,r5,CACHE_LINE_SIZE /* Point to the next one */
58: dcbz r5, r3 /* Clear the next to zeros */
59: bgt+ .L_phys_zero_loop /* Keep going until we do the page... */
60:
61: sync /* Make sure they're all done */
62: li r4,PPC_PGBYTES-CACHE_LINE_SIZE /* Point to the end of the page */
63:
64: .L_inst_inval_loop:
65: subic. r5,r4,CACHE_LINE_SIZE /* Point to the next one */
66: icbi r4, r3 /* Clear the whole thing to 0s */
67: subi r4,r5,CACHE_LINE_SIZE /* Point to the next one */
68: icbi r5, r3 /* Clear the next to zeros */
69: bgt+ .L_inst_inval_loop /* Keep going until we do the page... */
70:
71: sync /* Make sure they're all done */
72:
73: mtmsr r6 /* Restore original translations */
74: isync /* Ensure data translations are on */
75:
76: blr
77:
78: /* void
79: * phys_copy(src, dst, bytecount)
80: * vm_offset_t src;
81: * vm_offset_t dst;
82: * int bytecount
83: *
84: * This routine will copy bytecount bytes from physical address src to physical
85: * address dst.
86: */
87:
88: ENTRY(phys_copy, TAG_NO_FRAME_USED)
89:
90: /* Switch off data translations */
91: mfmsr r6
92: rlwinm r7, r6, 0, MSR_DR_BIT+1, MSR_DR_BIT-1
93: rlwinm r7, r7, 0, MSR_EE_BIT+1, MSR_EE_BIT-1
94: mtmsr r7
95: isync /* Ensure data translations are off */
96:
97: subi r3, r3, 4
98: subi r4, r4, 4
99:
100: cmpwi r5, 3
101: ble- .L_phys_copy_bytes
102: .L_phys_copy_loop:
103: lwz r0, 4(r3)
104: addi r3, r3, 4
105: subi r5, r5, 4
106: stw r0, 4(r4)
107: addi r4, r4, 4
108: cmpwi r5, 3
109: bgt+ .L_phys_copy_loop
110:
111: /* If no leftover bytes, we're done now */
112: cmpwi r5, 0
113: beq+ .L_phys_copy_done
114:
115: .L_phys_copy_bytes:
116: addi r3, r3, 3
117: addi r4, r4, 3
118: .L_phys_copy_byte_loop:
119: lbz r0, 1(r3)
120: addi r3, r3, 1
121: subi r5, r5, 1
122: stb r0, 1(r4)
123: addi r4, r4, 1
124: cmpwi r5, 0
125: bne+ .L_phys_copy_byte_loop
126:
127: .L_phys_copy_done:
128: mtmsr r6 /* Restore original translations */
129: isync /* Ensure data translations are off */
130:
131: blr
132:
133: /* void
134: * pmap_copy_page(src, dst)
135: * vm_offset_t src;
136: * vm_offset_t dst;
137: *
138: * This routine will copy the physical page src to physical page dst
139: *
140: * This routine assumes that the src and dst are page aligned and that the
141: * destination is cached.
142: *
143: * We also must assume that noone will be executing within the destination
144: * page. We also assume that this will be used for paging
145: *
146: */
147:
148: #if DEBUG
149: /* if debug, we have a little piece of C around this
150: * in pmap.c that gives some trace ability
151: */
152: ENTRY(pmap_copy_page_assembler, TAG_NO_FRAME_USED)
153: #else
154: ENTRY(pmap_copy_page, TAG_NO_FRAME_USED)
155: #endif /* DEBUG */
156:
157: #if 0
158: mfpvr r9 ; Get the PVR
159: rlwinm r9,r9,16,16,31 ; Isolate the PPC processor
160: cmplwi r9,PROCESSOR_VERSION_Max ; Do we have Altivec?
161: beq+ wegotaltivec ; Yeah...
162: #endif
163:
164: mfmsr r9 ; Get the MSR
165: stwu r1,-(FM_SIZE+32)(r1) ; Make a frame for us
166: rlwinm r7,r9,0,MSR_EE_BIT+1,MSR_EE_BIT-1 ; Disable interruptions
167: ori r7,r7,lo16(MASK(MSR_FP)) ; Turn on the FPU
168: mtmsr r7 ; Disable rupts and enable FPU
169: isync
170:
171: stfd f0,FM_SIZE+0(r1) ; Save an FP register
172: rlwinm r7,r7,0,MSR_DR_BIT+1,MSR_DR_BIT-1 ; Clear the DDAT bit
173: stfd f1,FM_SIZE+8(r1) ; Save an FP register
174: addi r6,r3,PPC_PGBYTES ; Point to the start of the next page
175: stfd f2,FM_SIZE+16(r1) ; Save an FP register
176: mr r8,r4 ; Save the destination
177: stfd f3,FM_SIZE+24(r1) ; Save an FP register
178:
179: mtmsr r7 ; Set the new MSR
180: isync ; Ensure data translations are off
181:
182: dcbt br0, r3 /* Start in first input line */
183: li r5, CACHE_LINE_SIZE /* Get the line size */
184:
185: .L_pmap_copy_page_loop:
186: dcbz 0, r4 /* Allocate a line for the output */
187: lfd f0, 0(r3) /* Get first 8 */
188: lfd f1, 8(r3) /* Get second 8 */
189: lfd f2, 16(r3) /* Get third 8 */
190: stfd f0, 0(r4) /* Put first 8 */
191: dcbt r5, r3 /* Start next line coming in */
192: lfd f3, 24(r3) /* Get fourth 8 */
193: stfd f1, 8(r4) /* Put second 8 */
194: addi r3,r3,CACHE_LINE_SIZE /* Point to the next line in */
195: stfd f2, 16(r4) /* Put third 8 */
196: cmplw cr0,r3,r6 /* See if we're finished yet */
197: stfd f3, 24(r4) /* Put fourth 8 */
198: dcbst br0,r4 /* Force it out */
199: addi r4,r4,CACHE_LINE_SIZE /* Point to the next line out */
200: blt+ .L_pmap_copy_page_loop /* Copy the whole page */
201:
202: sync /* Make sure they're all done */
203: li r4,PPC_PGBYTES-CACHE_LINE_SIZE /* Point to the end of the page */
204:
205: invalinst:
206: subic. r5,r4,CACHE_LINE_SIZE /* Point to the next one */
207: icbi r4, r8 /* Trash the i-cache */
208: subi r4,r5,CACHE_LINE_SIZE /* Point to the next one */
209: icbi r5, r8 /* Trash the i-cache */
210: bgt+ invalinst /* Keep going until we do the page... */
211:
212: rlwimi r7,r9,0,MSR_DR_BIT,MSR_DR_BIT ; Set DDAT if on
213: sync ; Make sure all invalidates done
214:
215: mtmsr r7 ; Set DDAT correctly
216: isync
217:
218: lfd f0,FM_SIZE+0(r1) ; Restore an FP register
219: lfd f1,FM_SIZE+8(r1) ; Restore an FP register
220: lfd f2,FM_SIZE+16(r1) ; Restore an FP register
221: lfd f3,FM_SIZE+24(r1) ; Restore an FP register
222:
223: lwz r1,0(r1) ; Pop up the stack
224:
225: mtmsr r9 ; Turn off FPU now and maybe rupts back on
226: isync
227: blr
228:
229: #if 1
230: ;
231: ; This is not very optimal. We just do it here for a test of
232: ; Altivec in the kernel.
233: ;
234: wegotaltivec:
235: mfmsr r9 ; Get the MSR
236: lis r8,hi16(0xC0000000) ; Make sure we keep the first 2 vector registers
237: rlwinm r7,r9,0,MSR_EE_BIT+1,MSR_EE_BIT-1 ; Disable interruptions
238: lis r6,lo16(2*256+128) ; Specify 128 blocks of 2 vectors each
239: rlwinm r7,r7,0,MSR_DR_BIT+1,MSR_DR_BIT-1 ; Clear the DDAT bit
240: ori r6,r6,32 ; Set a 32-byte stride
241: mtsprg 256,r8 ; Set VRSave
242: mtmsr r7 ; Disable rupts and turn xlate off
243: isync
244:
245: dstt r3,r6,3 ; Stream in the page
246: addi r11,r3,4096 ; Point to the next page
247: li r10,16 ; Get vector size
248:
249: avmovepg: lvxl v0,br0,r3 ; Get first half of line
250: dcba br0,r4 ; Allocate output
251: lvxl v1,r10,r3 ; Get second half of line
252: stvxl v0,br0,r4 ; Save first half of line
253: addi r3,r3,32 ; Point to the next line
254: icbi br0,r4 ; Make the icache go away also
255: stvxl v1,r10,r4 ; Save second half of line
256: cmplw r3,r11 ; Have we reached the next page?
257: dcbst br0,r4 ; Make sure the line is on its way out
258: addi r4,r4,32 ; Point to the next line
259: blt+ avmovepg ; Move the next line...
260:
261: li r8,0 ; Clear this
262: sync ; Make sure all the memory stuff is done
263: mtsprg 256,r8 ; Show we are not using VRs any more
264: mtmsr r9 ; Translation and interruptions back on
265: isync
266: blr
267: #endif
268:
269:
270:
271:
272: /*
273: * int
274: * copyin(src, dst, count)
275: * vm_offset_t src;
276: * vm_offset_t dst;
277: * int count;
278: *
279: */
280:
281: ENTRY2(copyin, copyinmsg, TAG_NO_FRAME_USED)
282:
283: /* Preamble allowing us to call a sub-function */
284: mflr r0
285: stw r0,FM_LR_SAVE(r1)
286: stwu r1,-(FM_SIZE+16)(r1)
287:
288: mfmsr r0 /* Get the MSR */
289: rlwinm r6,r0,0,MSR_EE_BIT+1,MSR_EE_BIT-1 /* Clear 'rupts */
290: mtmsr r6 /* Disable 'rupts */
291:
292: mfsprg r6,0 /* Get the per_proc */
293: lwz r6,PP_CPU_DATA(r6)
294: cmpli cr0,r5,0
295: lwz r10,CPU_ACTIVE_THREAD(r6)
296: mtmsr r0 /* Set 'rupts back */
297: ble- cr0,.L_copyinout_trivial
298:
299: /* we know we have a valid copyin to do now */
300: /* Set up thread_recover in case we hit an illegal address */
301:
302: lwz r8,THREAD_TOP_ACT(r10)
303: lis r11,hi16(.L_copyinout_error)
304: lis r7,SEG_REG_PROT>>16 /* Top byte of SR value */
305: lwz r8,ACT_VMMAP(r8)
306: ori r11,r11,lo16(.L_copyinout_error)
307: add r9,r3,r5 /* Get the end of the source */
308: lwz r8,VMMAP_PMAP(r8)
309: subi r9,r9,1 /* Make sure we don't go too far */
310: rlwimi r7,r3,24,8,11 /* Insert seg number */
311: stw r11,THREAD_RECOVER(r10)
312: xor r9,r9,r3 /* Smoosh 'em together */
313: lwz r8,PMAP_SPACE(r8)
314: rlwinm r3,r3,0,4,31
315: rlwimi r7,r8,0,12,31 /* Insert space */
316: oris r3,r3,(SR_COPYIN_NUM << (28-16)) /* Set the copyin segment as the source */
317: rlwinm. r9,r9,0,1,3 /* Top nybble equal? */
318: mtsr SR_COPYIN,r7
319: isync
320:
321: #if 0
322: lis r0,HIGH_ADDR(EXT(dbgRegsCall)) /* (TEST/DEBUG) */
323: ori r0,r0,LOW_ADDR(EXT(dbgRegsCall)) /* (TEST/DEBUG) */
324: sc /* (TEST/DEBUG) */
325: #endif
326:
327: /* For optimisation, we check if the copyin lies on a segment
328: * boundary. If it doesn't, we can use a simple copy. If it
329: * does, we split it into two separate copies in some C code.
330: */
331:
332: bne- .L_call_copyin_multiple /* Nope, we went past the segment boundary... */
333:
334: bl EXT(bcopy)
335:
336: /* Now that copyin is done, we don't need a recovery point */
337: mfmsr r7 /* Get the MSR */
338: rlwinm r6,r7,0,MSR_EE_BIT+1,MSR_EE_BIT-1 /* Clear 'rupts */
339: mtmsr r6 /* Disable 'rupts */
340:
341: mfsprg r6,0 /* Get the per_proc */
342:
343: lwz r6,PP_CPU_DATA(r6)
344: addi r1,r1,FM_SIZE+16
345: lwz r10,CPU_ACTIVE_THREAD(r6)
346: mtmsr r7 ; Restore interrupts
347: li r3,0
348: lwz r0,FM_LR_SAVE(r1)
349: stw r3,THREAD_RECOVER(r10) /* Clear recovery */
350: mtlr r0
351: blr
352:
353: /* we get here via the exception handler if an illegal
354: * user memory reference was made.
355: */
356: .L_copyinout_error:
357:
358: /* Now that copyin is done, we don't need a recovery point */
359:
360: mfmsr r7 /* Get the MSR */
361: rlwinm r6,r7,0,MSR_EE_BIT+1,MSR_EE_BIT-1 /* Clear 'rupts */
362: mtmsr r6 /* Disable 'rupts */
363:
364: mfsprg r6,0 /* Get the per_proc */
365:
366: lwz r6,PP_CPU_DATA(r6)
367: addi r1,r1,FM_SIZE+16
368: lwz r10,CPU_ACTIVE_THREAD(r6)
369: mtmsr r7 ; Restore interrupts
370: li r4,0
371: lwz r0,FM_LR_SAVE(r1)
372: stw r4,THREAD_RECOVER(r10) /* Clear recovery */
373: mtlr r0
374: li r3,EFAULT ; Indicate error (EFAULT)
375: blr
376:
377: .L_copyinout_trivial:
378: /* The copyin/out was for either 0 bytes or a negative
379: * number of bytes, return an appropriate value (0 == SUCCESS).
380: * cr0 still contains result of comparison of len with 0.
381: */
382: li r3, 0
383: beq+ cr0, .L_copyinout_negative
384: li r3, 1
385: .L_copyinout_negative:
386:
387: /* unwind the stack */
388: addi r1, r1, FM_SIZE+16
389: lwz r0, FM_LR_SAVE(r1)
390: mtlr r0
391:
392: blr
393:
394: .L_call_copyin_multiple:
395:
396: /* unwind the stack */
397: addi r1, r1, FM_SIZE+16
398: lwz r0, FM_LR_SAVE(r1)
399: mtlr r0
400:
401: b EXT(copyin_multiple) /* not a call - a jump! */
402:
403: /*
404: * int
405: * copyout(src, dst, count)
406: * vm_offset_t src;
407: * vm_offset_t dst;
408: * int count;
409: *
410: */
411:
412: ENTRY2(copyout, copyoutmsg, TAG_NO_FRAME_USED)
413:
414: /* Preamble allowing us to call a sub-function */
415:
416: mflr r0
417: stw r0,FM_LR_SAVE(r1)
418: stwu r1,-(FM_SIZE+16)(r1)
419:
420: #if 0
421: stw r3,FM_SIZE+0(r1) /* (TEST/DEBUG) */
422: stw r4,FM_SIZE+4(r1) /* (TEST/DEBUG) */
423: stw r5,FM_SIZE+8(r1) /* (TEST/DEBUG) */
424: mr r6,r0 /* (TEST/DEBUG) */
425:
426: bl EXT(tracecopyout) /* (TEST/DEBUG) */
427:
428: lwz r3,FM_SIZE+0(r1) /* (TEST/DEBUG) */
429: lwz r4,FM_SIZE+4(r1) /* (TEST/DEBUG) */
430: lwz r5,FM_SIZE+8(r1) /* (TEST/DEBUG) */
431: #endif
432:
433: mfmsr r7 /* Get the MSR */
434: rlwinm r6,r7,0,MSR_EE_BIT+1,MSR_EE_BIT-1 /* Clear 'rupts */
435: mtmsr r6 /* Disable 'rupts */
436:
437: mfsprg r6,0 /* Get the per_proc */
438:
439: lwz r6,PP_CPU_DATA(r6)
440: cmpli cr0,r5,0
441: lwz r10,CPU_ACTIVE_THREAD(r6)
442: mtmsr r7 /* Restore 'rupts */
443: ble- cr0,.L_copyinout_trivial
444: /* we know we have a valid copyout to do now */
445: /* Set up thread_recover in case we hit an illegal address */
446:
447:
448: lwz r8,THREAD_TOP_ACT(r10)
449: lis r11,HIGH_ADDR(.L_copyinout_error)
450: lis r7,SEG_REG_PROT>>16 /* Top byte of SR value */
451: lwz r8,ACT_VMMAP(r8)
452: ori r11,r11,LOW_ADDR(.L_copyinout_error)
453: add r9,r4,r5 /* Get the end of the destination */
454: lwz r8,VMMAP_PMAP(r8)
455: rlwimi r7,r4,24,8,11 /* Insert seg number */
456: subi r9,r9,1 /* Make sure we don't go too far */
457: stw r11,THREAD_RECOVER(r10)
458: xor r9,r9,r4 /* Smoosh 'em together */
459: lwz r8,PMAP_SPACE(r8)
460: rlwinm r4,r4,0,4,31
461: rlwimi r7,r8,0,12,31 /* Insert space */
462: oris r4,r4,(SR_COPYIN_NUM << (28-16)) /* Set the copyin segment as the source */
463: rlwinm. r9,r9,0,1,3 /* Top nybble equal? */
464: mtsr SR_COPYIN,r7
465: isync
466:
467:
468: /* For optimisation, we check if the copyout lies on a segment
469: * boundary. If it doesn't, we can use a simple copy. If it
470: * does, we split it into two separate copies in some C code.
471: */
472:
473: bne- .L_call_copyout_multiple /* Nope, we went past the segment boundary... */
474:
475: bl EXT(bcopy)
476:
477: /* Now that copyout is done, we don't need a recovery point */
478: mfmsr r7 /* Get the MSR */
479: rlwinm r6,r7,0,MSR_EE_BIT+1,MSR_EE_BIT-1 /* Clear 'rupts */
480: mtmsr r6 /* Disable 'rupts */
481:
482: mfsprg r6,0 /* Get the per_proc */
483:
484: lwz r6,PP_CPU_DATA(r6)
485: addi r1,r1,FM_SIZE+16
486: lwz r10,CPU_ACTIVE_THREAD(r6)
487: mtmsr r7 ; Restore interrupts
488: li r3,0
489: lwz r0,FM_LR_SAVE(r1)
490: stw r3,THREAD_RECOVER(r10) /* Clear recovery */
491: mtlr r0
492: blr
493:
494: .L_call_copyout_multiple:
495: /* unwind the stack */
496: addi r1, r1, FM_SIZE+16
497: lwz r0, FM_LR_SAVE(r1)
498: mtlr r0
499:
500: b EXT(copyout_multiple) /* not a call - a jump! */
501:
502: /*
503: * boolean_t
504: * copyinstr(src, dst, count, maxcount)
505: * vm_offset_t src;
506: * vm_offset_t dst;
507: * vm_size_t maxcount;
508: * vm_size_t* count;
509: *
510: * Set *count to the number of bytes copied
511: *
512: * If dst == NULL, don't copy, just count bytes.
513: * Only currently called from klcopyinstr.
514: */
515:
516: ENTRY(copyinstr, TAG_NO_FRAME_USED)
517:
518: /* Preamble allowing us to call a sub-function */
519: mflr r0
520: stw r0,FM_LR_SAVE(r1)
521: stwu r1,-(FM_SIZE+16)(r1)
522:
523: #if 0
524: stw r3,FM_SIZE+0(r1) /* (TEST/DEBUG) */
525: stw r4,FM_SIZE+4(r1) /* (TEST/DEBUG) */
526: stw r5,FM_SIZE+8(r1) /* (TEST/DEBUG) */
527: stw r6,FM_SIZE+12(r1) /* (TEST/DEBUG) */
528: mr r7,r0 /* (TEST/DEBUG) */
529:
530: bl EXT(tracecopystr) /* (TEST/DEBUG) */
531:
532: lwz r3,FM_SIZE+0(r1) /* (TEST/DEBUG) */
533: lwz r4,FM_SIZE+4(r1) /* (TEST/DEBUG) */
534: lwz r5,FM_SIZE+8(r1) /* (TEST/DEBUG) */
535: stw r6,FM_SIZE+12(r1) /* (TEST/DEBUG) */
536: #endif
537:
538: mfmsr r0 /* Get the MSR */
539: rlwinm r7,r0,0,MSR_EE_BIT+1,MSR_EE_BIT-1 /* Clear 'rupts */
540: mtmsr r7 /* Disable 'rupts */
541:
542: mfsprg r7,0 /* Get the per_proc */
543: lwz r7,PP_CPU_DATA(r7)
544: cmpli cr0,r5,0
545: lwz r10,CPU_ACTIVE_THREAD(r7)
546: mtmsr r0 /* Restore 'rupts */
547: ble- cr0,.L_copyinout_trivial
548:
549: /* we know we have a valid copyin to do now */
550: /* Set up thread_recover in case we hit an illegal address */
551:
552: li r0,0
553: lwz r8,THREAD_TOP_ACT(r10)
554: stw r0,0(r6) /* Clear result length */
555: lis r11,HIGH_ADDR(.L_copyinout_error)
556: lis r7,SEG_REG_PROT>>16 /* Top byte of SR value */
557: lwz r8,ACT_VMMAP(r8)
558: ori r11,r11,LOW_ADDR(.L_copyinout_error)
559: lwz r8,VMMAP_PMAP(r8)
560: rlwimi r7,r3,24,8,11 /* Insert seg number */
561: stw r11,THREAD_RECOVER(r10)
562: lwz r8,PMAP_SPACE(r8)
563: rlwinm r3,r3,0,4,31
564: rlwimi r7,r8,0,12,31 /* Insert space */
565: oris r3,r3,(SR_COPYIN_NUM << (28-16)) /* Set the copyin segment as the source */
566:
567: /* Copy byte by byte for now - TODO NMGS speed this up with
568: * some clever (but fairly standard) logic for word copies.
569: * We don't use a copyinstr_multiple since copyinstr is called
570: * with INT_MAX in the linux server. Eugh.
571: */
572:
573: li r9,0 /* Clear byte counter */
574:
575: /* If the destination is NULL, don't do writes,
576: * just count bytes. We set CR7 outside the loop to save time
577: */
578: cmpwi cr7,r4,0 /* Is the destination null? */
579:
580: nxtseg: mtsr SR_COPYIN,r7 /* Set the source SR */
581: isync
582:
583: .L_copyinstr_loop:
584: lbz r0,0(r3) /* Get the source */
585: addic. r5,r5,-1 /* Have we gone far enough? */
586: addi r3,r3,1 /* Bump source pointer */
587:
588: cmpwi cr1,r0,0 /* Did we hit a null? */
589:
590: beq cr7,.L_copyinstr_no_store /* If we are just counting, skip the store... */
591:
592: stb r0,0(r4) /* Move to sink */
593: addi r4,r4,1 /* Advance sink pointer */
594:
595: .L_copyinstr_no_store:
596:
597: addi r9,r9,1 /* Count the character */
598: beq- cr1,.L_copyinstr_done /* We're done if we did a null... */
599: beq- cr0,L_copyinstr_toobig /* Also if we maxed the count... */
600:
601: /* Check to see if the copyin pointer has moved out of the
602: * copyin segment, if it has we must remap.
603: */
604:
605: rlwinm. r0,r3,0,4,31 /* Did we wrap around to 0? */
606: bne+ cr0,.L_copyinstr_loop /* Nope... */
607:
608: oris r3,r0,(SR_COPYIN_NUM << (28-16)) /* Reset the segment number */
609: addis r7,r7,0x0010 /* Yeah, we did, so bump the segment */
610: b nxtseg /* Keep going... */
611:
612: L_copyinstr_toobig:
613: li r3,ENAMETOOLONG
614: b L_copyinstr_return
615: .L_copyinstr_done:
616: li r3,0 /* Normal return */
617: L_copyinstr_return:
618: li r4,0 /* to clear thread_recover */
619: stw r9,0(r6) /* Set how many bytes we did */
620: stw r4,THREAD_RECOVER(r10) /* Clear recovery exit */
621:
622: addi r1, r1, FM_SIZE+16
623: lwz r0, FM_LR_SAVE(r1)
624: mtlr r0
625: blr
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.