1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/seq_file.c 4 * 5 * helper functions for making synthetic files from sequences of records. 6 * initial implementation -- AV, Oct 2001. 7 */ 8 9 #include <linux/cache.h> 10 #include <linux/fs.h> 11 #include <linux/export.h> 12 #include <linux/seq_file.h> 13 #include <linux/vmalloc.h> 14 #include <linux/slab.h> 15 #include <linux/cred.h> 16 #include <linux/mm.h> 17 #include <linux/printk.h> 18 #include <linux/string_helpers.h> 19 20 #include <linux/uaccess.h> 21 #include <asm/page.h> 22 23 static struct kmem_cache *seq_file_cache __ro_after_init; 24 25 static void seq_set_overflow(struct seq_file *m) 26 { 27 m->count = m->size; 28 } 29 30 static void *seq_buf_alloc(unsigned long size) 31 { 32 return kvmalloc(size, GFP_KERNEL_ACCOUNT); 33 } 34 35 /** 36 * seq_open - initialize sequential file 37 * @file: file we initialize 38 * @op: method table describing the sequence 39 * 40 * seq_open() sets @file, associating it with a sequence described 41 * by @op. @op->start() sets the iterator up and returns the first 42 * element of sequence. @op->stop() shuts it down. @op->next() 43 * returns the next element of sequence. @op->show() prints element 44 * into the buffer. In case of error ->start() and ->next() return 45 * ERR_PTR(error). In the end of sequence they return %NULL. ->show() 46 * returns 0 in case of success and negative number in case of error. 47 * Returning SEQ_SKIP means "discard this element and move on". 48 * Note: seq_open() will allocate a struct seq_file and store its 49 * pointer in @file->private_data. This pointer should not be modified. 50 */ 51 int seq_open(struct file *file, const struct seq_operations *op) 52 { 53 struct seq_file *p; 54 55 WARN_ON(file->private_data); 56 57 p = kmem_cache_zalloc(seq_file_cache, GFP_KERNEL); 58 if (!p) 59 return -ENOMEM; 60 61 file->private_data = p; 62 63 mutex_init(&p->lock); 64 p->op = op; 65 66 // No refcounting: the lifetime of 'p' is constrained 67 // to the lifetime of the file. 68 p->file = file; 69 70 /* 71 * Wrappers around seq_open(e.g. swaps_open) need to be 72 * aware of this. If they set f_version themselves, they 73 * should call seq_open first and then set f_version. 74 */ 75 file->f_version = 0; 76 77 /* 78 * seq_files support lseek() and pread(). They do not implement 79 * write() at all, but we clear FMODE_PWRITE here for historical 80 * reasons. 81 * 82 * If a client of seq_files a) implements file.write() and b) wishes to 83 * support pwrite() then that client will need to implement its own 84 * file.open() which calls seq_open() and then sets FMODE_PWRITE. 85 */ 86 file->f_mode &= ~FMODE_PWRITE; 87 return 0; 88 } 89 EXPORT_SYMBOL(seq_open); 90 91 static int traverse(struct seq_file *m, loff_t offset) 92 { 93 loff_t pos = 0, index; 94 int error = 0; 95 void *p; 96 97 m->version = 0; 98 index = 0; 99 m->count = m->from = 0; 100 if (!offset) { 101 m->index = index; 102 return 0; 103 } 104 if (!m->buf) { 105 m->buf = seq_buf_alloc(m->size = PAGE_SIZE); 106 if (!m->buf) 107 return -ENOMEM; 108 } 109 p = m->op->start(m, &index); 110 while (p) { 111 error = PTR_ERR(p); 112 if (IS_ERR(p)) 113 break; 114 error = m->op->show(m, p); 115 if (error < 0) 116 break; 117 if (unlikely(error)) { 118 error = 0; 119 m->count = 0; 120 } 121 if (seq_has_overflowed(m)) 122 goto Eoverflow; 123 if (pos + m->count > offset) { 124 m->from = offset - pos; 125 m->count -= m->from; 126 m->index = index; 127 break; 128 } 129 pos += m->count; 130 m->count = 0; 131 if (pos == offset) { 132 index++; 133 m->index = index; 134 break; 135 } 136 p = m->op->next(m, p, &index); 137 } 138 m->op->stop(m, p); 139 m->index = index; 140 return error; 141 142 Eoverflow: 143 m->op->stop(m, p); 144 kvfree(m->buf); 145 m->count = 0; 146 m->buf = seq_buf_alloc(m->size <<= 1); 147 return !m->buf ? -ENOMEM : -EAGAIN; 148 } 149 150 /** 151 * seq_read - ->read() method for sequential files. 152 * @file: the file to read from 153 * @buf: the buffer to read to 154 * @size: the maximum number of bytes to read 155 * @ppos: the current position in the file 156 * 157 * Ready-made ->f_op->read() 158 */ 159 ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos) 160 { 161 struct seq_file *m = file->private_data; 162 size_t copied = 0; 163 loff_t pos; 164 size_t n; 165 void *p; 166 int err = 0; 167 168 mutex_lock(&m->lock); 169 170 /* 171 * seq_file->op->..m_start/m_stop/m_next may do special actions 172 * or optimisations based on the file->f_version, so we want to 173 * pass the file->f_version to those methods. 174 * 175 * seq_file->version is just copy of f_version, and seq_file 176 * methods can treat it simply as file version. 177 * It is copied in first and copied out after all operations. 178 * It is convenient to have it as part of structure to avoid the 179 * need of passing another argument to all the seq_file methods. 180 */ 181 m->version = file->f_version; 182 183 /* 184 * if request is to read from zero offset, reset iterator to first 185 * record as it might have been already advanced by previous requests 186 */ 187 if (*ppos == 0) { 188 m->index = 0; 189 m->version = 0; 190 m->count = 0; 191 } 192 193 /* Don't assume *ppos is where we left it */ 194 if (unlikely(*ppos != m->read_pos)) { 195 while ((err = traverse(m, *ppos)) == -EAGAIN) 196 ; 197 if (err) { 198 /* With prejudice... */ 199 m->read_pos = 0; 200 m->version = 0; 201 m->index = 0; 202 m->count = 0; 203 goto Done; 204 } else { 205 m->read_pos = *ppos; 206 } 207 } 208 209 /* grab buffer if we didn't have one */ 210 if (!m->buf) { 211 m->buf = seq_buf_alloc(m->size = PAGE_SIZE); 212 if (!m->buf) 213 goto Enomem; 214 } 215 /* if not empty - flush it first */ 216 if (m->count) { 217 n = min(m->count, size); 218 err = copy_to_user(buf, m->buf + m->from, n); 219 if (err) 220 goto Efault; 221 m->count -= n; 222 m->from += n; 223 size -= n; 224 buf += n; 225 copied += n; 226 if (!m->count) { 227 m->from = 0; 228 m->index++; 229 } 230 if (!size) 231 goto Done; 232 } 233 /* we need at least one record in buffer */ 234 pos = m->index; 235 p = m->op->start(m, &pos); 236 while (1) { 237 err = PTR_ERR(p); 238 if (!p || IS_ERR(p)) 239 break; 240 err = m->op->show(m, p); 241 if (err < 0) 242 break; 243 if (unlikely(err)) 244 m->count = 0; 245 if (unlikely(!m->count)) { 246 p = m->op->next(m, p, &pos); 247 m->index = pos; 248 continue; 249 } 250 if (m->count < m->size) 251 goto Fill; 252 m->op->stop(m, p); 253 kvfree(m->buf); 254 m->count = 0; 255 m->buf = seq_buf_alloc(m->size <<= 1); 256 if (!m->buf) 257 goto Enomem; 258 m->version = 0; 259 pos = m->index; 260 p = m->op->start(m, &pos); 261 } 262 m->op->stop(m, p); 263 m->count = 0; 264 goto Done; 265 Fill: 266 /* they want more? let's try to get some more */ 267 while (m->count < size) { 268 size_t offs = m->count; 269 loff_t next = pos; 270 p = m->op->next(m, p, &next); 271 if (!p || IS_ERR(p)) { 272 err = PTR_ERR(p); 273 break; 274 } 275 err = m->op->show(m, p); 276 if (seq_has_overflowed(m) || err) { 277 m->count = offs; 278 if (likely(err <= 0)) 279 break; 280 } 281 pos = next; 282 } 283 m->op->stop(m, p); 284 n = min(m->count, size); 285 err = copy_to_user(buf, m->buf, n); 286 if (err) 287 goto Efault; 288 copied += n; 289 m->count -= n; 290 if (m->count) 291 m->from = n; 292 else 293 pos++; 294 m->index = pos; 295 Done: 296 if (!copied) 297 copied = err; 298 else { 299 *ppos += copied; 300 m->read_pos += copied; 301 } 302 file->f_version = m->version; 303 mutex_unlock(&m->lock); 304 return copied; 305 Enomem: 306 err = -ENOMEM; 307 goto Done; 308 Efault: 309 err = -EFAULT; 310 goto Done; 311 } 312 EXPORT_SYMBOL(seq_read); 313 314 /** 315 * seq_lseek - ->llseek() method for sequential files. 316 * @file: the file in question 317 * @offset: new position 318 * @whence: 0 for absolute, 1 for relative position 319 * 320 * Ready-made ->f_op->llseek() 321 */ 322 loff_t seq_lseek(struct file *file, loff_t offset, int whence) 323 { 324 struct seq_file *m = file->private_data; 325 loff_t retval = -EINVAL; 326 327 mutex_lock(&m->lock); 328 m->version = file->f_version; 329 switch (whence) { 330 case SEEK_CUR: 331 offset += file->f_pos; 332 case SEEK_SET: 333 if (offset < 0) 334 break; 335 retval = offset; 336 if (offset != m->read_pos) { 337 while ((retval = traverse(m, offset)) == -EAGAIN) 338 ; 339 if (retval) { 340 /* with extreme prejudice... */ 341 file->f_pos = 0; 342 m->read_pos = 0; 343 m->version = 0; 344 m->index = 0; 345 m->count = 0; 346 } else { 347 m->read_pos = offset; 348 retval = file->f_pos = offset; 349 } 350 } else { 351 file->f_pos = offset; 352 } 353 } 354 file->f_version = m->version; 355 mutex_unlock(&m->lock); 356 return retval; 357 } 358 EXPORT_SYMBOL(seq_lseek); 359 360 /** 361 * seq_release - free the structures associated with sequential file. 362 * @file: file in question 363 * @inode: its inode 364 * 365 * Frees the structures associated with sequential file; can be used 366 * as ->f_op->release() if you don't have private data to destroy. 367 */ 368 int seq_release(struct inode *inode, struct file *file) 369 { 370 struct seq_file *m = file->private_data; 371 kvfree(m->buf); 372 kmem_cache_free(seq_file_cache, m); 373 return 0; 374 } 375 EXPORT_SYMBOL(seq_release); 376 377 /** 378 * seq_escape - print string into buffer, escaping some characters 379 * @m: target buffer 380 * @s: string 381 * @esc: set of characters that need escaping 382 * 383 * Puts string into buffer, replacing each occurrence of character from 384 * @esc with usual octal escape. 385 * Use seq_has_overflowed() to check for errors. 386 */ 387 void seq_escape(struct seq_file *m, const char *s, const char *esc) 388 { 389 char *buf; 390 size_t size = seq_get_buf(m, &buf); 391 int ret; 392 393 ret = string_escape_str(s, buf, size, ESCAPE_OCTAL, esc); 394 seq_commit(m, ret < size ? ret : -1); 395 } 396 EXPORT_SYMBOL(seq_escape); 397 398 void seq_vprintf(struct seq_file *m, const char *f, va_list args) 399 { 400 int len; 401 402 if (m->count < m->size) { 403 len = vsnprintf(m->buf + m->count, m->size - m->count, f, args); 404 if (m->count + len < m->size) { 405 m->count += len; 406 return; 407 } 408 } 409 seq_set_overflow(m); 410 } 411 EXPORT_SYMBOL(seq_vprintf); 412 413 void seq_printf(struct seq_file *m, const char *f, ...) 414 { 415 va_list args; 416 417 va_start(args, f); 418 seq_vprintf(m, f, args); 419 va_end(args); 420 } 421 EXPORT_SYMBOL(seq_printf); 422 423 /** 424 * mangle_path - mangle and copy path to buffer beginning 425 * @s: buffer start 426 * @p: beginning of path in above buffer 427 * @esc: set of characters that need escaping 428 * 429 * Copy the path from @p to @s, replacing each occurrence of character from 430 * @esc with usual octal escape. 431 * Returns pointer past last written character in @s, or NULL in case of 432 * failure. 433 */ 434 char *mangle_path(char *s, const char *p, const char *esc) 435 { 436 while (s <= p) { 437 char c = *p++; 438 if (!c) { 439 return s; 440 } else if (!strchr(esc, c)) { 441 *s++ = c; 442 } else if (s + 4 > p) { 443 break; 444 } else { 445 *s++ = '\\'; 446 *s++ = '0' + ((c & 0300) >> 6); 447 *s++ = '0' + ((c & 070) >> 3); 448 *s++ = '0' + (c & 07); 449 } 450 } 451 return NULL; 452 } 453 EXPORT_SYMBOL(mangle_path); 454 455 /** 456 * seq_path - seq_file interface to print a pathname 457 * @m: the seq_file handle 458 * @path: the struct path to print 459 * @esc: set of characters to escape in the output 460 * 461 * return the absolute path of 'path', as represented by the 462 * dentry / mnt pair in the path parameter. 463 */ 464 int seq_path(struct seq_file *m, const struct path *path, const char *esc) 465 { 466 char *buf; 467 size_t size = seq_get_buf(m, &buf); 468 int res = -1; 469 470 if (size) { 471 char *p = d_path(path, buf, size); 472 if (!IS_ERR(p)) { 473 char *end = mangle_path(buf, p, esc); 474 if (end) 475 res = end - buf; 476 } 477 } 478 seq_commit(m, res); 479 480 return res; 481 } 482 EXPORT_SYMBOL(seq_path); 483 484 /** 485 * seq_file_path - seq_file interface to print a pathname of a file 486 * @m: the seq_file handle 487 * @file: the struct file to print 488 * @esc: set of characters to escape in the output 489 * 490 * return the absolute path to the file. 491 */ 492 int seq_file_path(struct seq_file *m, struct file *file, const char *esc) 493 { 494 return seq_path(m, &file->f_path, esc); 495 } 496 EXPORT_SYMBOL(seq_file_path); 497 498 /* 499 * Same as seq_path, but relative to supplied root. 500 */ 501 int seq_path_root(struct seq_file *m, const struct path *path, 502 const struct path *root, const char *esc) 503 { 504 char *buf; 505 size_t size = seq_get_buf(m, &buf); 506 int res = -ENAMETOOLONG; 507 508 if (size) { 509 char *p; 510 511 p = __d_path(path, root, buf, size); 512 if (!p) 513 return SEQ_SKIP; 514 res = PTR_ERR(p); 515 if (!IS_ERR(p)) { 516 char *end = mangle_path(buf, p, esc); 517 if (end) 518 res = end - buf; 519 else 520 res = -ENAMETOOLONG; 521 } 522 } 523 seq_commit(m, res); 524 525 return res < 0 && res != -ENAMETOOLONG ? res : 0; 526 } 527 528 /* 529 * returns the path of the 'dentry' from the root of its filesystem. 530 */ 531 int seq_dentry(struct seq_file *m, struct dentry *dentry, const char *esc) 532 { 533 char *buf; 534 size_t size = seq_get_buf(m, &buf); 535 int res = -1; 536 537 if (size) { 538 char *p = dentry_path(dentry, buf, size); 539 if (!IS_ERR(p)) { 540 char *end = mangle_path(buf, p, esc); 541 if (end) 542 res = end - buf; 543 } 544 } 545 seq_commit(m, res); 546 547 return res; 548 } 549 EXPORT_SYMBOL(seq_dentry); 550 551 static void *single_start(struct seq_file *p, loff_t *pos) 552 { 553 return NULL + (*pos == 0); 554 } 555 556 static void *single_next(struct seq_file *p, void *v, loff_t *pos) 557 { 558 ++*pos; 559 return NULL; 560 } 561 562 static void single_stop(struct seq_file *p, void *v) 563 { 564 } 565 566 int single_open(struct file *file, int (*show)(struct seq_file *, void *), 567 void *data) 568 { 569 struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL_ACCOUNT); 570 int res = -ENOMEM; 571 572 if (op) { 573 op->start = single_start; 574 op->next = single_next; 575 op->stop = single_stop; 576 op->show = show; 577 res = seq_open(file, op); 578 if (!res) 579 ((struct seq_file *)file->private_data)->private = data; 580 else 581 kfree(op); 582 } 583 return res; 584 } 585 EXPORT_SYMBOL(single_open); 586 587 int single_open_size(struct file *file, int (*show)(struct seq_file *, void *), 588 void *data, size_t size) 589 { 590 char *buf = seq_buf_alloc(size); 591 int ret; 592 if (!buf) 593 return -ENOMEM; 594 ret = single_open(file, show, data); 595 if (ret) { 596 kvfree(buf); 597 return ret; 598 } 599 ((struct seq_file *)file->private_data)->buf = buf; 600 ((struct seq_file *)file->private_data)->size = size; 601 return 0; 602 } 603 EXPORT_SYMBOL(single_open_size); 604 605 int single_release(struct inode *inode, struct file *file) 606 { 607 const struct seq_operations *op = ((struct seq_file *)file->private_data)->op; 608 int res = seq_release(inode, file); 609 kfree(op); 610 return res; 611 } 612 EXPORT_SYMBOL(single_release); 613 614 int seq_release_private(struct inode *inode, struct file *file) 615 { 616 struct seq_file *seq = file->private_data; 617 618 kfree(seq->private); 619 seq->private = NULL; 620 return seq_release(inode, file); 621 } 622 EXPORT_SYMBOL(seq_release_private); 623 624 void *__seq_open_private(struct file *f, const struct seq_operations *ops, 625 int psize) 626 { 627 int rc; 628 void *private; 629 struct seq_file *seq; 630 631 private = kzalloc(psize, GFP_KERNEL_ACCOUNT); 632 if (private == NULL) 633 goto out; 634 635 rc = seq_open(f, ops); 636 if (rc < 0) 637 goto out_free; 638 639 seq = f->private_data; 640 seq->private = private; 641 return private; 642 643 out_free: 644 kfree(private); 645 out: 646 return NULL; 647 } 648 EXPORT_SYMBOL(__seq_open_private); 649 650 int seq_open_private(struct file *filp, const struct seq_operations *ops, 651 int psize) 652 { 653 return __seq_open_private(filp, ops, psize) ? 0 : -ENOMEM; 654 } 655 EXPORT_SYMBOL(seq_open_private); 656 657 void seq_putc(struct seq_file *m, char c) 658 { 659 if (m->count >= m->size) 660 return; 661 662 m->buf[m->count++] = c; 663 } 664 EXPORT_SYMBOL(seq_putc); 665 666 void seq_puts(struct seq_file *m, const char *s) 667 { 668 int len = strlen(s); 669 670 if (m->count + len >= m->size) { 671 seq_set_overflow(m); 672 return; 673 } 674 memcpy(m->buf + m->count, s, len); 675 m->count += len; 676 } 677 EXPORT_SYMBOL(seq_puts); 678 679 /** 680 * A helper routine for putting decimal numbers without rich format of printf(). 681 * only 'unsigned long long' is supported. 682 * @m: seq_file identifying the buffer to which data should be written 683 * @delimiter: a string which is printed before the number 684 * @num: the number 685 * @width: a minimum field width 686 * 687 * This routine will put strlen(delimiter) + number into seq_filed. 688 * This routine is very quick when you show lots of numbers. 689 * In usual cases, it will be better to use seq_printf(). It's easier to read. 690 */ 691 void seq_put_decimal_ull_width(struct seq_file *m, const char *delimiter, 692 unsigned long long num, unsigned int width) 693 { 694 int len; 695 696 if (m->count + 2 >= m->size) /* we'll write 2 bytes at least */ 697 goto overflow; 698 699 if (delimiter && delimiter[0]) { 700 if (delimiter[1] == 0) 701 seq_putc(m, delimiter[0]); 702 else 703 seq_puts(m, delimiter); 704 } 705 706 if (!width) 707 width = 1; 708 709 if (m->count + width >= m->size) 710 goto overflow; 711 712 len = num_to_str(m->buf + m->count, m->size - m->count, num, width); 713 if (!len) 714 goto overflow; 715 716 m->count += len; 717 return; 718 719 overflow: 720 seq_set_overflow(m); 721 } 722 723 void seq_put_decimal_ull(struct seq_file *m, const char *delimiter, 724 unsigned long long num) 725 { 726 return seq_put_decimal_ull_width(m, delimiter, num, 0); 727 } 728 EXPORT_SYMBOL(seq_put_decimal_ull); 729 730 /** 731 * seq_put_hex_ll - put a number in hexadecimal notation 732 * @m: seq_file identifying the buffer to which data should be written 733 * @delimiter: a string which is printed before the number 734 * @v: the number 735 * @width: a minimum field width 736 * 737 * seq_put_hex_ll(m, "", v, 8) is equal to seq_printf(m, "%08llx", v) 738 * 739 * This routine is very quick when you show lots of numbers. 740 * In usual cases, it will be better to use seq_printf(). It's easier to read. 741 */ 742 void seq_put_hex_ll(struct seq_file *m, const char *delimiter, 743 unsigned long long v, unsigned int width) 744 { 745 unsigned int len; 746 int i; 747 748 if (delimiter && delimiter[0]) { 749 if (delimiter[1] == 0) 750 seq_putc(m, delimiter[0]); 751 else 752 seq_puts(m, delimiter); 753 } 754 755 /* If x is 0, the result of __builtin_clzll is undefined */ 756 if (v == 0) 757 len = 1; 758 else 759 len = (sizeof(v) * 8 - __builtin_clzll(v) + 3) / 4; 760 761 if (len < width) 762 len = width; 763 764 if (m->count + len > m->size) { 765 seq_set_overflow(m); 766 return; 767 } 768 769 for (i = len - 1; i >= 0; i--) { 770 m->buf[m->count + i] = hex_asc[0xf & v]; 771 v = v >> 4; 772 } 773 m->count += len; 774 } 775 776 void seq_put_decimal_ll(struct seq_file *m, const char *delimiter, long long num) 777 { 778 int len; 779 780 if (m->count + 3 >= m->size) /* we'll write 2 bytes at least */ 781 goto overflow; 782 783 if (delimiter && delimiter[0]) { 784 if (delimiter[1] == 0) 785 seq_putc(m, delimiter[0]); 786 else 787 seq_puts(m, delimiter); 788 } 789 790 if (m->count + 2 >= m->size) 791 goto overflow; 792 793 if (num < 0) { 794 m->buf[m->count++] = '-'; 795 num = -num; 796 } 797 798 if (num < 10) { 799 m->buf[m->count++] = num + '0'; 800 return; 801 } 802 803 len = num_to_str(m->buf + m->count, m->size - m->count, num, 0); 804 if (!len) 805 goto overflow; 806 807 m->count += len; 808 return; 809 810 overflow: 811 seq_set_overflow(m); 812 } 813 EXPORT_SYMBOL(seq_put_decimal_ll); 814 815 /** 816 * seq_write - write arbitrary data to buffer 817 * @seq: seq_file identifying the buffer to which data should be written 818 * @data: data address 819 * @len: number of bytes 820 * 821 * Return 0 on success, non-zero otherwise. 822 */ 823 int seq_write(struct seq_file *seq, const void *data, size_t len) 824 { 825 if (seq->count + len < seq->size) { 826 memcpy(seq->buf + seq->count, data, len); 827 seq->count += len; 828 return 0; 829 } 830 seq_set_overflow(seq); 831 return -1; 832 } 833 EXPORT_SYMBOL(seq_write); 834 835 /** 836 * seq_pad - write padding spaces to buffer 837 * @m: seq_file identifying the buffer to which data should be written 838 * @c: the byte to append after padding if non-zero 839 */ 840 void seq_pad(struct seq_file *m, char c) 841 { 842 int size = m->pad_until - m->count; 843 if (size > 0) { 844 if (size + m->count > m->size) { 845 seq_set_overflow(m); 846 return; 847 } 848 memset(m->buf + m->count, ' ', size); 849 m->count += size; 850 } 851 if (c) 852 seq_putc(m, c); 853 } 854 EXPORT_SYMBOL(seq_pad); 855 856 /* A complete analogue of print_hex_dump() */ 857 void seq_hex_dump(struct seq_file *m, const char *prefix_str, int prefix_type, 858 int rowsize, int groupsize, const void *buf, size_t len, 859 bool ascii) 860 { 861 const u8 *ptr = buf; 862 int i, linelen, remaining = len; 863 char *buffer; 864 size_t size; 865 int ret; 866 867 if (rowsize != 16 && rowsize != 32) 868 rowsize = 16; 869 870 for (i = 0; i < len && !seq_has_overflowed(m); i += rowsize) { 871 linelen = min(remaining, rowsize); 872 remaining -= rowsize; 873 874 switch (prefix_type) { 875 case DUMP_PREFIX_ADDRESS: 876 seq_printf(m, "%s%p: ", prefix_str, ptr + i); 877 break; 878 case DUMP_PREFIX_OFFSET: 879 seq_printf(m, "%s%.8x: ", prefix_str, i); 880 break; 881 default: 882 seq_printf(m, "%s", prefix_str); 883 break; 884 } 885 886 size = seq_get_buf(m, &buffer); 887 ret = hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize, 888 buffer, size, ascii); 889 seq_commit(m, ret < size ? ret : -1); 890 891 seq_putc(m, '\n'); 892 } 893 } 894 EXPORT_SYMBOL(seq_hex_dump); 895 896 struct list_head *seq_list_start(struct list_head *head, loff_t pos) 897 { 898 struct list_head *lh; 899 900 list_for_each(lh, head) 901 if (pos-- == 0) 902 return lh; 903 904 return NULL; 905 } 906 EXPORT_SYMBOL(seq_list_start); 907 908 struct list_head *seq_list_start_head(struct list_head *head, loff_t pos) 909 { 910 if (!pos) 911 return head; 912 913 return seq_list_start(head, pos - 1); 914 } 915 EXPORT_SYMBOL(seq_list_start_head); 916 917 struct list_head *seq_list_next(void *v, struct list_head *head, loff_t *ppos) 918 { 919 struct list_head *lh; 920 921 lh = ((struct list_head *)v)->next; 922 ++*ppos; 923 return lh == head ? NULL : lh; 924 } 925 EXPORT_SYMBOL(seq_list_next); 926 927 /** 928 * seq_hlist_start - start an iteration of a hlist 929 * @head: the head of the hlist 930 * @pos: the start position of the sequence 931 * 932 * Called at seq_file->op->start(). 933 */ 934 struct hlist_node *seq_hlist_start(struct hlist_head *head, loff_t pos) 935 { 936 struct hlist_node *node; 937 938 hlist_for_each(node, head) 939 if (pos-- == 0) 940 return node; 941 return NULL; 942 } 943 EXPORT_SYMBOL(seq_hlist_start); 944 945 /** 946 * seq_hlist_start_head - start an iteration of a hlist 947 * @head: the head of the hlist 948 * @pos: the start position of the sequence 949 * 950 * Called at seq_file->op->start(). Call this function if you want to 951 * print a header at the top of the output. 952 */ 953 struct hlist_node *seq_hlist_start_head(struct hlist_head *head, loff_t pos) 954 { 955 if (!pos) 956 return SEQ_START_TOKEN; 957 958 return seq_hlist_start(head, pos - 1); 959 } 960 EXPORT_SYMBOL(seq_hlist_start_head); 961 962 /** 963 * seq_hlist_next - move to the next position of the hlist 964 * @v: the current iterator 965 * @head: the head of the hlist 966 * @ppos: the current position 967 * 968 * Called at seq_file->op->next(). 969 */ 970 struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head, 971 loff_t *ppos) 972 { 973 struct hlist_node *node = v; 974 975 ++*ppos; 976 if (v == SEQ_START_TOKEN) 977 return head->first; 978 else 979 return node->next; 980 } 981 EXPORT_SYMBOL(seq_hlist_next); 982 983 /** 984 * seq_hlist_start_rcu - start an iteration of a hlist protected by RCU 985 * @head: the head of the hlist 986 * @pos: the start position of the sequence 987 * 988 * Called at seq_file->op->start(). 989 * 990 * This list-traversal primitive may safely run concurrently with 991 * the _rcu list-mutation primitives such as hlist_add_head_rcu() 992 * as long as the traversal is guarded by rcu_read_lock(). 993 */ 994 struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head, 995 loff_t pos) 996 { 997 struct hlist_node *node; 998 999 __hlist_for_each_rcu(node, head) 1000 if (pos-- == 0) 1001 return node; 1002 return NULL; 1003 } 1004 EXPORT_SYMBOL(seq_hlist_start_rcu); 1005 1006 /** 1007 * seq_hlist_start_head_rcu - start an iteration of a hlist protected by RCU 1008 * @head: the head of the hlist 1009 * @pos: the start position of the sequence 1010 * 1011 * Called at seq_file->op->start(). Call this function if you want to 1012 * print a header at the top of the output. 1013 * 1014 * This list-traversal primitive may safely run concurrently with 1015 * the _rcu list-mutation primitives such as hlist_add_head_rcu() 1016 * as long as the traversal is guarded by rcu_read_lock(). 1017 */ 1018 struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head, 1019 loff_t pos) 1020 { 1021 if (!pos) 1022 return SEQ_START_TOKEN; 1023 1024 return seq_hlist_start_rcu(head, pos - 1); 1025 } 1026 EXPORT_SYMBOL(seq_hlist_start_head_rcu); 1027 1028 /** 1029 * seq_hlist_next_rcu - move to the next position of the hlist protected by RCU 1030 * @v: the current iterator 1031 * @head: the head of the hlist 1032 * @ppos: the current position 1033 * 1034 * Called at seq_file->op->next(). 1035 * 1036 * This list-traversal primitive may safely run concurrently with 1037 * the _rcu list-mutation primitives such as hlist_add_head_rcu() 1038 * as long as the traversal is guarded by rcu_read_lock(). 1039 */ 1040 struct hlist_node *seq_hlist_next_rcu(void *v, 1041 struct hlist_head *head, 1042 loff_t *ppos) 1043 { 1044 struct hlist_node *node = v; 1045 1046 ++*ppos; 1047 if (v == SEQ_START_TOKEN) 1048 return rcu_dereference(head->first); 1049 else 1050 return rcu_dereference(node->next); 1051 } 1052 EXPORT_SYMBOL(seq_hlist_next_rcu); 1053 1054 /** 1055 * seq_hlist_start_precpu - start an iteration of a percpu hlist array 1056 * @head: pointer to percpu array of struct hlist_heads 1057 * @cpu: pointer to cpu "cursor" 1058 * @pos: start position of sequence 1059 * 1060 * Called at seq_file->op->start(). 1061 */ 1062 struct hlist_node * 1063 seq_hlist_start_percpu(struct hlist_head __percpu *head, int *cpu, loff_t pos) 1064 { 1065 struct hlist_node *node; 1066 1067 for_each_possible_cpu(*cpu) { 1068 hlist_for_each(node, per_cpu_ptr(head, *cpu)) { 1069 if (pos-- == 0) 1070 return node; 1071 } 1072 } 1073 return NULL; 1074 } 1075 EXPORT_SYMBOL(seq_hlist_start_percpu); 1076 1077 /** 1078 * seq_hlist_next_percpu - move to the next position of the percpu hlist array 1079 * @v: pointer to current hlist_node 1080 * @head: pointer to percpu array of struct hlist_heads 1081 * @cpu: pointer to cpu "cursor" 1082 * @pos: start position of sequence 1083 * 1084 * Called at seq_file->op->next(). 1085 */ 1086 struct hlist_node * 1087 seq_hlist_next_percpu(void *v, struct hlist_head __percpu *head, 1088 int *cpu, loff_t *pos) 1089 { 1090 struct hlist_node *node = v; 1091 1092 ++*pos; 1093 1094 if (node->next) 1095 return node->next; 1096 1097 for (*cpu = cpumask_next(*cpu, cpu_possible_mask); *cpu < nr_cpu_ids; 1098 *cpu = cpumask_next(*cpu, cpu_possible_mask)) { 1099 struct hlist_head *bucket = per_cpu_ptr(head, *cpu); 1100 1101 if (!hlist_empty(bucket)) 1102 return bucket->first; 1103 } 1104 return NULL; 1105 } 1106 EXPORT_SYMBOL(seq_hlist_next_percpu); 1107 1108 void __init seq_file_init(void) 1109 { 1110 seq_file_cache = KMEM_CACHE(seq_file, SLAB_ACCOUNT|SLAB_PANIC); 1111 } 1112