1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
|
/*-
* BSD LICENSE
*
* Copyright (c) Intel Corporation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* This is a simple example of a virtual block device module that passes IO
* down to a bdev (or bdevs) that its configured to attach to.
*/
#include "vbdev_passthru.h"
#include "spdk/env.h"
#include "spdk/conf.h"
#include "spdk/endian.h"
#include "spdk/thread.h"
static int vbdev_ext_passthru_init(void);
static void vbdev_ext_passthru_get_spdk_running_config(FILE *fp);
static int vbdev_ext_passthru_get_ctx_size(void);
static void vbdev_ext_passthru_examine(struct spdk_bdev *bdev);
static void vbdev_ext_passthru_finish(void);
static int vbdev_ext_passthru_config_json(struct spdk_json_write_ctx *w);
static struct spdk_bdev_module passthru_if_external = {
.name = "passthru_external",
.module_init = vbdev_ext_passthru_init,
.config_text = vbdev_ext_passthru_get_spdk_running_config,
.get_ctx_size = vbdev_ext_passthru_get_ctx_size,
.examine_config = vbdev_ext_passthru_examine,
.module_fini = vbdev_ext_passthru_finish,
.config_json = vbdev_ext_passthru_config_json
};
SPDK_BDEV_MODULE_REGISTER(passthru, &passthru_if_external)
/* List of pt_bdev names and their base bdevs via configuration file.
* Used so we can parse the conf once at init and use this list in examine().
*/
struct bdev_names {
char *vbdev_name;
char *bdev_name;
TAILQ_ENTRY(bdev_names) link;
};
static TAILQ_HEAD(, bdev_names) g_bdev_names = TAILQ_HEAD_INITIALIZER(g_bdev_names);
/* List of virtual bdevs and associated info for each. */
struct vbdev_passthru {
struct spdk_bdev *base_bdev; /* the thing we're attaching to */
struct spdk_bdev_desc *base_desc; /* its descriptor we get from open */
struct spdk_bdev pt_bdev; /* the PT virtual bdev */
TAILQ_ENTRY(vbdev_passthru) link;
};
static TAILQ_HEAD(, vbdev_passthru) g_pt_nodes = TAILQ_HEAD_INITIALIZER(g_pt_nodes);
/* The pt vbdev channel struct. It is allocated and freed on my behalf by the io channel code.
* If this vbdev needed to implement a poller or a queue for IO, this is where those things
* would be defined. This passthru bdev doesn't actually need to allocate a channel, it could
* simply pass back the channel of the bdev underneath it but for example purposes we will
* present its own to the upper layers.
*/
struct pt_io_channel {
struct spdk_io_channel *base_ch; /* IO channel of base device */
};
/* Just for fun, this pt_bdev module doesn't need it but this is essentially a per IO
* context that we get handed by the bdev layer.
*/
struct passthru_bdev_io {
uint8_t test;
/* bdev related */
struct spdk_io_channel *ch;
/* for bdev_io_wait */
struct spdk_bdev_io_wait_entry bdev_io_wait;
};
static void
vbdev_passthru_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io);
/* Callback for unregistering the IO device. */
static void
_device_unregister_cb(void *io_device)
{
struct vbdev_passthru *pt_node = io_device;
/* Done with this pt_node. */
free(pt_node->pt_bdev.name);
free(pt_node);
}
/* Called after we've unregistered following a hot remove callback.
* Our finish entry point will be called next.
*/
static int
vbdev_passthru_destruct(void *ctx)
{
struct vbdev_passthru *pt_node = (struct vbdev_passthru *)ctx;
/* It is important to follow this exact sequence of steps for destroying
* a vbdev...
*/
TAILQ_REMOVE(&g_pt_nodes, pt_node, link);
/* Unclaim the underlying bdev. */
spdk_bdev_module_release_bdev(pt_node->base_bdev);
/* Close the underlying bdev. */
spdk_bdev_close(pt_node->base_desc);
/* Unregister the io_device. */
spdk_io_device_unregister(pt_node, _device_unregister_cb);
return 0;
}
/* Completion callback for IO that were issued from this bdev. The original bdev_io
* is passed in as an arg so we'll complete that one with the appropriate status
* and then free the one that this module issued.
*/
static void
_pt_complete_io(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
{
struct spdk_bdev_io *orig_io = cb_arg;
int status = success ? SPDK_BDEV_IO_STATUS_SUCCESS : SPDK_BDEV_IO_STATUS_FAILED;
struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)orig_io->driver_ctx;
/* We setup this value in the submission routine, just showing here that it is
* passed back to us.
*/
if (io_ctx->test != 0x5a) {
SPDK_ERRLOG("Error, original IO device_ctx is wrong! 0x%x\n",
io_ctx->test);
}
/* Complete the original IO and then free the one that we created here
* as a result of issuing an IO via submit_reqeust.
*/
spdk_bdev_io_complete(orig_io, status);
spdk_bdev_free_io(bdev_io);
}
static void
vbdev_passthru_resubmit_io(void *arg)
{
struct spdk_bdev_io *bdev_io = (struct spdk_bdev_io *)arg;
struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)bdev_io->driver_ctx;
vbdev_passthru_submit_request(io_ctx->ch, bdev_io);
}
static void
vbdev_passthru_queue_io(struct spdk_bdev_io *bdev_io)
{
struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)bdev_io->driver_ctx;
int rc;
io_ctx->bdev_io_wait.bdev = bdev_io->bdev;
io_ctx->bdev_io_wait.cb_fn = vbdev_passthru_resubmit_io;
io_ctx->bdev_io_wait.cb_arg = bdev_io;
rc = spdk_bdev_queue_io_wait(bdev_io->bdev, io_ctx->ch, &io_ctx->bdev_io_wait);
if (rc != 0) {
SPDK_ERRLOG("Queue io failed in vbdev_passthru_queue_io, rc=%d.\n", rc);
spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
}
}
/* Callback for getting a buf from the bdev pool in the event that the caller passed
* in NULL, we need to own the buffer so it doesn't get freed by another vbdev module
* beneath us before we're done with it. That won't happen in this example but it could
* if this example were used as a template for something more complex.
*/
static void
pt_read_get_buf_cb(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io, bool success)
{
struct vbdev_passthru *pt_node = SPDK_CONTAINEROF(bdev_io->bdev, struct vbdev_passthru,
pt_bdev);
struct pt_io_channel *pt_ch = spdk_io_channel_get_ctx(ch);
struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)bdev_io->driver_ctx;
int rc;
if (!success) {
spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
return;
}
if (bdev_io->u.bdev.md_buf == NULL) {
rc = spdk_bdev_readv_blocks(pt_node->base_desc, pt_ch->base_ch, bdev_io->u.bdev.iovs,
bdev_io->u.bdev.iovcnt, bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks, _pt_complete_io,
bdev_io);
} else {
rc = spdk_bdev_readv_blocks_with_md(pt_node->base_desc, pt_ch->base_ch,
bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,
bdev_io->u.bdev.md_buf,
bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks,
_pt_complete_io, bdev_io);
}
if (rc != 0) {
if (rc == -ENOMEM) {
SPDK_ERRLOG("No memory, start to queue io for passthru.\n");
io_ctx->ch = ch;
vbdev_passthru_queue_io(bdev_io);
} else {
SPDK_ERRLOG("ERROR on bdev_io submission!\n");
spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
}
}
}
/* Called when someone above submits IO to this pt vbdev. We're simply passing it on here
* via SPDK IO calls which in turn allocate another bdev IO and call our cpl callback provided
* below along with the original bdiv_io so that we can complete it once this IO completes.
*/
static void
vbdev_passthru_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
{
struct vbdev_passthru *pt_node = SPDK_CONTAINEROF(bdev_io->bdev, struct vbdev_passthru, pt_bdev);
struct pt_io_channel *pt_ch = spdk_io_channel_get_ctx(ch);
struct passthru_bdev_io *io_ctx = (struct passthru_bdev_io *)bdev_io->driver_ctx;
int rc = 0;
/* Setup a per IO context value; we don't do anything with it in the vbdev other
* than confirm we get the same thing back in the completion callback just to
* demonstrate.
*/
io_ctx->test = 0x5a;
switch (bdev_io->type) {
case SPDK_BDEV_IO_TYPE_READ:
spdk_bdev_io_get_buf(bdev_io, pt_read_get_buf_cb,
bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen);
break;
case SPDK_BDEV_IO_TYPE_WRITE:
if (bdev_io->u.bdev.md_buf == NULL) {
rc = spdk_bdev_writev_blocks(pt_node->base_desc, pt_ch->base_ch, bdev_io->u.bdev.iovs,
bdev_io->u.bdev.iovcnt, bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks, _pt_complete_io,
bdev_io);
} else {
rc = spdk_bdev_writev_blocks_with_md(pt_node->base_desc, pt_ch->base_ch,
bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,
bdev_io->u.bdev.md_buf,
bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks,
_pt_complete_io, bdev_io);
}
break;
case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
rc = spdk_bdev_write_zeroes_blocks(pt_node->base_desc, pt_ch->base_ch,
bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks,
_pt_complete_io, bdev_io);
break;
case SPDK_BDEV_IO_TYPE_UNMAP:
rc = spdk_bdev_unmap_blocks(pt_node->base_desc, pt_ch->base_ch,
bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks,
_pt_complete_io, bdev_io);
break;
case SPDK_BDEV_IO_TYPE_FLUSH:
rc = spdk_bdev_flush_blocks(pt_node->base_desc, pt_ch->base_ch,
bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks,
_pt_complete_io, bdev_io);
break;
case SPDK_BDEV_IO_TYPE_RESET:
rc = spdk_bdev_reset(pt_node->base_desc, pt_ch->base_ch,
_pt_complete_io, bdev_io);
break;
default:
SPDK_ERRLOG("passthru: unknown I/O type %d\n", bdev_io->type);
spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
return;
}
if (rc != 0) {
if (rc == -ENOMEM) {
SPDK_ERRLOG("No memory, start to queue io for passthru.\n");
io_ctx->ch = ch;
vbdev_passthru_queue_io(bdev_io);
} else {
SPDK_ERRLOG("ERROR on bdev_io submission!\n");
spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
}
}
}
/* We'll just call the base bdev and let it answer however if we were more
* restrictive for some reason (or less) we could get the response back
* and modify according to our purposes.
*/
static bool
vbdev_passthru_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
{
struct vbdev_passthru *pt_node = (struct vbdev_passthru *)ctx;
return spdk_bdev_io_type_supported(pt_node->base_bdev, io_type);
}
/* We supplied this as an entry point for upper layers who want to communicate to this
* bdev. This is how they get a channel. We are passed the same context we provided when
* we created our PT vbdev in examine() which, for this bdev, is the address of one of
* our context nodes. From here we'll ask the SPDK channel code to fill out our channel
* struct and we'll keep it in our PT node.
*/
static struct spdk_io_channel *
vbdev_passthru_get_io_channel(void *ctx)
{
struct vbdev_passthru *pt_node = (struct vbdev_passthru *)ctx;
struct spdk_io_channel *pt_ch = NULL;
/* The IO channel code will allocate a channel for us which consists of
* the SPDK channel structure plus the size of our pt_io_channel struct
* that we passed in when we registered our IO device. It will then call
* our channel create callback to populate any elements that we need to
* update.
*/
pt_ch = spdk_get_io_channel(pt_node);
return pt_ch;
}
/* This is the output for get_bdevs() for this vbdev */
static int
vbdev_passthru_dump_info_json(void *ctx, struct spdk_json_write_ctx *w)
{
struct vbdev_passthru *pt_node = (struct vbdev_passthru *)ctx;
spdk_json_write_name(w, "passthru");
spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "name", spdk_bdev_get_name(&pt_node->pt_bdev));
spdk_json_write_named_string(w, "base_bdev_name", spdk_bdev_get_name(pt_node->base_bdev));
spdk_json_write_object_end(w);
return 0;
}
/* This is used to generate JSON that can configure this module to its current state. */
static int
vbdev_ext_passthru_config_json(struct spdk_json_write_ctx *w)
{
struct vbdev_passthru *pt_node;
TAILQ_FOREACH(pt_node, &g_pt_nodes, link) {
spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "method", "construct_passthru_bdev");
spdk_json_write_named_object_begin(w, "params");
spdk_json_write_named_string(w, "base_bdev_name", spdk_bdev_get_name(pt_node->base_bdev));
spdk_json_write_named_string(w, "name", spdk_bdev_get_name(&pt_node->pt_bdev));
spdk_json_write_object_end(w);
spdk_json_write_object_end(w);
}
return 0;
}
/* We provide this callback for the SPDK channel code to create a channel using
* the channel struct we provided in our module get_io_channel() entry point. Here
* we get and save off an underlying base channel of the device below us so that
* we can communicate with the base bdev on a per channel basis. If we needed
* our own poller for this vbdev, we'd register it here.
*/
static int
pt_bdev_ch_create_cb(void *io_device, void *ctx_buf)
{
struct pt_io_channel *pt_ch = ctx_buf;
struct vbdev_passthru *pt_node = io_device;
pt_ch->base_ch = spdk_bdev_get_io_channel(pt_node->base_desc);
return 0;
}
/* We provide this callback for the SPDK channel code to destroy a channel
* created with our create callback. We just need to undo anything we did
* when we created. If this bdev used its own poller, we'd unregsiter it here.
*/
static void
pt_bdev_ch_destroy_cb(void *io_device, void *ctx_buf)
{
struct pt_io_channel *pt_ch = ctx_buf;
spdk_put_io_channel(pt_ch->base_ch);
}
/* Create the passthru association from the bdev and vbdev name and insert
* on the global list. */
static int
vbdev_passthru_insert_name(const char *bdev_name, const char *vbdev_name)
{
struct bdev_names *name;
TAILQ_FOREACH(name, &g_bdev_names, link) {
if (strcmp(vbdev_name, name->vbdev_name) == 0) {
SPDK_ERRLOG("passthru bdev %s already exists\n", vbdev_name);
return -EEXIST;
}
}
name = calloc(1, sizeof(struct bdev_names));
if (!name) {
SPDK_ERRLOG("could not allocate bdev_names\n");
return -ENOMEM;
}
name->bdev_name = strdup(bdev_name);
if (!name->bdev_name) {
SPDK_ERRLOG("could not allocate name->bdev_name\n");
free(name);
return -ENOMEM;
}
name->vbdev_name = strdup(vbdev_name);
if (!name->vbdev_name) {
SPDK_ERRLOG("could not allocate name->vbdev_name\n");
free(name->bdev_name);
free(name);
return -ENOMEM;
}
TAILQ_INSERT_TAIL(&g_bdev_names, name, link);
return 0;
}
/* On init, just parse config file and build list of pt vbdevs and bdev name pairs. */
static int
vbdev_ext_passthru_init(void)
{
struct spdk_conf_section *sp = NULL;
const char *conf_bdev_name = NULL;
const char *conf_vbdev_name = NULL;
struct bdev_names *name;
int i, rc;
sp = spdk_conf_find_section(NULL, "Ext_Pt");
if (sp == NULL) {
return 0;
}
for (i = 0; ; i++) {
if (!spdk_conf_section_get_nval(sp, "PTE", i)) {
break;
}
conf_bdev_name = spdk_conf_section_get_nmval(sp, "PTE", i, 0);
if (!conf_bdev_name) {
SPDK_ERRLOG("Passthru configuration missing bdev name\n");
break;
}
conf_vbdev_name = spdk_conf_section_get_nmval(sp, "PTE", i, 1);
if (!conf_vbdev_name) {
SPDK_ERRLOG("Passthru configuration missing pt_bdev name\n");
break;
}
rc = vbdev_passthru_insert_name(conf_bdev_name, conf_vbdev_name);
if (rc != 0) {
return rc;
}
}
TAILQ_FOREACH(name, &g_bdev_names, link) {
SPDK_NOTICELOG("conf parse matched: %s\n", name->bdev_name);
}
return 0;
}
/* Called when the entire module is being torn down. */
static void
vbdev_ext_passthru_finish(void)
{
struct bdev_names *name;
while ((name = TAILQ_FIRST(&g_bdev_names))) {
TAILQ_REMOVE(&g_bdev_names, name, link);
free(name->bdev_name);
free(name->vbdev_name);
free(name);
}
}
/* During init we'll be asked how much memory we'd like passed to us
* in bev_io structures as context. Here's where we specify how
* much context we want per IO.
*/
static int
vbdev_ext_passthru_get_ctx_size(void)
{
return sizeof(struct passthru_bdev_io);
}
/* Called when SPDK wants to save the current config of this vbdev module to
* a file.
*/
static void
vbdev_ext_passthru_get_spdk_running_config(FILE *fp)
{
struct bdev_names *names = NULL;
fprintf(fp, "\n[Ext_Pt]\n");
TAILQ_FOREACH(names, &g_bdev_names, link) {
fprintf(fp, " PTE %s %s\n", names->bdev_name, names->vbdev_name);
}
fprintf(fp, "\n");
}
/* Where vbdev_ext_passthru_config_json() is used to generate per module JSON config data, this
* function is called to output any per bdev specific methods. For the PT module, there are
* none.
*/
static void
vbdev_passthru_write_config_json(struct spdk_bdev *bdev, struct spdk_json_write_ctx *w)
{
/* No config per bdev needed */
}
/* When we register our bdev this is how we specify our entry points. */
static const struct spdk_bdev_fn_table vbdev_passthru_fn_table = {
.destruct = vbdev_passthru_destruct,
.submit_request = vbdev_passthru_submit_request,
.io_type_supported = vbdev_passthru_io_type_supported,
.get_io_channel = vbdev_passthru_get_io_channel,
.dump_info_json = vbdev_passthru_dump_info_json,
.write_config_json = vbdev_passthru_write_config_json,
};
/* Called when the underlying base bdev goes away. */
static void
vbdev_passthru_base_bdev_hotremove_cb(void *ctx)
{
struct vbdev_passthru *pt_node, *tmp;
struct spdk_bdev *bdev_find = ctx;
TAILQ_FOREACH_SAFE(pt_node, &g_pt_nodes, link, tmp) {
if (bdev_find == pt_node->base_bdev) {
spdk_bdev_unregister(&pt_node->pt_bdev, NULL, NULL);
}
}
}
/* Create and register the passthru vbdev if we find it in our list of bdev names.
* This can be called either by the examine path or RPC method.
*/
static int
vbdev_passthru_register(struct spdk_bdev *bdev)
{
struct bdev_names *name;
struct vbdev_passthru *pt_node;
int rc = 0;
/* Check our list of names from config versus this bdev and if
* there's a match, create the pt_node & bdev accordingly.
*/
TAILQ_FOREACH(name, &g_bdev_names, link) {
if (strcmp(name->bdev_name, bdev->name) != 0) {
continue;
}
SPDK_NOTICELOG("Match on %s\n", bdev->name);
pt_node = calloc(1, sizeof(struct vbdev_passthru));
if (!pt_node) {
rc = -ENOMEM;
SPDK_ERRLOG("could not allocate pt_node\n");
break;
}
/* The base bdev that we're attaching to. */
pt_node->base_bdev = bdev;
pt_node->pt_bdev.name = strdup(name->vbdev_name);
if (!pt_node->pt_bdev.name) {
rc = -ENOMEM;
SPDK_ERRLOG("could not allocate pt_bdev name\n");
free(pt_node);
break;
}
pt_node->pt_bdev.product_name = "passthru";
/* Copy some properties from the underlying base bdev. */
pt_node->pt_bdev.write_cache = bdev->write_cache;
pt_node->pt_bdev.required_alignment = bdev->required_alignment;
pt_node->pt_bdev.optimal_io_boundary = bdev->optimal_io_boundary;
pt_node->pt_bdev.blocklen = bdev->blocklen;
pt_node->pt_bdev.blockcnt = bdev->blockcnt;
pt_node->pt_bdev.md_interleave = bdev->md_interleave;
pt_node->pt_bdev.md_len = bdev->md_len;
pt_node->pt_bdev.dif_type = bdev->dif_type;
pt_node->pt_bdev.dif_is_head_of_md = bdev->dif_is_head_of_md;
pt_node->pt_bdev.dif_check_flags = bdev->dif_check_flags;
/* This is the context that is passed to us when the bdev
* layer calls in so we'll save our pt_bdev node here.
*/
pt_node->pt_bdev.ctxt = pt_node;
pt_node->pt_bdev.fn_table = &vbdev_passthru_fn_table;
pt_node->pt_bdev.module = &passthru_if_external;
TAILQ_INSERT_TAIL(&g_pt_nodes, pt_node, link);
spdk_io_device_register(pt_node, pt_bdev_ch_create_cb, pt_bdev_ch_destroy_cb,
sizeof(struct pt_io_channel),
name->vbdev_name);
SPDK_NOTICELOG("io_device created at: 0x%p\n", pt_node);
rc = spdk_bdev_open(bdev, true, vbdev_passthru_base_bdev_hotremove_cb,
bdev, &pt_node->base_desc);
if (rc) {
SPDK_ERRLOG("could not open bdev %s\n", spdk_bdev_get_name(bdev));
TAILQ_REMOVE(&g_pt_nodes, pt_node, link);
spdk_io_device_unregister(pt_node, NULL);
free(pt_node->pt_bdev.name);
free(pt_node);
break;
}
SPDK_NOTICELOG("bdev opened\n");
rc = spdk_bdev_module_claim_bdev(bdev, pt_node->base_desc, pt_node->pt_bdev.module);
if (rc) {
SPDK_ERRLOG("could not claim bdev %s\n", spdk_bdev_get_name(bdev));
spdk_bdev_close(pt_node->base_desc);
TAILQ_REMOVE(&g_pt_nodes, pt_node, link);
spdk_io_device_unregister(pt_node, NULL);
free(pt_node->pt_bdev.name);
free(pt_node);
break;
}
SPDK_NOTICELOG("bdev claimed\n");
rc = spdk_bdev_register(&pt_node->pt_bdev);
if (rc) {
SPDK_ERRLOG("could not register pt_bdev\n");
spdk_bdev_module_release_bdev(&pt_node->pt_bdev);
spdk_bdev_close(pt_node->base_desc);
TAILQ_REMOVE(&g_pt_nodes, pt_node, link);
spdk_io_device_unregister(pt_node, NULL);
free(pt_node->pt_bdev.name);
free(pt_node);
break;
}
SPDK_NOTICELOG("ext_pt_bdev registered\n");
SPDK_NOTICELOG("created ext_pt_bdev for: %s\n", name->vbdev_name);
}
return rc;
}
/* Create the passthru disk from the given bdev and vbdev name. */
int
create_passthru_disk(const char *bdev_name, const char *vbdev_name)
{
struct spdk_bdev *bdev = NULL;
int rc = 0;
/* Insert the bdev into our global name list even if it doesn't exist yet,
* it may show up soon...
*/
rc = vbdev_passthru_insert_name(bdev_name, vbdev_name);
if (rc) {
return rc;
}
bdev = spdk_bdev_get_by_name(bdev_name);
if (!bdev) {
/* This is not an error, we tracked the name above and it still
* may show up later.
*/
SPDK_NOTICELOG("vbdev creation deferred pending base bdev arrival\n");
return 0;
}
return vbdev_passthru_register(bdev);
}
void
delete_passthru_disk(struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn, void *cb_arg)
{
struct bdev_names *name;
if (!bdev || bdev->module != &passthru_if_external) {
cb_fn(cb_arg, -ENODEV);
return;
}
/* Remove the association (vbdev, bdev) from g_bdev_names. This is required so that the
* vbdev does not get re-created if the same bdev is constructed at some other time,
* unless the underlying bdev was hot-removed.
*/
TAILQ_FOREACH(name, &g_bdev_names, link) {
if (strcmp(name->vbdev_name, bdev->name) == 0) {
TAILQ_REMOVE(&g_bdev_names, name, link);
free(name->bdev_name);
free(name->vbdev_name);
free(name);
break;
}
}
/* Additional cleanup happens in the destruct callback. */
spdk_bdev_unregister(bdev, cb_fn, cb_arg);
}
/* Because we specified this function in our pt bdev function table when we
* registered our pt bdev, we'll get this call anytime a new bdev shows up.
* Here we need to decide if we care about it and if so what to do. We
* parsed the config file at init so we check the new bdev against the list
* we built up at that time and if the user configured us to attach to this
* bdev, here's where we do it.
*/
static void
vbdev_ext_passthru_examine(struct spdk_bdev *bdev)
{
vbdev_passthru_register(bdev);
spdk_bdev_module_examine_done(&passthru_if_external);
}
|