1e653ed41279205a127c947c5da56abe64927f99
[multipath-tools/.git] / tests / vpd.c
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /* Copyright (c) 2019 Martin Wilck, SUSE Linux GmbH, Nuremberg */
3
4 #define _GNU_SOURCE
5 #include <sys/types.h>
6 #include <regex.h>
7 #include <ctype.h>
8 #include <stdio.h>
9 #include <stdint.h>
10 #include <stdlib.h>
11 #include <unistd.h>
12 #include <stdarg.h>
13 #include <stddef.h>
14 #include <setjmp.h>
15 #include <cmocka.h>
16 #include <scsi/sg.h>
17 #include "unaligned.h"
18 #include "debug.h"
19 #include "vector.h"
20 #include "structs.h"
21 #include "discovery.h"
22 #include "globals.c"
23
24 #define VPD_BUFSIZ 4096
25
26 struct vpdtest {
27         unsigned char vpdbuf[VPD_BUFSIZ];
28         char wwid[WWID_SIZE];
29 };
30
31 static int setup(void **state)
32 {
33         struct vpdtest *vt = malloc(sizeof(*vt));
34
35         if (vt == NULL)
36                 return -1;
37         *state = vt;
38         return 0;
39 }
40
41 static int teardown(void **state)
42 {
43         struct vpdtest *vt = *state;
44
45         free(vt);
46         *state = NULL;
47         return 0;
48 }
49
50 /* vendor_id should have less than 8 chars to test space handling */
51 static const char vendor_id[] = "Linux";
52 static const char test_id[] =
53         "A123456789AbcDefB123456789AbcDefC123456789AbcDefD123456789AbcDef";
54
55 int __wrap_ioctl(int fd, unsigned long request, void *param)
56 {
57         int len;
58         struct sg_io_hdr *io_hdr;
59         unsigned char *val;
60
61         len = mock();
62         io_hdr = (struct sg_io_hdr *)param;
63         assert_in_range(len, 0, io_hdr->dxfer_len);
64         val = mock_ptr_type(unsigned char *);
65         io_hdr->status = 0;
66         memcpy(io_hdr->dxferp, val, len);
67         return 0;
68 }
69
70
71 /**
72  * create_vpd80() - create a "unit serial number" VPD page.
73  * @buf:        VPD buffer
74  * @bufsiz:     length of VPD buffer
75  * @id:         input ID
76  * @size:       value for the "page length" field
77  * @len:        actual number of characters to use from @id
78  *
79  * If len < size, the content will be right aligned, as mandated by the
80  * SPC spec.
81  *
82  * Return:      VPD length.
83  */
84 static int create_vpd80(unsigned char *buf, size_t bufsiz, const char *id,
85                         int size, int len)
86 {
87         assert_true(len <= size);
88
89         memset(buf, 0, bufsiz);
90         buf[1] = 0x80;
91         put_unaligned_be16(size, buf + 2);
92
93         memset(buf + 4, ' ', size - len);
94         memcpy(buf + 4 + size - len, id, len);
95         return size + 4;
96 }
97
98 static int _hex2bin(const char hx)
99 {
100         assert_true(isxdigit(hx));
101         if (hx >= '0' && hx <= '9')
102                 return hx - '0';
103         if (hx >= 'a' && hx <= 'f')
104                 return hx - 'a' + 10;
105         if (hx >= 'A' && hx <= 'F')
106                 return hx - 'A' + 10;
107         return -1;
108 }
109
110 static void hex2bin(unsigned char *dst, const char *src,
111                     size_t dstlen, size_t srclen)
112 {
113         const char *sc;
114         unsigned char *ds;
115
116         assert(srclen % 2 == 0);
117         for (sc = src, ds = dst;
118              sc < src + srclen &&  ds < dst + dstlen;
119              sc += 2, ++ds)
120                 *ds = 16 * _hex2bin(sc[0]) + _hex2bin(sc[1]);
121 }
122
123 /**
124  * create_t10_vendor_id_desc() - Create T10 vendor ID
125  * @desc:       descriptor buffer
126  * @id:         input ID
127  * @n:          number of characters to use for ID
128  *              (includes 8 bytes for vendor ID!)
129  *
130  * Create a "T10 vendor specific ID" designation descriptor.
131  * The vendor field (8 bytes) is filled with vendor_id (above).
132  *
133  * Return:      descriptor length.
134  */
135 static int create_t10_vendor_id_desc(unsigned char *desc,
136                                      const char *id, size_t n)
137 {
138         int vnd_len = sizeof(vendor_id) - 1;
139
140         /* code set: ascii */
141         desc[0] = 2;
142         /* type: 10 vendor ID */
143         desc[1] = 1;
144         desc[2] = 0;
145         desc[3] = n;
146
147         memcpy(desc + 4, (const unsigned char *)vendor_id, vnd_len);
148         memset(desc + 4 + vnd_len, ' ', 8 - vnd_len);
149         memcpy(desc + 4 + 8, (const unsigned char *)id, n - 8);
150
151         return n + 4;
152 }
153
154 /**
155  * create_eui64_desc() - create EUI64 descriptor.
156  * @desc, @id:  see above.
157  * @n:          number of bytes (8, 12, or 16).
158  *
159  * Create an EUI64 designation descriptor.
160  *
161  * Return:      descriptor length.
162  */
163 static int create_eui64_desc(unsigned char *desc,
164                                  const char *id, size_t n)
165 {
166         assert_true(n == 8 || n == 12 || n == 16);
167
168         /* code set: binary */
169         desc[0] = 1;
170         /* type: EUI64 */
171         desc[1] = 2;
172         desc[2] = 0;
173         desc[3] = n;
174
175         hex2bin(desc + 4, id, n, 2 * n);
176         return n + 4;
177 }
178
179 /**
180  * create_naa_desc() - create an NAA designation descriptor
181  * @desc, @id:  see above.
182  * @naa:        Name Address Authority field (2, 3, 5, or 6).
183  *
184  * Return:      descriptor length.
185  */
186 static int create_naa_desc(unsigned char *desc,
187                                const char *id, int naa)
188 {
189         assert_true(naa == 2 || naa == 3 || naa == 5 || naa == 6);
190
191         /* code set: binary */
192         desc[0] = 1;
193         /* type: NAA */
194         desc[1] = 3;
195         desc[2] = 0;
196         desc[4] = _hex2bin(id[0]) | (naa << 4);
197         switch (naa) {
198         case 2:
199         case 3:
200         case 5:
201                 hex2bin(desc + 5, id + 1, 7, 14);
202                 desc[3] = 8;
203                 return 12;
204         case 6:
205                 hex2bin(desc + 5, id + 1, 15, 30);
206                 desc[3] = 16;
207                 return 20;
208         default:
209                 return 0;
210         }
211 }
212
213 /* type and flags for SCSI name string designation descriptor */
214 enum {
215         STR_EUI = 0,
216         STR_NAA,
217         STR_IQN,
218         STR_MASK = 0xf,
219         ZERO_LAST = 0x10,  /* flag to zero out some bytes at string end */
220 };
221
222 static const char * const str_prefix[] = {
223         [STR_EUI] = "eui.",
224         [STR_NAA] = "naa.",
225         [STR_IQN] = "iqn.",
226 };
227
228 static const char byte0[] = {
229         [STR_EUI] = '2',
230         [STR_NAA] = '3',
231         [STR_IQN] = '8',
232 };
233
234 /**
235  * create_scsi_string_desc() - create a SCSI name string descriptor.
236  * @desc, @id:  see above.
237  * @typ:        one of STR_EUI, STR_NAA, STR_IQN, possibly ORd with ZERO_LAST
238  * @maxlen:     number of characters to use from input ID.
239  *
240  * If ZERO_LAST is set, zero out the last byte.
241  *
242  * Return:      descriptor length.
243  */
244 static int create_scsi_string_desc(unsigned char *desc,
245                                    const char *id, int typ, int maxlen)
246 {
247         int len, plen;
248         int type = typ & STR_MASK;
249
250         /* code set: UTF-8 */
251         desc[0] = 3;
252         /* type: SCSI string */
253         desc[1] = 8;
254         desc[2] = 0;
255
256         assert_in_range(type, STR_EUI, STR_IQN);
257         assert_true(maxlen % 4 == 0);
258         len = snprintf((char *)(desc + 4), maxlen, "%s%s",
259                        str_prefix[type], id);
260         if (len > maxlen)
261                 len = maxlen;
262         /* zero-pad */
263         if (typ & ZERO_LAST)
264                 len -= 2;
265         plen = 4 * ((len - 1) / 4) + 4;
266         memset(desc + 4 + len, '\0', plen - len);
267         desc[3] = plen;
268         return plen + 4;
269 }
270
271 /**
272  * create_vpd83() - create "device identification" VPD page
273  * @buf, @bufsiz, @id:  see above.
274  * @type:       descriptor type to use (1, 2, 3, 8)
275  * @parm:       opaque parameter (e.g. means "naa" for NAA type)
276  * @len:        designator length (exact meaning depends on designator type)
277  *
278  * Create a "device identification" VPD page with a single
279  * designation descriptor.
280  *
281  * Return:      VPD page length.
282  */
283 static int create_vpd83(unsigned char *buf, size_t bufsiz, const char *id,
284                         uint8_t type, int parm, int len)
285 {
286         unsigned char *desc;
287         int n = 0;
288
289         memset(buf, 0, bufsiz);
290         buf[1] = 0x83;
291
292         desc = buf + 4;
293         switch (type) {
294         case 1:
295                 n = create_t10_vendor_id_desc(desc, id, len);
296                 break;
297         case 2:
298                 n = create_eui64_desc(desc, id, len);
299                 break;
300         case 3:
301                 n = create_naa_desc(desc, id, parm);
302                 break;
303         case 8:
304                 n = create_scsi_string_desc(desc, id, parm, len);
305                 break;
306         default:
307                 break;
308         }
309         put_unaligned_be16(n, buf + 2);
310         return n + 4;
311 }
312
313 /**
314  * assert_correct_wwid() - test that a retrieved WWID matches expectations
315  * @test:       test name
316  * @expected:   expected WWID length
317  * @returned:   WWID length as returned by code under test
318  * @byte0, @byte1: leading chars that our code prepends to the ID
319  *              (e.g. "36" for "NAA registered extended" type)
320  * @lowercase:  set if lower case WWID is expected
321  * @orig:       original ID string, may be longer than wwid
322  * @wwid:       WWID as returned by code under test
323  */
324 static void assert_correct_wwid(const char *test,
325                                 int expected, int returned,
326                                 int byte0, int byte1, bool lowercase,
327                                 const char *orig,
328                                 const char *wwid)
329 {
330         int ofs = 0, i;
331
332         condlog(2, "%s: exp/ret: %d/%d, wwid: %s", test,
333                 expected, returned, wwid);
334         /*
335          * byte0 and byte1 are the leading chars that our code prepends
336          * to the ID to indicate the designation descriptor type, .
337          */
338         if (byte0 != 0) {
339                 assert_int_equal(byte0, wwid[0]);
340                 ++ofs;
341         }
342         if (byte1 != 0) {
343                 assert_int_equal(byte1, wwid[1]);
344                 ++ofs;
345         }
346         /* check matching length, and length of WWID string */
347         assert_int_equal(expected, returned);
348         assert_int_equal(returned, strlen(wwid));
349         /* check expected string value up to expected length */
350         for (i = 0; i < returned - ofs; i++)
351                 assert_int_equal(wwid[ofs + i],
352                                  lowercase ? tolower(orig[i]) : orig[i]);
353 }
354
355 /*
356  * For T10 vendor ID - replace sequences of spaces with a single underscore.
357  * Use a different implementation then libmultipath, deliberately.
358  */
359 static char *subst_spaces(const char *src)
360 {
361         char *dst = calloc(1, strlen(src) + 1);
362         char *p;
363         static regex_t *re;
364         regmatch_t match;
365         int rc;
366
367         assert_non_null(dst);
368         if (re == NULL) {
369                 re = calloc(1, sizeof(*re));
370                 assert_non_null(re);
371                 rc = regcomp(re, " +", REG_EXTENDED);
372                 assert_int_equal(rc, 0);
373         }
374
375         for (rc = regexec(re, src, 1, &match, 0), p = dst;
376             rc == 0;
377             src += match.rm_eo, rc = regexec(re, src, 1, &match, 0)) {
378                 memcpy(p, src, match.rm_so);
379                 p += match.rm_so;
380                 *p = '_';
381                 ++p;
382         }
383         assert_int_equal(rc, REG_NOMATCH);
384         strcpy(p, src);
385         return dst;
386 }
387
388 /**
389  * test_vpd_vnd_LEN_WLEN() - test code for VPD 83, T10 vendor ID
390  * @LEN:        ID length in the VPD page (includes 8 byte vendor ID)
391  * @WLEN:       WWID buffer size
392  *
393  * The input ID is modified by inserting some spaces, to be able to
394  * test the handling of spaces by the code. This is relevant only for
395  * a minimum input length of 24.
396  * The expected result must be adjusted accordingly.
397  */
398 #define make_test_vpd_vnd(len, wlen)                                    \
399 static void test_vpd_vnd_ ## len ## _ ## wlen(void **state)             \
400 {                                                                       \
401         struct vpdtest *vt = *state;                                    \
402         int n, ret, rc;                                                 \
403         int exp_len;                                                    \
404         char *exp_wwid, *exp_subst, *input;                             \
405                                                                         \
406         input = strdup(test_id);                                        \
407         /* 8 vendor bytes collapsed to actual vendor ID length + 1 */   \
408         /* and one '1' prepended */                                     \
409         exp_len = len - 8 + sizeof(vendor_id) + 1;                      \
410                                                                         \
411         /* insert some spaces to test space collapsing */               \
412         input[15] = input[17] = input[18] = ' ';                        \
413         /* adjust expectation for space treatment */                    \
414         /* drop char for 2nd space on offset 17/18 */                   \
415         if (len >= 18 + 9)                                              \
416                 --exp_len;                                              \
417         /* drop trailing single '_' if input ends with space */         \
418         if (len == 15 + 9 || len == 17 + 9 || len == 18 + 9)            \
419                 --exp_len;                                              \
420         if (exp_len >= wlen)                                            \
421                 exp_len = wlen - 1;                                     \
422         n = create_vpd83(vt->vpdbuf, sizeof(vt->vpdbuf), input,         \
423                          1, 0, len);                                    \
424         rc = asprintf(&exp_wwid, "%s_%s", vendor_id, input);            \
425         assert_int_not_equal(rc, -1);                                   \
426         free(input);                                                    \
427         /* Replace spaces, like code under test */                      \
428         exp_subst = subst_spaces(exp_wwid);                             \
429         free(exp_wwid);                                                 \
430         will_return(__wrap_ioctl, n);                                   \
431         will_return(__wrap_ioctl, vt->vpdbuf);                          \
432         ret = get_vpd_sgio(10, 0x83, vt->wwid, wlen);                   \
433         assert_correct_wwid("test_vpd_vnd_" #len "_" #wlen,             \
434                             exp_len, ret, '1', 0, false,                \
435                             exp_subst, vt->wwid);                       \
436         free(exp_subst);                                                \
437 }
438
439 /**
440  * test_vpd_str_TYP_LEN_WLEN() - test code for VPD 83, SCSI name string
441  * @TYP:        numeric value of STR_EUI, STR_NAA, STR_IQN above
442  * @LEN:        ID length the VPD page
443  * @WLEN:       WWID buffer size
444  */
445 #define make_test_vpd_str(typ, len, wlen)                               \
446 static void test_vpd_str_ ## typ ## _ ## len ## _ ## wlen(void **state) \
447 {                                                                       \
448         struct vpdtest *vt = *state;                                    \
449         int n, ret;                                                     \
450         int exp_len;                                                    \
451         int type = typ & STR_MASK;                                      \
452                                                                         \
453         n = create_vpd83(vt->vpdbuf, sizeof(vt->vpdbuf), test_id,       \
454                          8, typ, len);                                  \
455         exp_len = len - strlen(str_prefix[type]);                       \
456         if (typ & ZERO_LAST)                                            \
457                 exp_len--;                                              \
458         if (exp_len >= wlen)                                            \
459                 exp_len = wlen - 1;                                     \
460         will_return(__wrap_ioctl, n);                                   \
461         will_return(__wrap_ioctl, vt->vpdbuf);                          \
462         ret = get_vpd_sgio(10, 0x83, vt->wwid, wlen);                   \
463         assert_correct_wwid("test_vpd_str_" #typ "_" #len "_" #wlen,    \
464                             exp_len, ret, byte0[type], 0,               \
465                             type != STR_IQN,                            \
466                             test_id, vt->wwid);                         \
467 }
468
469 /**
470  * test_vpd_naa_NAA_WLEN() - test code for VPD 83 NAA designation
471  * @NAA:        Network Name Authority (2, 3, 5, or 6)
472  * @WLEN:       WWID buffer size
473  */
474 #define make_test_vpd_naa(naa, wlen)                                    \
475 static void test_vpd_naa_ ## naa ## _ ## wlen(void **state)             \
476 {                                                                       \
477         struct vpdtest *vt = *state;                                    \
478         int n, ret;                                                     \
479         int len, exp_len;                                               \
480                                                                         \
481         switch (naa) {                                                  \
482         case 2:                                                         \
483         case 3:                                                         \
484         case 5:                                                         \
485                 len = 17;                                               \
486                 break;                                                  \
487         case 6:                                                         \
488                 len = 33;                                               \
489                 break;                                                  \
490         }                                                               \
491         /* returned size is always uneven */                            \
492         exp_len = wlen > len ? len :                                    \
493                 wlen % 2 == 0 ? wlen - 1 : wlen - 2;                    \
494                                                                         \
495         n = create_vpd83(vt->vpdbuf, sizeof(vt->vpdbuf), test_id,       \
496                          3, naa, 0);                                    \
497         will_return(__wrap_ioctl, n);                                   \
498         will_return(__wrap_ioctl, vt->vpdbuf);                          \
499         ret = get_vpd_sgio(10, 0x83, vt->wwid, wlen);                   \
500         assert_correct_wwid("test_vpd_naa_" #naa "_" #wlen,             \
501                             exp_len, ret, '3', '0' + naa, true,         \
502                             test_id, vt->wwid);                         \
503 }
504
505 /**
506  * test_vpd_eui_LEN_WLEN() - test code for VPD 83, EUI64
507  * @LEN:        EUI64 length (8, 12, or 16)
508  * @WLEN:       WWID buffer size
509  * @SML:        Use small VPD page size
510  */
511 #define make_test_vpd_eui(len, wlen, sml)                               \
512 static void test_vpd_eui_ ## len ## _ ## wlen ## _ ## sml(void **state) \
513 {                                                                       \
514         struct vpdtest *vt = *state;                                    \
515         int n, ret;                                                     \
516         /* returned size is always uneven */                            \
517         int exp_len = wlen > 2 * len + 1 ? 2 * len + 1 :                \
518                 wlen % 2 == 0 ? wlen - 1 : wlen - 2;                    \
519                                                                         \
520         n = create_vpd83(vt->vpdbuf, sizeof(vt->vpdbuf), test_id,       \
521                          2, 0, len);                                    \
522         if (sml) {                                                      \
523                 /* overwrite the page side to DEFAULT_SGIO_LEN + 1 */   \
524                 put_unaligned_be16(255, vt->vpdbuf + 2);                \
525                 will_return(__wrap_ioctl, n);                           \
526                 will_return(__wrap_ioctl, vt->vpdbuf);                  \
527         }                                                               \
528         will_return(__wrap_ioctl, n);                                   \
529         will_return(__wrap_ioctl, vt->vpdbuf);                          \
530         ret = get_vpd_sgio(10, 0x83, vt->wwid, wlen);                   \
531         assert_correct_wwid("test_vpd_eui_" #len "_" #wlen "_" #sml,    \
532                             exp_len, ret, '2', 0, true,                 \
533                             test_id, vt->wwid);                         \
534 }
535
536 /**
537  * test_vpd80_SIZE_LEN_WLEN() - test code for VPD 80
538  * @SIZE, @LEN: see create_vpd80()
539  * @WLEN:       WWID buffer size
540  */
541 #define make_test_vpd80(size, len, wlen)                                \
542 static void test_vpd80_ ## size ## _ ## len ## _ ## wlen(void **state)  \
543 {                                                                       \
544         struct vpdtest *vt = *state;                                    \
545         int n, ret;                                                     \
546         int exp_len = len > 20 ? 20 : len;                              \
547         char *input = strdup(test_id);                                  \
548                                                                         \
549         /* insert trailing whitespace after pos 20 */                   \
550         memset(input + 20, ' ', sizeof(test_id) - 20);                  \
551         if (exp_len >= wlen)                                            \
552                 exp_len = wlen - 1;                                     \
553         n = create_vpd80(vt->vpdbuf, sizeof(vt->vpdbuf), input,         \
554                          size, len);                                    \
555         will_return(__wrap_ioctl, n);                                   \
556         will_return(__wrap_ioctl, vt->vpdbuf);                          \
557         ret = get_vpd_sgio(10, 0x80, vt->wwid, wlen);                   \
558         assert_correct_wwid("test_vpd80_" #size "_" #len "_" #wlen,     \
559                             exp_len, ret, 0, 0, false,                  \
560                             input, vt->wwid);                           \
561         free(input);                                                    \
562 }
563
564 /* VPD 80 */
565 /* Tests without trailing whitespace: 21 WWID bytes required */
566 make_test_vpd80(20, 20, 30);
567 make_test_vpd80(20, 20, 21);
568 make_test_vpd80(20, 20, 20);
569 make_test_vpd80(20, 20, 10);
570
571 /* Tests with 4 byte trailing whitespace: 21 WWID bytes required */
572 make_test_vpd80(24, 24, 30);
573 make_test_vpd80(24, 24, 25);
574 make_test_vpd80(24, 24, 24);
575 make_test_vpd80(24, 24, 21);
576 make_test_vpd80(24, 24, 20);
577
578 /* Tests with 4 byte leading whitespace: 17 WWID bytes required */
579 make_test_vpd80(20, 16, 30);
580 make_test_vpd80(20, 16, 17);
581 make_test_vpd80(20, 16, 16);
582
583 /* Tests with 4 byte leading whitespace: 21 WWID bytes required */
584 make_test_vpd80(24, 20, 21);
585 make_test_vpd80(24, 20, 20);
586
587 /* Tests with leading and trailing whitespace: 21 WWID bytes required */
588 make_test_vpd80(30, 24, 30);
589 make_test_vpd80(30, 24, 21);
590 make_test_vpd80(30, 24, 20);
591
592 /* VPD 83, T10 vendor ID */
593 make_test_vpd_vnd(40, 40);
594 make_test_vpd_vnd(40, 30);
595 make_test_vpd_vnd(30, 20);
596 make_test_vpd_vnd(29, 30);
597 make_test_vpd_vnd(28, 30);
598 make_test_vpd_vnd(27, 30); /* space at end */
599 make_test_vpd_vnd(26, 30); /* space at end */
600 make_test_vpd_vnd(25, 30);
601 make_test_vpd_vnd(24, 30); /* space at end */
602 make_test_vpd_vnd(23, 30);
603 make_test_vpd_vnd(24, 20);
604 make_test_vpd_vnd(23, 20);
605 make_test_vpd_vnd(22, 20);
606 make_test_vpd_vnd(21, 20);
607 make_test_vpd_vnd(20, 20);
608 make_test_vpd_vnd(19, 20);
609 make_test_vpd_vnd(20, 10);
610 make_test_vpd_vnd(10, 10);
611
612 /* EUI64 tests */
613 /* small vpd page test */
614 make_test_vpd_eui(8, 32, 1);
615 make_test_vpd_eui(12, 32, 1);
616 make_test_vpd_eui(16, 40, 1);
617
618 /* 64bit, WWID size: 18 */
619 make_test_vpd_eui(8, 32, 0);
620 make_test_vpd_eui(8, 18, 0);
621 make_test_vpd_eui(8, 17, 0);
622 make_test_vpd_eui(8, 16, 0);
623 make_test_vpd_eui(8, 10, 0);
624
625 /* 96 bit, WWID size: 26 */
626 make_test_vpd_eui(12, 32, 0);
627 make_test_vpd_eui(12, 26, 0);
628 make_test_vpd_eui(12, 25, 0);
629 make_test_vpd_eui(12, 20, 0);
630 make_test_vpd_eui(12, 10, 0);
631
632 /* 128 bit, WWID size: 34 */
633 make_test_vpd_eui(16, 40, 0);
634 make_test_vpd_eui(16, 34, 0);
635 make_test_vpd_eui(16, 33, 0);
636 make_test_vpd_eui(16, 20, 0);
637
638 /* NAA IEEE registered extended (36), WWID size: 34 */
639 make_test_vpd_naa(6, 40);
640 make_test_vpd_naa(6, 34);
641 make_test_vpd_naa(6, 33);
642 make_test_vpd_naa(6, 32);
643 make_test_vpd_naa(6, 20);
644
645 /* NAA IEEE registered (35), WWID size: 18 */
646 make_test_vpd_naa(5, 20);
647 make_test_vpd_naa(5, 18);
648 make_test_vpd_naa(5, 17);
649 make_test_vpd_naa(5, 16);
650
651 /* NAA local (33), WWID size: 18 */
652 make_test_vpd_naa(3, 20);
653 make_test_vpd_naa(3, 18);
654 make_test_vpd_naa(3, 17);
655 make_test_vpd_naa(3, 16);
656
657 /* NAA IEEE extended (32), WWID size: 18 */
658 make_test_vpd_naa(2, 20);
659 make_test_vpd_naa(2, 18);
660 make_test_vpd_naa(2, 17);
661 make_test_vpd_naa(2, 16);
662
663 /* SCSI Name string: EUI64, WWID size: 17 */
664 make_test_vpd_str(0, 20, 18)
665 make_test_vpd_str(0, 20, 17)
666 make_test_vpd_str(0, 20, 16)
667 make_test_vpd_str(0, 20, 15)
668
669 /* SCSI Name string: EUI64, zero padded, WWID size: 16 */
670 make_test_vpd_str(16, 20, 18)
671 make_test_vpd_str(16, 20, 17)
672 make_test_vpd_str(16, 20, 16)
673 make_test_vpd_str(16, 20, 15)
674
675 /* SCSI Name string: NAA, WWID size: 17 */
676 make_test_vpd_str(1, 20, 18)
677 make_test_vpd_str(1, 20, 17)
678 make_test_vpd_str(1, 20, 16)
679 make_test_vpd_str(1, 20, 15)
680
681 /* SCSI Name string: NAA, zero padded, WWID size: 16 */
682 make_test_vpd_str(17, 20, 18)
683 make_test_vpd_str(17, 20, 17)
684 make_test_vpd_str(17, 20, 16)
685 make_test_vpd_str(17, 20, 15)
686
687 /* SCSI Name string: IQN, WWID size: 17 */
688 make_test_vpd_str(2, 20, 18)
689 make_test_vpd_str(2, 20, 17)
690 make_test_vpd_str(2, 20, 16)
691 make_test_vpd_str(2, 20, 15)
692
693 /* SCSI Name string: IQN, zero padded, WWID size: 16 */
694 make_test_vpd_str(18, 20, 18)
695 make_test_vpd_str(18, 20, 17)
696 make_test_vpd_str(18, 20, 16)
697 make_test_vpd_str(18, 20, 15)
698
699 static int test_vpd(void)
700 {
701         const struct CMUnitTest tests[] = {
702                 cmocka_unit_test(test_vpd80_20_20_30),
703                 cmocka_unit_test(test_vpd80_20_20_21),
704                 cmocka_unit_test(test_vpd80_20_20_20),
705                 cmocka_unit_test(test_vpd80_20_20_10),
706                 cmocka_unit_test(test_vpd80_24_24_30),
707                 cmocka_unit_test(test_vpd80_24_24_25),
708                 cmocka_unit_test(test_vpd80_24_24_24),
709                 cmocka_unit_test(test_vpd80_24_24_21),
710                 cmocka_unit_test(test_vpd80_24_24_20),
711                 cmocka_unit_test(test_vpd80_20_16_30),
712                 cmocka_unit_test(test_vpd80_20_16_17),
713                 cmocka_unit_test(test_vpd80_20_16_16),
714                 cmocka_unit_test(test_vpd80_24_20_21),
715                 cmocka_unit_test(test_vpd80_24_20_20),
716                 cmocka_unit_test(test_vpd80_30_24_30),
717                 cmocka_unit_test(test_vpd80_30_24_21),
718                 cmocka_unit_test(test_vpd80_30_24_20),
719                 cmocka_unit_test(test_vpd_vnd_40_40),
720                 cmocka_unit_test(test_vpd_vnd_40_30),
721                 cmocka_unit_test(test_vpd_vnd_30_20),
722                 cmocka_unit_test(test_vpd_vnd_29_30),
723                 cmocka_unit_test(test_vpd_vnd_28_30),
724                 cmocka_unit_test(test_vpd_vnd_27_30),
725                 cmocka_unit_test(test_vpd_vnd_26_30),
726                 cmocka_unit_test(test_vpd_vnd_25_30),
727                 cmocka_unit_test(test_vpd_vnd_24_30),
728                 cmocka_unit_test(test_vpd_vnd_23_30),
729                 cmocka_unit_test(test_vpd_vnd_24_20),
730                 cmocka_unit_test(test_vpd_vnd_23_20),
731                 cmocka_unit_test(test_vpd_vnd_22_20),
732                 cmocka_unit_test(test_vpd_vnd_21_20),
733                 cmocka_unit_test(test_vpd_vnd_20_20),
734                 cmocka_unit_test(test_vpd_vnd_19_20),
735                 cmocka_unit_test(test_vpd_vnd_20_10),
736                 cmocka_unit_test(test_vpd_vnd_10_10),
737                 cmocka_unit_test(test_vpd_eui_8_32_1),
738                 cmocka_unit_test(test_vpd_eui_12_32_1),
739                 cmocka_unit_test(test_vpd_eui_16_40_1),
740                 cmocka_unit_test(test_vpd_eui_8_32_0),
741                 cmocka_unit_test(test_vpd_eui_8_18_0),
742                 cmocka_unit_test(test_vpd_eui_8_17_0),
743                 cmocka_unit_test(test_vpd_eui_8_16_0),
744                 cmocka_unit_test(test_vpd_eui_8_10_0),
745                 cmocka_unit_test(test_vpd_eui_12_32_0),
746                 cmocka_unit_test(test_vpd_eui_12_26_0),
747                 cmocka_unit_test(test_vpd_eui_12_25_0),
748                 cmocka_unit_test(test_vpd_eui_12_20_0),
749                 cmocka_unit_test(test_vpd_eui_12_10_0),
750                 cmocka_unit_test(test_vpd_eui_16_40_0),
751                 cmocka_unit_test(test_vpd_eui_16_34_0),
752                 cmocka_unit_test(test_vpd_eui_16_33_0),
753                 cmocka_unit_test(test_vpd_eui_16_20_0),
754                 cmocka_unit_test(test_vpd_naa_6_40),
755                 cmocka_unit_test(test_vpd_naa_6_34),
756                 cmocka_unit_test(test_vpd_naa_6_33),
757                 cmocka_unit_test(test_vpd_naa_6_32),
758                 cmocka_unit_test(test_vpd_naa_6_20),
759                 cmocka_unit_test(test_vpd_naa_5_20),
760                 cmocka_unit_test(test_vpd_naa_5_18),
761                 cmocka_unit_test(test_vpd_naa_5_17),
762                 cmocka_unit_test(test_vpd_naa_5_16),
763                 cmocka_unit_test(test_vpd_naa_3_20),
764                 cmocka_unit_test(test_vpd_naa_3_18),
765                 cmocka_unit_test(test_vpd_naa_3_17),
766                 cmocka_unit_test(test_vpd_naa_3_16),
767                 cmocka_unit_test(test_vpd_naa_2_20),
768                 cmocka_unit_test(test_vpd_naa_2_18),
769                 cmocka_unit_test(test_vpd_naa_2_17),
770                 cmocka_unit_test(test_vpd_naa_2_16),
771                 cmocka_unit_test(test_vpd_str_0_20_18),
772                 cmocka_unit_test(test_vpd_str_0_20_17),
773                 cmocka_unit_test(test_vpd_str_0_20_16),
774                 cmocka_unit_test(test_vpd_str_0_20_15),
775                 cmocka_unit_test(test_vpd_str_16_20_18),
776                 cmocka_unit_test(test_vpd_str_16_20_17),
777                 cmocka_unit_test(test_vpd_str_16_20_16),
778                 cmocka_unit_test(test_vpd_str_16_20_15),
779                 cmocka_unit_test(test_vpd_str_1_20_18),
780                 cmocka_unit_test(test_vpd_str_1_20_17),
781                 cmocka_unit_test(test_vpd_str_1_20_16),
782                 cmocka_unit_test(test_vpd_str_1_20_15),
783                 cmocka_unit_test(test_vpd_str_17_20_18),
784                 cmocka_unit_test(test_vpd_str_17_20_17),
785                 cmocka_unit_test(test_vpd_str_17_20_16),
786                 cmocka_unit_test(test_vpd_str_17_20_15),
787                 cmocka_unit_test(test_vpd_str_2_20_18),
788                 cmocka_unit_test(test_vpd_str_2_20_17),
789                 cmocka_unit_test(test_vpd_str_2_20_16),
790                 cmocka_unit_test(test_vpd_str_2_20_15),
791                 cmocka_unit_test(test_vpd_str_18_20_18),
792                 cmocka_unit_test(test_vpd_str_18_20_17),
793                 cmocka_unit_test(test_vpd_str_18_20_16),
794                 cmocka_unit_test(test_vpd_str_18_20_15),
795         };
796         return cmocka_run_group_tests(tests, setup, teardown);
797 }
798
799 int main(void)
800 {
801         int ret = 0;
802
803         ret += test_vpd();
804         return ret;
805 }