From mboxrd@z Thu Jan  1 00:00:00 1970
Content-Type: multipart/mixed; boundary="===============6488239744043742906=="
MIME-Version: 1.0
From: Baruch Even <baruch at weka.io>
Subject: Re: [SPDK] Handling of physical disk removals
Date: Wed, 30 May 2018 14:46:00 +0300
Message-ID: <CAKye4QZzOsZnuHo3t040n532e49YyjUWgQ3ieuCK-3qiK6maug@mail.gmail.com>
In-Reply-To: 37B08312E007AE46A00101F43DA919DDCE68BF9F@FMSMSX105.amr.corp.intel.com
List-ID: <spdk@lists.01.org>
To: spdk@lists.01.org

--===============6488239744043742906==
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: quoted-printable

As for threading, the only thing I need to make things integrate better
into my green-threads is to use a function call to do a context switch if
needed (spdk_yield() of sorts), that is empty/no-op for most users and can
be a compile time option (weak symbol? define?) to use some user-provided
function. This will immediately integrate into any green thread system by
switching to another user-thread and returning for a poll when other
actions are taken. This way the posix-thread will not block and there is no
special async logic that needs to happen.

As for the low level api, my application already has its own queue for each
device, and we split our requests as we need to and combine them as
possible to improve performance. It took us by surprise to find that SPDK
internally breaks out the requests to smaller chunks, queues them
internally and completions may not really complete the full request. There
was even was scenario that we had a deadlock because we overflowed the spdk
queues. Once we found these out we made sure to expose to our application
all the device constraints and break the IOs with the device limitations in
mind and now all the extra work and checks that SPDK does are a waste of
cpu cycles as far as we are concerned.

There is also the issue that we track our IOs and SPDK because it does the
extra work has IO tracking of its own and it means there is an extra memory
allocation on the data path for no good reason from our point of view.

When I'm building my command in the queue I need to keep the list of
buffers in some data structure, currently I keep it in a vector and then
this gets translated to PRP/SGL when the command is submitted. I could save
that step if I could just maintain the PRP/SGL myself and just pass the
ready-made list to the command. This will save me some memory and time.

All of this just means that spdk is wasting some cpu cycles on things we
don't want it to do and after all the main reason to use spdk and dpdk is
to eke out all the possible performance from the system (cpu/nvme devices)
by a more integrated design. I can understand that other users of spdk do
want the higher levels and do need the features provided but for us we have
better places to do these actions.

Baruch

On Thu, May 24, 2018 at 7:44 PM Walker, Benjamin <benjamin.walker(a)intel.c=
om>
wrote:

> Hi Baruch,
>
>
>
> Regarding blocking threads =E2=80=93 only the NVMe initialization path do=
es that
> today. We considered doing a fully asynchronous initialization path for
> NVMe devices, but we received a lot of feedback that it makes it very
> difficult to use. I=E2=80=99d personally be open to adding a second initi=
alization
> path that was entirely asynchronous and required the user to explicitly
> poll some initialization context to advance the state machine until the
> devices come online. This clearly makes much more sense in the context of
> hot plug since the device initialization may occur on a thread that is al=
so
> processing I/O. Contributions are always very welcome!
>
>
>
> I do expect to see some fairly major movement this year regarding
> abstractions around threading models and I=E2=80=99d love to define some
> abstraction that allows SPDK to nicely integrate into applications using
> green threads or coroutines without tying SPDK to any specific
> implementation. This is definitely at the front of mind currently (as is
> dynamic memory management =E2=80=93 the other major hurdle for integratin=
g with
> existing applications). I think over the coming months there are going to
> be several lively discussions on the mailing list and in IRC as we try to
> sort all of this out.
>
>
>
> Regarding a lower level API =E2=80=93 we have some lower level interfaces,
> although not as low-level as you=E2=80=99re talking about. See
> spdk_nvme_ctrlr_io_cmd_raw()
> <http://www.spdk.io/doc/nvme_8h.html#a1e3def668122e76abbfb74305f118291>,
> for example, which lets you build an arbitrary NVMe command and send it. =
We
> haven=E2=80=99t exposed any knobs to control internal queueing or to allo=
w a user
> to build their own SGL/PRP. Can you outline what the use cases for those
> are? Why would you want to deviate from what SPDK does by default today?
> We=E2=80=99re always amenable to providing more control, if that control =
has value.
>
>
>
> Thanks,
>
> Ben
>
>
>
> *From:* SPDK [mailto:spdk-bounces(a)lists.01.org] *On Behalf Of *Baruch E=
ven
> *Sent:* Thursday, May 24, 2018 1:17 AM
>
>
> *To:* Storage Performance Development Kit <spdk(a)lists.01.org>
>
> *Subject:* Re: [SPDK] Handling of physical disk removals
>
>
>
> Hi,
>
> I logged the issue as https://github.com/spdk/spdk/issues/310
>
> I do call detach but I do not use the empty probe call, instead I have
> another part of my application monitor the same uevent information and
> trigger a larger process to remove the drive. I also have this triggered =
by
> the timeout callback. I had to remove the timeout callback or I'd get
> bombarded with the callback until it actually happened, looks like the
> timeout callback assumes that the reset call will happen from inside it a=
nd
> complete before it returns but that doesn't work very well with our
> application.
>
> I have an issue with the threading model you are using as we are using
> user-space-threads (aka green threads or coroutines) and spdk will block
> the entire application for no good reason. It would have been nice if the=
re
> was a yield callback I can provide you so you won't block the main thread.
> For now I need to resort to send the spdk admin calls to a thread to be
> done there since spdk may block.
>
> If I am on a ranting roll I also would have preferred a lower level
> interface than currently provided that doesn't implement internal queuing
> and internal allocations so much and doesn't hide all the nvme details
> (prp, sgl), though by that stage I'm probably better of with unvme instead
> of spdk. If they had support uio_pci_generic in addition to vfio-pci it
> would probably be a better direction for me.
>
>
>
> Baruch
>
>
>
> On Wed, May 23, 2018 at 8:18 PM Harris, James R <james.r.harris(a)intel.c=
om>
> wrote:
>
> Hi Baruch,
>
>
>
> Thanks for raising this issue =E2=80=93 there are absolutely changes that=
 SPDK
