Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * seq_buf.c
       4                 :            :  *
       5                 :            :  * Copyright (C) 2014 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
       6                 :            :  *
       7                 :            :  * The seq_buf is a handy tool that allows you to pass a descriptor around
       8                 :            :  * to a buffer that other functions can write to. It is similar to the
       9                 :            :  * seq_file functionality but has some differences.
      10                 :            :  *
      11                 :            :  * To use it, the seq_buf must be initialized with seq_buf_init().
      12                 :            :  * This will set up the counters within the descriptor. You can call
      13                 :            :  * seq_buf_init() more than once to reset the seq_buf to start
      14                 :            :  * from scratch.
      15                 :            :  */
      16                 :            : #include <linux/uaccess.h>
      17                 :            : #include <linux/seq_file.h>
      18                 :            : #include <linux/seq_buf.h>
      19                 :            : 
      20                 :            : /**
      21                 :            :  * seq_buf_can_fit - can the new data fit in the current buffer?
      22                 :            :  * @s: the seq_buf descriptor
      23                 :            :  * @len: The length to see if it can fit in the current buffer
      24                 :            :  *
      25                 :            :  * Returns true if there's enough unused space in the seq_buf buffer
      26                 :            :  * to fit the amount of new data according to @len.
      27                 :            :  */
      28                 :            : static bool seq_buf_can_fit(struct seq_buf *s, size_t len)
      29                 :            : {
      30                 :          0 :         return s->len + len <= s->size;
      31                 :            : }
      32                 :            : 
      33                 :            : /**
      34                 :            :  * seq_buf_print_seq - move the contents of seq_buf into a seq_file
      35                 :            :  * @m: the seq_file descriptor that is the destination
      36                 :            :  * @s: the seq_buf descriptor that is the source.
      37                 :            :  *
      38                 :            :  * Returns zero on success, non zero otherwise
      39                 :            :  */
      40                 :          0 : int seq_buf_print_seq(struct seq_file *m, struct seq_buf *s)
      41                 :            : {
      42                 :            :         unsigned int len = seq_buf_used(s);
      43                 :            : 
      44                 :          0 :         return seq_write(m, s->buffer, len);
      45                 :            : }
      46                 :            : 
      47                 :            : /**
      48                 :            :  * seq_buf_vprintf - sequence printing of information.
      49                 :            :  * @s: seq_buf descriptor
      50                 :            :  * @fmt: printf format string
      51                 :            :  * @args: va_list of arguments from a printf() type function
      52                 :            :  *
      53                 :            :  * Writes a vnprintf() format into the sequencce buffer.
      54                 :            :  *
      55                 :            :  * Returns zero on success, -1 on overflow.
      56                 :            :  */
      57                 :          0 : int seq_buf_vprintf(struct seq_buf *s, const char *fmt, va_list args)
      58                 :            : {
      59                 :            :         int len;
      60                 :            : 
      61                 :          0 :         WARN_ON(s->size == 0);
      62                 :            : 
      63                 :          0 :         if (s->len < s->size) {
      64                 :          0 :                 len = vsnprintf(s->buffer + s->len, s->size - s->len, fmt, args);
      65                 :          0 :                 if (s->len + len < s->size) {
      66                 :          0 :                         s->len += len;
      67                 :          0 :                         return 0;
      68                 :            :                 }
      69                 :            :         }
      70                 :            :         seq_buf_set_overflow(s);
      71                 :          0 :         return -1;
      72                 :            : }
      73                 :            : 
      74                 :            : /**
      75                 :            :  * seq_buf_printf - sequence printing of information
      76                 :            :  * @s: seq_buf descriptor
      77                 :            :  * @fmt: printf format string
      78                 :            :  *
      79                 :            :  * Writes a printf() format into the sequence buffer.
      80                 :            :  *
      81                 :            :  * Returns zero on success, -1 on overflow.
      82                 :            :  */
      83                 :          0 : int seq_buf_printf(struct seq_buf *s, const char *fmt, ...)
      84                 :            : {
      85                 :            :         va_list ap;
      86                 :            :         int ret;
      87                 :            : 
      88                 :          0 :         va_start(ap, fmt);
      89                 :          0 :         ret = seq_buf_vprintf(s, fmt, ap);
      90                 :          0 :         va_end(ap);
      91                 :            : 
      92                 :          0 :         return ret;
      93                 :            : }
      94                 :            : 
      95                 :            : #ifdef CONFIG_BINARY_PRINTF
      96                 :            : /**
      97                 :            :  * seq_buf_bprintf - Write the printf string from binary arguments
      98                 :            :  * @s: seq_buf descriptor
      99                 :            :  * @fmt: The format string for the @binary arguments
     100                 :            :  * @binary: The binary arguments for @fmt.
     101                 :            :  *
     102                 :            :  * When recording in a fast path, a printf may be recorded with just
     103                 :            :  * saving the format and the arguments as they were passed to the
     104                 :            :  * function, instead of wasting cycles converting the arguments into
     105                 :            :  * ASCII characters. Instead, the arguments are saved in a 32 bit
     106                 :            :  * word array that is defined by the format string constraints.
     107                 :            :  *
     108                 :            :  * This function will take the format and the binary array and finish
     109                 :            :  * the conversion into the ASCII string within the buffer.
     110                 :            :  *
     111                 :            :  * Returns zero on success, -1 on overflow.
     112                 :            :  */
     113                 :          0 : int seq_buf_bprintf(struct seq_buf *s, const char *fmt, const u32 *binary)
     114                 :            : {
     115                 :            :         unsigned int len = seq_buf_buffer_left(s);
     116                 :            :         int ret;
     117                 :            : 
     118                 :          0 :         WARN_ON(s->size == 0);
     119                 :            : 
     120                 :          0 :         if (s->len < s->size) {
     121                 :          0 :                 ret = bstr_printf(s->buffer + s->len, len, fmt, binary);
     122                 :          0 :                 if (s->len + ret < s->size) {
     123                 :          0 :                         s->len += ret;
     124                 :          0 :                         return 0;
     125                 :            :                 }
     126                 :            :         }
     127                 :            :         seq_buf_set_overflow(s);
     128                 :          0 :         return -1;
     129                 :            : }
     130                 :            : #endif /* CONFIG_BINARY_PRINTF */
     131                 :            : 
     132                 :            : /**
     133                 :            :  * seq_buf_puts - sequence printing of simple string
     134                 :            :  * @s: seq_buf descriptor
     135                 :            :  * @str: simple string to record
     136                 :            :  *
     137                 :            :  * Copy a simple string into the sequence buffer.
     138                 :            :  *
     139                 :            :  * Returns zero on success, -1 on overflow
     140                 :            :  */
     141                 :          0 : int seq_buf_puts(struct seq_buf *s, const char *str)
     142                 :            : {
     143                 :          0 :         size_t len = strlen(str);
     144                 :            : 
     145                 :          0 :         WARN_ON(s->size == 0);
     146                 :            : 
     147                 :            :         /* Add 1 to len for the trailing null byte which must be there */
     148                 :          0 :         len += 1;
     149                 :            : 
     150                 :          0 :         if (seq_buf_can_fit(s, len)) {
     151                 :          0 :                 memcpy(s->buffer + s->len, str, len);
     152                 :            :                 /* Don't count the trailing null byte against the capacity */
     153                 :          0 :                 s->len += len - 1;
     154                 :          0 :                 return 0;
     155                 :            :         }
     156                 :            :         seq_buf_set_overflow(s);
     157                 :          0 :         return -1;
     158                 :            : }
     159                 :            : 
     160                 :            : /**
     161                 :            :  * seq_buf_putc - sequence printing of simple character
     162                 :            :  * @s: seq_buf descriptor
     163                 :            :  * @c: simple character to record
     164                 :            :  *
     165                 :            :  * Copy a single character into the sequence buffer.
     166                 :            :  *
     167                 :            :  * Returns zero on success, -1 on overflow
     168                 :            :  */
     169                 :          0 : int seq_buf_putc(struct seq_buf *s, unsigned char c)
     170                 :            : {
     171                 :          0 :         WARN_ON(s->size == 0);
     172                 :            : 
     173                 :          0 :         if (seq_buf_can_fit(s, 1)) {
     174                 :          0 :                 s->buffer[s->len++] = c;
     175                 :          0 :                 return 0;
     176                 :            :         }
     177                 :            :         seq_buf_set_overflow(s);
     178                 :          0 :         return -1;
     179                 :            : }
     180                 :            : 
     181                 :            : /**
     182                 :            :  * seq_buf_putmem - write raw data into the sequenc buffer
     183                 :            :  * @s: seq_buf descriptor
     184                 :            :  * @mem: The raw memory to copy into the buffer
     185                 :            :  * @len: The length of the raw memory to copy (in bytes)
     186                 :            :  *
     187                 :            :  * There may be cases where raw memory needs to be written into the
     188                 :            :  * buffer and a strcpy() would not work. Using this function allows
     189                 :            :  * for such cases.
     190                 :            :  *
     191                 :            :  * Returns zero on success, -1 on overflow
     192                 :            :  */
     193                 :          0 : int seq_buf_putmem(struct seq_buf *s, const void *mem, unsigned int len)
     194                 :            : {
     195                 :          0 :         WARN_ON(s->size == 0);
     196                 :            : 
     197                 :          0 :         if (seq_buf_can_fit(s, len)) {
     198                 :          0 :                 memcpy(s->buffer + s->len, mem, len);
     199                 :          0 :                 s->len += len;
     200                 :          0 :                 return 0;
     201                 :            :         }
     202                 :            :         seq_buf_set_overflow(s);
     203                 :          0 :         return -1;
     204                 :            : }
     205                 :            : 
     206                 :            : #define MAX_MEMHEX_BYTES        8U
     207                 :            : #define HEX_CHARS               (MAX_MEMHEX_BYTES*2 + 1)
     208                 :            : 
     209                 :            : /**
     210                 :            :  * seq_buf_putmem_hex - write raw memory into the buffer in ASCII hex
     211                 :            :  * @s: seq_buf descriptor
     212                 :            :  * @mem: The raw memory to write its hex ASCII representation of
     213                 :            :  * @len: The length of the raw memory to copy (in bytes)
     214                 :            :  *
     215                 :            :  * This is similar to seq_buf_putmem() except instead of just copying the
     216                 :            :  * raw memory into the buffer it writes its ASCII representation of it
     217                 :            :  * in hex characters.
     218                 :            :  *
     219                 :            :  * Returns zero on success, -1 on overflow
     220                 :            :  */
     221                 :          0 : int seq_buf_putmem_hex(struct seq_buf *s, const void *mem,
     222                 :            :                        unsigned int len)
     223                 :            : {
     224                 :            :         unsigned char hex[HEX_CHARS];
     225                 :            :         const unsigned char *data = mem;
     226                 :            :         unsigned int start_len;
     227                 :            :         int i, j;
     228                 :            : 
     229                 :          0 :         WARN_ON(s->size == 0);
     230                 :            : 
     231                 :          0 :         while (len) {
     232                 :          0 :                 start_len = min(len, HEX_CHARS - 1);
     233                 :            : #ifdef __BIG_ENDIAN
     234                 :            :                 for (i = 0, j = 0; i < start_len; i++) {
     235                 :            : #else
     236                 :          0 :                 for (i = start_len-1, j = 0; i >= 0; i--) {
     237                 :            : #endif
     238                 :          0 :                         hex[j++] = hex_asc_hi(data[i]);
     239                 :          0 :                         hex[j++] = hex_asc_lo(data[i]);
     240                 :            :                 }
     241                 :          0 :                 if (WARN_ON_ONCE(j == 0 || j/2 > len))
     242                 :            :                         break;
     243                 :            : 
     244                 :            :                 /* j increments twice per loop */
     245                 :          0 :                 len -= j / 2;
     246                 :          0 :                 hex[j++] = ' ';
     247                 :            : 
     248                 :          0 :                 seq_buf_putmem(s, hex, j);
     249                 :          0 :                 if (seq_buf_has_overflowed(s))
     250                 :            :                         return -1;
     251                 :            :         }
     252                 :            :         return 0;
     253                 :            : }
     254                 :            : 
     255                 :            : /**
     256                 :            :  * seq_buf_path - copy a path into the sequence buffer
     257                 :            :  * @s: seq_buf descriptor
     258                 :            :  * @path: path to write into the sequence buffer.
     259                 :            :  * @esc: set of characters to escape in the output
     260                 :            :  *
     261                 :            :  * Write a path name into the sequence buffer.
     262                 :            :  *
     263                 :            :  * Returns the number of written bytes on success, -1 on overflow
     264                 :            :  */
     265                 :          0 : int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc)
     266                 :            : {
     267                 :            :         char *buf;
     268                 :          0 :         size_t size = seq_buf_get_buf(s, &buf);
     269                 :            :         int res = -1;
     270                 :            : 
     271                 :          0 :         WARN_ON(s->size == 0);
     272                 :            : 
     273                 :          0 :         if (size) {
     274                 :          0 :                 char *p = d_path(path, buf, size);
     275                 :          0 :                 if (!IS_ERR(p)) {
     276                 :          0 :                         char *end = mangle_path(buf, p, esc);
     277                 :          0 :                         if (end)
     278                 :          0 :                                 res = end - buf;
     279                 :            :                 }
     280                 :            :         }
     281                 :          0 :         seq_buf_commit(s, res);
     282                 :            : 
     283                 :          0 :         return res;
     284                 :            : }
     285                 :            : 
     286                 :            : /**
     287                 :            :  * seq_buf_to_user - copy the squence buffer to user space
     288                 :            :  * @s: seq_buf descriptor
     289                 :            :  * @ubuf: The userspace memory location to copy to
     290                 :            :  * @cnt: The amount to copy
     291                 :            :  *
     292                 :            :  * Copies the sequence buffer into the userspace memory pointed to
     293                 :            :  * by @ubuf. It starts from the last read position (@s->readpos)
     294                 :            :  * and writes up to @cnt characters or till it reaches the end of
     295                 :            :  * the content in the buffer (@s->len), which ever comes first.
     296                 :            :  *
     297                 :            :  * On success, it returns a positive number of the number of bytes
     298                 :            :  * it copied.
     299                 :            :  *
     300                 :            :  * On failure it returns -EBUSY if all of the content in the
     301                 :            :  * sequence has been already read, which includes nothing in the
     302                 :            :  * sequence (@s->len == @s->readpos).
     303                 :            :  *
     304                 :            :  * Returns -EFAULT if the copy to userspace fails.
     305                 :            :  */
     306                 :          0 : int seq_buf_to_user(struct seq_buf *s, char __user *ubuf, int cnt)
     307                 :            : {
     308                 :            :         int len;
     309                 :            :         int ret;
     310                 :            : 
     311                 :          0 :         if (!cnt)
     312                 :            :                 return 0;
     313                 :            : 
     314                 :          0 :         len = seq_buf_used(s);
     315                 :            : 
     316                 :          0 :         if (len <= s->readpos)
     317                 :            :                 return -EBUSY;
     318                 :            : 
     319                 :          0 :         len -= s->readpos;
     320                 :          0 :         if (cnt > len)
     321                 :            :                 cnt = len;
     322                 :          0 :         ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
     323                 :          0 :         if (ret == cnt)
     324                 :            :                 return -EFAULT;
     325                 :            : 
     326                 :          0 :         cnt -= ret;
     327                 :            : 
     328                 :          0 :         s->readpos += cnt;
     329                 :          0 :         return cnt;
     330                 :            : }