开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
llsc4.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：24k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

llsc4.c：源码内容
  1. /* 
  2.  *
  3.  * This file is subject to the terms and conditions of the GNU General Public
  4.  * License.  See the file "COPYING" in the main directory of this archive
  5.  * for more details.
  6.  *
  7.  * Copyright (C) 2000-2002 Silicon Graphics, Inc. All rights reserved.
  8.  */
  10. #include <linux/config.h>
  11. #include <linux/kernel.h>
  12. #include <linux/sched.h>
  13. #include <linux/init.h>
  14. #include <linux/interrupt.h>
  15. #include <linux/smp.h>
  16. #include <linux/kernel_stat.h>
  17. #include <linux/mm.h>
  18. #include <linux/delay.h>
  19. #include <linux/string.h>
  20. #include <linux/efi.h>
  21. #include <asm/page.h>
  22. #include <linux/threads.h>
  23. #include <asm/sn/simulator.h>
  24. #include <asm/sn/leds.h>
  26. #include "llsc4.h"
  29. #ifdef STANDALONE
  30. #include "lock.h"
  31. #endif
  33. #ifdef INTTEST
  34. static int inttest=0;
  35. #endif
  37. #ifdef IA64_SEMFIX_INSN
  38. #undef IA64_SEMFIX_INSN
  39. #endif
  40. #ifdef IA64_SEMFIX
  41. #undef IA64_SEMFIX
  42. #endif
  43. # define IA64_SEMFIX_INSN
  44. # define IA64_SEMFIX    ""
  46. #define NOLOCK 0xdead
  47. #define BGUARD(linei) (0xbbbb0000 | (linei));
  48. #define EGUARD(linei) (0xeeee0000 | (linei));
  49. #define GUARDLINE(v) ((v)&0xffff)
  51. /*
  52.  * Test parameter table for AUTOTEST
  53.  */
  54. typedef struct {
  55. int passes;
  56. int linecount;
  57. int linepad;
  58. } autotest_table_t;
  60. autotest_table_t autotest_table[] = {
  61. {50000000, 2, 0x2b4 },
  62. {50000000, 16, 0, },
  63. {50000000, 16, 4, },
  64. {50000000, 128, 0x44 },
  65. {50000000, 128, 0x84 },
  66. {50000000, 128, 0x200 },
  67. {50000000, 128, 0x204 },
  68. {50000000, 128, 0x2b4 },
  69. {50000000, 2, 8*MB+0x2b4 },
  70. {50000000, 16, 8*MB+0 },
  71. {50000000, 16, 8*MB+4 },
  72. {50000000, 128, 8*MB+0x44 },
  73. {50000000, 128, 8*MB+0x84 },
  74. {50000000, 128, 8*MB+0x200 },
  75. {50000000, 128, 8*MB+0x204 },
  76. {50000000, 128, 8*MB+0x2b4 },
  77. {0}};
  79. /*
  80.  * Array of virtual addresses available for test purposes.
  81.  */
  83. typedef struct {
  84. long vstart;
  85. long vend;
  86. long nextaddr;
  87. long nextinit;
  88. int wrapcount;
  89. } memmap_t;
  91. #define MAPCHUNKS 128
  92. memmap_t  memmap[MAPCHUNKS];
  93. int memmapx=0;
  95. typedef struct {
  96. void *addr;
  97. long data[16];
  98. long data_fc[16];
  99. } capture_line_t;
  101. typedef struct {
  102. int size;
  103. void *blockaddr;
  104. void *shadaddr;
  105. long blockdata[48];
  106. long shaddata[48];
  107. long blockdata_fc[48];
  108. long shaddata_fc[48];
  109. long synerr;
  110. } capture_t;
  112. /*
  113.  * PORTING NOTE: revisit this statement. On hardware we put mbase at 0 and
  114.  * the rest of the tables have to start at 1MB to skip PROM tables.
  115.  */
  116. #define THREADPRIVATESZ() ((sizeof(threadprivate_t)+511)/512*512)
  117. #define THREADPRIVATE(t) ((threadprivate_t*)(((long)mbase)+4096+t*THREADPRIVATESZ()))
  119. #define k_capture mbase->sk_capture
  120. #define k_go mbase->sk_go
  121. #define k_linecount mbase->sk_linecount
  122. #define k_passes mbase->sk_passes
  123. #define k_napticks mbase->sk_napticks
  124. #define k_stop_on_error mbase->sk_stop_on_error
  125. #define k_verbose mbase->sk_verbose
  126. #define k_threadprivate mbase->sk_threadprivate
  127. #define k_blocks mbase->sk_blocks
  128. #define k_iter_msg mbase->sk_iter_msg
  129. #define k_vv mbase->sk_vv
  130. #define k_linepad mbase->sk_linepad
  131. #define k_options mbase->sk_options
  132. #define k_testnumber mbase->sk_testnumber
  133. #define k_currentpass mbase->sk_currentpass
  135. static long blocks[MAX_LINECOUNT]; /* addresses of data blocks */
  136. static control_t *mbase;
  137. static vint initialized=0;
  139. static unsigned int ran_conf_llsc(int);
  140. static int  rerr(capture_t *, char *, void *, void *, int, int, int, int, int, int);
  141. static void dumpline(void *, char *, char *, void *, void *, int);
  142. static int  checkstop(int, int, uint);
  143. static void spin(int);
  144. static void capturedata(capture_t *, uint, void *, void *, int);
  145. static int  randn(uint max, uint *seed);
  146. static uint zrandom (uint *zranseed);
  147. static int  set_lock(uint *, uint);
  148. static int  clr_lock(uint *, uint);
  149. static void Speedo(void);
  151. int autotest_enabled=0;
  152. static int llsctest_number=-1;
  153. static int errstop_enabled=0;
  154. static int fail_enabled=0;
  155. static int l4_opt=0;
  156. static int selective_trigger=0;
  157. static int dump_block_addrs_opt=0;
  158. static lock_t errlock=NOLOCK;
  159. static private_t init_private[LLSC_MAXCPUS];
  161. static int __init autotest_enable(char *str)
  162. {
  163.         autotest_enabled = 1;
  164. return 1;
  165. }
  166. static int __init set_llscblkadr(char *str)
  167. {
  168. dump_block_addrs_opt = 1;
  169. return 1;
  170. }
  171. static int __init set_llscselt(char *str)
  172. {
  173. selective_trigger = 1;
  174. return 1;
  175. }
  176. static int __init set_llsctest(char *str)
  177. {
  178.         llsctest_number = simple_strtol(str, &str, 10);
  179. if (llsctest_number < 0 || llsctest_number > 15)
  180. llsctest_number = -1;
  181. return 1;
  182. }
  183. static int __init set_llscerrstop(char *str)
  184. {
  185.         errstop_enabled = 1;
  186. return 1;
  187. }
  188. static int __init set_llscfail(char *str)
  189. {
  190.         fail_enabled = 8;
  191. return 1;
  192. }
  193. static int __init set_llscl4(char *str)
  194. {
  195.         l4_opt = 1;
  196. return 1;
  197. }
  199. static void print_params(void)
  200. {
  201. printk ("********* Enter AUTOTEST facility on master cpu *************n");
  202. printk ("  Test options:n");
  203. printk ("     llsctest=<n>t%dtTest number to run (all = -1)n", llsctest_number);
  204. printk ("     llscerrstop t%stStop on errorn", errstop_enabled ? "on" : "off");
  205. printk ("     llscfail    t%stForce a failure to test the trigger & error messagesn", fail_enabled ? "on" : "off");
  206. printk ("     llscselt    t%stSelective triger on failuresn", selective_trigger ? "on" : "off");
  207. printk ("     llscblkadr  t%stDump data block addressesn", dump_block_addrs_opt ? "on" : "off");
  208. printk ("     llscl4      t%stRun only tests that evict from L4n", l4_opt ? "on" : "off");
  209. printk ("  SEMFIX: %sn", IA64_SEMFIX);
  210. printk ("n");
  211. }
  212. __setup("autotest", autotest_enable);
  213. __setup("llsctest=", set_llsctest);
  214. __setup("llscerrstop", set_llscerrstop);
  215. __setup("llscfail", set_llscfail);
  216. __setup("llscselt", set_llscselt);
  217. __setup("llscblkadr", set_llscblkadr);
  218. __setup("llscl4", set_llscl4);
  222. static inline int
  223. set_lock(uint *lock, uint id)
  224. {
  225. uint old;
  226. old = cmpxchg_acq(lock, NOLOCK, id);
  227. return (old == NOLOCK);
  228. }
  230. static inline int
  231. clr_lock(uint *lock, uint id)
  232. {
  233. uint old;
  234. old = cmpxchg_rel(lock, id, NOLOCK);
  235. return (old == id);
  236. }
  238. static inline void
  239. init_lock(uint *lock)
  240. {
  241. *lock = NOLOCK;
  242. }
  244. /*------------------------------------------------------------------------+
  245. | Routine  :  ran_conf_llsc - ll/sc shared data test                      |
  246. | Description: This test checks the coherency of shared data              |
  247. +------------------------------------------------------------------------*/
  248. static unsigned int
  249. ran_conf_llsc(int thread)
  250. {
  251. private_t pval;
  252. share_t sval, sval2;
  253. uint vv, linei, slinei, sharei, pass;
  254. long t;
  255. lock_t lockpat;
  256. share_t *sharecopy;
  257. long verbose, napticks, passes, linecount, lcount;
  258. dataline_t *linep, *slinep;
  259. int s, seed;
  260. threadprivate_t *tp;
  261. uint iter_msg, iter_msg_i=0;
  262. int vv_mask;
  263. int correct_errors;
  264. int errs=0;
  265. int stillbad;
  266. capture_t capdata;
  267. private_t *privp;
  268. share_t *sharep;
  271. linecount = k_linecount;
  272. napticks = k_napticks;
  273. verbose = k_verbose;
  274. passes = k_passes;
  275. iter_msg = k_iter_msg;
  276. seed = (thread + 1) * 647;
  277. tp = THREADPRIVATE(thread);
  278. vv_mask = (k_vv>>((thread%16)*4)) & 0xf;
  279. correct_errors = k_options&0xff;
  281. memset (&capdata, 0, sizeof(capdata));
  282. for (linei=0; linei<linecount; linei++)
  283. tp->private[linei] = thread;
  285. for (pass = 1; passes == 0 || pass < passes; pass++) {
  286. lockpat = (pass & 0x0fffffff) + (thread <<28);
  287. if (lockpat == NOLOCK)
  288. continue;
  289. tp->threadpasses = pass;
  290. if (checkstop(thread, pass, lockpat))
  291. return 0;
  292. iter_msg_i++;
  293. if (iter_msg && iter_msg_i > iter_msg) {
  294. printk("Thread %d, Pass %dn", thread, pass);
  295. iter_msg_i = 0;
  296. }
  297. lcount = 0;
  299. /*
  300.  * Select line to perform operations on.
  301.  */
  302. linei = randn(linecount, &seed);
  303. sharei = randn(2, &seed);
  304. slinei = (linei + (linecount/2))%linecount; /* I dont like this - fix later */
  306. linep = (dataline_t *)blocks[linei];
  307. slinep = (dataline_t *)blocks[slinei];
  308. if (sharei == 0)
  309. sharecopy = &slinep->share0;
  310. else
  311. sharecopy = &slinep->share1;
  314. vv = randn(4, &seed);
  315. if ((vv_mask & (1<<vv)) == 0)
  316. continue;
  318. if (napticks) {
  319. t = randn(napticks, &seed);
  320. udelay(t);
  321. }
  322. privp = &linep->private[thread];
  323. sharep = &linep->share[sharei];
  325. switch(vv) {
  326. case 0:
  327. /* Read and verify private count on line. */
  328. pval = *privp;
  329. if (verbose)
  330. printk("Line:%3d, Thread:%d:%d. Val: %xn", linei, thread, vv, tp->private[linei]);
  331. if (pval != tp->private[linei]) {
  332. capturedata(&capdata, pass, privp, NULL, sizeof(*privp));
  333. stillbad = (*privp != tp->private[linei]);
  334. if (rerr(&capdata, "Private count", linep, slinep, thread, pass, linei, tp->private[linei], pval, stillbad)) {
  335. return 1;
  336. }
  337. if (correct_errors) {
  338. tp->private[linei] = *privp;
  339. }
  340. errs++;
  341. }
  342. break;
  344. case 1:
  345. /* Read, verify, and increment private count on line. */
  346. pval = *privp;
  347. if (verbose)
  348. printk("Line:%3d, Thread:%d:%d. Val: %xn", linei, thread, vv, tp->private[linei]);
  349. if (pval != tp->private[linei]) {
  350. capturedata(&capdata, pass, privp, NULL, sizeof(*privp));
  351. stillbad = (*privp != tp->private[linei]);
  352. if (rerr(&capdata, "Private count & inc", linep, slinep, thread, pass, linei, tp->private[linei], pval, stillbad)) {
  353. return 1;
  354. }
  355. errs++;
  356. }
  357. pval = (pval==255) ? 0 : pval+1;
  358. *privp = pval;
  359. tp->private[linei] = pval;
  360. break;
  362. case 2:
  363. /* Lock line, read and verify shared data. */
  364. if (verbose)
  365. printk("Line:%3d, Thread:%d:%d. Val: %xn", linei, thread, vv, *sharecopy);
  366. lcount = 0;
  367. while (LOCK(sharei) != 1) {
  368. if (checkstop(thread, pass, lockpat))
  369. return 0;
  370. if (lcount++>1000000) {
  371. capturedata(&capdata, pass, LOCKADDR(sharei), NULL, sizeof(lock_t));
  372. stillbad = (GETLOCK(sharei) != 0);
  373. rerr(&capdata, "Shared data lock", linep, slinep, thread, pass, linei, 0, GETLOCK(sharei), stillbad);
  374. return 1;
  375. }
  376. if ((lcount&0x3fff) == 0)
  377. udelay(1000);
  378. }
  380. sval = *sharep;
  381. sval2 = *sharecopy;
  382. if (pass > 12 && thread == 0 && fail_enabled == 1)
  383. sval++;
  384. if (sval != sval2) {
  385. capturedata(&capdata, pass, sharep, sharecopy, sizeof(*sharecopy));
  386. stillbad = (*sharep != *sharecopy);
  387. if (!stillbad && *sharep != sval && *sharecopy == sval2)
  388. stillbad = 2;
  389. if (rerr(&capdata, "Shared data", linep, slinep, thread, pass, linei, sval2, sval, stillbad)) {
  390. return 1;
  391. }
  392. if (correct_errors)
  393. *sharep = *sharecopy;
  394. errs++;
  395. }
  398. if ( (s=UNLOCK(sharei)) != 1) {
  399. capturedata(&capdata, pass, LOCKADDR(sharei), NULL, 4);
  400. stillbad = (GETLOCK(sharei) != lockpat);
  401. if (rerr(&capdata, "Shared data unlock", linep, slinep, thread, pass, linei, lockpat, GETLOCK(sharei), stillbad))
  402. return 1;
  403. if (correct_errors)
  404. ZEROLOCK(sharei);
  405. errs++;
  406. }
  407. break;
  409. case 3:
  410. /* Lock line, read and verify shared data, modify shared data. */
  411. if (verbose)
  412. printk("Line:%3d, Thread:%d:%d. Val: %xn", linei, thread, vv, *sharecopy);
  413. lcount = 0;
  414. while (LOCK(sharei) != 1) {
  415. if (checkstop(thread, pass, lockpat))
  416. return 0;
  417. if (lcount++>1000000) {
  418. capturedata(&capdata, pass, LOCKADDR(sharei), NULL, sizeof(lock_t));
  419. stillbad = (GETLOCK(sharei) != 0);
  420. rerr(&capdata, "Shared data lock & inc", linep, slinep, thread, pass, linei, 0, GETLOCK(sharei), stillbad);
  421. return 1;
  422. }
  423. if ((lcount&0x3fff) == 0)
  424. udelay(1000);
  425. }
  426. sval = *sharep;
  427. sval2 = *sharecopy;
  428. if (sval != sval2) {
  429. capturedata(&capdata, pass, sharep, sharecopy, sizeof(*sharecopy));
  430. stillbad = (*sharep != *sharecopy);
  431. if (!stillbad && *sharep != sval && *sharecopy == sval2)
  432. stillbad = 2;
  433. if (rerr(&capdata, "Shared data & inc", linep, slinep, thread, pass, linei, sval2, sval, stillbad)) {
  434. return 1;
  435. }
  436. errs++;
  437. }
  439. *sharep = lockpat;
  440. *sharecopy = lockpat;
  443. if ( (s=UNLOCK(sharei)) != 1) {
  444. capturedata(&capdata, pass, LOCKADDR(sharei), NULL, 4);
  445. stillbad = (GETLOCK(sharei) != lockpat);
  446. if (rerr(&capdata, "Shared data & inc unlock", linep, slinep, thread, pass, linei, thread, GETLOCK(sharei), stillbad))
  447. return 1;
  448. if (correct_errors)
  449. ZEROLOCK(sharei);
  450. errs++;
  451. }
  452. break;
  453. }
  454. }
  456. return (errs > 0);
  457. }
  459. static void
  460. trigger_la(long val)
  461. {
  462. long *p;
  464. p = (long*)0xc0000a0001000020L; /* PI_CPU_NUM */
  465. *p = val;
  466. }
  468. static long
  469. getsynerr(void)
  470. {
  471. long err, *errp;
  473. errp = (long*)0xc0000e0000000340L; /* SYN_ERR */
  474. err = *errp;
  475. if (err)
  476. *errp = -1L;
  477. return (err & ~0x60);
  478. }
  480. static int
  481. rerr(capture_t *cap, char *msg, void *lp, void *slp, int thread, int pass, int badlinei, int exp, int found, int stillbad)
  482. {
  483. int cpu, i, linei;
  484. long  synerr;
  485. int selt;
  488. selt = selective_trigger && stillbad > 1 && 
  489. memcmp(cap->blockdata, cap->blockdata_fc, 128) != 0 &&
  490. memcmp(cap->shaddata, cap->shaddata_fc, 128) == 0;
  491. if (selt) {
  492. trigger_la(pass);
  493. } else if (selective_trigger) {
  494. k_go = ST_STOP;
  495. return k_stop_on_error;;
  496. }
  498. spin(1);
  499. i = 100;
  500. while (i && set_lock(&errlock, 1) != 1) {
  501. spin(1);
  502. i--;
  503. }
  504. printk ("nDataError!: %-20s, test %ld, thread %d, line:%d, pass %d (0x%x), time %ld expected:%x, found:%xn",
  505.     msg, k_testnumber, thread, badlinei, pass, pass, jiffies, exp, found);
  507. dumpline (lp, "Corrupted data", "D ", cap->blockaddr, cap->blockdata, cap->size);
  508. #ifdef ZZZ
  509. if (memcmp(cap->blockdata, cap->blockdata_fc, 128))
  510. dumpline (lp, "Corrupted data", "DF", cap->blockaddr, cap->blockdata_fc, cap->size);
  511. #endif
  513. if (cap->shadaddr) {
  514. dumpline (slp, "Shadow    data", "S ", cap->shadaddr, cap->shaddata, cap->size);
  515. #ifdef ZZZ
  516. if (memcmp(cap->shaddata, cap->shaddata_fc, 128))
  517. dumpline (slp, "Shadow    data", "SF", cap->shadaddr, cap->shaddata_fc, cap->size);
  518. #endif
  519. }
  521. printk("Threadpasses: ");
  522. for (cpu=0,i=0; cpu<LLSC_MAXCPUS; cpu++)
  523. if (k_threadprivate[cpu]->threadpasses) {
  524. if (i && (i%8) == 0)
  525. printk("n            : ");
  526. printk("  %d:0x%x", cpu, k_threadprivate[cpu]->threadpasses);
  527. i++;
  528. }
  529. printk("n");
  531. for (linei=0; linei<k_linecount; linei++) {
  532. int slinei, g1linei, g2linei, g1err, g2err, sh0err, sh1err;
  533. dataline_t *linep, *slinep;
  535. slinei = (linei + (k_linecount/2))%k_linecount;
  536. linep = (dataline_t *)blocks[linei];
  537. slinep = (dataline_t *)blocks[slinei];
  539. g1linei = GUARDLINE(linep->guard1);
  540. g2linei = GUARDLINE(linep->guard2);
  541. g1err = (g1linei != linei);
  542. g2err = (g2linei != linei);
  543. sh0err = (linep->share[0] != slinep->share0);
  544. sh1err = (linep->share[1] != slinep->share1);
  546. if (g1err || g2err || sh0err || sh1err) {
  547. printk("Line 0x%lx (%03d), %sG1 0x%lx (%03d), %sG2 0x%lx (%03d), %sSH0 %08x (%08x), %sSH1 %08x (%08x)n",
  548. blocks[linei], linei, 
  549. g1err ? "*" : " ", blocks[g1linei], g1linei,
  550. g2err ? "*" : " ", blocks[g2linei], g2linei,
  551. sh0err ? "*" : " ", linep->share[0], slinep->share0,
  552. sh1err ? "*" : " ", linep->share[1], slinep->share1);
  555. }
  556. }
  558. printk("nData was %sfixed by flushcachen", (stillbad == 1 ? "**** NOT **** " : " "));
  559. synerr = getsynerr();
  560. if (synerr)
  561. printk("SYNERR: Thread %d, Synerr: 0x%lxn", thread, synerr);
  562. spin(2);
  563. printk("nn");
  564. clr_lock(&errlock, 1);
  566. if (errstop_enabled) {
  567. local_irq_disable();
  568. while(1);
  569. }
  570. return k_stop_on_error;
  571. }
  574. static void
  575. dumpline(void *lp, char *str1, char *str2, void *addr, void *data, int size)
  576. {
  577. long *p;
  578. int i, off;
  580. printk("%s at 0x%lx, size %d, block starts at 0x%lxn", str1, (long)addr, size, (long)lp);
  581. p = (long*) data;
  582. for (i=0; i<48; i++, p++) {
  583. if (i%8 == 0) printk("%2s", i==16 ? str2 : "  ");
  584. printk(" %016lx", *p);
  585. if ((i&7)==7) printk("n");
  586. }
  587. printk("   ");
  588. off = (((long)addr) ^ size) & 63L;
  589. for (i=0; i<off+size; i++) {
  590. printk("%s", (i>=off) ? "--" : "  ");
  591. if ((i%8) == 7)
  592. printk(" ");
  593. }
  595. off = ((long)addr) & 127;
  596. printk(" (line %d)n", 2+off/64+1);
  597. }
  600. static int
  601. randn(uint max, uint *seedp)
  602. {
  603. if (max == 1)
  604. return(0);
  605. else
  606. return((int)(zrandom(seedp)>>10) % max);
  607. }
  610. static int
  611. checkstop(int thread, int pass, uint lockpat)
  612. {
  613. long synerr;
  615. if (k_go == ST_RUN)
  616. return 0;
  617. if (k_go == ST_STOP)
  618. return 1;
  620. if (errstop_enabled) {
  621. local_irq_disable();
  622. while(1);
  623. }
  624. synerr = getsynerr();
  625. spin(2);
  626. if (k_go == ST_STOP)
  627. return 1;
  628. if (synerr)
  629. printk("SYNERR: Thread %d, Synerr: 0x%lxn", thread, synerr);
  630. return 1;
  631. }
  634. static void
  635. spin(int j)
  636. {
  637. udelay(j * 500000);
  638. }
  640. static void
  641. capturedata(capture_t *cap, uint pass, void *blockaddr, void *shadaddr, int size)
  642. {
  644. if (!selective_trigger)
  645. trigger_la (pass);
  647. memcpy (cap->blockdata, CACHEALIGN(blockaddr)-128, 3*128);
  648. if (shadaddr) 
  649. memcpy (cap->shaddata, CACHEALIGN(shadaddr)-128, 3*128);
  651. if (k_stop_on_error) {
  652. k_go = ST_ERRSTOP;
  653. }
  655.   cap->size = size;
  656. cap->blockaddr = blockaddr;
  657. cap->shadaddr = shadaddr;
  659. asm volatile ("fc %0" :: "r"(blockaddr) : "memory");
  660. ia64_sync_i();
  661. ia64_srlz_d();
  662. memcpy (cap->blockdata_fc, CACHEALIGN(blockaddr)-128, 3*128);
  664. if (shadaddr) {
  665. asm volatile ("fc %0" :: "r"(shadaddr) : "memory");
  666. ia64_sync_i();
  667. ia64_srlz_d();
  668. memcpy (cap->shaddata_fc, CACHEALIGN(shadaddr)-128, 3*128);
  669. }
  670. }
  672. int             zranmult = 0x48c27395;
  674. static uint  
  675. zrandom (uint *seedp)
  676. {
  677.         *seedp = (*seedp * zranmult) & 0x7fffffff;
  678.         return (*seedp);
  679. }
  682. void
  683. set_autotest_params(void)
  684. {
  685. static int testnumber=-1;
  687. if (llsctest_number >= 0) {
  688. testnumber = llsctest_number;
  689. } else {
  690. testnumber++;
  691. if (autotest_table[testnumber].passes == 0) {
  692. testnumber = 0;
  693. dump_block_addrs_opt = 0;
  694. }
  695. }
  696. if (testnumber == 0 && l4_opt) testnumber = 9;
  698. k_passes = autotest_table[testnumber].passes;
  699. k_linepad = autotest_table[testnumber].linepad;
  700. k_linecount = autotest_table[testnumber].linecount;
  701. k_testnumber = testnumber;
  703. if (IS_RUNNING_ON_SIMULATOR()) {
  704. printk ("llsc start test %ldn", k_testnumber);
  705. k_passes = 1000;
  706. }
  707. }
  710. static void
  711. set_leds(int errs)
  712. {
  713. unsigned char leds=0;
  715. /*
  716.  * Leds are:
  717.  *  ppppeee-  
  718.  *   where
  719.  *      pppp = test number
  720.  *       eee = error count but top bit is stick
  721.  */
  723. leds =  ((errs&7)<<1) | ((k_testnumber&15)<<4) | (errs ? 0x08 : 0);
  724. set_led_bits(leds, LED_MASK_AUTOTEST);
  725. }
  727. static void
  728. setup_block_addresses(void)
  729. {
  730. int i, stride, memmapi;
  731. dataline_t *dp;
  732. long *ip, *ipe;
  735. stride = k_linepad + sizeof(dataline_t);
  736. memmapi = 0;
  737. for (i=0; i<memmapx; i++) {
  738. memmap[i].nextaddr = memmap[i].vstart;
  739. memmap[i].nextinit = memmap[i].vstart;
  740. memmap[i].wrapcount = 0;
  741. }
  743. for (i=0; i<k_linecount; i++) {
  744. blocks[i] = memmap[memmapi].nextaddr;
  745. dp = (dataline_t*)blocks[i];
  746. memmap[memmapi].nextaddr += (stride & 0xffff);
  747. if (memmap[memmapi].nextaddr + sizeof(dataline_t) >= memmap[memmapi].vend) {
  748. memmap[memmapi].wrapcount++;
  749. memmap[memmapi].nextaddr = memmap[memmapi].vstart + 
  750. memmap[memmapi].wrapcount * sizeof(dataline_t);
  751. }
  753. ip = (long*)((memmap[memmapi].nextinit+7)&~7);
  754. ipe = (long*)(memmap[memmapi].nextaddr+2*sizeof(dataline_t)+8);
  755. while(ip <= ipe && ip < ((long*)memmap[memmapi].vend-8))
  756. *ip++ = (long)ip;
  757. memmap[memmapi].nextinit = (long) ipe;
  758. dp->guard1 = BGUARD(i);
  759. dp->guard2 = EGUARD(i);
  760. dp->lock[0] = dp->lock[1] = NOLOCK;
  761. dp->share[0] = dp->share0 = 0x1111;
  762. dp->share[1] = dp->share1 = 0x2222;
  763. memcpy(dp->private, init_private, LLSC_MAXCPUS*sizeof(private_t));
  766. if (stride > 16384) {
  767. memmapi++;
  768. if (memmapi == memmapx)
  769. memmapi = 0;
  770. }
  771. }
  773. }
  775. static void
  776. dump_block_addrs(void)
  777. {
  778. int i;
  780. printk("LLSC TestNumber %ldn", k_testnumber);
  782. for (i=0; i<k_linecount; i++) {
  783. printk("  %lx", blocks[i]);
  784. if (i%4 == 3)
  785. printk("n");
  786. }
  787. printk("n");
  788. }
  791. static void
  792. set_thread_state(int cpuid, int state)
  793. {
  794. if (k_threadprivate[cpuid]->threadstate == TS_KILLED) {
  795. set_led_bits(LED_MASK_AUTOTEST, LED_MASK_AUTOTEST);
  796. while(1);
  797. }
  798. k_threadprivate[cpuid]->threadstate = state;
  799. }
  801. #define MINBLK (16*1024*1024)
  802. static int
  803. build_mem_map(unsigned long start, unsigned long end, void *arg)
  804. {
  805. long lstart, lend;
  806. long align = 8*MB;
  808. printk ("LLSC memmap: start 0x%lx, end 0x%lx, (0x%lx - 0x%lx)n", 
  809. start, end, (long) virt_to_page(start), (long) virt_to_page(end-PAGE_SIZE));
  811. if (memmapx >= MAPCHUNKS || (end-start) < MINBLK)
  812. return 0;
  814. /*
  815.  * Start in the middle of the range & find the first non-free page in both directions
  816.  * from the midpoint. This is likely to be the bigest free block.
  817.  */
  818. lend = lstart = start + (end-start)/2;
  819. while (lend < end && !PageReserved(virt_to_page(lend)) && virt_to_page(lend)->count.counter == 0)
  820. lend += PAGE_SIZE;
  821. lend -= PAGE_SIZE;
  823. while (lstart >= start && !PageReserved(virt_to_page(lstart)) && virt_to_page(lstart)->count.counter == 0)
  824. lstart -= PAGE_SIZE;
  825. lstart += PAGE_SIZE;
  827. lstart = (lstart + align -1) /align * align;
  828. end = end / align * align;
  829. if (lstart >= end)
  830. return 0;
  831. printk ("     memmap: start 0x%lx, end 0x%lxn", lstart, end);
  833. memmap[memmapx].vstart = lstart;
  834. memmap[memmapx].vend = end;
  835. memmapx++;
  836. return 0;
  837. }
  839. void int_test(void);
  841. int
  842. llsc_main (int cpuid)
  843. {
  844. int i, cpu, is_master, repeatcnt=0;
  845. unsigned int preverr=0, errs=0, pass=0;
  846. int automode=0;
  848. #ifdef INTTEST
  849. if (inttest)
  850. int_test();
  851. #endif
  853. if (!autotest_enabled)
  854. return 0;
  856. #ifdef CONFIG_SMP
  857. is_master = !smp_processor_id();
  858. #else
  859. is_master = 1;
  860. #endif
  863. if (is_master) {
  864. mbase = (control_t*) __get_free_pages(GFP_KERNEL, get_order(4096+THREADPRIVATESZ()*LLSC_MAXCPUS));
  865. printk("LLSC: mbase 0x%lxn", (long)mbase);
  866. print_params();
  867. if(!IS_RUNNING_ON_SIMULATOR())
  868. spin(10);
  869. k_currentpass = 0;
  870. k_go = ST_IDLE;
  871. k_passes = DEF_PASSES;
  872. k_napticks = DEF_NAPTICKS;
  873. k_stop_on_error = DEF_STOP_ON_ERROR;
  874. k_verbose = DEF_VERBOSE;
  875. k_linecount = DEF_LINECOUNT;
  876. k_iter_msg = DEF_ITER_MSG;
  877. k_vv = DEF_VV;
  878. k_linepad = DEF_LINEPAD;
  879. k_blocks = (void*)blocks;
  880. efi_memmap_walk(build_mem_map, 0);
  882. #ifdef CONFIG_IA64_SGI_AUTOTEST
  883. automode = 1;
  884. #endif
  886. for (i=0; i<LLSC_MAXCPUS; i++) {
  887. k_threadprivate[i] = THREADPRIVATE(i);
  888. memset(k_threadprivate[i], 0, sizeof(*k_threadprivate[i]));
  889. init_private[i] = i;
  890. }
  891. mb();
  892. initialized = 1;
  893. } else {
  894. while (initialized == 0)
  895. udelay(100);
  896. }
  898. loop:
  899. if (is_master) {
  900. if (automode) {
  901. if (!preverr || repeatcnt++ > 5) {
  902. set_autotest_params();
  903. repeatcnt = 0;
  904. }
  905. } else {
  906. while (k_go == ST_IDLE);
  907. }
  909. k_go = ST_INIT;
  910. if (k_linecount > MAX_LINECOUNT) k_linecount = MAX_LINECOUNT;
  911. k_linecount = k_linecount & ~1;
  912. setup_block_addresses();
  913. if (!preverr && dump_block_addrs_opt)
  914. dump_block_addrs();
  916. k_currentpass = pass++;
  917. k_go = ST_RUN;
  918. if (fail_enabled)
  919. fail_enabled--;
  921. } else {
  922. while (k_go != ST_RUN || k_currentpass != pass);
  923. pass++;
  924. }
  927. set_leds(errs);
  928. set_thread_state(cpuid, TS_RUNNING);
  930. errs += ran_conf_llsc(cpuid);
  931. preverr = (k_go == ST_ERRSTOP);
  933. set_leds(errs);
  934. set_thread_state(cpuid, TS_STOPPED);
  936. if (is_master) {
  937. Speedo();
  938. for (i=0, cpu=0; cpu<LLSC_MAXCPUS; cpu++) {
  939. while (k_threadprivate[cpu]->threadstate == TS_RUNNING) {
  940. i++;
  941. if (i == 10000) { 
  942. k_go = ST_STOP;
  943. printk ("  llsc master stopping test number %ldn", k_testnumber);
  944. }
  945. if (i > 100000) {
  946. k_threadprivate[cpu]->threadstate = TS_KILLED;
  947. printk ("  llsc: master killing cpuid %d, running test number %ldn", 
  948. cpu, k_testnumber);
  949. }
  950. udelay(1000);
  951. }
  952. }
  953. }
  955. goto loop;
  956. }
  959. static void
  960. Speedo(void)
  961. {
  962. static int i = 0;
  964. switch (++i%4) {
  965. case 0:
  966. printk("|b");
  967. break;
  968. case 1:
  969. printk("\b");
  970. break;
  971. case 2:
  972. printk("-b");
  973. break;
  974. case 3:
  975. printk("/b");
  976. break;
  977. }
  978. }
  980. #ifdef INTTEST
  982. /* ======================================================================================================== 
  983.  *
  984.  * Some test code to verify that interrupts work
  985.  *
  986.  * Add the following to the arch/ia64/kernel/smp.c after the comment "Reschedule callback"
  987.  *  if (zzzprint_resched) printk("  cpu %d got interruptn", smp_processor_id());
  988.  *
  989.  * Enable the code in arch/ia64/sn/sn1/smp.c to print sending IPIs.
  990.  *
  991.  */
  993. static int __init set_inttest(char *str)
  994. {
  995.         inttest = 1;
  996. autotest_enabled = 1;
  998. return 1;
  999. }
  1001. __setup("inttest=", set_inttest);
  1003. int zzzprint_resched=0;
  1005. void
  1006. int_test() {
  1007. int mycpu, cpu;
  1008. static volatile int control_cpu=0;
  1010. mycpu = smp_processor_id();
  1011. zzzprint_resched = 2;
  1013. printk("Testing cross interruptsn");
  1015. while (control_cpu != smp_num_cpus) {
  1016. if (mycpu == cpu_logical_map(control_cpu)) {
  1017. for (cpu=0; cpu<smp_num_cpus; cpu++) {
  1018. printk("Sending interrupt from %d to %dn", mycpu, cpu_logical_map(cpu));
  1019. udelay(IS_RUNNING_ON_SIMULATOR ? 10000 : 400000);
  1020. smp_send_reschedule(cpu_logical_map(cpu));
  1021. udelay(IS_RUNNING_ON_SIMULATOR ? 10000 : 400000);
  1022. smp_send_reschedule(cpu_logical_map(cpu));
  1023. udelay(IS_RUNNING_ON_SIMULATOR ? 10000 : 400000);
  1024. }
  1025. control_cpu++;
  1026. }
  1027. }
  1029. zzzprint_resched = 1;
  1031. if (mycpu == cpu_logical_map(smp_num_cpus-1)) {
  1032. printk("nTight loop of cpu %d sending ints to cpu 0 (every 100 us)n", mycpu);
  1033. udelay(IS_RUNNING_ON_SIMULATOR ? 1000 : 1000000);
  1034. __cli();
  1035. while (1) {
  1036. smp_send_reschedule(0);
  1037. udelay(100);
  1038. }
  1040. }
  1042. while(1);
  1043. }
  1044. #endif