mem_search.c 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Tests for memory commands
  4. *
  5. * Copyright 2020 Google LLC
  6. * Written by Simon Glass <sjg@chromium.org>
  7. */
  8. #include <common.h>
  9. #include <console.h>
  10. #include <mapmem.h>
  11. #include <dm/test.h>
  12. #include <test/ut.h>
  13. #define BUF_SIZE 0x100
  14. /* Declare a new mem test */
  15. #define MEM_TEST(_name, _flags) UNIT_TEST(_name, _flags, mem_test)
  16. /* Test 'ms' command with bytes */
  17. static int mem_test_ms_b(struct unit_test_state *uts)
  18. {
  19. u8 *buf;
  20. buf = map_sysmem(0, BUF_SIZE + 1);
  21. memset(buf, '\0', BUF_SIZE);
  22. buf[0x0] = 0x12;
  23. buf[0x31] = 0x12;
  24. buf[0xff] = 0x12;
  25. buf[0x100] = 0x12;
  26. ut_assertok(console_record_reset_enable());
  27. run_command("ms.b 1 ff 12", 0);
  28. ut_assert_nextline("00000030: 00 12 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................");
  29. ut_assert_nextline("--");
  30. ut_assert_nextline("000000f0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 12 ................");
  31. ut_assert_nextline("2 matches");
  32. ut_assert_console_end();
  33. ut_asserteq(2, env_get_hex("memmatches", 0));
  34. ut_asserteq(0xff, env_get_hex("memaddr", 0));
  35. ut_asserteq(0xfe, env_get_hex("mempos", 0));
  36. unmap_sysmem(buf);
  37. return 0;
  38. }
  39. MEM_TEST(mem_test_ms_b, UT_TESTF_CONSOLE_REC);
  40. /* Test 'ms' command with 16-bit values */
  41. static int mem_test_ms_w(struct unit_test_state *uts)
  42. {
  43. u16 *buf;
  44. buf = map_sysmem(0, BUF_SIZE + 2);
  45. memset(buf, '\0', BUF_SIZE);
  46. buf[0x34 / 2] = 0x1234;
  47. buf[BUF_SIZE / 2] = 0x1234;
  48. ut_assertok(console_record_reset_enable());
  49. run_command("ms.w 0 80 1234", 0);
  50. ut_assert_nextline("00000030: 0000 0000 1234 0000 0000 0000 0000 0000 ....4...........");
  51. ut_assert_nextline("1 match");
  52. ut_assert_console_end();
  53. ut_asserteq(1, env_get_hex("memmatches", 0));
  54. ut_asserteq(0x34, env_get_hex("memaddr", 0));
  55. ut_asserteq(0x34 / 2, env_get_hex("mempos", 0));
  56. unmap_sysmem(buf);
  57. return 0;
  58. }
  59. MEM_TEST(mem_test_ms_w, UT_TESTF_CONSOLE_REC);
  60. /* Test 'ms' command with 32-bit values */
  61. static int mem_test_ms_l(struct unit_test_state *uts)
  62. {
  63. u32 *buf;
  64. buf = map_sysmem(0, BUF_SIZE + 4);
  65. memset(buf, '\0', BUF_SIZE);
  66. buf[0x38 / 4] = 0x12345678;
  67. buf[BUF_SIZE / 4] = 0x12345678;
  68. ut_assertok(console_record_reset_enable());
  69. run_command("ms 0 40 12345678", 0);
  70. ut_assert_nextline("00000030: 00000000 00000000 12345678 00000000 ........xV4.....");
  71. ut_assert_nextline("1 match");
  72. ut_assert_console_end();
  73. ut_asserteq(1, env_get_hex("memmatches", 0));
  74. ut_asserteq(0x38, env_get_hex("memaddr", 0));
  75. ut_asserteq(0x38 / 4, env_get_hex("mempos", 0));
  76. ut_assertok(console_record_reset_enable());
  77. run_command("ms 0 80 12345679", 0);
  78. ut_assert_nextline("0 matches");
  79. ut_assert_console_end();
  80. ut_asserteq(0, env_get_hex("memmatches", 0));
  81. ut_asserteq(0, env_get_hex("memaddr", 0));
  82. ut_asserteq(0 / 4, env_get_hex("mempos", 0));
  83. unmap_sysmem(buf);
  84. return 0;
  85. }
  86. MEM_TEST(mem_test_ms_l, UT_TESTF_CONSOLE_REC);
  87. /* Test 'ms' command with continuation */
  88. static int mem_test_ms_cont(struct unit_test_state *uts)
  89. {
  90. char *const args[] = {"ms.b", "0", "100", "34"};
  91. int repeatable;
  92. u8 *buf;
  93. int i;
  94. buf = map_sysmem(0, BUF_SIZE);
  95. memset(buf, '\0', BUF_SIZE);
  96. for (i = 5; i < 0x33; i += 3)
  97. buf[i] = 0x34;
  98. ut_assertok(console_record_reset_enable());
  99. run_command("ms.b 0 100 34", 0);
  100. ut_assert_nextlinen("00000000: 00 00 00 00 00 34 00 00 34 00 00 34 00 00 34 00");
  101. ut_assert_nextline("--");
  102. ut_assert_nextlinen("00000010: 00 34 00 00 34 00 00 34 00 00 34 00 00 34 00 00");
  103. ut_assert_nextline("--");
  104. ut_assert_nextlinen("00000020: 34 00 00 34 00 00 34 00 00 34 00 00 34 00 00 34");
  105. ut_assert_nextlinen("10 matches (repeat command to check for more)");
  106. ut_assert_console_end();
  107. ut_asserteq(10, env_get_hex("memmatches", 0));
  108. ut_asserteq(0x20, env_get_hex("memaddr", 0));
  109. ut_asserteq(0x20, env_get_hex("mempos", 0));
  110. /*
  111. * run_command() ignoes the repeatable flag when using hush, so call
  112. * cmd_process() directly
  113. */
  114. ut_assertok(console_record_reset_enable());
  115. cmd_process(CMD_FLAG_REPEAT, 4, args, &repeatable, NULL);
  116. ut_assert_nextlinen("00000020: 34 00 00 34 00 00 34 00 00 34 00 00 34 00 00 34");
  117. ut_assert_nextline("--");
  118. ut_assert_nextlinen("00000030: 00 00 34 00 00 00 00 00");
  119. ut_assert_nextlinen("6 matches");
  120. ut_assert_console_end();
  121. ut_asserteq(6, env_get_hex("memmatches", 0));
  122. ut_asserteq(0x32, env_get_hex("memaddr", 0));
  123. /* 0x32 less 0x21, where the second search started */
  124. ut_asserteq(0x11, env_get_hex("mempos", 0));
  125. unmap_sysmem(buf);
  126. return 0;
  127. }
  128. MEM_TEST(mem_test_ms_cont, UT_TESTF_CONSOLE_REC);
  129. /* Test that an 'ms' command with continuation stops at the end of the range */
  130. static int mem_test_ms_cont_end(struct unit_test_state *uts)
  131. {
  132. char *const args[] = {"ms.b", "1", "ff", "12"};
  133. int repeatable;
  134. u8 *buf;
  135. buf = map_sysmem(0, BUF_SIZE);
  136. memset(buf, '\0', BUF_SIZE);
  137. buf[0x0] = 0x12;
  138. buf[0x31] = 0x12;
  139. buf[0xff] = 0x12;
  140. buf[0x100] = 0x12;
  141. ut_assertok(console_record_reset_enable());
  142. run_command("ms.b 1 ff 12", 0);
  143. ut_assert_nextlinen("00000030");
  144. ut_assert_nextlinen("--");
  145. ut_assert_nextlinen("000000f0");
  146. ut_assert_nextlinen("2 matches");
  147. ut_assert_console_end();
  148. /*
  149. * run_command() ignoes the repeatable flag when using hush, so call
  150. * cmd_process() directly.
  151. *
  152. * This should produce no matches.
  153. */
  154. ut_assertok(console_record_reset_enable());
  155. cmd_process(CMD_FLAG_REPEAT, 4, args, &repeatable, NULL);
  156. ut_assert_nextlinen("0 matches");
  157. ut_assert_console_end();
  158. /* One more time */
  159. ut_assertok(console_record_reset_enable());
  160. cmd_process(CMD_FLAG_REPEAT, 4, args, &repeatable, NULL);
  161. ut_assert_nextlinen("0 matches");
  162. ut_assert_console_end();
  163. unmap_sysmem(buf);
  164. return 0;
  165. }
  166. MEM_TEST(mem_test_ms_cont_end, UT_TESTF_CONSOLE_REC);
  167. /* Test 'ms' command with multiple values */
  168. static int mem_test_ms_mult(struct unit_test_state *uts)
  169. {
  170. static const char str[] = "hello";
  171. char *buf;
  172. buf = map_sysmem(0, BUF_SIZE + 5);
  173. memset(buf, '\0', BUF_SIZE);
  174. strcpy(buf + 0x1e, str);
  175. strcpy(buf + 0x63, str);
  176. strcpy(buf + BUF_SIZE - strlen(str) + 1, str);
  177. ut_assertok(console_record_reset_enable());
  178. run_command("ms.b 0 100 68 65 6c 6c 6f", 0);
  179. ut_assert_nextline("00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 68 65 ..............he");
  180. ut_assert_nextline("00000020: 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 00 00 llo.............");
  181. ut_assert_nextline("--");
  182. ut_assert_nextline("00000060: 00 00 00 68 65 6c 6c 6f 00 00 00 00 00 00 00 00 ...hello........");
  183. ut_assert_nextline("2 matches");
  184. ut_assert_console_end();
  185. unmap_sysmem(buf);
  186. ut_asserteq(2, env_get_hex("memmatches", 0));
  187. ut_asserteq(0x63, env_get_hex("memaddr", 0));
  188. ut_asserteq(0x63, env_get_hex("mempos", 0));
  189. return 0;
  190. }
  191. MEM_TEST(mem_test_ms_mult, UT_TESTF_CONSOLE_REC);
  192. /* Test 'ms' command with string */
  193. static int mem_test_ms_s(struct unit_test_state *uts)
  194. {
  195. static const char str[] = "hello";
  196. static const char str2[] = "hellothere";
  197. char *buf;
  198. buf = map_sysmem(0, BUF_SIZE);
  199. memset(buf, '\0', BUF_SIZE);
  200. strcpy(buf + 0x1e, str);
  201. strcpy(buf + 0x63, str);
  202. strcpy(buf + 0xa1, str2);
  203. ut_assertok(console_record_reset_enable());
  204. run_command("ms.s 0 100 hello", 0);
  205. ut_assert_nextline("00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 68 65 ..............he");
  206. ut_assert_nextline("00000020: 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 00 00 llo.............");
  207. ut_assert_nextline("--");
  208. ut_assert_nextline("00000060: 00 00 00 68 65 6c 6c 6f 00 00 00 00 00 00 00 00 ...hello........");
  209. ut_assert_nextline("--");
  210. ut_assert_nextline("000000a0: 00 68 65 6c 6c 6f 74 68 65 72 65 00 00 00 00 00 .hellothere.....");
  211. ut_assert_nextline("3 matches");
  212. ut_assert_console_end();
  213. ut_asserteq(3, env_get_hex("memmatches", 0));
  214. ut_asserteq(0xa1, env_get_hex("memaddr", 0));
  215. ut_asserteq(0xa1, env_get_hex("mempos", 0));
  216. ut_assertok(console_record_reset_enable());
  217. run_command("ms.s 0 100 hello there", 0);
  218. ut_assert_nextline("000000a0: 00 68 65 6c 6c 6f 74 68 65 72 65 00 00 00 00 00 .hellothere.....");
  219. ut_assert_nextline("1 match");
  220. ut_assert_console_end();
  221. ut_asserteq(1, env_get_hex("memmatches", 0));
  222. ut_asserteq(0xa1, env_get_hex("memaddr", 0));
  223. ut_asserteq(0xa1, env_get_hex("mempos", 0));
  224. unmap_sysmem(buf);
  225. return 0;
  226. }
  227. MEM_TEST(mem_test_ms_s, UT_TESTF_CONSOLE_REC);
  228. /* Test 'ms' command with limit */
  229. static int mem_test_ms_limit(struct unit_test_state *uts)
  230. {
  231. u8 *buf;
  232. buf = map_sysmem(0, BUF_SIZE + 1);
  233. memset(buf, '\0', BUF_SIZE);
  234. buf[0x0] = 0x12;
  235. buf[0x31] = 0x12;
  236. buf[0x62] = 0x12;
  237. buf[0x76] = 0x12;
  238. ut_assertok(console_record_reset_enable());
  239. run_command("ms.b -l2 1 ff 12", 0);
  240. ut_assert_nextline("00000030: 00 12 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................");
  241. ut_assert_nextline("--");
  242. ut_assert_nextlinen("00000060: 00 00 12 00 00 00 00 00 00 00 00 00 00 00 00 00");
  243. ut_assert_nextline("2 matches (repeat command to check for more)");
  244. ut_assert_console_end();
  245. ut_asserteq(2, env_get_hex("memmatches", 0));
  246. ut_asserteq(0x62, env_get_hex("memaddr", 0));
  247. ut_asserteq(0x61, env_get_hex("mempos", 0));
  248. unmap_sysmem(buf);
  249. return 0;
  250. }
  251. MEM_TEST(mem_test_ms_limit, UT_TESTF_CONSOLE_REC);
  252. /* Test 'ms' command in quiet mode */
  253. static int mem_test_ms_quiet(struct unit_test_state *uts)
  254. {
  255. u8 *buf;
  256. buf = map_sysmem(0, BUF_SIZE + 1);
  257. memset(buf, '\0', BUF_SIZE);
  258. buf[0x0] = 0x12;
  259. buf[0x31] = 0x12;
  260. buf[0x62] = 0x12;
  261. buf[0x76] = 0x12;
  262. ut_assertok(console_record_reset_enable());
  263. run_command("ms.b -q -l2 1 ff 12", 0);
  264. ut_assert_console_end();
  265. unmap_sysmem(buf);
  266. ut_asserteq(2, env_get_hex("memmatches", 0));
  267. ut_asserteq(0x62, env_get_hex("memaddr", 0));
  268. ut_asserteq(0x61, env_get_hex("mempos", 0));
  269. return 0;
  270. }
  271. MEM_TEST(mem_test_ms_quiet, UT_TESTF_CONSOLE_REC);