1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: utprint - Formatted printing routines 5 * 6 * Copyright (C) 2000 - 2023, Intel Corp. 7 * 8 *****************************************************************************/ 9 10 #include <acpi/acpi.h> 11 #include "accommon.h" 12 13 #define _COMPONENT ACPI_UTILITIES 14 ACPI_MODULE_NAME("utprint") 15 16 #define ACPI_FORMAT_SIGN 0x01 17 #define ACPI_FORMAT_SIGN_PLUS 0x02 18 #define ACPI_FORMAT_SIGN_PLUS_SPACE 0x04 19 #define ACPI_FORMAT_ZERO 0x08 20 #define ACPI_FORMAT_LEFT 0x10 21 #define ACPI_FORMAT_UPPER 0x20 22 #define ACPI_FORMAT_PREFIX 0x40 23 /* Local prototypes */ 24 static acpi_size 25 acpi_ut_bound_string_length(const char *string, acpi_size count); 26 27 static char *acpi_ut_bound_string_output(char *string, const char *end, char c); 28 29 static char *acpi_ut_format_number(char *string, 30 char *end, 31 u64 number, 32 u8 base, s32 width, s32 precision, u8 type); 33 34 static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper); 35 36 /******************************************************************************* 37 * 38 * FUNCTION: acpi_ut_bound_string_length 39 * 40 * PARAMETERS: string - String with boundary 41 * count - Boundary of the string 42 * 43 * RETURN: Length of the string. Less than or equal to Count. 44 * 45 * DESCRIPTION: Calculate the length of a string with boundary. 46 * 47 ******************************************************************************/ 48 49 static acpi_size 50 acpi_ut_bound_string_length(const char *string, acpi_size count) 51 { 52 u32 length = 0; 53 54 while (*string && count) { 55 length++; 56 string++; 57 count--; 58 } 59 60 return (length); 61 } 62 63 /******************************************************************************* 64 * 65 * FUNCTION: acpi_ut_bound_string_output 66 * 67 * PARAMETERS: string - String with boundary 68 * end - Boundary of the string 69 * c - Character to be output to the string 70 * 71 * RETURN: Updated position for next valid character 72 * 73 * DESCRIPTION: Output a character into a string with boundary check. 74 * 75 ******************************************************************************/ 76 77 static char *acpi_ut_bound_string_output(char *string, const char *end, char c) 78 { 79 80 if (string < end) { 81 *string = c; 82 } 83 84 ++string; 85 return (string); 86 } 87 88 /******************************************************************************* 89 * 90 * FUNCTION: acpi_ut_put_number 91 * 92 * PARAMETERS: string - Buffer to hold reverse-ordered string 93 * number - Integer to be converted 94 * base - Base of the integer 95 * upper - Whether or not using upper cased digits 96 * 97 * RETURN: Updated position for next valid character 98 * 99 * DESCRIPTION: Convert an integer into a string, note that, the string holds a 100 * reversed ordered number without the trailing zero. 101 * 102 ******************************************************************************/ 103 104 static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper) 105 { 106 const char *digits; 107 u64 digit_index; 108 char *pos; 109 110 pos = string; 111 digits = upper ? acpi_gbl_upper_hex_digits : acpi_gbl_lower_hex_digits; 112 113 if (number == 0) { 114 *(pos++) = '0'; 115 } else { 116 while (number) { 117 (void)acpi_ut_divide(number, base, &number, 118 &digit_index); 119 *(pos++) = digits[digit_index]; 120 } 121 } 122 123 /* *(Pos++) = '0'; */ 124 return (pos); 125 } 126 127 /******************************************************************************* 128 * 129 * FUNCTION: acpi_ut_scan_number 130 * 131 * PARAMETERS: string - String buffer 132 * number_ptr - Where the number is returned 133 * 134 * RETURN: Updated position for next valid character 135 * 136 * DESCRIPTION: Scan a string for a decimal integer. 137 * 138 ******************************************************************************/ 139 140 const char *acpi_ut_scan_number(const char *string, u64 *number_ptr) 141 { 142 u64 number = 0; 143 144 while (isdigit((int)*string)) { 145 acpi_ut_short_multiply(number, 10, &number); 146 number += *(string++) - '0'; 147 } 148 149 *number_ptr = number; 150 return (string); 151 } 152 153 /******************************************************************************* 154 * 155 * FUNCTION: acpi_ut_print_number 156 * 157 * PARAMETERS: string - String buffer 158 * number - The number to be converted 159 * 160 * RETURN: Updated position for next valid character 161 * 162 * DESCRIPTION: Print a decimal integer into a string. 163 * 164 ******************************************************************************/ 165 166 const char *acpi_ut_print_number(char *string, u64 number) 167 { 168 char ascii_string[20]; 169 const char *pos1; 170 char *pos2; 171 172 pos1 = acpi_ut_put_number(ascii_string, number, 10, FALSE); 173 pos2 = string; 174 175 while (pos1 != ascii_string) { 176 *(pos2++) = *(--pos1); 177 } 178 179 *pos2 = 0; 180 return (string); 181 } 182 183 /******************************************************************************* 184 * 185 * FUNCTION: acpi_ut_format_number 186 * 187 * PARAMETERS: string - String buffer with boundary 188 * end - Boundary of the string 189 * number - The number to be converted 190 * base - Base of the integer 191 * width - Field width 192 * precision - Precision of the integer 193 * type - Special printing flags 194 * 195 * RETURN: Updated position for next valid character 196 * 197 * DESCRIPTION: Print an integer into a string with any base and any precision. 198 * 199 ******************************************************************************/ 200 201 static char *acpi_ut_format_number(char *string, 202 char *end, 203 u64 number, 204 u8 base, s32 width, s32 precision, u8 type) 205 { 206 char *pos; 207 char sign; 208 char zero; 209 u8 need_prefix; 210 u8 upper; 211 s32 i; 212 char reversed_string[66]; 213 214 /* Parameter validation */ 215 216 if (base < 2 || base > 16) { 217 return (NULL); 218 } 219 220 if (type & ACPI_FORMAT_LEFT) { 221 type &= ~ACPI_FORMAT_ZERO; 222 } 223 224 need_prefix = ((type & ACPI_FORMAT_PREFIX) 225 && base != 10) ? TRUE : FALSE; 226 upper = (type & ACPI_FORMAT_UPPER) ? TRUE : FALSE; 227 zero = (type & ACPI_FORMAT_ZERO) ? '0' : ' '; 228 229 /* Calculate size according to sign and prefix */ 230 231 sign = '\0'; 232 if (type & ACPI_FORMAT_SIGN) { 233 if ((s64)number < 0) { 234 sign = '-'; 235 number = -(s64)number; 236 width--; 237 } else if (type & ACPI_FORMAT_SIGN_PLUS) { 238 sign = '+'; 239 width--; 240 } else if (type & ACPI_FORMAT_SIGN_PLUS_SPACE) { 241 sign = ' '; 242 width--; 243 } 244 } 245 if (need_prefix) { 246 width--; 247 if (base == 16) { 248 width--; 249 } 250 } 251 252 /* Generate full string in reverse order */ 253 254 pos = acpi_ut_put_number(reversed_string, number, base, upper); 255 i = (s32)ACPI_PTR_DIFF(pos, reversed_string); 256 257 /* Printing 100 using %2d gives "100", not "00" */ 258 259 if (i > precision) { 260 precision = i; 261 } 262 263 width -= precision; 264 265 /* Output the string */ 266 267 if (!(type & (ACPI_FORMAT_ZERO | ACPI_FORMAT_LEFT))) { 268 while (--width >= 0) { 269 string = acpi_ut_bound_string_output(string, end, ' '); 270 } 271 } 272 if (sign) { 273 string = acpi_ut_bound_string_output(string, end, sign); 274 } 275 if (need_prefix) { 276 string = acpi_ut_bound_string_output(string, end, '0'); 277 if (base == 16) { 278 string = 279 acpi_ut_bound_string_output(string, end, 280 upper ? 'X' : 'x'); 281 } 282 } 283 if (!(type & ACPI_FORMAT_LEFT)) { 284 while (--width >= 0) { 285 string = acpi_ut_bound_string_output(string, end, zero); 286 } 287 } 288 289 while (i <= --precision) { 290 string = acpi_ut_bound_string_output(string, end, '0'); 291 } 292 while (--i >= 0) { 293 string = acpi_ut_bound_string_output(string, end, 294 reversed_string[i]); 295 } 296 while (--width >= 0) { 297 string = acpi_ut_bound_string_output(string, end, ' '); 298 } 299 300 return (string); 301 } 302 303 /******************************************************************************* 304 * 305 * FUNCTION: vsnprintf 306 * 307 * PARAMETERS: string - String with boundary 308 * size - Boundary of the string 309 * format - Standard printf format 310 * args - Argument list 311 * 312 * RETURN: Number of bytes actually written. 313 * 314 * DESCRIPTION: Formatted output to a string using argument list pointer. 315 * 316 ******************************************************************************/ 317 318 int vsnprintf(char *string, acpi_size size, const char *format, va_list args) 319 { 320 u8 base; 321 u8 type; 322 s32 width; 323 s32 precision; 324 char qualifier; 325 u64 number; 326 char *pos; 327 char *end; 328 char c; 329 const char *s; 330 const void *p; 331 s32 length; 332 int i; 333 334 pos = string; 335 336 if (size != ACPI_UINT32_MAX) { 337 end = string + size; 338 } else { 339 end = ACPI_CAST_PTR(char, ACPI_UINT32_MAX); 340 } 341 342 for (; *format; ++format) { 343 if (*format != '%') { 344 pos = acpi_ut_bound_string_output(pos, end, *format); 345 continue; 346 } 347 348 type = 0; 349 base = 10; 350 351 /* Process sign */ 352 353 do { 354 ++format; 355 if (*format == '#') { 356 type |= ACPI_FORMAT_PREFIX; 357 } else if (*format == '0') { 358 type |= ACPI_FORMAT_ZERO; 359 } else if (*format == '+') { 360 type |= ACPI_FORMAT_SIGN_PLUS; 361 } else if (*format == ' ') { 362 type |= ACPI_FORMAT_SIGN_PLUS_SPACE; 363 } else if (*format == '-') { 364 type |= ACPI_FORMAT_LEFT; 365 } else { 366 break; 367 } 368 369 } while (1); 370 371 /* Process width */ 372 373 width = -1; 374 if (isdigit((int)*format)) { 375 format = acpi_ut_scan_number(format, &number); 376 width = (s32)number; 377 } else if (*format == '*') { 378 ++format; 379 width = va_arg(args, int); 380 if (width < 0) { 381 width = -width; 382 type |= ACPI_FORMAT_LEFT; 383 } 384 } 385 386 /* Process precision */ 387 388 precision = -1; 389 if (*format == '.') { 390 ++format; 391 if (isdigit((int)*format)) { 392 format = acpi_ut_scan_number(format, &number); 393 precision = (s32)number; 394 } else if (*format == '*') { 395 ++format; 396 precision = va_arg(args, int); 397 } 398 399 if (precision < 0) { 400 precision = 0; 401 } 402 } 403 404 /* Process qualifier */ 405 406 qualifier = -1; 407 if (*format == 'h' || *format == 'l' || *format == 'L') { 408 qualifier = *format; 409 ++format; 410 411 if (qualifier == 'l' && *format == 'l') { 412 qualifier = 'L'; 413 ++format; 414 } 415 } 416 417 switch (*format) { 418 case '%': 419 420 pos = acpi_ut_bound_string_output(pos, end, '%'); 421 continue; 422 423 case 'c': 424 425 if (!(type & ACPI_FORMAT_LEFT)) { 426 while (--width > 0) { 427 pos = 428 acpi_ut_bound_string_output(pos, 429 end, 430 ' '); 431 } 432 } 433 434 c = (char)va_arg(args, int); 435 pos = acpi_ut_bound_string_output(pos, end, c); 436 437 while (--width > 0) { 438 pos = 439 acpi_ut_bound_string_output(pos, end, ' '); 440 } 441 continue; 442 443 case 's': 444 445 s = va_arg(args, char *); 446 if (!s) { 447 s = "<NULL>"; 448 } 449 length = (s32)acpi_ut_bound_string_length(s, precision); 450 if (!(type & ACPI_FORMAT_LEFT)) { 451 while (length < width--) { 452 pos = 453 acpi_ut_bound_string_output(pos, 454 end, 455 ' '); 456 } 457 } 458 459 for (i = 0; i < length; ++i) { 460 pos = acpi_ut_bound_string_output(pos, end, *s); 461 ++s; 462 } 463 464 while (length < width--) { 465 pos = 466 acpi_ut_bound_string_output(pos, end, ' '); 467 } 468 continue; 469 470 case 'o': 471 472 base = 8; 473 break; 474 475 case 'X': 476 477 type |= ACPI_FORMAT_UPPER; 478 ACPI_FALLTHROUGH; 479 480 case 'x': 481 482 base = 16; 483 break; 484 485 case 'd': 486 case 'i': 487 488 type |= ACPI_FORMAT_SIGN; 489 490 case 'u': 491 492 break; 493 494 case 'p': 495 496 if (width == -1) { 497 width = 2 * sizeof(void *); 498 type |= ACPI_FORMAT_ZERO; 499 } 500 501 p = va_arg(args, void *); 502 pos = 503 acpi_ut_format_number(pos, end, ACPI_TO_INTEGER(p), 504 16, width, precision, type); 505 continue; 506 507 default: 508 509 pos = acpi_ut_bound_string_output(pos, end, '%'); 510 if (*format) { 511 pos = 512 acpi_ut_bound_string_output(pos, end, 513 *format); 514 } else { 515 --format; 516 } 517 continue; 518 } 519 520 if (qualifier == 'L') { 521 number = va_arg(args, u64); 522 if (type & ACPI_FORMAT_SIGN) { 523 number = (s64)number; 524 } 525 } else if (qualifier == 'l') { 526 number = va_arg(args, unsigned long); 527 if (type & ACPI_FORMAT_SIGN) { 528 number = (s32)number; 529 } 530 } else if (qualifier == 'h') { 531 number = (u16)va_arg(args, int); 532 if (type & ACPI_FORMAT_SIGN) { 533 number = (s16)number; 534 } 535 } else { 536 number = va_arg(args, unsigned int); 537 if (type & ACPI_FORMAT_SIGN) { 538 number = (signed int)number; 539 } 540 } 541 542 pos = acpi_ut_format_number(pos, end, number, base, 543 width, precision, type); 544 } 545 546 if (size > 0) { 547 if (pos < end) { 548 *pos = '\0'; 549 } else { 550 end[-1] = '\0'; 551 } 552 } 553 554 return ((int)ACPI_PTR_DIFF(pos, string)); 555 } 556 557 /******************************************************************************* 558 * 559 * FUNCTION: snprintf 560 * 561 * PARAMETERS: string - String with boundary 562 * size - Boundary of the string 563 * Format, ... - Standard printf format 564 * 565 * RETURN: Number of bytes actually written. 566 * 567 * DESCRIPTION: Formatted output to a string. 568 * 569 ******************************************************************************/ 570 571 int snprintf(char *string, acpi_size size, const char *format, ...) 572 { 573 va_list args; 574 int length; 575 576 va_start(args, format); 577 length = vsnprintf(string, size, format, args); 578 va_end(args); 579 580 return (length); 581 } 582 583 /******************************************************************************* 584 * 585 * FUNCTION: sprintf 586 * 587 * PARAMETERS: string - String with boundary 588 * Format, ... - Standard printf format 589 * 590 * RETURN: Number of bytes actually written. 591 * 592 * DESCRIPTION: Formatted output to a string. 593 * 594 ******************************************************************************/ 595 596 int sprintf(char *string, const char *format, ...) 597 { 598 va_list args; 599 int length; 600 601 va_start(args, format); 602 length = vsnprintf(string, ACPI_UINT32_MAX, format, args); 603 va_end(args); 604 605 return (length); 606 } 607 608 #ifdef ACPI_APPLICATION 609 /******************************************************************************* 610 * 611 * FUNCTION: vprintf 612 * 613 * PARAMETERS: format - Standard printf format 614 * args - Argument list 615 * 616 * RETURN: Number of bytes actually written. 617 * 618 * DESCRIPTION: Formatted output to stdout using argument list pointer. 619 * 620 ******************************************************************************/ 621 622 int vprintf(const char *format, va_list args) 623 { 624 acpi_cpu_flags flags; 625 int length; 626 627 flags = acpi_os_acquire_lock(acpi_gbl_print_lock); 628 length = vsnprintf(acpi_gbl_print_buffer, 629 sizeof(acpi_gbl_print_buffer), format, args); 630 631 (void)fwrite(acpi_gbl_print_buffer, length, 1, ACPI_FILE_OUT); 632 acpi_os_release_lock(acpi_gbl_print_lock, flags); 633 634 return (length); 635 } 636 637 /******************************************************************************* 638 * 639 * FUNCTION: printf 640 * 641 * PARAMETERS: Format, ... - Standard printf format 642 * 643 * RETURN: Number of bytes actually written. 644 * 645 * DESCRIPTION: Formatted output to stdout. 646 * 647 ******************************************************************************/ 648 649 int printf(const char *format, ...) 650 { 651 va_list args; 652 int length; 653 654 va_start(args, format); 655 length = vprintf(format, args); 656 va_end(args); 657 658 return (length); 659 } 660 661 /******************************************************************************* 662 * 663 * FUNCTION: vfprintf 664 * 665 * PARAMETERS: file - File descriptor 666 * format - Standard printf format 667 * args - Argument list 668 * 669 * RETURN: Number of bytes actually written. 670 * 671 * DESCRIPTION: Formatted output to a file using argument list pointer. 672 * 673 ******************************************************************************/ 674 675 int vfprintf(FILE * file, const char *format, va_list args) 676 { 677 acpi_cpu_flags flags; 678 int length; 679 680 flags = acpi_os_acquire_lock(acpi_gbl_print_lock); 681 length = vsnprintf(acpi_gbl_print_buffer, 682 sizeof(acpi_gbl_print_buffer), format, args); 683 684 (void)fwrite(acpi_gbl_print_buffer, length, 1, file); 685 acpi_os_release_lock(acpi_gbl_print_lock, flags); 686 687 return (length); 688 } 689 690 /******************************************************************************* 691 * 692 * FUNCTION: fprintf 693 * 694 * PARAMETERS: file - File descriptor 695 * Format, ... - Standard printf format 696 * 697 * RETURN: Number of bytes actually written. 698 * 699 * DESCRIPTION: Formatted output to a file. 700 * 701 ******************************************************************************/ 702 703 int fprintf(FILE * file, const char *format, ...) 704 { 705 va_list args; 706 int length; 707 708 va_start(args, format); 709 length = vfprintf(file, format, args); 710 va_end(args); 711 712 return (length); 713 } 714 #endif 715