Commit fc9c0a9c authored by Stefan Hajnoczi's avatar Stefan Hajnoczi
Browse files

blockjob: add pause points 



Block jobs are coroutines that usually perform I/O but sometimes also
sleep or yield.  Currently only sleeping or yielded block jobs can be
paused.  This means jobs that do not sleep or yield (using
block_job_yield()) are unaffected by block_job_pause().

Add block_job_pause_point() so that block jobs can mark quiescent points
that are suitable for pausing.  This solves the problem that it can take
a block job a long time to pause if it is performing a long series of
I/O operations.

Transitioning to paused state involves a .pause()/.resume() callback.
These callbacks are used to ensure that I/O and event loop activity has
ceased while the job is at a pause point.

Note that this patch introduces a stricter pause state than previously.
The job->busy flag was incorrectly documented as a quiescent state
without I/O pending.  This is violated by any job that has I/O pending
across sleep or block_job_yield(), like the mirror block job.

[Add missing block_job_should_pause() check to avoid deadlock after
job->driver->pause() in block_job_pause_point().
--Stefan]

Signed-off-by: default avatarStefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
Reviewed-by: default avatarFam Zheng <famz@redhat.com>
Message-id: 1466096189-6477-4-git-send-email-stefanha@redhat.com
parent a7f3b7ff

blockjob.c

+33 −5
Original line number Diff line number Diff line
@@ -257,6 +257,32 @@ static bool block_job_should_pause(BlockJob *job) 
    return job->pause_count > 0;

}



void coroutine_fn block_job_pause_point(BlockJob *job)

{

    if (!block_job_should_pause(job)) {

        return;

    }

    if (block_job_is_cancelled(job)) {

        return;

    }



    if (job->driver->pause) {

        job->driver->pause(job);

    }



    if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {

        job->paused = true;

        job->busy = false;

        qemu_coroutine_yield(); /* wait for block_job_resume() */

        job->busy = true;

        job->paused = false;

    }



    if (job->driver->resume) {

        job->driver->resume(job);

    }

}



void block_job_resume(BlockJob *job)

{

    assert(job->pause_count > 0);
@@ -364,11 +390,9 @@ void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns) 
    if (!block_job_should_pause(job)) {

        co_aio_sleep_ns(blk_get_aio_context(job->blk), type, ns);

    }

    /* The job can be paused while sleeping, so check this again */

    if (block_job_should_pause(job)) {

        qemu_coroutine_yield();

    }

    job->busy = true;



    block_job_pause_point(job);

}



void block_job_yield(BlockJob *job)
@@ -381,8 +405,12 @@ void block_job_yield(BlockJob *job) 
    }



    job->busy = false;

    if (!block_job_should_pause(job)) {

        qemu_coroutine_yield();

    }

    job->busy = true;



    block_job_pause_point(job);

}



BlockJobInfo *block_job_query(BlockJob *job)

include/block/blockjob.h

+32 −3
Original line number Diff line number Diff line
@@ -70,6 +70,20 @@ typedef struct BlockJobDriver { 
     * never both.

     */

    void (*abort)(BlockJob *job);



    /**

     * If the callback is not NULL, it will be invoked when the job transitions

     * into the paused state.  Paused jobs must not perform any asynchronous

     * I/O or event loop activity.  This callback is used to quiesce jobs.

     */

    void coroutine_fn (*pause)(BlockJob *job);



    /**

     * If the callback is not NULL, it will be invoked when the job transitions

     * out of the paused state.  Any asynchronous I/O or event loop activity

     * should be restarted from this callback.

     */

    void coroutine_fn (*resume)(BlockJob *job);

} BlockJobDriver;



/**
@@ -119,12 +133,18 @@ struct BlockJob { 
    bool user_paused;



    /**

     * Set to false by the job while it is in a quiescent state, where

     * no I/O is pending and the job has yielded on any condition

     * that is not detected by #aio_poll, such as a timer.

     * Set to false by the job while the coroutine has yielded and may be

     * re-entered by block_job_enter().  There may still be I/O or event loop

     * activity pending.

     */

    bool busy;



    /**

     * Set to true by the job while it is in a quiescent state, where

     * no I/O or event loop activity is pending.

     */

    bool paused;



    /**

     * Set to true when the job is ready to be completed.

     */
@@ -298,6 +318,15 @@ bool block_job_is_cancelled(BlockJob *job); 
 */

BlockJobInfo *block_job_query(BlockJob *job);



/**

 * block_job_pause_point:

 * @job: The job that is ready to pause.

 *

 * Pause now if block_job_pause() has been called.  Block jobs that perform

 * lots of I/O must call this between requests so that the job can be paused.

 */

void coroutine_fn block_job_pause_point(BlockJob *job);



/**

 * block_job_pause:

 * @job: The job to be paused.