cutils/debug.c at master · matthmr/cutils · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#include "macros.h"
#include "debug.h"

#ifdef DEBUG_MM

#include <stdio.h>
#include <string.h>

#define MM_NEXT_WITH(x,n) ((struct mm_header*)((byte*)((x) + 1) + (n)))
#define MM_NEXT(x) MM_NEXT_WITH(x, (x)->payload)
#define MM_UPPER(x) (((byte*)(x)) + (x)->cap)
#define MM_BASE(x) ((struct mm_header*) \
                    (((byte*)(x)) + sizeof(struct mm_header) + (x)->m_off))
#  define EDGEP(h) TOP_BIT((h)->payload)

static inline struct mm_header* mm_header_next(struct mm_header* header) {
  if (!header) {
    return NULL;
  }

  register struct mm_sec* sec = header->sec;

  if (EDGEP(header)) {
    return sec->next? MM_BASE(sec->next): NULL;
  }

  register struct mm_header* ret = MM_NEXT(header);

  return (ret >= MM_BASE(sec) && ((byte*)ret < MM_UPPER(sec)))? ret: NULL;
}

void
debug_mm_headers(char* msg, struct mm_header* header) {
  struct mm_sec* sec;

  uint size = 0;
  uint tsize = 0;
  uint headers = 0;
  uint secs = 0;

  if (msg) {
    // puts(msg);
    fprintf(stderr, "%s\n", msg);
  }

  // get the ending sector ...
  for (sec = header->sec; sec->next; sec = sec->next);

  // ... then the ending header ...
  header = (struct mm_header*)(sec + 1);

  // ... go to the edge ...
  for (;;) {
    struct mm_header* n_header = mm_header_next(header);

    if (!n_header) {
      break;
    }

    header = n_header;
  }

  fprintf(stderr, "---\n");

  char stat[6] = {0};
  uint stati = 0;

  // ... then iterate backwards:
  for (;;header = header->prev) {
    bzero(stat, SIZEOF(stat));
    stati = 0;

    struct mm_sec* sec = header->sec;
    struct mm_header* p_header = NULL;

    if (!header->used) {
      stat[stati] = 'f';
      stati++;
    }
    else {
      stat[stati] = 'm';
      stati++;
    }
    if (EDGEP(header)) {
      stat[stati] = 'e';
      stati++;
    }
    if (header == sec->cur) {
      stat[stati] = 'c';
      stati++;
    }
    if (header == mm_acsec->cur) {
      stat[stati] = 'C';
      stati++;
    }
    if (header == (struct mm_header*)
                  ((byte*)sec + sizeof(*header) + sec->m_off)) {
      stat[stati] = 'b';
      stati++;
    }

    const uint payload = header->payload & ~BIT(BITSIZEOF(header->payload)-1);

    fprintf(stderr, "%p : %p : %p [%d%s]\n",
            header->sec, header, header+1, payload, stat);

    if (p_header && mm_header_next(header) != p_header) {
      fprintf(stderr, "[ !! ] CLASH: %p -!> %p\n", header, p_header);
    }

    size += payload;
    headers++;

    p_header = header;

    if (header->prev && header->prev->sec != sec) {
      tsize = size + headers*sizeof(*header) + sizeof(*sec);
      fprintf(stderr, "\nsize(%d): %d (%d), total: %d\n", headers, size,
             tsize, sec->cap);
      fprintf(stderr, "---\n");

      size = 0;
      headers = 0;
    }

    if (!header->prev) {
      tsize = size + headers*sizeof(*header) + sizeof(*sec);
      fprintf(stderr, "\nsize(%d): %d (%d), total: %d\n", headers, size,
             tsize, sec->cap);

      break;
    }
  }

  fprintf(stderr, "---\n");
}
#endif

struct mm_header* mm_header_of(void* mem) {
  return (((struct mm_header*) mem) - 1);
}