1 /*
2 * lib/hexdump.c
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation. See README and COPYING for
7 * more details.
8 */
9
10 #include <linux/types.h>
11 #include <linux/ctype.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14
15 const char hex_asc[] = "0123456789abcdef";
16 EXPORT_SYMBOL(hex_asc);
17
18 /**
19 * hex_dump_to_buffer - convert a blob of data to "hex ASCII" in memory
20 * @buf: data blob to dump
21 * @len: number of bytes in the @buf
22 * @rowsize: number of bytes to print per line; must be 16 or 32
23 * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
24 * @linebuf: where to put the converted data
25 * @linebuflen: total size of @linebuf, including space for terminating NUL
26 * @ascii: include ASCII after the hex output
27 *
28 * hex_dump_to_buffer() works on one "line" of output at a time, i.e.,
29 * 16 or 32 bytes of input data converted to hex + ASCII output.
30 *
31 * Given a buffer of u8 data, hex_dump_to_buffer() converts the input data
32 * to a hex + ASCII dump at the supplied memory location.
33 * The converted output is always NUL-terminated.
34 *
35 * E.g.:
36 * hex_dump_to_buffer(frame->data, frame->len, 16, 1,
37 * linebuf, sizeof(linebuf), 1);
38 *
39 * example output buffer:
40 * 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO
41 */
hex_dump_to_buffer(const void * buf,size_t len,int rowsize,int groupsize,char * linebuf,size_t linebuflen,bool ascii)42 void hex_dump_to_buffer(const void *buf, size_t len, int rowsize,
43 int groupsize, char *linebuf, size_t linebuflen,
44 bool ascii)
45 {
46 const u8 *ptr = buf;
47 u8 ch;
48 int j, lx = 0;
49 int ascii_column;
50
51 if (rowsize != 16 && rowsize != 32)
52 rowsize = 16;
53
54 if (!len)
55 goto nil;
56 if (len > rowsize) /* limit to one line at a time */
57 len = rowsize;
58 if ((len % groupsize) != 0) /* no mixed size output */
59 groupsize = 1;
60
61 switch (groupsize) {
62 case 8: {
63 const u64 *ptr8 = buf;
64 int ngroups = len / groupsize;
65
66 for (j = 0; j < ngroups; j++)
67 lx += scnprintf(linebuf + lx, linebuflen - lx,
68 "%16.16llx ", (unsigned long long)*(ptr8 + j));
69 ascii_column = 17 * ngroups + 2;
70 break;
71 }
72
73 case 4: {
74 const u32 *ptr4 = buf;
75 int ngroups = len / groupsize;
76
77 for (j = 0; j < ngroups; j++)
78 lx += scnprintf(linebuf + lx, linebuflen - lx,
79 "%8.8x ", *(ptr4 + j));
80 ascii_column = 9 * ngroups + 2;
81 break;
82 }
83
84 case 2: {
85 const u16 *ptr2 = buf;
86 int ngroups = len / groupsize;
87
88 for (j = 0; j < ngroups; j++)
89 lx += scnprintf(linebuf + lx, linebuflen - lx,
90 "%4.4x ", *(ptr2 + j));
91 ascii_column = 5 * ngroups + 2;
92 break;
93 }
94
95 default:
96 for (j = 0; (j < rowsize) && (j < len) && (lx + 4) < linebuflen;
97 j++) {
98 ch = ptr[j];
99 linebuf[lx++] = hex_asc_hi(ch);
100 linebuf[lx++] = hex_asc_lo(ch);
101 linebuf[lx++] = ' ';
102 }
103 ascii_column = 3 * rowsize + 2;
104 break;
105 }
106 if (!ascii)
107 goto nil;
108
109 while (lx < (linebuflen - 1) && lx < (ascii_column - 1))
110 linebuf[lx++] = ' ';
111 for (j = 0; (j < rowsize) && (j < len) && (lx + 2) < linebuflen; j++)
112 linebuf[lx++] = (isascii(ptr[j]) && isprint(ptr[j])) ? ptr[j]
113 : '.';
114 nil:
115 linebuf[lx++] = '\0';
116 }
117 EXPORT_SYMBOL(hex_dump_to_buffer);
118
119 /**
120 * print_hex_dump - print a text hex dump to syslog for a binary blob of data
121 * @level: kernel log level (e.g. KERN_DEBUG)
122 * @prefix_str: string to prefix each line with;
123 * caller supplies trailing spaces for alignment if desired
124 * @prefix_type: controls whether prefix of an offset, address, or none
125 * is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
126 * @rowsize: number of bytes to print per line; must be 16 or 32
127 * @groupsize: number of bytes to print at a time (1, 2, 4, 8; default = 1)
128 * @buf: data blob to dump
129 * @len: number of bytes in the @buf
130 * @ascii: include ASCII after the hex output
131 *
132 * Given a buffer of u8 data, print_hex_dump() prints a hex + ASCII dump
133 * to the kernel log at the specified kernel log level, with an optional
134 * leading prefix.
135 *
136 * print_hex_dump() works on one "line" of output at a time, i.e.,
137 * 16 or 32 bytes of input data converted to hex + ASCII output.
138 * print_hex_dump() iterates over the entire input @buf, breaking it into
139 * "line size" chunks to format and print.
140 *
141 * E.g.:
142 * print_hex_dump(KERN_DEBUG, "raw data: ", DUMP_PREFIX_ADDRESS,
143 * 16, 1, frame->data, frame->len, 1);
144 *
145 * Example output using %DUMP_PREFIX_OFFSET and 1-byte mode:
146 * 0009ab42: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f @ABCDEFGHIJKLMNO
147 * Example output using %DUMP_PREFIX_ADDRESS and 4-byte mode:
148 * ffffffff88089af0: 73727170 77767574 7b7a7978 7f7e7d7c pqrstuvwxyz{|}~.
149 */
print_hex_dump(const char * level,const char * prefix_str,int prefix_type,int rowsize,int groupsize,const void * buf,size_t len,bool ascii)150 void print_hex_dump(const char *level, const char *prefix_str, int prefix_type,
151 int rowsize, int groupsize,
152 const void *buf, size_t len, bool ascii)
153 {
154 const u8 *ptr = buf;
155 int i, linelen, remaining = len;
156 unsigned char linebuf[200];
157
158 if (rowsize != 16 && rowsize != 32)
159 rowsize = 16;
160
161 for (i = 0; i < len; i += rowsize) {
162 linelen = min(remaining, rowsize);
163 remaining -= rowsize;
164 hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
165 linebuf, sizeof(linebuf), ascii);
166
167 switch (prefix_type) {
168 case DUMP_PREFIX_ADDRESS:
169 printk("%s%s%*p: %s\n", level, prefix_str,
170 (int)(2 * sizeof(void *)), ptr + i, linebuf);
171 break;
172 case DUMP_PREFIX_OFFSET:
173 printk("%s%s%.8x: %s\n", level, prefix_str, i, linebuf);
174 break;
175 default:
176 printk("%s%s%s\n", level, prefix_str, linebuf);
177 break;
178 }
179 }
180 }
181 EXPORT_SYMBOL(print_hex_dump);
182
183 /**
184 * print_hex_dump_bytes - shorthand form of print_hex_dump() with default params
185 * @prefix_str: string to prefix each line with;
186 * caller supplies trailing spaces for alignment if desired
187 * @prefix_type: controls whether prefix of an offset, address, or none
188 * is printed (%DUMP_PREFIX_OFFSET, %DUMP_PREFIX_ADDRESS, %DUMP_PREFIX_NONE)
189 * @buf: data blob to dump
190 * @len: number of bytes in the @buf
191 *
192 * Calls print_hex_dump(), with log level of KERN_DEBUG,
193 * rowsize of 16, groupsize of 1, and ASCII output included.
194 */
print_hex_dump_bytes(const char * prefix_str,int prefix_type,const void * buf,size_t len)195 void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
196 const void *buf, size_t len)
197 {
198 print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, 16, 1,
199 buf, len, 1);
200 }
201 EXPORT_SYMBOL(print_hex_dump_bytes);
202