~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/seq_file.c

Version: ~ [ linux-5.6-rc7 ] ~ [ linux-5.5.11 ] ~ [ linux-5.4.27 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.112 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.174 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.217 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.217 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <asm/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         /* 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->index++;
228                 if (!size)
229                         goto Done;
230         }
231         /* we need at least one record in buffer */
232         pos = m->index;
233         p = m->op->start(m, &pos);
234         while (1) {
235                 err = PTR_ERR(p);
236                 if (!p || IS_ERR(p))
237                         break;
238                 err = m->op->show(m, p);
239                 if (err < 0)
240                         break;
241                 if (unlikely(err))
242                         m->count = 0;
243                 if (unlikely(!m->count)) {
244                         p = m->op->next(m, p, &pos);
245                         m->index = pos;
246                         continue;
247                 }
248                 if (m->count < m->size)
249                         goto Fill;
250                 m->op->stop(m, p);
251                 kvfree(m->buf);
252                 m->count = 0;
253                 m->buf = seq_buf_alloc(m->size <<= 1);
254                 if (!m->buf)
255                         goto Enomem;
256                 m->version = 0;
257                 pos = m->index;
258                 p = m->op->start(m, &pos);
259         }
260         m->op->stop(m, p);
261         m->count = 0;
262         goto Done;
263 Fill:
264         /* they want more? let's try to get some more */
265         while (m->count < size) {
266                 size_t offs = m->count;
267                 loff_t next = pos;
268                 p = m->op->next(m, p, &next);
269                 if (!p || IS_ERR(p)) {
270                         err = PTR_ERR(p);
271                         break;
272                 }
273                 err = m->op->show(m, p);
274                 if (seq_has_overflowed(m) || err) {
275                         m->count = offs;
276                         if (likely(err <= 0))
277                                 break;
278                 }
279                 pos = next;
280         }
281         m->op->stop(m, p);
282         n = min(m->count, size);
283         err = copy_to_user(buf, m->buf, n);
284         if (err)
285                 goto Efault;
286         copied += n;
287         m->count -= n;
288         if (m->count)
289                 m->from = n;
290         else
291                 pos++;
292         m->index = pos;
293 Done:
294         if (!copied)
295                 copied = err;
296         else {
297                 *ppos += copied;
298                 m->read_pos += copied;
299         }
300         file->f_version = m->version;
301         mutex_unlock(&m->lock);
302         return copied;
303 Enomem:
304         err = -ENOMEM;
305         goto Done;
306 Efault:
307         err = -EFAULT;
308         goto Done;
309 }
310 EXPORT_SYMBOL(seq_read);
311 
312 /**
313  *      seq_lseek -     ->llseek() method for sequential files.
314  *      @file: the file in question
315  *      @offset: new position
316  *      @whence: 0 for absolute, 1 for relative position
317  *
318  *      Ready-made ->f_op->llseek()
319  */
320 loff_t seq_lseek(struct file *file, loff_t offset, int whence)
321 {
322         struct seq_file *m = file->private_data;
323         loff_t retval = -EINVAL;
324 
325         mutex_lock(&m->lock);
326         m->version = file->f_version;
327         switch (whence) {
328         case SEEK_CUR:
329                 offset += file->f_pos;
330         case SEEK_SET:
331                 if (offset < 0)
332                         break;
333                 retval = offset;
334                 if (offset != m->read_pos) {
335                         while ((retval = traverse(m, offset)) == -EAGAIN)
336                                 ;
337                         if (retval) {
338                                 /* with extreme prejudice... */
339                                 file->f_pos = 0;
340                                 m->read_pos = 0;
341                                 m->version = 0;
342                                 m->index = 0;
343                                 m->count = 0;
344                         } else {
345                                 m->read_pos = offset;
346                                 retval = file->f_pos = offset;
347                         }
348                 } else {
349                         file->f_pos = offset;
350                 }
351         }
352         file->f_version = m->version;
353         mutex_unlock(&m->lock);
354         return retval;
355 }
356 EXPORT_SYMBOL(seq_lseek);
357 
358 /**
359  *      seq_release -   free the structures associated with sequential file.
360  *      @file: file in question
361  *      @inode: its inode
362  *
363  *      Frees the structures associated with sequential file; can be used
364  *      as ->f_op->release() if you don't have private data to destroy.
365  */
366 int seq_release(struct inode *inode, struct file *file)
367 {
368         struct seq_file *m = file->private_data;
369         kvfree(m->buf);
370         kfree(m);
371         return 0;
372 }
373 EXPORT_SYMBOL(seq_release);
374 
375 /**
376  *      seq_escape -    print string into buffer, escaping some characters
377  *      @m:     target buffer
378  *      @s:     string
379  *      @esc:   set of characters that need escaping
380  *
381  *      Puts string into buffer, replacing each occurrence of character from
382  *      @esc with usual octal escape.
383  *      Use seq_has_overflowed() to check for errors.
384  */
385 void seq_escape(struct seq_file *m, const char *s, const char *esc)
386 {
387         char *buf;
388         size_t size = seq_get_buf(m, &buf);
389         int ret;
390 
391         ret = string_escape_str(s, buf, size, ESCAPE_OCTAL, esc);
392         seq_commit(m, ret < size ? ret : -1);
393 }
394 EXPORT_SYMBOL(seq_escape);
395 
396 void seq_vprintf(struct seq_file *m, const char *f, va_list args)
397 {
398         int len;
399 
400         if (m->count < m->size) {
401                 len = vsnprintf(m->buf + m->count, m->size - m->count, f, args);
402                 if (m->count + len < m->size) {
403                         m->count += len;
404                         return;
405                 }
406         }
407         seq_set_overflow(m);
408 }
409 EXPORT_SYMBOL(seq_vprintf);
410 
411 void seq_printf(struct seq_file *m, const char *f, ...)
412 {
413         va_list args;
414 
415         va_start(args, f);
416         seq_vprintf(m, f, args);
417         va_end(args);
418 }
419 EXPORT_SYMBOL(seq_printf);
420 
421 /**
422  *      mangle_path -   mangle and copy path to buffer beginning
423  *      @s: buffer start
424  *      @p: beginning of path in above buffer
425  *      @esc: set of characters that need escaping
426  *
427  *      Copy the path from @p to @s, replacing each occurrence of character from
428  *      @esc with usual octal escape.
429  *      Returns pointer past last written character in @s, or NULL in case of
430  *      failure.
431  */
432 char *mangle_path(char *s, const char *p, const char *esc)
433 {
434         while (s <= p) {
435                 char c = *p++;
436                 if (!c) {
437                         return s;
438                 } else if (!strchr(esc, c)) {
439                         *s++ = c;
440                 } else if (s + 4 > p) {
441                         break;
442                 } else {
443                         *s++ = '\\';
444                         *s++ = '' + ((c & 0300) >> 6);
445                         *s++ = '' + ((c & 070) >> 3);
446                         *s++ = '' + (c & 07);
447                 }
448         }
449         return NULL;
450 }
451 EXPORT_SYMBOL(mangle_path);
452 
453 /**
454  * seq_path - seq_file interface to print a pathname
455  * @m: the seq_file handle
456  * @path: the struct path to print
457  * @esc: set of characters to escape in the output
458  *
459  * return the absolute path of 'path', as represented by the
460  * dentry / mnt pair in the path parameter.
461  */
462 int seq_path(struct seq_file *m, const struct path *path, const char *esc)
463 {
464         char *buf;
465         size_t size = seq_get_buf(m, &buf);
466         int res = -1;
467 
468         if (size) {
469                 char *p = d_path(path, buf, size);
470                 if (!IS_ERR(p)) {
471                         char *end = mangle_path(buf, p, esc);
472                         if (end)
473                                 res = end - buf;
474                 }
475         }
476         seq_commit(m, res);
477 
478         return res;
479 }
480 EXPORT_SYMBOL(seq_path);
481 
482 /**
483  * seq_file_path - seq_file interface to print a pathname of a file
484  * @m: the seq_file handle
485  * @file: the struct file to print
486  * @esc: set of characters to escape in the output
487  *
488  * return the absolute path to the file.
489  */
490 int seq_file_path(struct seq_file *m, struct file *file, const char *esc)
491 {
492         return seq_path(m, &file->f_path, esc);
493 }
494 EXPORT_SYMBOL(seq_file_path);
495 
496 /*
497  * Same as seq_path, but relative to supplied root.
498  */
499 int seq_path_root(struct seq_file *m, const struct path *path,
500                   const struct path *root, const char *esc)
501 {
502         char *buf;
503         size_t size = seq_get_buf(m, &buf);
504         int res = -ENAMETOOLONG;
505 
506         if (size) {
507                 char *p;
508 
509                 p = __d_path(path, root, buf, size);
510                 if (!p)
511                         return SEQ_SKIP;
512                 res = PTR_ERR(p);
513                 if (!IS_ERR(p)) {
514                         char *end = mangle_path(buf, p, esc);
515                         if (end)
516                                 res = end - buf;
517                         else
518                                 res = -ENAMETOOLONG;
519                 }
520         }
521         seq_commit(m, res);
522 
523         return res < 0 && res != -ENAMETOOLONG ? res : 0;
524 }
525 
526 /*
527  * returns the path of the 'dentry' from the root of its filesystem.
528  */
529 int seq_dentry(struct seq_file *m, struct dentry *dentry, const char *esc)
530 {
531         char *buf;
532         size_t size = seq_get_buf(m, &buf);
533         int res = -1;
534 
535         if (size) {
536                 char *p = dentry_path(dentry, buf, size);
537                 if (!IS_ERR(p)) {
538                         char *end = mangle_path(buf, p, esc);
539                         if (end)
540                                 res = end - buf;
541                 }
542         }
543         seq_commit(m, res);
544 
545         return res;
546 }
547 EXPORT_SYMBOL(seq_dentry);
548 
549 static void *single_start(struct seq_file *p, loff_t *pos)
550 {
551         return NULL + (*pos == 0);
552 }
553 
554 static void *single_next(struct seq_file *p, void *v, loff_t *pos)
555 {
556         ++*pos;
557         return NULL;
558 }
559 
560 static void single_stop(struct seq_file *p, void *v)
561 {
562 }
563 
564 int single_open(struct file *file, int (*show)(struct seq_file *, void *),
565                 void *data)
566 {
567         struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL);
568         int res = -ENOMEM;
569 
570         if (op) {
571                 op->start = single_start;
572                 op->next = single_next;
573                 op->stop = single_stop;
574                 op->show = show;
575                 res = seq_open(file, op);
576                 if (!res)
577                         ((struct seq_file *)file->private_data)->private = data;
578                 else
579                         kfree(op);
580         }
581         return res;
582 }
583 EXPORT_SYMBOL(single_open);
584 
585 int single_open_size(struct file *file, int (*show)(struct seq_file *, void *),
586                 void *data, size_t size)
587 {
588         char *buf = seq_buf_alloc(size);
589         int ret;
590         if (!buf)
591                 return -ENOMEM;
592         ret = single_open(file, show, data);
593         if (ret) {
594                 kvfree(buf);
595                 return ret;
596         }
597         ((struct seq_file *)file->private_data)->buf = buf;
598         ((struct seq_file *)file->private_data)->size = size;
599         return 0;
600 }
601 EXPORT_SYMBOL(single_open_size);
602 
603 int single_release(struct inode *inode, struct file *file)
604 {
605         const struct seq_operations *op = ((struct seq_file *)file->private_data)->op;
606         int res = seq_release(inode, file);
607         kfree(op);
608         return res;
609 }
610 EXPORT_SYMBOL(single_release);
611 
612 int seq_release_private(struct inode *inode, struct file *file)
613 {
614         struct seq_file *seq = file->private_data;
615 
616         kfree(seq->private);
617         seq->private = NULL;
618         return seq_release(inode, file);
619 }
620 EXPORT_SYMBOL(seq_release_private);
621 
622 void *__seq_open_private(struct file *f, const struct seq_operations *ops,
623                 int psize)
624 {
625         int rc;
626         void *private;
627         struct seq_file *seq;
628 
629         private = kzalloc(psize, GFP_KERNEL);
630         if (private == NULL)
631                 goto out;
632 
633         rc = seq_open(f, ops);
634         if (rc < 0)
635                 goto out_free;
636 
637         seq = f->private_data;
638         seq->private = private;
639         return private;
640 
641 out_free:
642         kfree(private);
643 out:
644         return NULL;
645 }
646 EXPORT_SYMBOL(__seq_open_private);
647 
648 int seq_open_private(struct file *filp, const struct seq_operations *ops,
649                 int psize)
650 {
651         return __seq_open_private(filp, ops, psize) ? 0 : -ENOMEM;
652 }
653 EXPORT_SYMBOL(seq_open_private);
654 
655 void seq_putc(struct seq_file *m, char c)
656 {
657         if (m->count >= m->size)
658                 return;
659 
660         m->buf[m->count++] = c;
661 }
662 EXPORT_SYMBOL(seq_putc);
663 
664 void seq_puts(struct seq_file *m, const char *s)
665 {
666         int len = strlen(s);
667 
668         if (m->count + len >= m->size) {
669                 seq_set_overflow(m);
670                 return;
671         }
672         memcpy(m->buf + m->count, s, len);
673         m->count += len;
674 }
675 EXPORT_SYMBOL(seq_puts);
676 
677 /*
678  * A helper routine for putting decimal numbers without rich format of printf().
679  * only 'unsigned long long' is supported.
680  * This routine will put one byte delimiter + number into seq_file.
681  * This routine is very quick when you show lots of numbers.
682  * In usual cases, it will be better to use seq_printf(). It's easier to read.
683  */
684 void seq_put_decimal_ull(struct seq_file *m, char delimiter,
685                          unsigned long long num)
686 {
687         int len;
688 
689         if (m->count + 2 >= m->size) /* we'll write 2 bytes at least */
690                 goto overflow;
691 
692         if (delimiter)
693                 m->buf[m->count++] = delimiter;
694 
695         if (num < 10) {
696                 m->buf[m->count++] = num + '';
697                 return;
698         }
699 
700         len = num_to_str(m->buf + m->count, m->size - m->count, num);
701         if (!len)
702                 goto overflow;
703         m->count += len;
704         return;
705 
706 overflow:
707         seq_set_overflow(m);
708 }
709 EXPORT_SYMBOL(seq_put_decimal_ull);
710 
711 void seq_put_decimal_ll(struct seq_file *m, char delimiter, long long num)
712 {
713         if (num < 0) {
714                 if (m->count + 3 >= m->size) {
715                         seq_set_overflow(m);
716                         return;
717                 }
718                 if (delimiter)
719                         m->buf[m->count++] = delimiter;
720                 num = -num;
721                 delimiter = '-';
722         }
723         seq_put_decimal_ull(m, delimiter, num);
724 }
725 EXPORT_SYMBOL(seq_put_decimal_ll);
726 
727 /**
728  * seq_write - write arbitrary data to buffer
729  * @seq: seq_file identifying the buffer to which data should be written
730  * @data: data address
731  * @len: number of bytes
732  *
733  * Return 0 on success, non-zero otherwise.
734  */
735 int seq_write(struct seq_file *seq, const void *data, size_t len)
736 {
737         if (seq->count + len < seq->size) {
738                 memcpy(seq->buf + seq->count, data, len);
739                 seq->count += len;
740                 return 0;
741         }
742         seq_set_overflow(seq);
743         return -1;
744 }
745 EXPORT_SYMBOL(seq_write);
746 
747 /**
748  * seq_pad - write padding spaces to buffer
749  * @m: seq_file identifying the buffer to which data should be written
750  * @c: the byte to append after padding if non-zero
751  */
752 void seq_pad(struct seq_file *m, char c)
753 {
754         int size = m->pad_until - m->count;
755         if (size > 0)
756                 seq_printf(m, "%*s", size, "");
757         if (c)
758                 seq_putc(m, c);
759 }
760 EXPORT_SYMBOL(seq_pad);
761 
762 /* A complete analogue of print_hex_dump() */
763 void seq_hex_dump(struct seq_file *m, const char *prefix_str, int prefix_type,
764                   int rowsize, int groupsize, const void *buf, size_t len,
765                   bool ascii)
766 {
767         const u8 *ptr = buf;
768         int i, linelen, remaining = len;
769         char *buffer;
770         size_t size;
771         int ret;
772 
773         if (rowsize != 16 && rowsize != 32)
774                 rowsize = 16;
775 
776         for (i = 0; i < len && !seq_has_overflowed(m); i += rowsize) {
777                 linelen = min(remaining, rowsize);
778                 remaining -= rowsize;
779 
780                 switch (prefix_type) {
781                 case DUMP_PREFIX_ADDRESS:
782                         seq_printf(m, "%s%p: ", prefix_str, ptr + i);
783                         break;
784                 case DUMP_PREFIX_OFFSET:
785                         seq_printf(m, "%s%.8x: ", prefix_str, i);
786                         break;
787                 default:
788                         seq_printf(m, "%s", prefix_str);
789                         break;
790                 }
791 
792                 size = seq_get_buf(m, &buffer);
793                 ret = hex_dump_to_buffer(ptr + i, linelen, rowsize, groupsize,
794                                          buffer, size, ascii);
795                 seq_commit(m, ret < size ? ret : -1);
796 
797                 seq_putc(m, '\n');
798         }
799 }
800 EXPORT_SYMBOL(seq_hex_dump);
801 
802 struct list_head *seq_list_start(struct list_head *head, loff_t pos)
803 {
804         struct list_head *lh;
805 
806         list_for_each(lh, head)
807                 if (pos-- == 0)
808                         return lh;
809 
810         return NULL;
811 }
812 EXPORT_SYMBOL(seq_list_start);
813 
814 struct list_head *seq_list_start_head(struct list_head *head, loff_t pos)
815 {
816         if (!pos)
817                 return head;
818 
819         return seq_list_start(head, pos - 1);
820 }
821 EXPORT_SYMBOL(seq_list_start_head);
822 
823 struct list_head *seq_list_next(void *v, struct list_head *head, loff_t *ppos)
824 {
825         struct list_head *lh;
826 
827         lh = ((struct list_head *)v)->next;
828         ++*ppos;
829         return lh == head ? NULL : lh;
830 }
831 EXPORT_SYMBOL(seq_list_next);
832 
833 /**
834  * seq_hlist_start - start an iteration of a hlist
835  * @head: the head of the hlist
836  * @pos:  the start position of the sequence
837  *
838  * Called at seq_file->op->start().
839  */
840 struct hlist_node *seq_hlist_start(struct hlist_head *head, loff_t pos)
841 {
842         struct hlist_node *node;
843 
844         hlist_for_each(node, head)
845                 if (pos-- == 0)
846                         return node;
847         return NULL;
848 }
849 EXPORT_SYMBOL(seq_hlist_start);
850 
851 /**
852  * seq_hlist_start_head - start an iteration of a hlist
853  * @head: the head of the hlist
854  * @pos:  the start position of the sequence
855  *
856  * Called at seq_file->op->start(). Call this function if you want to
857  * print a header at the top of the output.
858  */
859 struct hlist_node *seq_hlist_start_head(struct hlist_head *head, loff_t pos)
860 {
861         if (!pos)
862                 return SEQ_START_TOKEN;
863 
864         return seq_hlist_start(head, pos - 1);
865 }
866 EXPORT_SYMBOL(seq_hlist_start_head);
867 
868 /**
869  * seq_hlist_next - move to the next position of the hlist
870  * @v:    the current iterator
871  * @head: the head of the hlist
872  * @ppos: the current position
873  *
874  * Called at seq_file->op->next().
875  */
876 struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
877                                   loff_t *ppos)
878 {
879         struct hlist_node *node = v;
880 
881         ++*ppos;
882         if (v == SEQ_START_TOKEN)
883                 return head->first;
884         else
885                 return node->next;
886 }
887 EXPORT_SYMBOL(seq_hlist_next);
888 
889 /**
890  * seq_hlist_start_rcu - start an iteration of a hlist protected by RCU
891  * @head: the head of the hlist
892  * @pos:  the start position of the sequence
893  *
894  * Called at seq_file->op->start().
895  *
896  * This list-traversal primitive may safely run concurrently with
897  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
898  * as long as the traversal is guarded by rcu_read_lock().
899  */
900 struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
901                                        loff_t pos)
902 {
903         struct hlist_node *node;
904 
905         __hlist_for_each_rcu(node, head)
906                 if (pos-- == 0)
907                         return node;
908         return NULL;
909 }
910 EXPORT_SYMBOL(seq_hlist_start_rcu);
911 
912 /**
913  * seq_hlist_start_head_rcu - start an iteration of a hlist protected by RCU
914  * @head: the head of the hlist
915  * @pos:  the start position of the sequence
916  *
917  * Called at seq_file->op->start(). Call this function if you want to
918  * print a header at the top of the output.
919  *
920  * This list-traversal primitive may safely run concurrently with
921  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
922  * as long as the traversal is guarded by rcu_read_lock().
923  */
924 struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
925                                             loff_t pos)
926 {
927         if (!pos)
928                 return SEQ_START_TOKEN;
929 
930         return seq_hlist_start_rcu(head, pos - 1);
931 }
932 EXPORT_SYMBOL(seq_hlist_start_head_rcu);
933 
934 /**
935  * seq_hlist_next_rcu - move to the next position of the hlist protected by RCU
936  * @v:    the current iterator
937  * @head: the head of the hlist
938  * @ppos: the current position
939  *
940  * Called at seq_file->op->next().
941  *
942  * This list-traversal primitive may safely run concurrently with
943  * the _rcu list-mutation primitives such as hlist_add_head_rcu()
944  * as long as the traversal is guarded by rcu_read_lock().
945  */
946 struct hlist_node *seq_hlist_next_rcu(void *v,
947                                       struct hlist_head *head,
948                                       loff_t *ppos)
949 {
950         struct hlist_node *node = v;
951 
952         ++*ppos;
953         if (v == SEQ_START_TOKEN)
954                 return rcu_dereference(head->first);
955         else
956                 return rcu_dereference(node->next);
957 }
958 EXPORT_SYMBOL(seq_hlist_next_rcu);
959 
960 /**
961  * seq_hlist_start_precpu - start an iteration of a percpu hlist array
962  * @head: pointer to percpu array of struct hlist_heads
963  * @cpu:  pointer to cpu "cursor"
964  * @pos:  start position of sequence
965  *
966  * Called at seq_file->op->start().
967  */
968 struct hlist_node *
969 seq_hlist_start_percpu(struct hlist_head __percpu *head, int *cpu, loff_t pos)
970 {
971         struct hlist_node *node;
972 
973         for_each_possible_cpu(*cpu) {
974                 hlist_for_each(node, per_cpu_ptr(head, *cpu)) {
975                         if (pos-- == 0)
976                                 return node;
977                 }
978         }
979         return NULL;
980 }
981 EXPORT_SYMBOL(seq_hlist_start_percpu);
982 
983 /**
984  * seq_hlist_next_percpu - move to the next position of the percpu hlist array
985  * @v:    pointer to current hlist_node
986  * @head: pointer to percpu array of struct hlist_heads
987  * @cpu:  pointer to cpu "cursor"
988  * @pos:  start position of sequence
989  *
990  * Called at seq_file->op->next().
991  */
992 struct hlist_node *
993 seq_hlist_next_percpu(void *v, struct hlist_head __percpu *head,
994                         int *cpu, loff_t *pos)
995 {
996         struct hlist_node *node = v;
997 
998         ++*pos;
999 
1000         if (node->next)
1001                 return node->next;
1002 
1003         for (*cpu = cpumask_next(*cpu, cpu_possible_mask); *cpu < nr_cpu_ids;
1004              *cpu = cpumask_next(*cpu, cpu_possible_mask)) {
1005                 struct hlist_head *bucket = per_cpu_ptr(head, *cpu);
1006 
1007                 if (!hlist_empty(bucket))
1008                         return bucket->first;
1009         }
1010         return NULL;
1011 }
1012 EXPORT_SYMBOL(seq_hlist_next_percpu);
1013 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp