acidleak.c 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301
  1. #include <u.h>
  2. #include <libc.h>
  3. #include <bio.h>
  4. void*
  5. emalloc(ulong sz)
  6. {
  7. void *v;
  8. v = malloc(sz);
  9. if(v == nil)
  10. sysfatal("malloc %lud fails\n", sz);
  11. memset(v, 0, sz);
  12. return v;
  13. }
  14. void*
  15. erealloc(void *v, ulong sz)
  16. {
  17. v = realloc(v, sz);
  18. if(v == nil)
  19. sysfatal("realloc %lud fails\n", sz);
  20. return v;
  21. }
  22. typedef struct Block Block;
  23. typedef struct Data Data;
  24. struct Block {
  25. ulong addr;
  26. ulong size;
  27. ulong w0;
  28. ulong w1;
  29. int mark;
  30. int free;
  31. Data *d;
  32. };
  33. struct Data {
  34. ulong addr;
  35. ulong val;
  36. uchar type;
  37. Block *b;
  38. };
  39. Block *block;
  40. int nblock;
  41. Data *data;
  42. Data *edata;
  43. int ndata;
  44. int
  45. addrcmp(void *va, void *vb)
  46. {
  47. ulong *a, *b;
  48. a = va;
  49. b = vb;
  50. if(*a < *b)
  51. return -1;
  52. if(*a > *b)
  53. return 1;
  54. return 0;
  55. }
  56. Block*
  57. findblock(ulong addr)
  58. {
  59. int lo, hi, m;
  60. lo = 0;
  61. hi = nblock;
  62. while(lo < hi) {
  63. m = (lo+hi)/2;
  64. if(block[m].addr < addr)
  65. lo = m+1;
  66. else if(addr < block[m].addr)
  67. hi = m;
  68. else
  69. return &block[m];
  70. }
  71. return nil;
  72. }
  73. Data*
  74. finddata(ulong addr)
  75. {
  76. int lo, hi, m;
  77. lo = 0;
  78. hi = ndata;
  79. while(lo < hi) {
  80. m = (lo+hi)/2;
  81. if(data[m].addr < addr)
  82. lo = m+1;
  83. else if(addr < data[m].addr)
  84. hi = m;
  85. else
  86. return &data[m];
  87. }
  88. if(0 <= lo && lo < ndata)
  89. return &data[lo];
  90. }
  91. int nmark;
  92. int
  93. markblock(ulong from, ulong fromval, Block *b)
  94. {
  95. Data *d;
  96. ulong top;
  97. Block *nb;
  98. USED(from);
  99. //print("trace 0x%.8lux from 0x%.8lux (%d)\n", b->addr, from, b->mark);
  100. if(b->free){
  101. // fprint(2, "possible dangling pointer *0x%.8lux = 0x%.8lux\n", from, fromval);
  102. return 0;
  103. }
  104. if(b->mark)
  105. return 0;
  106. b->mark = 1;
  107. nmark++;
  108. if(d = finddata(b->addr)) {
  109. assert(d->addr >= b->addr);
  110. b->d = d;
  111. top = b->addr+b->size;
  112. for(; d < edata && d->addr < top; d++) {
  113. assert(d->b == 0);
  114. d->b = b;
  115. if((nb = findblock(d->val-8)) || (nb = findblock(d->val-8-8)))
  116. markblock(d->addr, d->val, nb);
  117. }
  118. return 1;
  119. }
  120. return 0;
  121. }
  122. enum {
  123. AllocColor = 2, // dark blue: completely allocated region
  124. HdrColor = 54, // bright blue: region with header
  125. LeakColor = 205, // dark red: region with leak
  126. LeakHdrColor = 240, // bright red: region with leaked header
  127. FreeColor = 252, // bright yellow: completely free region
  128. NoColor = 255, // padding, white
  129. };
  130. int
  131. rXr(int as, int ae, int bs, int be)
  132. {
  133. return bs < ae && as < be;
  134. }
  135. void
  136. main(int argc, char **argv)
  137. {
  138. Biobuf bio;
  139. char *p, *f[10];
  140. int bitmap, c, nf, resolution, n8, n16, hdr, nhdr, nlhdr, nleak, x, y, nb;
  141. ulong allocstart, allocend, len, u;
  142. Data *d, *ed;
  143. Block *b, *eb;
  144. bitmap = 0;
  145. resolution = 8;
  146. x = 512;
  147. ARGBEGIN{
  148. case 'b':
  149. bitmap=1;
  150. break;
  151. case 'r':
  152. resolution = atoi(EARGF(sysfatal("usage")));
  153. break;
  154. case 'x':
  155. x = atoi(EARGF(sysfatal("usage")));
  156. break;
  157. }ARGEND
  158. n8 = n16 = 0;
  159. allocstart = allocend = 0;
  160. Binit(&bio, 0, OREAD);
  161. while(p=Brdline(&bio, '\n')) {
  162. p[Blinelen(&bio)-1] = '\0';
  163. nf = tokenize(p, f, nelem(f));
  164. if(nf >= 4 && strcmp(f[0], "data") == 0) {
  165. if(ndata%64==0)
  166. data = erealloc(data, (ndata+64)*sizeof(Data));
  167. data[ndata].addr = strtoul(f[1], nil, 0);
  168. data[ndata].val = strtoul(f[2], nil, 0);
  169. data[ndata].type = f[3][0];
  170. data[ndata].b = 0;
  171. ndata++;
  172. }
  173. if(nf >= 5 && (strcmp(f[0], "block") == 0 || strcmp(f[0], "free") == 0)) {
  174. if(nblock%64 == 0)
  175. block = erealloc(block, (nblock+64)*sizeof(Block));
  176. block[nblock].addr = strtoul(f[1], nil, 0);
  177. block[nblock].size = strtoul(f[2], nil, 0);
  178. block[nblock].w0 = strtoul(f[3], nil, 0);
  179. block[nblock].w1 = strtoul(f[4], nil, 0);
  180. block[nblock].mark = 0;
  181. block[nblock].d = 0;
  182. block[nblock].free = strcmp(f[0], "free") == 0;
  183. nblock++;
  184. }
  185. if(nf >= 4 && strcmp(f[0], "range") == 0 && strcmp(f[1], "alloc") == 0) {
  186. allocstart = strtoul(f[2], 0, 0)&~15;
  187. allocend = strtoul(f[3], 0, 0);
  188. }
  189. }
  190. qsort(block, nblock, sizeof(Block), addrcmp);
  191. qsort(data, ndata, sizeof(Data), addrcmp);
  192. ed = edata = data+ndata;
  193. for(d=data; d<ed; d++) {
  194. if(d->type == 'a')
  195. continue;
  196. if(b = findblock(d->val-8)) // pool header 2 words
  197. n8 += markblock(d->addr, d->val, b);
  198. else if(b = findblock(d->val-8-8)) // sometimes malloc header 2 words
  199. n16 += markblock(d->addr, d->val, b);
  200. else
  201. {}//print("noblock %.8lux\n", d->val);
  202. }
  203. Binit(&bio, 1, OWRITE);
  204. if(bitmap){
  205. if(n8 > n16) // guess size of header
  206. hdr = 8;
  207. else
  208. hdr = 16;
  209. for(d=data; d<ed; d++)
  210. if(d->type=='a')
  211. break;
  212. if(d==ed)
  213. sysfatal("no allocated data region");
  214. len = (allocend-allocstart+resolution-1)/resolution;
  215. y = (len+x-1)/x;
  216. Bprint(&bio, "%11s %11d %11d %11d %11d ", "m8", 0, 0, x, y);
  217. //fprint(2, "alloc %lux %lux x %d y %d res %d\n", allocstart, allocend, x, y, resolution);
  218. b = block;
  219. eb = block+nblock;
  220. for(u = allocstart; u<allocend; u+=resolution){
  221. //fprint(2, "u %lux %lux baddr %lux\n", u, u+resolution, b->addr);
  222. while(b->addr+b->size <= u && b < eb)
  223. //{
  224. //fprint(2, "\tskip %lux %lux\n", b->addr, b->addr+b->size);
  225. b++;
  226. //}
  227. nhdr = 0;
  228. nleak = 0;
  229. nb = 0;
  230. nlhdr = 0;
  231. if(block < b && u < (b-1)->addr+(b-1)->size)
  232. b--;
  233. for(; b->addr < u+resolution && b < eb; b++){
  234. //fprint(2, "\tblock %lux %lux %d\n", b->addr, b->addr+b->size, b->mark);
  235. if(rXr(b->addr, b->addr+hdr, u, u+resolution)
  236. || rXr(b->addr+b->size-8, b->addr+b->size, u, u+resolution)){
  237. if(b->mark == 0 && !b->free)
  238. nlhdr++;
  239. else
  240. nhdr++;
  241. }
  242. if(b->mark == 0)
  243. nleak++;
  244. nb++;
  245. }
  246. if(nhdr)
  247. c = HdrColor;
  248. else if(nlhdr)
  249. c = LeakHdrColor;
  250. else if(nleak)
  251. c = LeakColor;
  252. else if(nb)
  253. c = AllocColor;
  254. else
  255. c = FreeColor;
  256. //fprint(2, "\t%d\n", c);
  257. Bputc(&bio, c);
  258. }
  259. allocend = allocstart+x*y*resolution;
  260. for(; u < allocend; u+=resolution)
  261. Bputc(&bio, NoColor);
  262. }else{
  263. eb = block+nblock;
  264. for(b=block; b<eb; b++)
  265. if(b->mark == 0 && !b->free)
  266. Bprint(&bio, "block 0x%.8lux 0x%.8lux 0x%.8lux 0x%.8lux\n", b->addr, b->size, b->w0, b->w1);
  267. }
  268. Bterm(&bio);
  269. }