?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmake: do not set MAKEFLAGS=k
[unleashed/tickless.git] / usr / src / lib / cfgadm_plugins / ac / common / mema_test.c
blobba3e703dcb538ea32963f258a2008dc8b3eb3c51
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(patternbuf1, 0x55, PAGE_SIZE(handle));
159 (void) memset(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(patternbuf1, 0x55, PAGE_SIZE(handle));
314 (void) memset(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(patternbuf0, 0x55, PAGE_SIZE(handle));
446 (void) memset(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 }
unleashed repo fork