> needs to make here.
>
>
>
> Can you describe your code path a bit more?  Or let me try to guess and
> you can tell me where I=E2=80=99m wrong.
>
>
>
> 1)       You=E2=80=99re using spdk_nvme_probe() with a NULL trid and a re=
move_cb
> handler to detect physically removed devices.
>
> 2)       In your remove_cb handler, you call spdk_nvme_detach().
>
>
>
> The SPDK bdev nvme module doesn=E2=80=99t call spdk_nvme_detach() in its =
remove_cb
> which is why the SPDK automated tests don=E2=80=99t run into this issue. =
 But I
> don=E2=80=99t this is correct =E2=80=93 we should be calling spdk_nvme_de=
tach() at some
> point to clean up any allocated resources.  It needs to make sure any
> associate IO channels are freed up first (to avoid racing between the
> remove callback and different threads submitting IO to that removed
> controller).
>
>
>
> Could you file this as a bug in github?  Please add any additional details
> on how you=E2=80=99re hitting this issue if it=E2=80=99s different than w=
hat I=E2=80=99ve guessed
> above.
>
>
>
> https://github.com/spdk/spdk/issues
>
>
>
> Thanks,
>
>
>
> Jim
>
>
>
>
>
> *From: *SPDK <spdk-bounces(a)lists.01.org> on behalf of Baruch Even <
> baruch(a)weka.io>
> *Reply-To: *Storage Performance Development Kit <spdk(a)lists.01.org>
> *Date: *Wednesday, May 23, 2018 at 1:44 AM
> *To: *Storage Performance Development Kit <spdk(a)lists.01.org>
> *Subject: *[SPDK] Handling of physical disk removals
>
>
>
> Hi,
>
> I'm using spdk for local nvme through the nvme interface, I find that
> physical disk removals are not handled properly for my use case and wonder
> if others see it that way as well and if there is an intention to fix thi=
s.
>
> Our system uses long running processes that control one or more disks at a
> time, if a disk fails it may drop completely from the pcie bus and it will
> also look like that if the disk is physically removed (say a technician
> mistakes the disk that he should replace).
>
> The problem that I see is that spdk doesnt consider a device completely
> disappearing from the bus and will try to release the io qpair by sending
> the delete io sq and delete io cq commands, both of these will never get =
an
> answer (the device is not on the pcie device anymore) and there is no
> timeout logic in that code path. This means two things, the process will
> halt forever and there is an effective memory leak which currently means
> that we need to restart the process. Now, our system is resilient enough
> that restarting the process is not a big deal but it is a very messy way =
to
> go about handlign a physical drive removal.
>
>
>
> Have others seen this behavior? Does it bother others?
>
> For my own use I put a timeout in there of a few seconds and that solves
> it for me.
>
>
>
> Baruch Even
>
>
>
> --
>
> [image: image001.jpg]
> * Baruch Even, **Software Developer  *
>
> *E * baruch(a)weka.io <liran(a)weka.io>
> www.weka.io
>
> _______________________________________________
> SPDK mailing list
> SPDK(a)lists.01.org
> https://lists.01.org/mailman/listinfo/spdk
>
> --
>
> [image: ~WRD000.jpg]
> * Baruch Even, **Software Developer  *
>
> *E * baruch(a)weka.io <liran(a)weka.io>
> www.weka.io
> _______________________________________________
> SPDK mailing list
> SPDK(a)lists.01.org
> https://lists.01.org/mailman/listinfo/spdk
>
-- =




*Baruch Even, Software Developer  E  baruch(a)weka.io <liran(a)weka.io>
www.weka.io <http://www.weka.io>*

--===============6488239744043742906==
Content-Type: text/html
MIME-Version: 1.0
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="attachment.html"
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--===============6488239744043742906==
Content-Type: image/jpeg
MIME-Version: 1.0
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="WRD000.jpg"

/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a
HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIy
MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCABkAGQDASIA
AhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA
AAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3
ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWm
p6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEA
AwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSEx
BhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElK
U1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3
uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iii
gAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKA
CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK
KKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAoo
ooAKKKKACiiigAooooAKKKKACiiigD//2Q==
--===============6488239744043742906==
Content-Type: image/jpeg
MIME-Version: 1.0
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="image001.jpg"

/9j/4AAQSkZJRgABAQEAeAB4AAD/2wBDAAoHBwgHBgoICAgLCgoLDhgQDg0NDh0VFhEYIx8lJCIf
IiEmKzcvJik0KSEiMEExNDk7Pj4+JS5ESUM8SDc9Pjv/wAALCAA6ALkBAREA/8QAHwAAAQUBAQEB
AQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1Fh
ByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZ
WmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG
x8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/9oACAEBAAA/APZqKKKKKKKKKKKKKKKK
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
KKKKKKKKKKKKKKKKKKKKKKK//9k=
--===============6488239744043742906==--