lib/kunit/string-stream.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * C++ stream style string builder used in KUnit for building messages.
   4  *
   5  * Copyright (C) 2019, Google LLC.
   6  * Author: Brendan Higgins <brendanhiggins@google.com>
   7  */
   8
   9 #include <kunit/string-stream.h>
  10 #include <kunit/test.h>
  11 #include <linux/list.h>
  12 #include <linux/slab.h>
  13
  14 struct string_stream_fragment_alloc_context {
  15         struct kunit *test;
  16         int len;
  17         gfp_t gfp;
  18 };
  19
  20 static int string_stream_fragment_init(struct kunit_resource *res,
  21                                        void *context)
  22 {
  23         struct string_stream_fragment_alloc_context *ctx = context;
  24         struct string_stream_fragment *frag;
  25
  26         frag = kunit_kzalloc(ctx->test, sizeof(*frag), ctx->gfp);
  27         if (!frag)
  28                 return -ENOMEM;
  29
  30         frag->test = ctx->test;
  31         frag->fragment = kunit_kmalloc(ctx->test, ctx->len, ctx->gfp);
  32         if (!frag->fragment)
  33                 return -ENOMEM;
  34
  35         res->allocation = frag;
  36
  37         return 0;
  38 }
  39
  40 static void string_stream_fragment_free(struct kunit_resource *res)
  41 {
  42         struct string_stream_fragment *frag = res->allocation;
  43
  44         list_del(&frag->node);
  45         kunit_kfree(frag->test, frag->fragment);
  46         kunit_kfree(frag->test, frag);
  47 }
  48
  49 static struct string_stream_fragment *alloc_string_stream_fragment(
  50                 struct kunit *test, int len, gfp_t gfp)
  51 {
  52         struct string_stream_fragment_alloc_context context = {
  53                 .test = test,
  54                 .len = len,
  55                 .gfp = gfp
  56         };
  57
  58         return kunit_alloc_resource(test,
  59                                     string_stream_fragment_init,
  60                                     string_stream_fragment_free,
  61                                     gfp,
  62                                     &context);
  63 }
  64
  65 static int string_stream_fragment_destroy(struct string_stream_fragment *frag)
  66 {
  67         return kunit_resource_destroy(frag->test,
  68                                       kunit_resource_instance_match,
  69                                       string_stream_fragment_free,
  70                                       frag);
  71 }
  72
  73 int string_stream_vadd(struct string_stream *stream,
  74                        const char *fmt,
  75                        va_list args)
  76 {
  77         struct string_stream_fragment *frag_container;
  78         int len;
  79         va_list args_for_counting;
  80
  81         /* Make a copy because `vsnprintf` could change it */
  82         va_copy(args_for_counting, args);
  83
  84         /* Need space for null byte. */
  85         len = vsnprintf(NULL, 0, fmt, args_for_counting) + 1;
  86
  87         va_end(args_for_counting);
  88
  89         frag_container = alloc_string_stream_fragment(stream->test,
  90                                                       len,
  91                                                       stream->gfp);
  92         if (!frag_container)
  93                 return -ENOMEM;
  94
  95         len = vsnprintf(frag_container->fragment, len, fmt, args);
  96         spin_lock(&stream->lock);
  97         stream->length += len;
  98         list_add_tail(&frag_container->node, &stream->fragments);
  99         spin_unlock(&stream->lock);
 100
 101         return 0;
 102 }
 103
 104 int string_stream_add(struct string_stream *stream, const char *fmt, ...)
 105 {
 106         va_list args;
 107         int result;
 108
 109         va_start(args, fmt);
 110         result = string_stream_vadd(stream, fmt, args);
 111         va_end(args);
 112
 113         return result;
 114 }
 115
 116 static void string_stream_clear(struct string_stream *stream)
 117 {
 118         struct string_stream_fragment *frag_container, *frag_container_safe;
 119
 120         spin_lock(&stream->lock);
 121         list_for_each_entry_safe(frag_container,
 122                                  frag_container_safe,
 123                                  &stream->fragments,
 124                                  node) {
 125                 string_stream_fragment_destroy(frag_container);
 126         }
 127         stream->length = 0;
 128         spin_unlock(&stream->lock);
 129 }
 130
 131 char *string_stream_get_string(struct string_stream *stream)
 132 {
 133         struct string_stream_fragment *frag_container;
 134         size_t buf_len = stream->length + 1; /* +1 for null byte. */
 135         char *buf;
 136
 137         buf = kunit_kzalloc(stream->test, buf_len, stream->gfp);
 138         if (!buf)
 139                 return NULL;
 140
 141         spin_lock(&stream->lock);
 142         list_for_each_entry(frag_container, &stream->fragments, node)
 143                 strlcat(buf, frag_container->fragment, buf_len);
 144         spin_unlock(&stream->lock);
 145
 146         return buf;
 147 }
 148
 149 int string_stream_append(struct string_stream *stream,
 150                          struct string_stream *other)
 151 {
 152         const char *other_content;
 153
 154         other_content = string_stream_get_string(other);
 155
 156         if (!other_content)
 157                 return -ENOMEM;
 158
 159         return string_stream_add(stream, other_content);
 160 }
 161
 162 bool string_stream_is_empty(struct string_stream *stream)
 163 {
 164         return list_empty(&stream->fragments);
 165 }
 166
 167 struct string_stream_alloc_context {
 168         struct kunit *test;
 169         gfp_t gfp;
 170 };
 171
 172 static int string_stream_init(struct kunit_resource *res, void *context)
 173 {
 174         struct string_stream *stream;
 175         struct string_stream_alloc_context *ctx = context;
 176
 177         stream = kunit_kzalloc(ctx->test, sizeof(*stream), ctx->gfp);
 178         if (!stream)
 179                 return -ENOMEM;
 180
 181         res->allocation = stream;
 182         stream->gfp = ctx->gfp;
 183         stream->test = ctx->test;
 184         INIT_LIST_HEAD(&stream->fragments);
 185         spin_lock_init(&stream->lock);
 186
 187         return 0;
 188 }
 189
 190 static void string_stream_free(struct kunit_resource *res)
 191 {
 192         struct string_stream *stream = res->allocation;
 193
 194         string_stream_clear(stream);
 195 }
 196
 197 struct string_stream *alloc_string_stream(struct kunit *test, gfp_t gfp)
 198 {
 199         struct string_stream_alloc_context context = {
 200                 .test = test,
 201                 .gfp = gfp
 202         };
 203
 204         return kunit_alloc_resource(test,
 205                                     string_stream_init,
 206                                     string_stream_free,
 207                                     gfp,
 208                                     &context);
 209 }
 210
 211 int string_stream_destroy(struct string_stream *stream)
 212 {
 213         return kunit_resource_destroy(stream->test,
 214                                       kunit_resource_instance_match,
 215                                       string_stream_free,
 216                                       stream);
 217 }