Lines Matching refs:the
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
92 ! LOFAULT_SET flag before restoring the error handler.
145 ! using word reads and writes with the proper shifts
155 ! l5 the number 32
198 ! get the odd bytes between alignments
221 ! the source address is aligned and destination is not
266 b .dbytecp ! let dbytecp do the rest
267 sub %i0, %i1, %i0 ! i0 gets the difference of src and dst
269 ! the destination address is aligned and the source is not
283 ! longer to align the thing than to do the transfer
297 sub %i0, %i1, %i0 ! i0 gets the difference of src and dst
325 sub %i0, %i1, %i0 ! i0 gets the difference of src and dst
440 * Copies exactly one page. This routine assumes the caller (ppcopy)
503 ! %o0 contains the dest. address
518 * It is assumed that the kernel has nothing at
519 * less than KERNELBASE in the virtual address space.
521 * Note that copyin(9F) and copyout(9F) are part of the
527 * which return the errno that we've faithfully computed. This
529 * Given that these are used pretty heavily, we expand the calling
543 * None of the copyops routines grab a window.
549 * Store the previous lo_fault handler into %g6.
551 * Place the address of our fault handler into %o3.
556 * If count is > SMALL_LIMIT, we check the alignment of the input
557 * and output pointers. We store -count in %o3, we store the number
559 * in %o2. Following this we branch to the appropriate copy loop and
560 * copy that many chunks. Since we've been adding the chunk size
563 * zero, we're done and can go home. If not, we figure out what the
569 * current mapping. All forms share the same copyio_fault handler.
570 * This routine handles fixing up the stack and general housecleaning.
572 * to do the work specific to the invidual operation. The handler
573 * for copyOP and xcopyOP are found at the end of individual function.
574 * The handlers for xcopyOP_little are found at the end of xcopyin_little.
575 * The handlers for copyOP_noerr are found at the end of copyin_noerr.
592 * We save the arguments in the following registers in case of a fault:
605 * Generic copyio fault handler. This is the first line of defense when a
607 * properly, the value of the 'real' lofault handler should be in REAL_LOFAULT.
608 * This allows us to share common code for all the flavors of the copy
609 * operations, including the _noerr versions.
611 * Note that this function will restore the original input parameters before
612 * calling REAL_LOFAULT. So the real handler can vector to the appropriate
613 * member of the t_copyop structure, if needed.
631 ! Check the length and bail if zero.
651 ! Run in leaf mode, using the %o regs as our input regs.
659 add %o0, %o2, %o0 ! make %o0 point at the end
660 add %o1, %o2, %o1 ! make %o1 point at the end
664 ! %o0 and %o2 point at the end and remain pointing at the end
666 ! the negation of the length) to the buffer end which gives us
667 ! the curent location in the buffers. By incrementing %o3 we walk
695 ! See if we're single byte aligned. If we are, check the
697 ! bounce to the byte for byte copy loop. Otherwise do it in
714 ! Housekeeping for copy loops. Uses same idea as in the byte for
736 ! The check for small copies was done in the
765 ! Four byte copy loop. %o2 is the number of 4 byte chunks to copy.
786 ! two byte aligned copy loop. %o2 is the number of 2 byte chunks to
802 ! Deal with the last byte
911 ! Check the length and bail if zero.
943 ! %o0 and %o1 point at the end and remain pointing at the end
945 ! the negation of the length) to the buffer end which gives us
946 ! the curent location in the buffers. By incrementing %o3 we walk
968 ! See if we're single byte aligned. If we are, check the
970 ! bounce to the byte for byte copy loop. Otherwise do it in
987 ! Housekeeping for copy loops. Uses same idea as in the byte for
1003 ! Housekeeping for copy loops. Uses same idea as in the byte
1072 ! Deal with the last byte
1234 * longer than 256 bytes in length. For the generic module we will simply
1235 * call bzero and return 1 to ensure that the pages in cache should be
1254 ! Simply call bzero and notify the caller that bzero was used
1305 * uzero is used by the kernel to zero a block in user address space.
1354 * Otherwise we've already run screaming from the room.
1360 ! Undo asi register setting. Just set it to be the
1375 ! Old handler was zero. Just return the error.
1384 ! T_LOFAULT to the value of %o5 after clearing LOFAULT_SET
1385 ! before we either simply return the error or we invoke the
1450 add %o1, %o3, %o1 ! o1 is the remainder
1534 ! Set the remaining doubles
1540 stxa %g0, [%o0]%asi ! Clear the doubles
1567 ! Set the leftover bytes
1583 ! this even if the value of %o5 is otherwise zero.
1587 ! before resetting the error handler.