bcopytest.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 #include <cpus.h>
    2 #include <debug.h>
    3 #include <mach_kgdb.h>
    4 #include <mach_vm_debug.h>
    5 #include <db_machine_commands.h>
    6 
    7 #include <kern/thread.h>
    8 #include <kern/thread_act.h>
    9 #include <mach/vm_attributes.h>
   10 #include <mach/vm_param.h>
   11 #include <vm/vm_kern.h>
   12 #include <vm/vm_map.h>
   13 #include <vm/vm_page.h>
   14 #include <kern/spl.h>
   15 
   16 #include <kern/misc_protos.h>
   17 #include <ppc/exception.h>
   18 #include <ppc/misc_protos.h>
   19 #include <ppc/proc_reg.h>
   20 
   21 #include <vm/pmap.h>
   22 #include <ppc/pmap.h>
   23 #include <ppc/mem.h>
   24 
   25 #include <ppc/new_screen.h>
   26 #include <ppc/Firmware.h>
   27 #include <ppc/mappings.h>
   28 #include <ddb/db_output.h>
   29 
   30 #include <console/video_console.h>              /* (TEST/DEBUG) */
   31 
   32 #define patper 253
   33 
   34 
   35 int main(void);
   36 void clrarea(unsigned int *source, unsigned int *sink);
   37 int tstcopy(void *src, void *snk, unsigned int lgn);
   38 void clrarea2(unsigned int *source, unsigned int *sink);
   39 int tstcopy2(void *src, void *snk, unsigned int lgn);
   40 int tstcopy3(void *src, void *snk, unsigned int lgn);
   41 int tstcopy4(void *src, void *snk, unsigned int lgn);
   42 int tstcopy5(void *src, void *snk, unsigned int lgn);
   43 int dumbcopy(void *src, void *snk, unsigned int lgn);
   44 
   45 
   46 unsigned int gtick(void);
   47 
   48 
   49 void bcopytest(void);
   50 void bcopytest(void) {
   51 
   52         void *srcptr, *snkptr, *asrc, *asnk;
   53         int bsrc, bsnk, size, iterations, i, ret, n; 
   54         unsigned int makerand, timein, timeout, ticks;
   55         volatile int dbg = 0;
   56         unsigned int *sink, *source;
   57         
   58         long long tottime, totbytes;
   59         long long tottime2, totbytes2;
   60         
   61         kern_return_t retr;
   62         
   63         db_printf("bcopy test\n");      
   64         
   65         retr = kmem_alloc_wired(kernel_map, (vm_offset_t *)&sink, (1024*1024)+4096);    /* Get sink area */
   66         if(retr != KERN_SUCCESS) {      /* Did we find any memory at all? */
   67                 panic("bcopytest: Whoops...  no memory for sink\n");
   68         }
   69         
   70         retr = kmem_alloc_wired(kernel_map, (vm_offset_t *)&source, (1024*1024)+4096);  /* Get source area */
   71         if(retr != KERN_SUCCESS) {      /* Did we find any memory at all? */
   72                 panic("bcopytest: Whoops...  no memory for source\n");
   73         }
   74 
   75         db_printf("Source at %08X; Sink at %08X\n", source, sink);
   76         
   77         srcptr = (void *)&source[0];
   78         snkptr = (void *)&sink[0];
   79         
   80 #if 1
   81         db_printf("Testing non-overlap case; source bndry = 0 to 7F; sink bndry = 0 - 7F; lgn = 1 to 256\n");
   82         for(bsrc = 0; bsrc < 128; bsrc++) {                     /* Step the source by 1 */
   83                 for(bsnk = 0; bsnk < 128; bsnk++) {             /* Step the sink by 1 */
   84                         for(size = 1; size <= 256; size++) {    /* Step the size by 1 */
   85                         
   86                                 clrarea(source, sink);                                          /* Reset source and clear sink */
   87                                 if(size == 255) {
   88                                         dbg = 99;
   89                                 }
   90                                 if(tstcopy((void *)((unsigned int)srcptr + bsrc), (void *)((unsigned int)snkptr + bsnk), size)) {       
   91                                         db_printf("Test failed; source = %02X; sink = %02X; length = %d\n", bsrc, bsnk, size);
   92                                         db_printf("failed\n");
   93                                 }
   94                         }
   95                 }
   96         }
   97         db_printf("Non-overlap test complete\n");
   98 #endif
   99 
  100 
  101 #if 1   
  102         db_printf("Testing overlap\n");
  103         for(bsrc = 1; bsrc < 128; bsrc++) {                     /* Step the source by 1 */
  104                 for(bsnk = 0; bsnk < 128; bsnk++) {             /* Step the sink by 1 */
  105                         for(size = 1; size <= 256; size++) {    /* Step the size by 1 */
  106                         
  107                                 clrarea2(source, sink);                                         /* Reset source and clear sink */
  108                                 if(bsrc < bsnk) {
  109                                         dbg = 88;
  110                                 }
  111                                 else {
  112                                         dbg = 99;
  113                                 }
  114                                 if(tstcopy2((void *)((unsigned int)srcptr + bsrc), (void *)((unsigned int)srcptr + bsnk), size)) {      
  115                                         db_printf("Test failed; source = %02X; sink = %02X; length = %d\n", bsrc, bsnk, size);
  116                                         db_printf("failed\n");
  117                                 }
  118                         }
  119                 }
  120         }
  121         db_printf("Overlap test complete\n");
  122 #endif
  123 
  124 #if 1
  125         db_printf("Starting exhaustive tests\n");
  126         for(i = 0; i < 262144 * 4; i++) {               /* Set all 1MB of source and dest to known pattern */
  127                 ((unsigned char *)srcptr)[i] = i % patper;      /* Make a non-power-of-two length pattern */
  128                 ((unsigned char *)snkptr)[i] = i % patper;      /* Make a non-power-of-two length pattern */
  129         }
  130 
  131         db_printf("No overlap; source < sink, length = 0 to 1023\nSource =");
  132 
  133 #if 1
  134         for(bsrc = 0; bsrc < 128; bsrc++) {                             /* Step source by 1 */
  135                 db_printf(" %3d", bsrc);                                        /* Show where we're at */
  136                 for(bsnk = 0; bsnk < 128; bsnk++) {                     /* Step sink by 1 */
  137                         for(size = 0; size < 1025; size++) {    /* Step size from 0 to 1023 */                          
  138                                 asrc = (void *)((unsigned int)srcptr + bsrc);                   /* Start byte address */
  139                                 asnk = (void *)((unsigned int)srcptr + bsnk + 2048);    /* End byte address */
  140                                 ret = tstcopy5(asrc, asnk, size);       /* Copy and validate */
  141                                 if(ret) {       
  142                                         db_printf("\nTest failed - source = %3d, sink = %3d size = %d\n", bsrc, bsnk, size);
  143                                         db_printf("failed\n");
  144                                 }
  145                         }
  146                 }
  147         }
  148 #endif
  149                                 
  150         db_printf("\n");
  151         db_printf("No overlap; source > sink, length = 0 to 1023\nSource =");
  152 
  153 #if 1
  154         for(bsrc = 0; bsrc < 128; bsrc++) {                             /* Step source by 1 */
  155                 db_printf(" %3d", bsrc);                                        /* Show where we're at */
  156                 for(bsnk = 0; bsnk < 128; bsnk++) {                     /* Step sink by 1 */
  157                         for(size = 0; size < 1025; size++) {    /* Step size from 0 to 1023 */                          
  158                                 asrc = (void *)((unsigned int)srcptr + bsrc + 2048);    /* Start byte address */
  159                                 asnk = (void *)((unsigned int)srcptr + bsnk);                   /* End byte address */
  160                                 ret = tstcopy5(asrc, asnk, size);       /* Copy and validate */
  161                                 if(ret) {       
  162                                         db_printf("\nTest failed - source = %3d, sink = %3d size = %d\n", bsrc, bsnk, size);
  163                                         db_printf("failed\n");
  164                                 }
  165                         }
  166                 }
  167         }
  168 #endif
  169                                 
  170         db_printf("\n");
  171         db_printf("Overlap; source = sink + N (N = 0 to 127), length = 0 to 1023\nN =");
  172 
  173 #if 1
  174         for(n = 0; n < 128; n++) {                                              /* Step n by 1 */
  175                 db_printf(" %3d", n);                                   /* Show where we're at */
  176                 for(bsnk = 0; bsnk < 128; bsnk++) {                     /* Step sink by 1 */
  177                         for(size = 0; size < 1025; size++) {    /* Step size from 0 to 1023 */                          
  178                                 asrc = (void *)((unsigned int)srcptr + bsnk + n);       /* Start byte address */
  179                                 asnk = (void *)((unsigned int)srcptr + bsnk);           /* End byte address */
  180                                 ret = tstcopy5(asrc, asnk, size);       /* Copy and validate */
  181                                 if(ret) {       
  182                                         db_printf("\nTest failed - source = %3d, sink = %3d size = %d\n", bsrc, bsnk, size);
  183                                         db_printf("failed\n");
  184                                 }
  185                         }
  186                 }
  187         }
  188 #endif
  189                                 
  190         db_printf("\n");
  191         db_printf("Overlap; source + N = sink (N = 0 to 127), length = 0 to 1023\nSource =");
  192 
  193 #if 1
  194         for(bsrc = 0; bsrc < 128; bsrc++) {                             /* Step source by 1 */
  195                 db_printf(" %3d", bsrc);                                        /* Show where we're at */
  196                 for(n = 0; n < 128; n++) {                                      /* Step N by 1 */
  197                         for(size = 0; size < 1025; size++) {    /* Step size from 0 to 1023 */                          
  198                                 asrc = (void *)((unsigned int)srcptr + bsnk);   /* Start byte address */
  199                                 asnk = (void *)((unsigned int)srcptr + bsnk + n);       /* End byte address */
  200                                 ret = tstcopy5(asrc, asnk, size);       /* Copy and validate */
  201                                 if(ret) {       
  202                                         db_printf("\nTest failed - source = %3d, n = %3d size = %d\n", bsrc, n, size);
  203                                         db_printf("failed\n");
  204                                 }
  205                         }
  206                 }
  207         }
  208 #endif
  209                                 
  210                                 
  211         db_printf("\n");
  212         db_printf("Overlap; source = sink + N + 128 (N = 0 to 127), length = 0 to 1023\nN =");
  213 
  214 #if 1
  215         for(n = 0; n < 128; n++) {                                              /* Step n by 1 */
  216                 db_printf(" %3d", n);                                   /* Show where we're at */
  217                 for(bsnk = 0; bsnk < 128; bsnk++) {                     /* Step sink by 1 */
  218                         for(size = 0; size < 1025; size++) {    /* Step size from 0 to 1023 */                          
  219                                 asrc = (void *)((unsigned int)srcptr + bsnk + n + 128); /* Start byte address */
  220                                 asnk = (void *)((unsigned int)srcptr + bsnk);           /* End byte address */
  221                                 ret = tstcopy5(asrc, asnk, size);       /* Copy and validate */
  222                                 if(ret) {       
  223                                         db_printf("\nTest failed - source = %3d, sink = %3d size = %d\n", bsrc, bsnk, size);
  224                                         db_printf("failed\n");
  225                                 }
  226                         }
  227                 }
  228         }
  229 #endif
  230                                 
  231         db_printf("\n");
  232         db_printf("Overlap; source + N + 128 = sink (N = 0 to 127), length = 0 to 1023\nSource =");
  233 
  234 #if 1
  235         for(bsrc = 0; bsrc < 128; bsrc++) {                             /* Step source by 1 */
  236                 db_printf(" %3d", bsrc);                                        /* Show where we're at */
  237                 for(n = 0; n < 128; n++) {                                      /* Step N by 1 */
  238                         for(size = 0; size < 1025; size++) {    /* Step size from 0 to 1023 */                          
  239                                 asrc = (void *)((unsigned int)srcptr + bsnk);   /* Start byte address */
  240                                 asnk = (void *)((unsigned int)srcptr + bsnk + n + 128); /* End byte address */
  241                                 ret = tstcopy5(asrc, asnk, size);       /* Copy and validate */
  242                                 if(ret) {       
  243                                         db_printf("\nTest failed - source = %3d, n = %3d size = %d\n", bsrc, n, size);
  244                                         db_printf("failed\n");
  245                                 }
  246                         }
  247                 }
  248         }
  249 #endif
  250                                 
  251         db_printf("\n");
  252         db_printf("Overlap; source = sink + N + 256 (N = 0 to 127), length = 0 to 1023\nSource =");
  253 
  254 #if 1
  255         for(n = 0; n < 128; n++) {                                              /* Step n by 1 */
  256                 db_printf(" %3d", n);                                   /* Show where we're at */
  257                 for(bsnk = 0; bsnk < 128; bsnk++) {                     /* Step sink by 1 */
  258                         for(size = 0; size < 1025; size++) {    /* Step size from 0 to 1023 */                          
  259                                 asrc = (void *)((unsigned int)srcptr + bsnk + n + 256); /* Start byte address */
  260                                 asnk = (void *)((unsigned int)srcptr + bsnk);           /* End byte address */
  261                                 ret = tstcopy5(asrc, asnk, size);       /* Copy and validate */
  262                                 if(ret) {       
  263                                         db_printf("\nTest failed - source = %3d, sink = %3d size = %d\n", bsrc, bsnk, size);
  264                                         db_printf("failed\n");
  265                                 }
  266                         }
  267                 }
  268         }
  269 #endif
  270                                 
  271         db_printf("\n");
  272         db_printf("Overlap; source + N + 256 = sink (N = 0 to 127), length = 0 to 1023\nSource =");
  273 #if 1
  274         for(bsrc = 0; bsrc < 128; bsrc++) {                             /* Step source by 1 */
  275                 db_printf(" %3d", bsrc);                                        /* Show where we're at */
  276                 for(n = 0; n < 128; n++) {                                      /* Step N by 1 */
  277                         for(size = 0; size < 1025; size++) {    /* Step size from 0 to 1023 */                          
  278                                 asrc = (void *)((unsigned int)srcptr + bsnk);   /* Start byte address */
  279                                 asnk = (void *)((unsigned int)srcptr + bsnk + n + 256); /* End byte address */
  280                                 ret = tstcopy5(asrc, asnk, size);       /* Copy and validate */
  281                                 if(ret) {       
  282                                         db_printf("\nTest failed - source = %3d, n = %3d size = %d\n", bsrc, n, size);
  283                                         db_printf("failed\n");
  284                                 }
  285                         }
  286                 }
  287         }
  288 #endif
  289                                 
  290 
  291 
  292 
  293 
  294 
  295 #endif
  296         
  297 #if 0
  298         iterations = 1000;
  299         tottime = 0;
  300         totbytes = 0;
  301         
  302         db_printf("Random test starting; iterations = %d\n", iterations);
  303         for(i = 0; i < 262144 * 4; i++) {               /* Clear all 2MB of source (and dest for this test) */
  304                 ((unsigned char *)srcptr)[i] = i & 255;
  305         }
  306         
  307         for(i = 0; i < iterations; i++) {                       /* Test until we are done */
  308                 makerand = rand() << 16 | (rand() & 0x0000FFFF);
  309                 bsrc = makerand & 0x0007FFFF;                   /* Generate source */
  310                 makerand = rand() << 16 | (rand() & 0x0000FFFF);
  311                 bsnk = makerand & 0x0007FFFF;                   /* Generate sink */
  312                 makerand = rand() << 16 | (rand() & 0x0000FFFF);
  313                 size = makerand & 0x0007FFFF;                   /* Generate length */
  314 #if 1
  315                 db_printf("rt %7d: src = %08X; sink = %08X; length = %7d\n", i, ((unsigned int)srcptr + bsrc),
  316                         ((unsigned int)srcptr + bsnk), size);
  317 #endif
  318 
  319                 asrc = (void *)((unsigned int)srcptr + bsrc); 
  320                 asnk = (void *)((unsigned int)srcptr + bsnk); 
  321                 timein = gtick();
  322                 ret = tstcopy3(asrc, asnk, size);
  323                 timeout = gtick();
  324                 if(ret) {       
  325                         db_printf("Test failed; source = %02X; sink = %02X; length = %d\n", bsrc, bsnk, size);
  326                         db_printf("failed\n");
  327         
  328                 }
  329                 ticks = timeout - timein;                               /* Get time in ticks for copy */
  330                 tottime += ticks;
  331                 totbytes += size;
  332                 
  333                 rate = (double) totbytes / (double)tottime;     /* Get bytes per tick */ 
  334 //              rate = rate * (double)11250000.0;                               /* Bytes per second */
  335 //              rate = rate * (double)16500000.0;                               /* Bytes per second */
  336                 rate = rate * (double)tbfreq;                                   /* Bytes per second */
  337                 rate = rate / (double)1000000.0;                                /* Get number of MBs */
  338                 
  339                 db_printf("Total bytes = %lld; total time = %lld; rate = %f10\n", totbytes, tottime, rate);
  340                 
  341         }
  342 #endif
  343 
  344 
  345         
  346 #if 0
  347         iterations = 100;
  348         tottime = 0;
  349         totbytes = 0;
  350         
  351         db_printf("Random test starting; iterations = %d\n", iterations);
  352         for(i = 0; i < 262144 * 4; i++) {               /* Clear all 2MB of source (and dest for this test) */
  353                 ((unsigned char *)srcptr)[i] = i & 255;
  354         }
  355         
  356         for(i = 0; i < iterations; i++) {                       /* Test until we are done */
  357                 makerand = rand() << 16 | (rand() & 0x0000FFFF);
  358                 bsrc = makerand & 0x0007FFFF;                   /* Generate source */
  359                 makerand = rand() << 16 | (rand() & 0x0000FFFF);
  360                 bsnk = makerand & 0x0007FFFF;                   /* Generate sink */
  361                 makerand = rand() << 16 | (rand() & 0x0000FFFF);
  362                 size = makerand & 0x0007FFFF;                   /* Generate length */
  363 #if 1
  364                 db_printf("rt %7d: src = %08X; sink = %08X; length = %7d\n", i, ((unsigned int)srcptr + bsrc),
  365                         ((unsigned int)srcptr + bsnk), size);
  366 #endif
  367 
  368                 asrc = (void *)((unsigned int)srcptr + bsrc); 
  369                 asnk = (void *)((unsigned int)srcptr + bsnk); 
  370                 timein = gtick();
  371                 ret = tstcopy4(asrc, asnk, size);
  372                 timeout = gtick();
  373                 if(ret) {       
  374                         db_printf("Test failed; source = %02X; sink = %02X; length = %d\n", bsrc, bsnk, size);
  375                         db_printf("failed\n");
  376         
  377                 }
  378                 ticks = timeout - timein;                               /* Get time in ticks for copy */
  379                 tottime += ticks;
  380                 totbytes += size;
  381                 
  382                 rate = (double) totbytes / (double)tottime;     /* Get bytes per tick */ 
  383 //              rate = rate * (double)11250000.0;                               /* Bytes per second */
  384 //              rate = rate * (double)16500000.0;                               /* Bytes per second */
  385                 rate = rate * (double)tbfreq;                                   /* Bytes per second */
  386                 rate = rate / (double)1000000.0;                                /* Get number of MBs */
  387                 
  388                 db_printf("Total bytes = %lld; total time = %lld; rate = %f10\n", totbytes, tottime, rate);
  389                 
  390         }
  391 #endif
  392         
  393 #if 0
  394         iterations = 100;
  395         tottime = 0;
  396         totbytes = 0;
  397         
  398         db_printf("Random test starting; iterations = %d\n", iterations);
  399         for(i = 0; i < 262144 * 4; i++) {               /* Clear all 2MB of source (and dest for this test) */
  400                 ((unsigned char *)srcptr)[i] = i & 255;
  401         }
  402         
  403         for(i = 0; i < iterations; i++) {                       /* Test until we are done */
  404                 makerand = rand() << 16 | (rand() & 0x0000FFFF);
  405                 bsrc = makerand & 0x0007FFFF;                   /* Generate source */
  406                 makerand = rand() << 16 | (rand() & 0x0000FFFF);
  407                 bsnk = makerand & 0x0007FFFF;                   /* Generate sink */
  408                 makerand = rand() << 16 | (rand() & 0x0000FFFF);
  409                 size = makerand & 0x0007FFFF;                   /* Generate length */
  410 #if 1
  411                 db_printf("rt %7d: src = %08X; sink = %08X; length = %7d\n", i, ((unsigned int)srcptr + bsrc),
  412                         ((unsigned int)srcptr + bsnk), size);
  413 #endif
  414 
  415                 asrc = (void *)((unsigned int)srcptr + bsrc); 
  416                 asnk = (void *)((unsigned int)srcptr + bsnk); 
  417                 timein = gtick();
  418                 ret = dumbcopy(asrc, asnk, size);
  419                 timeout = gtick();
  420                 if(ret) {       
  421                         db_printf("Test failed; source = %02X; sink = %02X; length = %d\n", bsrc, bsnk, size);
  422                         db_printf("failed\n");
  423         
  424                 }
  425                 ticks = timeout - timein;                               /* Get time in ticks for copy */
  426                 tottime += ticks;
  427                 totbytes += size;
  428                 
  429                 rate = (double) totbytes / (double)tottime;     /* Get bytes per tick */ 
  430                 rate = rate * (double)tbfreq;                           /* Bytes per second */
  431                 rate = rate / (double)1000000.0;                        /* Get number of MBs */
  432                 
  433                 db_printf("Total bytes = %lld; total time = %lld; rate = %f10\n", totbytes, tottime, rate);
  434                 
  435         }
  436 #endif
  437         
  438         kmem_free(kernel_map, (vm_offset_t) sink, (1024*1024)+4096);    /* Release this mapping block */
  439         kmem_free(kernel_map, (vm_offset_t) source, (1024*1024)+4096);  /* Release this mapping block */
  440         
  441         if(dbg == 22) db_printf("Gabbagoogoo\n");
  442         return;
  443 }
  444 
  445 void clrarea(unsigned int *source, unsigned int *sink) {
  446 
  447         unsigned int i;
  448         
  449         for(i=0; i < 1024; i++) {               /* Init source & sink */
  450                 source[i]       = 0x55555555;   /* Known pattern */
  451                 sink[i]         = 0xAAAAAAAA;   /* Known pattern */
  452         }
  453         return;
  454 }
  455 
  456 void clrarea2(unsigned int *source, unsigned int *sink) {
  457 
  458         unsigned int i;
  459         unsigned char *ss;
  460         
  461         ss = (unsigned char *)&source[0];
  462         
  463         for(i=0; i < 1024 * 4; i++) {   /* Init source/sink */
  464                 ss[i] = i & 0xFF;                       /* Known pattern */
  465         }
  466         return;
  467 }
  468 
  469 int tstcopy(void *src, void *snk, unsigned int lgn) {
  470 
  471         unsigned int i, crap;
  472         
  473         bcopy(src, snk, lgn);
  474         
  475         for(i = 0; i < lgn; i++) {
  476                 if(((unsigned char *)snk)[i] != 0x55) {
  477                         crap = (unsigned int)&((unsigned char *)snk)[i];
  478                         db_printf("bad copy at sink[%d] (%08X) it is %02X\n", i,crap, ((unsigned char *)snk)[i]);
  479                         return 1;
  480                 }
  481         }
  482         if(((unsigned char *)snk)[lgn] != 0xAA) {       /* Is it right? */
  483                 crap = (unsigned int)&((unsigned char *)snk)[i];
  484                 db_printf("Copied too far at sink[%d] (%08X) it is %02X\n", i, crap, ((unsigned char *)snk)[lgn]);
  485                 return 1;
  486         }
  487         return 0;
  488 
  489 }
  490 
  491 int tstcopy2(void *src, void *snk, unsigned int lgn) {
  492 
  493         unsigned int i, crap;
  494         unsigned char ic, ec;
  495         
  496         ic = ((unsigned char *)src)[0];
  497         ec = ((unsigned char *)snk)[lgn];
  498         
  499         bcopy(src, snk, lgn);
  500         
  501         for(i = 0; i < lgn; i++) {
  502                 if(((unsigned char *)snk)[i] != ic) {
  503                         crap = (unsigned int)&((unsigned char *)snk)[i];
  504                         db_printf("bad copy at sink[%d] (%08X) it is %02X\n", i,crap, ((unsigned char *)snk)[i]);
  505                         return 1;
  506                 }
  507                 ic = (ic + 1) & 0xFF;
  508         }
  509         
  510         if(((unsigned char *)snk)[lgn] != ec) { /* Is it right? */
  511                 crap = (unsigned int)&((unsigned char *)snk)[i];
  512                 db_printf("Copied too far at sink[%d] (%08X) it is %02X\n", i, crap, ((unsigned char *)snk)[lgn]);
  513                 return 1;
  514         }
  515         return 0;
  516 
  517 }
  518 
  519 int tstcopy3(void *src, void *snk, unsigned int lgn) {
  520 
  521         unsigned int i, crap;
  522         unsigned char ic, ec, oic;
  523         
  524         oic = ((unsigned char *)snk)[0];
  525         ic = ((unsigned char *)src)[0];
  526         ec = ((unsigned char *)snk)[lgn];
  527         
  528         bcopy(src, snk, lgn);
  529         
  530         for(i = 0; i < lgn; i++) {
  531                 if(((unsigned char *)snk)[i] != ic) {
  532                         crap = (unsigned int)&((unsigned char *)snk)[i];
  533                         db_printf("bad copy at sink[%d] (%08X) it is %02X\n", i ,crap, ((unsigned char *)snk)[i]);
  534                         return 1;
  535                 }
  536                 ic = (ic + 1) & 0xFF;
  537         }
  538         
  539         if(((unsigned char *)snk)[lgn] != ec) { /* Is it right? */
  540                 crap = (unsigned int)&((unsigned char *)snk)[i];
  541                 db_printf("Copied too far at sink[%d] (%08X) it is %02X\n", i, crap, ((unsigned char *)snk)[lgn]);
  542                 return 1;
  543         }
  544 
  545         for(i=0; i < lgn; i++) {        /* Restore pattern */
  546                 ((unsigned char *)snk)[i] = oic;                
  547                 oic = (oic + 1) & 0xFF;
  548         }
  549 
  550         return 0;
  551 
  552 }
  553 
  554 int tstcopy4(void *src, void *snk, unsigned int lgn) {
  555         
  556         bcopy(src, snk, lgn);
  557         return 0;
  558 
  559 }
  560 
  561 int tstcopy5(void *src, void *snk, unsigned int lgn) {
  562 
  563         unsigned int i, crap;
  564         unsigned char ic, ec, oic, pc;
  565         
  566         oic = ((unsigned char *)snk)[0];                                /* Original first sink character */
  567         ic = ((unsigned char *)src)[0];                                 /* Original first source character */
  568         ec = ((unsigned char *)snk)[lgn];                               /* Original character just after last sink character */
  569         pc = ((unsigned char *)snk)[-1];                                /* Original character just before sink */
  570         
  571         bcopy(src, snk, lgn);
  572         
  573         if(((unsigned char *)snk)[lgn] != ec) {                 /* Did we copy too far forward? */
  574                 crap = (unsigned int)&((unsigned char *)snk)[i];
  575                 db_printf("Copied too far at sink[%d] (%08X) it is %02X\n", i, crap, ((unsigned char *)snk)[lgn]);
  576                 return 1;
  577         }
  578 
  579         if(((unsigned char *)snk)[-1] != pc) {                  /* Did we copy too far backward? */
  580                 crap = (unsigned int)&((unsigned char *)snk)[i];
  581                 db_printf("Copied too far at sink[%d] (%08X) it is %02X\n", i, crap, ((unsigned char *)snk)[lgn]);
  582                 return 1;
  583         }
  584 
  585         for(i = 0; i < lgn; i++) {                                              /* Check sink byte sequence */
  586                 if(((unsigned char *)snk)[i] != ic) {
  587                         crap = (unsigned int)&((unsigned char *)snk)[i];
  588                         db_printf("bad copy at sink[%d] (%08X) it is %02X\n", i ,crap, ((unsigned char *)snk)[i]);
  589                         return 1;
  590                 }
  591                 ic = (ic + 1) % patper;
  592         }
  593 
  594         for(i=0; i < lgn; i++) {        /* Restore pattern */
  595                 ((unsigned char *)snk)[i] = oic;                
  596                 oic = (oic + 1) % patper;
  597         }
  598 
  599         return 0;
  600 
  601 }
  602 
  603 int dumbcopy(void *src, void *snk, unsigned int lgn) {
  604         int i;
  605         char *p = (char *)snk;
  606         char *q = (char *)src;
  607         
  608         for(i = 0; i < lgn; i++) {
  609                 *p++ = *q++;
  610         }
  611         return 0;
  612 
  613 }
  614 
  615 
  616 
  617 
  618 
  619 
  620 
  621 
  622 
  623 
  624 
  625 
  626
Cache object: 2a95934f0864cabbf63ad783aa2e361d
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/osfmk/ppc/bcopytest.c

FreeBSD/Linux Kernel Cross Reference
sys/osfmk/ppc/bcopytest.c
