Re: [PATCH v3 2/5] block-copy: improve comments of BlockCopyTask and BlockCopyState types and functions

[Emanuele Giuseppe Esposito]

On 09/06/2021 11:12, Vladimir Sementsov-Ogievskiy wrote:
> 08.06.2021 10:33, Emanuele Giuseppe Esposito wrote:
> > As done in BlockCopyCallState, categorize BlockCopyTask
> > and BlockCopyState in IN, State and OUT fields.
> > This is just to understand which field has to be protected with a lock.
> >
> > .sleep_state is handled in the series "coroutine: new sleep/wake API"
> > and thus here left as TODO.
> >
> > Signed-off-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>
> > ---
> >   block/block-copy.c | 47 ++++++++++++++++++++++++++++++----------------
> >   1 file changed, 31 insertions(+), 16 deletions(-)
> >
> > diff --git a/block/block-copy.c b/block/block-copy.c
> > index d58051288b..b3533a3003 100644
> > --- a/block/block-copy.c
> > +++ b/block/block-copy.c
> > @@ -56,25 +56,33 @@ typedef struct BlockCopyCallState {
> >       QLIST_ENTRY(BlockCopyCallState) list;
> >       /* State */
>
> Why previous @list field is not in the state? For sure it's not an IN 
> parameter and should be protected somehow.
>
> > -    int ret;
> >       bool finished;
> > -    QemuCoSleep sleep;
> > -    bool cancelled;
> > +    QemuCoSleep sleep; /* TODO: protect API with a lock */
> >       /* OUT parameters */
> > +    bool cancelled;
> >       bool error_is_read;
> > +    int ret;
> >   } BlockCopyCallState;
> >   typedef struct BlockCopyTask {
> >       AioTask task;
> > +    /*
> > +     * IN parameters. Initialized in block_copy_task_create()
> > +     * and never changed.
> > +     */
> >       BlockCopyState *s;
> >       BlockCopyCallState *call_state;
> >       int64_t offset;
> > -    int64_t bytes;
> > -    BlockCopyMethod method;
> > -    QLIST_ENTRY(BlockCopyTask) list;
> > +    int64_t bytes; /* only re-set in task_shrink, before running the 
> > task */
> > +    BlockCopyMethod method; /* initialized in 
> > block_copy_dirty_clusters() */
>
> hmm. to be precise method is initialized in block_copy_task_create.
>
> And after block_copy_task_create finished, task is in the list and can 
> be read by parallel block_copy_dirty_clusters(). So, @bytes is part of 
> State, we must protect it..

So if I understand correctly, you refer to the fact that a parallel 
block_copy_dirty_clusters() can create another task and search with 
find_conflicting_task_locked(), or in general also block_copy_wait_one() 
can do the same in parallel, correct?

Here there is also another problem: if we add the task to the list and 
then shrink it in two different critical sections, we are going to have 
problems because in the meanwhile find_conflicting_tasks can be issued 
in parallel.

So, is there a reason why we don't want
QLIST_INSERT_HEAD(&s->tasks, task, list);
in block_copy_dirty_clusters()?

By doing that, I think we also spare @bytes from the critical section, 
since it is only read from that point onwards.

I am also trying to see if I can group some critical sections.

Btw I think we already talked about @bytes and it's not the first time 
we switch it from IN to STATE and vice-versa...
I mean, I agree with you but it starts to be confusing.


This also goes against your comment later in patch 4,
> > @@ -212,7 +222,7 @@ static BlockCopyTask *block_copy_task_create(BlockCopyState 
> > *s,
> >       bytes = QEMU_ALIGN_UP(bytes, s->cluster_size);
> >         /* region is dirty, so no existent tasks possible in it */
> > -    assert(!find_conflicting_task(s, offset, bytes));
> > +    assert(!find_conflicting_task_locked(s, offset, bytes));
> >         bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
> >       s->in_flight_bytes += bytes;
> > @@ -248,16 +258,19 @@ static void coroutine_fn 
> > block_copy_task_shrink(BlockCopyTask *task,
> >   
>
> The function reads task->bytes not under mutex.. It's safe, as only that function is modifying the field, and it's called once. Still, let's make critical section a little bit wider, just for simplicity. I mean, simple QEMU_LOCK_GUARD() at start of function. 

Where if I understand correctly, it is not safe, because 
find_conflicting_tasks might search the non-updated task.

Thank you,
Emanuele