Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/fs/seq_file.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us