3 * Optimized version of the copy_user() routine.
4 * It is used to copy date across the kernel/user boundary.
6 * The source and destination are always on opposite side of
7 * the boundary. When reading from user space we must catch
8 * faults on loads. When writing to user space we must catch
9 * errors on stores. Note that because of the nature of the copy
10 * we don't need to worry about overlapping regions.
14 * in0 address of source buffer
15 * in1 address of destination buffer
16 * in2 number of bytes to copy
19 * ret0 0 in case of success. The number of bytes NOT copied in
22 * Copyright (C) 2000-2001 Hewlett-Packard Co
23 * Stephane Eranian <eranian@hpl.hp.com>
26 * - handle the case where we have more than 16 bytes and the alignment
29 * - fix extraneous stop bit introduced by the EX() macro.
32 #include <asm/asmmacro.h>
33 #include <asm/export.h>
36 // Tuneable parameters
38 #define COPY_BREAK 16 // we do byte copy below (must be >=16)
39 #define PIPE_DEPTH 21 // pipe depth
41 #define EPI p[PIPE_DEPTH-1]
53 #define t1 r2 // rshift in bytes
54 #define t2 r3 // lshift in bytes
55 #define rshift r14 // right shift in bits
56 #define lshift r15 // left shift in bits
74 GLOBAL_ENTRY(__copy_user)
76 .save ar.pfs, saved_pfs
77 alloc saved_pfs=ar.pfs,3,((2*PIPE_DEPTH+7)&~7),0,((2*PIPE_DEPTH+7)&~7)
79 .rotr val1[PIPE_DEPTH],val2[PIPE_DEPTH]
82 adds len2=-1,len // br.ctop is repeat/until
85 ;; // RAW of cfm when len=0
86 cmp.eq p8,p0=r0,len // check for zero length
88 mov saved_lc=ar.lc // preserve ar.lc (slow)
89 (p8) br.ret.spnt.many rp // empty mempcy()
91 add enddst=dst,len // first byte after end of source
92 add endsrc=src,len // first byte after end of destination
94 mov saved_pr=pr // preserve predicates
98 mov dst1=dst // copy because of rotation
100 mov pr.rot=1<<16 // p16=true all others are false
102 mov src1=src // copy because of rotation
103 mov ar.lc=len2 // initialize lc for small count
104 cmp.lt p10,p7=COPY_BREAK,len // if len > COPY_BREAK then long copy
106 xor tmp=src,dst // same alignment test prepare
107 (p10) br.cond.dptk .long_copy_user
108 ;; // RAW pr.rot/p16 ?
110 // Now we do the byte by byte loop with software pipeline
112 // p7 is necessarily false by now
114 EX(.failure_in_pipe1,(p16) ld1 val1[0]=[src1],1)
115 EX(.failure_out,(EPI) st1 [dst1]=val1[PIPE_DEPTH-1],1)
119 mov pr=saved_pr,0xffffffffffff0000
120 mov ar.pfs=saved_pfs // restore ar.ec
121 br.ret.sptk.many rp // end of short memcpy
124 // Not 8-byte aligned
126 .diff_align_copy_user:
127 // At this point we know we have more than 16 bytes to copy
128 // and also that src and dest do _not_ have the same alignment.
129 and src2=0x7,src1 // src offset
130 and dst2=0x7,dst1 // dst offset
132 // The basic idea is that we copy byte-by-byte at the head so
133 // that we can reach 8-byte alignment for both src1 and dst1.
134 // Then copy the body using software pipelined 8-byte copy,
135 // shifting the two back-to-back words right and left, then copy
136 // the tail by copying byte-by-byte.
138 // Fault handling. If the byte-by-byte at the head fails on the
139 // load, then restart and finish the pipleline by copying zeros
140 // to the dst1. Then copy zeros for the rest of dst1.
141 // If 8-byte software pipeline fails on the load, do the same as
142 // failure_in3 does. If the byte-by-byte at the tail fails, it is
143 // handled simply by failure_in_pipe1.
145 // The case p14 represents the source has more bytes in the
146 // the first word (by the shifted part), whereas the p15 needs to
147 // copy some bytes from the 2nd word of the source that has the
148 // tail of the 1st of the destination.
152 // Optimization. If dst1 is 8-byte aligned (quite common), we don't need
153 // to copy the head to dst1, to start 8-byte copy software pipeline.
154 // We know src1 is not 8-byte aligned in this case.
156 cmp.eq p14,p15=r0,dst2
157 (p15) br.cond.spnt 1f
163 sub len1=len,t1 // set len1
167 br.cond.spnt .word_copy_user
170 cmp.leu p14,p15=src2,dst2
173 .pred.rel "mutex", p14, p15
174 (p14) sub word1=8,src2 // (8 - src offset)
175 (p15) sub t1=r0,t1 // absolute value
176 (p15) sub word1=8,dst2 // (8 - dst offset)
178 // For the case p14, we don't need to copy the shifted part to
179 // the 1st word of destination.
181 (p14) sub word1=word1,t1
183 sub len1=len,word1 // resulting len
184 (p15) shl rshift=t1,3 // in bits
185 (p14) shl rshift=t2,3
187 (p14) sub len1=len1,t1
192 mov pr.rot=1<<16 // p16=true all others are false
196 EX(.failure_in_pipe2,(p16) ld1 val1[0]=[src1],1)
197 EX(.failure_out,(EPI) st1 [dst1]=val1[PIPE_DEPTH-1],1)
203 cmp.gtu p9,p0=16,len1
204 (p9) br.cond.spnt 4f // if (16 > len1) skip 8-byte copy
206 shr.u cnt=len1,3 // number of 64-bit words
210 .pred.rel "mutex", p14, p15
211 (p14) sub src1=src1,t2
212 (p15) sub src1=src1,t1
214 // Now both src1 and dst1 point to an 8-byte aligned address. And
215 // we have more than 8 bytes to copy.
219 mov pr.rot=1<<16 // p16=true all others are false
223 // The pipleline consists of 3 stages:
224 // 1 (p16): Load a word from src1
225 // 2 (EPI_1): Shift right pair, saving to tmp
226 // 3 (EPI): Store tmp to dst1
228 // To make it simple, use at least 2 (p16) loops to set up val1[n]
229 // because we need 2 back-to-back val1[] to get tmp.
230 // Note that this implies EPI_2 must be p18 or greater.
233 #define EPI_1 p[PIPE_DEPTH-2]
234 #define SWITCH(pred, shift) cmp.eq pred,p0=shift,rshift
235 #define CASE(pred, shift) \
236 (pred) br.cond.spnt .copy_user_bit##shift
237 #define BODY(rshift) \
238 .copy_user_bit##rshift: \
240 EX(.failure_out,(EPI) st8 [dst1]=tmp,8); \
241 (EPI_1) shrp tmp=val1[PIPE_DEPTH-2],val1[PIPE_DEPTH-1],rshift; \
242 EX(3f,(p16) ld8 val1[1]=[src1],8); \
243 (p16) mov val1[0]=r0; \
246 br.cond.sptk.many .diff_align_do_tail; \
248 (EPI) st8 [dst1]=tmp,8; \
249 (EPI_1) shrp tmp=val1[PIPE_DEPTH-2],val1[PIPE_DEPTH-1],rshift; \
251 (p16) mov val1[1]=r0; \
252 (p16) mov val1[0]=r0; \
255 br.cond.sptk.many .failure_in2
258 // Since the instruction 'shrp' requires a fixed 128-bit value
259 // specifying the bits to shift, we need to provide 7 cases
287 .pred.rel "mutex", p14, p15
288 (p14) sub src1=src1,t1
289 (p14) adds dst1=-8,dst1
290 (p15) sub dst1=dst1,t1
295 // The problem with this piplelined loop is that the last word is not
296 // loaded and thus parf of the last word written is not correct.
297 // To fix that, we simply copy the tail byte by byte.
299 sub len1=endsrc,src1,1
303 mov pr.rot=1<<16 // p16=true all others are false
307 EX(.failure_in_pipe1,(p16) ld1 val1[0]=[src1],1)
308 EX(.failure_out,(EPI) st1 [dst1]=val1[PIPE_DEPTH-1],1)
312 mov pr=saved_pr,0xffffffffffff0000
317 // Beginning of long mempcy (i.e. > 16 bytes)
320 tbit.nz p6,p7=src1,0 // odd alignment
324 mov len1=len // copy because of rotation
325 (p8) br.cond.dpnt .diff_align_copy_user
327 // At this point we know we have more than 16 bytes to copy
328 // and also that both src and dest have the same alignment
329 // which may not be the one we want. So for now we must move
330 // forward slowly until we reach 16byte alignment: no need to
331 // worry about reaching the end of buffer.
333 EX(.failure_in1,(p6) ld1 val1[0]=[src1],1) // 1-byte aligned
334 (p6) adds len1=-1,len1;;
337 EX(.failure_in1,(p7) ld2 val1[1]=[src1],2) // 2-byte aligned
338 (p7) adds len1=-2,len1;;
342 // Stop bit not required after ld4 because if we fail on ld4
343 // we have never executed the ld1, therefore st1 is not executed.
345 EX(.failure_in1,(p8) ld4 val2[0]=[src1],4) // 4-byte aligned
347 EX(.failure_out,(p6) st1 [dst1]=val1[0],1)
351 // Stop bit not required after ld8 because if we fail on ld8
352 // we have never executed the ld2, therefore st2 is not executed.
354 EX(.failure_in1,(p9) ld8 val2[1]=[src1],8) // 8-byte aligned
355 EX(.failure_out,(p7) st2 [dst1]=val1[1],2)
356 (p8) adds len1=-4,len1
358 EX(.failure_out, (p8) st4 [dst1]=val2[0],4)
359 (p9) adds len1=-8,len1;;
360 shr.u cnt=len1,4 // number of 128-bit (2x64bit) words
362 EX(.failure_out, (p9) st8 [dst1]=val2[1],8)
365 adds tmp=-1,cnt // br.ctop is repeat/until
366 (p7) br.cond.dpnt .dotail // we have less than 16 bytes left
376 EX(.failure_in3,(p16) ld8 val1[0]=[src1],16)
377 (p16) ld8 val2[0]=[src2],16
379 EX(.failure_out, (EPI) st8 [dst1]=val1[PIPE_DEPTH-1],16)
380 (EPI) st8 [dst2]=val2[PIPE_DEPTH-1],16
382 ;; // RAW on src1 when fall through from loop
384 // Tail correction based on len only
386 // No matter where we come from (loop or test) the src1 pointer
387 // is 16 byte aligned AND we have less than 16 bytes to copy.
390 EX(.failure_in1,(p6) ld8 val1[0]=[src1],8) // at least 8 bytes
393 EX(.failure_in1,(p7) ld4 val1[1]=[src1],4) // at least 4 bytes
396 EX(.failure_in1,(p8) ld2 val2[0]=[src1],2) // at least 2 bytes
399 EX(.failure_out, (p6) st8 [dst1]=val1[0],8)
401 EX(.failure_in1,(p9) ld1 val2[1]=[src1]) // only 1 byte left
404 EX(.failure_out,(p7) st4 [dst1]=val1[1],4)
405 mov pr=saved_pr,0xffffffffffff0000
407 EX(.failure_out, (p8) st2 [dst1]=val2[0],2)
410 EX(.failure_out, (p9) st1 [dst1]=val2[1])
415 // Here we handle the case where the byte by byte copy fails
417 // Several factors make the zeroing of the rest of the buffer kind of
419 // - the pipeline: loads/stores are not in sync (pipeline)
421 // In the same loop iteration, the dst1 pointer does not directly
422 // reflect where the faulty load was.
425 // When you get a fault on load, you may have valid data from
426 // previous loads not yet store in transit. Such data must be
427 // store normally before moving onto zeroing the rest.
429 // - single/multi dispersal independence.
432 // - we don't disrupt the pipeline, i.e. data in transit in
433 // the software pipeline will be eventually move to memory.
434 // We simply replace the load with a simple mov and keep the
435 // pipeline going. We can't really do this inline because
436 // p16 is always reset to 1 when lc > 0.
439 sub ret0=endsrc,src1 // number of bytes to zero, i.e. not copied
442 (EPI) st1 [dst1]=val1[PIPE_DEPTH-1],1
445 mov pr=saved_pr,0xffffffffffff0000
451 // This is the case where the byte by byte copy fails on the load
452 // when we copy the head. We need to finish the pipeline and copy
453 // zeros for the rest of the destination. Since this happens
454 // at the top we still need to fill the body and tail.
456 sub ret0=endsrc,src1 // number of bytes to zero, i.e. not copied
459 (EPI) st1 [dst1]=val1[PIPE_DEPTH-1],1
462 sub len=enddst,dst1,1 // precompute len
463 br.cond.dptk.many .failure_in1bis
467 // Here we handle the head & tail part when we check for alignment.
468 // The following code handles only the load failures. The
469 // main diffculty comes from the fact that loads/stores are
470 // scheduled. So when you fail on a load, the stores corresponding
471 // to previous successful loads must be executed.
473 // However some simplifications are possible given the way
477 // Theory of operation:
491 // page_size >= 4k (2^12). (x means 4, 2, 1)
492 // Here we suppose Page A exists and Page B does not.
494 // As we move towards eight byte alignment we may encounter faults.
495 // The numbers on each page show the size of the load (current alignment).
498 // - if you fail on 1, 2, 4 then you have never executed any smaller
499 // size loads, e.g. failing ld4 means no ld1 nor ld2 executed
502 // This allows us to simplify the cleanup code, because basically you
503 // only have to worry about "pending" stores in the case of a failing
504 // ld8(). Given the way the code is written today, this means only
505 // worry about st2, st4. There we can use the information encapsulated
506 // into the predicates.
509 // - if you fail on the ld8 in the head, it means you went straight
510 // to it, i.e. 8byte alignment within an unexisting page.
511 // Again this comes from the fact that if you crossed just for the ld8 then
512 // you are 8byte aligned but also 16byte align, therefore you would
513 // either go for the 16byte copy loop OR the ld8 in the tail part.
514 // The combination ld1, ld2, ld4, ld8 where you fail on ld8 is impossible
515 // because it would mean you had 15bytes to copy in which case you
516 // would have defaulted to the byte by byte copy.
520 // Here we now we have less than 16 bytes AND we are either 8 or 16 byte
524 // This means that we either:
525 // - are right on a page boundary
527 // - are at more than 16 bytes from a page boundary with
528 // at most 15 bytes to copy: no chance of crossing.
530 // This allows us to assume that if we fail on a load we haven't possibly
531 // executed any of the previous (tail) ones, so we don't need to do
532 // any stores. For instance, if we fail on ld2, this means we had
533 // 2 or 3 bytes left to copy and we did not execute the ld8 nor ld4.
535 // This means that we are in a situation similar the a fault in the
536 // head part. That's nice!
539 sub ret0=endsrc,src1 // number of bytes to zero, i.e. not copied
540 sub len=endsrc,src1,1
542 // we know that ret0 can never be zero at this point
543 // because we failed why trying to do a load, i.e. there is still
545 // The failure_in1bis and length problem is taken care of at the
549 .failure_in1bis: // from (.failure_in3)
550 mov ar.lc=len // Continue with a stupid byte store.
556 mov pr=saved_pr,0xffffffffffff0000
562 // Here we simply restart the loop but instead
563 // of doing loads we fill the pipeline with zeroes
564 // We can't simply store r0 because we may have valid
565 // data in transit in the pipeline.
566 // ar.lc and ar.ec are setup correctly at this point
568 // we MUST use src1/endsrc here and not dst1/enddst because
569 // of the pipeline effect.
572 sub ret0=endsrc,src1 // number of bytes to zero, i.e. not copied
577 (EPI) st8 [dst1]=val1[PIPE_DEPTH-1],16
578 (EPI) st8 [dst2]=val2[PIPE_DEPTH-1],16
581 cmp.ne p6,p0=dst1,enddst // Do we need to finish the tail ?
582 sub len=enddst,dst1,1 // precompute len
583 (p6) br.cond.dptk .failure_in1bis
585 mov pr=saved_pr,0xffffffffffff0000
592 cmp.ne p6,p0=dst1,enddst // Do we need to finish the tail ?
593 sub len=enddst,dst1,1 // precompute len
594 (p6) br.cond.dptk .failure_in1bis
596 mov pr=saved_pr,0xffffffffffff0000
602 // handling of failures on stores: that's the easy part
606 mov pr=saved_pr,0xffffffffffff0000
612 EXPORT_SYMBOL(__copy_user)