test mbuf attach
[dpdk.git] / app / test / resource.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2016 RehiveTech. All rights reserved.
3  */
4
5 #include <stdio.h>
6 #include <string.h>
7 #include <errno.h>
8 #include <sys/queue.h>
9
10 #include <rte_debug.h>
11
12 #include "resource.h"
13
14 struct resource_list resource_list = TAILQ_HEAD_INITIALIZER(resource_list);
15
16 size_t resource_size(const struct resource *r)
17 {
18         return r->end - r->begin;
19 }
20
21 const struct resource *resource_find(const char *name)
22 {
23         struct resource *r;
24
25         TAILQ_FOREACH(r, &resource_list, next) {
26                 RTE_VERIFY(r->name);
27
28                 if (!strcmp(r->name, name))
29                         return r;
30         }
31
32         return NULL;
33 }
34
35 int resource_fwrite(const struct resource *r, FILE *f)
36 {
37         const size_t goal = resource_size(r);
38         size_t total = 0;
39
40         while (total < goal) {
41                 size_t wlen = fwrite(r->begin + total, 1, goal - total, f);
42                 if (wlen == 0) {
43                         perror(__func__);
44                         return -1;
45                 }
46
47                 total += wlen;
48         }
49
50         return 0;
51 }
52
53 int resource_fwrite_file(const struct resource *r, const char *fname)
54 {
55         FILE *f;
56         int ret;
57
58         f = fopen(fname, "w");
59         if (f == NULL) {
60                 perror(__func__);
61                 return -1;
62         }
63
64         ret = resource_fwrite(r, f);
65         fclose(f);
66         return ret;
67 }
68
69 #ifdef RTE_APP_TEST_RESOURCE_TAR
70 #include <archive.h>
71 #include <archive_entry.h>
72
73 static int do_copy(struct archive *r, struct archive *w)
74 {
75         const void *buf;
76         size_t len;
77 #if ARCHIVE_VERSION_NUMBER >= 3000000
78         int64_t off;
79 #else
80         off_t off;
81 #endif
82         int ret;
83
84         while (1) {
85                 ret = archive_read_data_block(r, &buf, &len, &off);
86                 if (ret == ARCHIVE_RETRY)
87                         continue;
88
89                 if (ret == ARCHIVE_EOF)
90                         return 0;
91
92                 if (ret != ARCHIVE_OK)
93                         return ret;
94
95                 do {
96                         ret = archive_write_data_block(w, buf, len, off);
97                         if (ret != ARCHIVE_OK && ret != ARCHIVE_RETRY)
98                                 return ret;
99                 } while (ret != ARCHIVE_OK);
100         }
101 }
102
103 int resource_untar(const struct resource *res)
104 {
105         struct archive *r;
106         struct archive *w;
107         struct archive_entry *e;
108         void *p;
109         int flags = 0;
110         int ret;
111
112         p = malloc(resource_size(res));
113         if (p == NULL)
114                 rte_panic("Failed to malloc %zu B\n", resource_size(res));
115
116         memcpy(p, res->begin, resource_size(res));
117
118         r = archive_read_new();
119         if (r == NULL) {
120                 free(p);
121                 return -1;
122         }
123
124         archive_read_support_format_all(r);
125         archive_read_support_filter_all(r);
126
127         w = archive_write_disk_new();
128         if (w == NULL) {
129                 archive_read_free(r);
130                 free(p);
131                 return -1;
132         }
133
134         flags |= ARCHIVE_EXTRACT_PERM;
135         flags |= ARCHIVE_EXTRACT_FFLAGS;
136         archive_write_disk_set_options(w, flags);
137         archive_write_disk_set_standard_lookup(w);
138
139         ret = archive_read_open_memory(r, p, resource_size(res));
140         if (ret != ARCHIVE_OK)
141                 goto fail;
142
143         while (1) {
144                 ret = archive_read_next_header(r, &e);
145                 if (ret == ARCHIVE_EOF)
146                         break;
147                 if (ret != ARCHIVE_OK)
148                         goto fail;
149
150                 ret = archive_write_header(w, e);
151                 if (ret == ARCHIVE_EOF)
152                         break;
153                 if (ret != ARCHIVE_OK)
154                         goto fail;
155
156                 if (archive_entry_size(e) == 0)
157                         continue;
158
159                 ret = do_copy(r, w);
160                 if (ret != ARCHIVE_OK)
161                         goto fail;
162
163                 ret = archive_write_finish_entry(w);
164                 if (ret != ARCHIVE_OK)
165                         goto fail;
166         }
167
168         archive_write_free(w);
169         archive_read_free(r);
170         free(p);
171         return 0;
172
173 fail:
174         archive_write_free(w);
175         archive_read_free(r);
176         free(p);
177         rte_panic("Failed: %s\n", archive_error_string(r));
178         return -1;
179 }
180
181 int resource_rm_by_tar(const struct resource *res)
182 {
183         struct archive *r;
184         struct archive_entry *e;
185         void *p;
186         int try_again = 1;
187         int attempts = 0;
188         int ret;
189
190         p = malloc(resource_size(res));
191         if (p == NULL)
192                 rte_panic("Failed to malloc %zu B\n", resource_size(res));
193
194         memcpy(p, res->begin, resource_size(res));
195
196         /*
197          * If somebody creates a file somewhere inside the extracted TAR
198          * hierarchy during a test the resource_rm_by_tar might loop
199          * infinitely. We prevent this by adding the attempts counter there.
200          * In normal case, max N iteration is done where N is the depth of
201          * the file-hierarchy.
202          */
203         while (try_again && attempts < 10000) {
204                 r = archive_read_new();
205                 if (r == NULL) {
206                         free(p);
207                         return -1;
208                 }
209
210                 archive_read_support_format_all(r);
211                 archive_read_support_filter_all(r);
212
213                 ret = archive_read_open_memory(r, p, resource_size(res));
214                 if (ret != ARCHIVE_OK) {
215                         fprintf(stderr, "Failed: %s\n",
216                                         archive_error_string(r));
217                         goto fail;
218                 }
219
220                 try_again = 0;
221
222                 while (1) {
223                         ret = archive_read_next_header(r, &e);
224                         if (ret == ARCHIVE_EOF)
225                                 break;
226                         if (ret != ARCHIVE_OK)
227                                 goto fail;
228
229                         ret = remove(archive_entry_pathname(e));
230                         if (ret < 0) {
231                                 switch (errno) {
232                                 case ENOTEMPTY:
233                                 case EEXIST:
234                                         try_again = 1;
235                                         break;
236
237                                 /* should not usually happen: */
238                                 case ENOENT:
239                                 case ENOTDIR:
240                                 case EROFS:
241                                         attempts += 1;
242                                         continue;
243                                 default:
244                                         perror("Failed to remove file");
245                                         goto fail;
246                                 }
247                         }
248                 }
249
250                 archive_read_free(r);
251                 attempts += 1;
252         }
253
254         if (attempts >= 10000) {
255                 fprintf(stderr, "Failed to remove archive\n");
256                 free(p);
257                 return -1;
258         }
259
260         free(p);
261         return 0;
262
263 fail:
264         archive_read_free(r);
265         free(p);
266
267         rte_panic("Failed: %s\n", archive_error_string(r));
268         return -1;
269 }
270
271 #endif /* RTE_APP_TEST_RESOURCE_TAR */
272
273 void resource_register(struct resource *r)
274 {
275         TAILQ_INSERT_TAIL(&resource_list, r, next);
276 }