Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'cxl/for-6.12/printf' into cxl-for-next
Add support for adding a printf specifier '$pra' to emit 'struct range'
content.
+141
-11
+19
-1
Documentation/core-api/printk-formats.rst
+19
-1
Documentation/core-api/printk-formats.rst
···
209
209
::
210
210
211
211
%pr [mem 0x60000000-0x6fffffff flags 0x2200] or
212
+
[mem 0x60000000 flags 0x2200] or
212
213
[mem 0x0000000060000000-0x000000006fffffff flags 0x2200]
214
+
[mem 0x0000000060000000 flags 0x2200]
213
215
%pR [mem 0x60000000-0x6fffffff pref] or
216
+
[mem 0x60000000 pref] or
214
217
[mem 0x0000000060000000-0x000000006fffffff pref]
218
+
[mem 0x0000000060000000 pref]
215
219
216
220
For printing struct resources. The ``R`` and ``r`` specifiers result in a
217
-
printed resource with (R) or without (r) a decoded flags member.
221
+
printed resource with (R) or without (r) a decoded flags member. If start is
222
+
equal to end only print the start value.
218
223
219
224
Passed by reference.
220
225
···
233
228
For printing a phys_addr_t type (and its derivatives, such as
234
229
resource_size_t) which can vary based on build options, regardless of the
235
230
width of the CPU data path.
231
+
232
+
Passed by reference.
233
+
234
+
Struct Range
235
+
------------
236
+
237
+
::
238
+
239
+
%pra [range 0x0000000060000000-0x000000006fffffff] or
240
+
[range 0x0000000060000000]
241
+
242
+
For printing struct range. struct range holds an arbitrary range of u64
243
+
values. If start is equal to end only print the start value.
236
244
237
245
Passed by reference.
238
246
+4
-4
drivers/cxl/core/cdat.c
+4
-4
drivers/cxl/core/cdat.c
···
247
247
dpa_perf->dpa_range = dent->dpa_range;
248
248
dpa_perf->qos_class = dent->qos_class;
249
249
dev_dbg(dev,
250
-
"DSMAS: dpa: %#llx qos: %d read_bw: %d write_bw %d read_lat: %d write_lat: %d\n",
251
-
dent->dpa_range.start, dpa_perf->qos_class,
250
+
"DSMAS: dpa: %pra qos: %d read_bw: %d write_bw %d read_lat: %d write_lat: %d\n",
251
+
&dent->dpa_range, dpa_perf->qos_class,
252
252
dent->coord[ACCESS_COORDINATE_CPU].read_bandwidth,
253
253
dent->coord[ACCESS_COORDINATE_CPU].write_bandwidth,
254
254
dent->coord[ACCESS_COORDINATE_CPU].read_latency,
···
279
279
range_contains(&pmem_range, &dent->dpa_range))
280
280
update_perf_entry(dev, dent, &mds->pmem_perf);
281
281
else
282
-
dev_dbg(dev, "no partition for dsmas dpa: %#llx\n",
283
-
dent->dpa_range.start);
282
+
dev_dbg(dev, "no partition for dsmas dpa: %pra\n",
283
+
&dent->dpa_range);
284
284
}
285
285
}
286
286
+6
include/linux/range.h
+6
include/linux/range.h
+61
lib/test_printf.c
+61
lib/test_printf.c
···
386
386
static void __init
387
387
struct_resource(void)
388
388
{
389
+
struct resource test_resource = {
390
+
.start = 0xc0ffee00,
391
+
.end = 0xc0ffee00,
392
+
.flags = IORESOURCE_MEM,
393
+
};
394
+
395
+
test("[mem 0xc0ffee00 flags 0x200]",
396
+
"%pr", &test_resource);
397
+
398
+
test_resource = (struct resource) {
399
+
.start = 0xc0ffee,
400
+
.end = 0xba5eba11,
401
+
.flags = IORESOURCE_MEM,
402
+
};
403
+
test("[mem 0x00c0ffee-0xba5eba11 flags 0x200]",
404
+
"%pr", &test_resource);
405
+
406
+
test_resource = (struct resource) {
407
+
.start = 0xba5eba11,
408
+
.end = 0xc0ffee,
409
+
.flags = IORESOURCE_MEM,
410
+
};
411
+
test("[mem 0xba5eba11-0x00c0ffee flags 0x200]",
412
+
"%pr", &test_resource);
413
+
414
+
test_resource = (struct resource) {
415
+
.start = 0xba5eba11,
416
+
.end = 0xba5eca11,
417
+
.flags = IORESOURCE_MEM,
418
+
};
419
+
420
+
test("[mem 0xba5eba11-0xba5eca11 flags 0x200]",
421
+
"%pr", &test_resource);
422
+
423
+
test_resource = (struct resource) {
424
+
.start = 0xba11,
425
+
.end = 0xca10,
426
+
.flags = IORESOURCE_IO |
427
+
IORESOURCE_DISABLED |
428
+
IORESOURCE_UNSET,
429
+
};
430
+
431
+
test("[io size 0x1000 disabled]",
432
+
"%pR", &test_resource);
433
+
}
434
+
435
+
static void __init
436
+
struct_range(void)
437
+
{
438
+
struct range test_range = DEFINE_RANGE(0xc0ffee00ba5eba11,
439
+
0xc0ffee00ba5eba11);
440
+
test("[range 0xc0ffee00ba5eba11]", "%pra", &test_range);
441
+
442
+
test_range = DEFINE_RANGE(0xc0ffee, 0xba5eba11);
443
+
test("[range 0x0000000000c0ffee-0x00000000ba5eba11]",
444
+
"%pra", &test_range);
445
+
446
+
test_range = DEFINE_RANGE(0xba5eba11, 0xc0ffee);
447
+
test("[range 0x00000000ba5eba11-0x0000000000c0ffee]",
448
+
"%pra", &test_range);
389
449
}
390
450
391
451
static void __init
···
823
763
symbol_ptr();
824
764
kernel_ptr();
825
765
struct_resource();
766
+
struct_range();
826
767
addr();
827
768
escaped_str();
828
769
hex_string();
+51
-6
lib/vsprintf.c
+51
-6
lib/vsprintf.c
···
1040
1040
};
1041
1041
1042
1042
static noinline_for_stack
1043
+
char *hex_range(char *buf, char *end, u64 start_val, u64 end_val,
1044
+
struct printf_spec spec)
1045
+
{
1046
+
buf = number(buf, end, start_val, spec);
1047
+
if (start_val == end_val)
1048
+
return buf;
1049
+
1050
+
if (buf < end)
1051
+
*buf = '-';
1052
+
++buf;
1053
+
return number(buf, end, end_val, spec);
1054
+
}
1055
+
1056
+
static noinline_for_stack
1043
1057
char *resource_string(char *buf, char *end, struct resource *res,
1044
1058
struct printf_spec spec, const char *fmt)
1045
1059
{
···
1129
1115
p = string_nocheck(p, pend, "size ", str_spec);
1130
1116
p = number(p, pend, resource_size(res), *specp);
1131
1117
} else {
1132
-
p = number(p, pend, res->start, *specp);
1133
-
if (res->start != res->end) {
1134
-
*p++ = '-';
1135
-
p = number(p, pend, res->end, *specp);
1136
-
}
1118
+
p = hex_range(p, pend, res->start, res->end, *specp);
1137
1119
}
1138
1120
if (decode) {
1139
1121
if (res->flags & IORESOURCE_MEM_64)
···
1144
1134
p = string_nocheck(p, pend, " flags ", str_spec);
1145
1135
p = number(p, pend, res->flags, default_flag_spec);
1146
1136
}
1137
+
*p++ = ']';
1138
+
*p = '\0';
1139
+
1140
+
return string_nocheck(buf, end, sym, spec);
1141
+
}
1142
+
1143
+
static noinline_for_stack
1144
+
char *range_string(char *buf, char *end, const struct range *range,
1145
+
struct printf_spec spec, const char *fmt)
1146
+
{
1147
+
char sym[sizeof("[range 0x0123456789abcdef-0x0123456789abcdef]")];
1148
+
char *p = sym, *pend = sym + sizeof(sym);
1149
+
1150
+
struct printf_spec range_spec = {
1151
+
.field_width = 2 + 2 * sizeof(range->start), /* 0x + 2 * 8 */
1152
+
.flags = SPECIAL | SMALL | ZEROPAD,
1153
+
.base = 16,
1154
+
.precision = -1,
1155
+
};
1156
+
1157
+
if (check_pointer(&buf, end, range, spec))
1158
+
return buf;
1159
+
1160
+
p = string_nocheck(p, pend, "[range ", default_str_spec);
1161
+
p = hex_range(p, pend, range->start, range->end, range_spec);
1147
1162
*p++ = ']';
1148
1163
*p = '\0';
1149
1164
···
2264
2229
return widen_string(buf, buf - buf_start, end, spec);
2265
2230
}
2266
2231
2232
+
static noinline_for_stack
2233
+
char *resource_or_range(const char *fmt, char *buf, char *end, void *ptr,
2234
+
struct printf_spec spec)
2235
+
{
2236
+
if (*fmt == 'r' && fmt[1] == 'a')
2237
+
return range_string(buf, end, ptr, spec, fmt);
2238
+
return resource_string(buf, end, ptr, spec, fmt);
2239
+
}
2240
+
2267
2241
int __init no_hash_pointers_enable(char *str)
2268
2242
{
2269
2243
if (no_hash_pointers)
···
2321
2277
* - 'Bb' as above with module build ID (for use in backtraces)
2322
2278
* - 'R' For decoded struct resource, e.g., [mem 0x0-0x1f 64bit pref]
2323
2279
* - 'r' For raw struct resource, e.g., [mem 0x0-0x1f flags 0x201]
2280
+
* - 'ra' For struct ranges, e.g., [range 0x0000000000000000 - 0x00000000000000ff]
2324
2281
* - 'b[l]' For a bitmap, the number of bits is determined by the field
2325
2282
* width which must be explicitly specified either as part of the
2326
2283
* format string '%32b[l]' or through '%*b[l]', [l] selects
···
2446
2401
return symbol_string(buf, end, ptr, spec, fmt);
2447
2402
case 'R':
2448
2403
case 'r':
2449
-
return resource_string(buf, end, ptr, spec, fmt);
2404
+
return resource_or_range(fmt, buf, end, ptr, spec);
2450
2405
case 'h':
2451
2406
return hex_string(buf, end, ptr, spec, fmt);
2452
2407
case 'b':