1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright (c) 1996-1998, 2001 by Sun Microsystems, Inc. 24 * All rights reserved. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <stddef.h> 30 #include <stdio.h> 31 #include <sys/param.h> 32 #include <config_admin.h> 33 #include <memory.h> 34 #include <sys/types.h> 35 #include <time.h> 36 #include "mema_test.h" 37 38 typedef u_longlong_t pbuf_t; 39 40 /* 41 * Test for stuck-at fault and transitional faults 42 * Algorithm: 43 * for i = 0 to npages 44 * write(0x55) 45 * for npages to 0 46 * read_compare(0x55) 47 * write(0xaa) 48 * for 0 to number of pages 49 * read_compare(0xaa) 50 * write(0x55) 51 * read_compare(0x55) 52 * 53 * stuck-at fault is detected because each cell have a 1 and a 0 is read 54 * transitional fault is detected because after each 0 to 1 and 1 to 0 55 * transition the value is check to be sure that the cell is not frozen. 56 */ 57 58 /* 59 * The following strings are subject of stderr output and 60 * gettext() is not used for them. 61 */ 62 static const char err_sum[] = "total error %u\n"; 63 static const char nts_msg[] = "Normal test started\n"; 64 static const char ntf_msg[] = "Normal test finished\n"; 65 static const char qts_msg[] = "Quick test started\n"; 66 static const char qtf_msg[] = "Quick test finished\n"; 67 static const char ets_msg[] = "Extended test started\n"; 68 static const char etf_msg[] = "Extended test finished\n"; 69 static const char m1_msg[] = " March 1, "; 70 static const char m2_msg[] = " March 2, "; 71 static const char m3_msg[] = " March 3, "; 72 static const char m4_msg[] = " March 4, "; 73 static const char wr_msg[] = "write. "; 74 static const char rd_cmp_msg[] = "read/compare. "; 75 static const char rpt_rd_cmp_msg[] = "repeated read/compare. "; 76 static const char ml_rd_cmp_msg[] = "mixed line read/compare. "; 77 static const char ln_rd_cmp_msg[] = "line read/compare. "; 78 static const char report_msg[] = "%s%s%d%% complete.\n"; 79 static const char pg_header_msg[] = " Errors at page address: 0x%x.\n"; 80 static const char rd_err_msg[] = " Error reading page at address: 0x%x.\n"; 81 static const char wr_err_msg[] = " Error writing page at address: 0x%x.\n"; 82 static const 83 char mem_err_msg[] = " Offset: 0x%x, data written/read: 0x%2x/0x%2x.\n"; 84 85 /* 86 * Macros do deal with test conditions. 87 */ 88 #define TEST_END(END_MSG) \ 89 if ((handle->max_errors != 0) &&\ 90 (handle->max_errors == total_errors)) {\ 91 mtest_message(handle, (END_MSG));\ 92 error_summary(handle, total_errors);\ 93 SET_CONDITION(handle, cond);\ 94 return (MTEST_DONE);\ 95 } 96 97 static void 98 error_summary(mtest_handle_t handle, uint_t total_errors) 99 { 100 char msgbuf[100]; 101 102 (void) sprintf(msgbuf, err_sum, total_errors); 103 mtest_message(handle, msgbuf); 104 } 105 106 107 static void 108 error_print(char *writebuf, char *readbuf, mtest_handle_t handle, long pageno, 109 uint_t *total_errorsp) 110 { 111 char msgbuf[100]; 112 size_t offset; 113 114 (void) sprintf(msgbuf, pg_header_msg, PAGE_SIZE(handle) * pageno); 115 mtest_message(handle, msgbuf); 116 117 for (offset = 0; offset < PAGE_SIZE(handle); offset++) { 118 if ((handle->max_errors != 0) && 119 (readbuf[offset] != writebuf[offset]) && 120 (handle->max_errors == *total_errorsp)) 121 return; 122 else { 123 (*total_errorsp)++; 124 (void) sprintf(msgbuf, mem_err_msg, offset, 125 writebuf[offset], readbuf[offset]); 126 mtest_message(handle, msgbuf); 127 } 128 } 129 } 130 131 int 132 memory_test_normal( 133 mtest_handle_t handle) 134 { 135 pbuf_t *patternbuf1; 136 pbuf_t *patternbuf2; 137 pbuf_t *readbuf; 138 long npages, pageno; 139 struct mtest_error errbuf; 140 uint_t total_errors; 141 cfga_cond_t cond; 142 time_t time_rep; 143 char msgbuf[100]; 144 145 patternbuf1 = (pbuf_t *)mtest_allocate_page_buf(handle); 146 patternbuf2 = (pbuf_t *)mtest_allocate_page_buf(handle); 147 readbuf = (pbuf_t *)mtest_allocate_page_buf(handle); 148 if (patternbuf1 == NULL || patternbuf2 == NULL || readbuf == NULL) { 149 return (MTEST_LIB_ERROR); 150 } 151 152 mtest_message(handle, nts_msg); 153 npages = BANK_SIZE(handle) / PAGE_SIZE(handle); 154 155 total_errors = 0; 156 cond = CFGA_COND_OK; 157 158 (void) memset((void *)patternbuf1, 0x55, PAGE_SIZE(handle)); 159 (void) memset((void *)patternbuf2, 0xaa, PAGE_SIZE(handle)); 160 161 time_rep = time(NULL) + REPORT_SEC; 162 163 for (pageno = 0; pageno < npages; pageno++) { 164 if (mtest_write(handle, (void *)patternbuf1, pageno, 0, 0) 165 == -1) { 166 (void) sprintf(msgbuf, wr_err_msg, pageno); 167 mtest_message(handle, msgbuf); 168 return (MTEST_DEV_ERROR); 169 } 170 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 171 (pageno == 0)) { 172 (void) sprintf(msgbuf, report_msg, m1_msg, wr_msg, 173 ((pageno + 1) * 100) / npages); 174 mtest_message(handle, msgbuf); 175 time_rep = time(NULL) + REPORT_SEC; 176 } 177 } 178 for (pageno = npages-1; pageno >= 0; pageno--) { 179 if (mtest_read(handle, (void *)readbuf, pageno, 0, 0, &errbuf) 180 == -1) { 181 (void) sprintf(msgbuf, rd_err_msg, pageno); 182 mtest_message(handle, msgbuf); 183 return (MTEST_DEV_ERROR); 184 } 185 if (errbuf.error_type != MTEST_ERR_NONE) { 186 if (errbuf.error_type == MTEST_ERR_CE && 187 cond != CFGA_COND_FAILED) 188 cond = CFGA_COND_FAILING; 189 else 190 cond = CFGA_COND_FAILED; 191 total_errors++; 192 /* 193 * Keep going if max errors is 0 or limit not 194 * reached. 195 */ 196 TEST_END(ntf_msg); 197 } 198 if (memcmp((void *)patternbuf1, (void *)readbuf, 199 PAGE_SIZE(handle)) != 0) { 200 cond = CFGA_COND_FAILED; 201 error_print((void *)patternbuf1, (void *)readbuf, 202 handle, pageno, &total_errors); 203 TEST_END(ntf_msg); 204 } 205 if (mtest_write(handle, (void *)patternbuf2, pageno, 0, 0) 206 == -1) { 207 (void) sprintf(msgbuf, wr_err_msg, pageno); 208 mtest_message(handle, msgbuf); 209 return (MTEST_DEV_ERROR); 210 } 211 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 212 (pageno == 0)) { 213 (void) sprintf(msgbuf, report_msg, m1_msg, rd_cmp_msg, 214 ((npages - pageno) * 100) / npages); 215 mtest_message(handle, msgbuf); 216 time_rep = time(NULL) + REPORT_SEC; 217 } 218 } 219 /* March 2 (repeated) */ 220 for (pageno = 0; pageno < npages; pageno++) { 221 if (mtest_read(handle, (void *)readbuf, pageno, 0, 0, &errbuf) 222 == -1) { 223 (void) sprintf(msgbuf, rd_err_msg, pageno); 224 mtest_message(handle, msgbuf); 225 return (MTEST_DEV_ERROR); 226 } 227 if (errbuf.error_type != MTEST_ERR_NONE) { 228 if (errbuf.error_type == MTEST_ERR_CE && 229 cond != CFGA_COND_FAILED) 230 cond = CFGA_COND_FAILING; 231 else 232 cond = CFGA_COND_FAILED; 233 total_errors++; 234 TEST_END(ntf_msg); 235 } 236 if (memcmp((void *)patternbuf2, (void *)readbuf, 237 PAGE_SIZE(handle)) != 0) { 238 cond = CFGA_COND_FAILED; 239 error_print((void *)patternbuf2, (void *)readbuf, 240 handle, pageno, &total_errors); 241 TEST_END(ntf_msg); 242 } 243 if (mtest_write(handle, (void *)patternbuf1, pageno, 0, 0) 244 == -1) { 245 (void) sprintf(msgbuf, wr_err_msg, pageno); 246 mtest_message(handle, msgbuf); 247 return (MTEST_DEV_ERROR); 248 } 249 if (mtest_read(handle, (void *)readbuf, pageno, 0, 0, &errbuf) 250 == -1) { 251 (void) sprintf(msgbuf, rd_err_msg, pageno); 252 mtest_message(handle, msgbuf); 253 return (MTEST_DEV_ERROR); 254 } 255 if (errbuf.error_type != MTEST_ERR_NONE) { 256 if (errbuf.error_type == MTEST_ERR_CE && 257 cond != CFGA_COND_FAILED) 258 cond = CFGA_COND_FAILING; 259 else 260 cond = CFGA_COND_FAILED; 261 total_errors++; 262 TEST_END(ntf_msg); 263 } 264 if (memcmp((void *)patternbuf1, (void *)readbuf, 265 PAGE_SIZE(handle)) != 0) { 266 cond = CFGA_COND_FAILED; 267 error_print((void *)patternbuf1, (void *)readbuf, 268 handle, pageno, &total_errors); 269 TEST_END(ntf_msg); 270 } 271 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 272 (pageno == 0)) { 273 (void) sprintf(msgbuf, report_msg, m2_msg, 274 rpt_rd_cmp_msg, ((pageno + 1) * 100) / npages); 275 mtest_message(handle, msgbuf); 276 time_rep = time(NULL) + REPORT_SEC; 277 } 278 } 279 mtest_message(handle, ntf_msg); 280 error_summary(handle, total_errors); 281 SET_CONDITION(handle, cond); 282 return (MTEST_DONE); 283 } 284 285 /* this test look only for stuck-at fault */ 286 int 287 memory_test_quick( 288 mtest_handle_t handle) 289 { 290 pbuf_t *patternbuf1; 291 pbuf_t *patternbuf2; 292 pbuf_t *readbuf; 293 long npages, pageno; 294 struct mtest_error errbuf; 295 uint_t total_errors; 296 cfga_cond_t cond; 297 time_t time_rep; 298 char msgbuf[100]; 299 300 patternbuf1 = (pbuf_t *)mtest_allocate_page_buf(handle); 301 patternbuf2 = (pbuf_t *)mtest_allocate_page_buf(handle); 302 readbuf = (pbuf_t *)mtest_allocate_page_buf(handle); 303 if (patternbuf1 == NULL || patternbuf2 == NULL || readbuf == NULL) { 304 return (MTEST_LIB_ERROR); 305 } 306 307 mtest_message(handle, qts_msg); 308 npages = BANK_SIZE(handle) / PAGE_SIZE(handle); 309 310 total_errors = 0; 311 cond = CFGA_COND_OK; 312 313 (void) memset((void *)patternbuf1, 0x55, PAGE_SIZE(handle)); 314 (void) memset((void *)patternbuf2, 0xaa, PAGE_SIZE(handle)); 315 316 time_rep = time(NULL) + REPORT_SEC; 317 318 for (pageno = 0; pageno < npages; pageno++) { 319 if (mtest_write(handle, (void *)patternbuf1, pageno, 0, 0) 320 == -1) { 321 (void) sprintf(msgbuf, wr_err_msg, pageno); 322 mtest_message(handle, msgbuf); 323 return (MTEST_DEV_ERROR); 324 } 325 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 326 (pageno == 0)) { 327 (void) sprintf(msgbuf, report_msg, m1_msg, wr_msg, 328 ((pageno + 1) * 100) / npages); 329 mtest_message(handle, msgbuf); 330 time_rep = time(NULL) + REPORT_SEC; 331 } 332 } 333 334 for (pageno = npages-1; pageno >= 0; pageno--) { 335 if (mtest_read(handle, (void *)readbuf, pageno, 0, 0, &errbuf) 336 == -1) { 337 (void) sprintf(msgbuf, rd_err_msg, pageno); 338 mtest_message(handle, msgbuf); 339 return (MTEST_DEV_ERROR); 340 } 341 if (errbuf.error_type != MTEST_ERR_NONE) { 342 if (errbuf.error_type == MTEST_ERR_CE && 343 cond != CFGA_COND_FAILED) 344 cond = CFGA_COND_FAILING; 345 else 346 cond = CFGA_COND_FAILED; 347 total_errors++; 348 /* 349 * Keep going if max errors is 0 or limit not 350 * reached. 351 */ 352 TEST_END(qtf_msg); 353 } 354 if (memcmp((void *)patternbuf1, (void *)readbuf, 355 PAGE_SIZE(handle)) != 0) { 356 cond = CFGA_COND_FAILED; 357 error_print((void *)patternbuf1, (void *)readbuf, 358 handle, pageno, &total_errors); 359 TEST_END(qtf_msg); 360 } 361 if (mtest_write(handle, (void *)patternbuf2, pageno, 0, 0) 362 == -1) { 363 (void) sprintf(msgbuf, wr_err_msg, pageno); 364 mtest_message(handle, msgbuf); 365 return (MTEST_DEV_ERROR); 366 } 367 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 368 (pageno == 0)) { 369 (void) sprintf(msgbuf, report_msg, m1_msg, rd_cmp_msg, 370 ((npages - pageno) * 100) / npages); 371 mtest_message(handle, msgbuf); 372 time_rep = time(NULL) + REPORT_SEC; 373 } 374 } 375 /* March 2 */ 376 for (pageno = 0; pageno < npages; pageno++) { 377 if (mtest_read(handle, (void *)readbuf, pageno, 0, 0, &errbuf) 378 == -1) { 379 (void) sprintf(msgbuf, rd_err_msg, pageno); 380 mtest_message(handle, msgbuf); 381 return (MTEST_DEV_ERROR); 382 } 383 if (errbuf.error_type != MTEST_ERR_NONE) { 384 if (errbuf.error_type == MTEST_ERR_CE && 385 cond != CFGA_COND_FAILED) 386 cond = CFGA_COND_FAILING; 387 else 388 cond = CFGA_COND_FAILED; 389 total_errors++; 390 TEST_END(qtf_msg); 391 } 392 if (memcmp((void *)patternbuf2, (void *)readbuf, 393 PAGE_SIZE(handle)) != 0) { 394 cond = CFGA_COND_FAILED; 395 error_print((void *)patternbuf2, (void *)readbuf, 396 handle, pageno, &total_errors); 397 TEST_END(qtf_msg); 398 } 399 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 400 (pageno == 0)) { 401 (void) sprintf(msgbuf, report_msg, m2_msg, rd_cmp_msg, 402 ((pageno + 1) * 100) / npages); 403 mtest_message(handle, msgbuf); 404 time_rep = time(NULL) + REPORT_SEC; 405 } 406 } 407 mtest_message(handle, qtf_msg); 408 error_summary(handle, total_errors); 409 SET_CONDITION(handle, cond); 410 return (MTEST_DONE); 411 } 412 413 414 /* look for stuck-at, transition, coupling fault: inversion, idempotent */ 415 int 416 memory_test_extended( 417 mtest_handle_t handle) 418 { 419 pbuf_t *patternbuf0, *patternbuf1; 420 pbuf_t *readbuf0, *readbuf1, *readbuf2; 421 long npages, pageno; 422 long line; 423 struct mtest_error errbuf; 424 uint_t total_errors; 425 cfga_cond_t cond; 426 time_t time_rep; 427 char msgbuf[100]; 428 429 patternbuf0 = (pbuf_t *)mtest_allocate_page_buf(handle); 430 patternbuf1 = (pbuf_t *)mtest_allocate_page_buf(handle); 431 readbuf0 = (pbuf_t *)mtest_allocate_page_buf(handle); 432 readbuf1 = (pbuf_t *)mtest_allocate_page_buf(handle); 433 readbuf2 = (pbuf_t *)mtest_allocate_page_buf(handle); 434 if (patternbuf0 == NULL || patternbuf1 == NULL || 435 readbuf0 == NULL || readbuf1 == NULL || readbuf2 == NULL) { 436 return (MTEST_LIB_ERROR); 437 } 438 439 mtest_message(handle, ets_msg); 440 npages = BANK_SIZE(handle) / PAGE_SIZE(handle); 441 442 total_errors = 0; 443 cond = CFGA_COND_OK; 444 445 (void) memset((void *)patternbuf0, 0x55, PAGE_SIZE(handle)); 446 (void) memset((void *)patternbuf1, 0xaa, PAGE_SIZE(handle)); 447 448 time_rep = time(NULL) + REPORT_SEC; 449 450 for (pageno = 0; pageno < npages; pageno++) { 451 if (mtest_write(handle, (void *)patternbuf0, pageno, 0, 0) 452 == -1) { 453 (void) sprintf(msgbuf, wr_err_msg, pageno); 454 mtest_message(handle, msgbuf); 455 return (MTEST_DEV_ERROR); 456 } 457 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 458 (pageno == 0)) { 459 (void) sprintf(msgbuf, report_msg, m1_msg, wr_msg, 460 ((pageno + 1) * 100) / npages); 461 mtest_message(handle, msgbuf); 462 time_rep = time(NULL) + REPORT_SEC; 463 } 464 } 465 466 /* 467 * Line tests take 5-9 time longer and the reprting interval 468 * should be extended 3-5 times. 469 */ 470 471 /* March 1 */ 472 for (pageno = npages-1; pageno >= 0; pageno--) { 473 for (line = (LINES_PER_PAGE(handle) - 1); line >= 0; line--) { 474 if (mtest_read(handle, (void *)readbuf0, pageno, 475 line, 1, &errbuf) == -1) { 476 (void) sprintf(msgbuf, rd_err_msg, pageno); 477 mtest_message(handle, msgbuf); 478 return (MTEST_DEV_ERROR); 479 } 480 if (errbuf.error_type != MTEST_ERR_NONE) { 481 if (errbuf.error_type == MTEST_ERR_CE && 482 cond != CFGA_COND_FAILED) 483 cond = CFGA_COND_FAILING; 484 else 485 cond = CFGA_COND_FAILED; 486 total_errors++; 487 /* 488 * Keep going if max errors is 0 or limit not 489 * reached. 490 */ 491 TEST_END(ntf_msg); 492 } 493 if (mtest_write(handle, (void*)patternbuf1, pageno, 494 line, 1) == -1) { 495 (void) sprintf(msgbuf, wr_err_msg, pageno); 496 mtest_message(handle, msgbuf); 497 return (MTEST_DEV_ERROR); 498 } 499 if (mtest_read(handle, (void *)readbuf1, pageno, 500 line, 1, &errbuf) == -1) { 501 (void) sprintf(msgbuf, rd_err_msg, pageno); 502 mtest_message(handle, msgbuf); 503 return (MTEST_DEV_ERROR); 504 } 505 if (errbuf.error_type != MTEST_ERR_NONE) { 506 if (errbuf.error_type == MTEST_ERR_CE && 507 cond != CFGA_COND_FAILED) 508 cond = CFGA_COND_FAILING; 509 else 510 cond = CFGA_COND_FAILED; 511 total_errors++; 512 TEST_END(ntf_msg); 513 } 514 if (mtest_write(handle, (void*)patternbuf0, pageno, 515 line, 1) == -1) { 516 (void) sprintf(msgbuf, wr_err_msg, pageno); 517 mtest_message(handle, msgbuf); 518 return (MTEST_DEV_ERROR); 519 } 520 if (mtest_read(handle, (void *)readbuf2, pageno, 521 line, 1, &errbuf) == -1) { 522 (void) sprintf(msgbuf, rd_err_msg, pageno); 523 mtest_message(handle, msgbuf); 524 return (MTEST_DEV_ERROR); 525 } 526 if (errbuf.error_type != MTEST_ERR_NONE) { 527 if (errbuf.error_type == MTEST_ERR_CE && 528 cond != CFGA_COND_FAILED) 529 cond = CFGA_COND_FAILING; 530 else 531 cond = CFGA_COND_FAILED; 532 total_errors++; 533 TEST_END(ntf_msg); 534 } 535 if (mtest_write(handle, (void*)patternbuf1, pageno, 536 line, 1) == -1) { 537 (void) sprintf(msgbuf, wr_err_msg, pageno); 538 return (MTEST_DEV_ERROR); 539 } 540 } /* line */ 541 if (memcmp((void *)patternbuf0, (void *)readbuf0, 542 PAGE_SIZE(handle)) != 0) { 543 cond = CFGA_COND_FAILED; 544 error_print((void *)patternbuf0, (void *)readbuf0, 545 handle, pageno, &total_errors); 546 TEST_END(ntf_msg); 547 } 548 if (memcmp((void *)patternbuf1, (void *)readbuf1, 549 PAGE_SIZE(handle)) != 0) { 550 cond = CFGA_COND_FAILED; 551 error_print((void *)patternbuf1, (void *)readbuf1, 552 handle, pageno, &total_errors); 553 TEST_END(ntf_msg); 554 } 555 if (memcmp((void *)patternbuf0, (void *)readbuf2, 556 PAGE_SIZE(handle)) != 0) { 557 cond = CFGA_COND_FAILED; 558 error_print((void *)patternbuf0, (void *)readbuf2, 559 handle, pageno, &total_errors); 560 TEST_END(ntf_msg); 561 } 562 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 563 (pageno == 0)) { 564 (void) sprintf(msgbuf, report_msg, m1_msg, 565 ml_rd_cmp_msg, ((npages - pageno) * 100) / npages); 566 mtest_message(handle, msgbuf); 567 time_rep = time(NULL) + REPORT_SEC * 3; 568 } 569 } /* page */ 570 571 /* March 2 */ 572 for (pageno = npages-1; pageno >= 0; pageno--) { 573 for (line = (LINES_PER_PAGE(handle) - 1); line >= 0; line--) { 574 if (mtest_read(handle, (void *)readbuf0, pageno, 575 line, 1, &errbuf) == -1) { 576 (void) sprintf(msgbuf, rd_err_msg, pageno); 577 mtest_message(handle, msgbuf); 578 return (MTEST_DEV_ERROR); 579 } 580 if (errbuf.error_type != MTEST_ERR_NONE) { 581 if (errbuf.error_type == MTEST_ERR_CE && 582 cond != CFGA_COND_FAILED) 583 cond = CFGA_COND_FAILING; 584 else 585 cond = CFGA_COND_FAILED; 586 total_errors++; 587 /* 588 * Keep going if max errors is 0 or limit not 589 * reached. 590 */ 591 TEST_END(ntf_msg); 592 } 593 if (mtest_write(handle, (void*)patternbuf0, pageno, 594 line, 1) == -1) { 595 (void) sprintf(msgbuf, wr_err_msg, pageno); 596 mtest_message(handle, msgbuf); 597 return (MTEST_DEV_ERROR); 598 } 599 if (mtest_write(handle, (void*)patternbuf1, pageno, 600 line, 1) == -1) { 601 (void) sprintf(msgbuf, wr_err_msg, pageno); 602 mtest_message(handle, msgbuf); 603 return (MTEST_DEV_ERROR); 604 } 605 } 606 if (memcmp((void *)patternbuf1, (void *)readbuf0, 607 PAGE_SIZE(handle)) != 0) { 608 cond = CFGA_COND_FAILED; 609 total_errors++; 610 } 611 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 612 (pageno == 0)) { 613 (void) sprintf(msgbuf, report_msg, m2_msg, 614 ln_rd_cmp_msg, ((npages - pageno) * 100) / npages); 615 mtest_message(handle, msgbuf); 616 time_rep = time(NULL) + REPORT_SEC * 3; 617 } 618 } /* page */ 619 620 /* March 3 */ 621 for (pageno = 0; pageno < npages; pageno++) { 622 for (line = 0; line < LINES_PER_PAGE(handle); line++) { 623 if (mtest_read(handle, (void *)readbuf0, pageno, 624 line, 1, &errbuf) == -1) { 625 (void) sprintf(msgbuf, rd_err_msg, pageno); 626 mtest_message(handle, msgbuf); 627 return (MTEST_DEV_ERROR); 628 } 629 if (errbuf.error_type != MTEST_ERR_NONE) { 630 if (errbuf.error_type == MTEST_ERR_CE && 631 cond != CFGA_COND_FAILED) 632 cond = CFGA_COND_FAILING; 633 else 634 cond = CFGA_COND_FAILED; 635 total_errors++; 636 TEST_END(ntf_msg); 637 } 638 if (mtest_write(handle, (void*)patternbuf0, pageno, 639 line, 1) == -1) { 640 (void) sprintf(msgbuf, wr_err_msg, pageno); 641 mtest_message(handle, msgbuf); 642 return (MTEST_DEV_ERROR); 643 } 644 if (mtest_write(handle, (void*)patternbuf1, pageno, 645 line, 1) == -1) { 646 (void) sprintf(msgbuf, wr_err_msg, pageno); 647 mtest_message(handle, msgbuf); 648 return (MTEST_DEV_ERROR); 649 } 650 if (mtest_write(handle, (void*)patternbuf0, pageno, 651 line, 1) == -1) { 652 (void) sprintf(msgbuf, wr_err_msg, pageno); 653 mtest_message(handle, msgbuf); 654 return (MTEST_DEV_ERROR); 655 } 656 } 657 if (memcmp((void *)patternbuf1, (void *)readbuf0, 658 PAGE_SIZE(handle)) != 0) { 659 cond = CFGA_COND_FAILED; 660 error_print((void *)patternbuf1, (void *)readbuf0, 661 handle, pageno, &total_errors); 662 TEST_END(ntf_msg); 663 } 664 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 665 (pageno == 0)) { 666 (void) sprintf(msgbuf, report_msg, m3_msg, 667 ml_rd_cmp_msg, ((pageno + 1) * 100) / npages); 668 mtest_message(handle, msgbuf); 669 time_rep = time(NULL) + REPORT_SEC * 3; 670 } 671 } /* page */ 672 673 /* March 4 */ 674 for (pageno = 0; pageno < npages; pageno++) { 675 for (line = 0; line < LINES_PER_PAGE(handle); line++) { 676 if (mtest_read(handle, (void *)readbuf0, pageno, 677 line, 1, &errbuf) == -1) { 678 (void) sprintf(msgbuf, rd_err_msg, pageno); 679 mtest_message(handle, msgbuf); 680 return (MTEST_DEV_ERROR); 681 } 682 if (errbuf.error_type != MTEST_ERR_NONE) { 683 if (errbuf.error_type == MTEST_ERR_CE && 684 cond != CFGA_COND_FAILED) 685 cond = CFGA_COND_FAILING; 686 else 687 cond = CFGA_COND_FAILED; 688 total_errors++; 689 TEST_END(ntf_msg); 690 } 691 if (mtest_write(handle, (void*)patternbuf1, pageno, 692 line, 1) == -1) { 693 (void) sprintf(msgbuf, wr_err_msg, pageno); 694 mtest_message(handle, msgbuf); 695 return (MTEST_DEV_ERROR); 696 } 697 if (mtest_write(handle, (void*)patternbuf0, pageno, 698 line, 1) == -1) { 699 (void) sprintf(msgbuf, wr_err_msg, pageno); 700 mtest_message(handle, msgbuf); 701 return (MTEST_DEV_ERROR); 702 } 703 } 704 if (memcmp((void *)patternbuf0, (void *)readbuf0, 705 PAGE_SIZE(handle)) != 0) { 706 cond = CFGA_COND_FAILED; 707 error_print((void *)patternbuf0, (void *)readbuf0, 708 handle, pageno, &total_errors); 709 TEST_END(ntf_msg); 710 } 711 if ((time(NULL) >= time_rep) || (pageno == npages - 1) || 712 (pageno == 0)) { 713 (void) sprintf(msgbuf, report_msg, m4_msg, 714 ln_rd_cmp_msg, ((pageno + 1) * 100) / npages); 715 mtest_message(handle, msgbuf); 716 time_rep = time(NULL) + REPORT_SEC * 3; 717 } 718 } /* page */ 719 mtest_message(handle, etf_msg); 720 error_summary(handle, total_errors); 721 SET_CONDITION(handle, cond); 722 return (MTEST_DONE); 723 } 724