[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] RFC: Death to the BQDL (Big QEMU Driver Lock)

Many years ago when the QEMU driver was first written for libvirt the
daemon was single threaded, so we didn't have to worry about locking
at all. Then we introduced threads and so we had to have locking.

Since then locking has been done at two levels. The big QEMU driver
lock must be acquired first, then the per-VM lock could be acquired.
If no field in the driver struct was used, we could quickly
release the QEMU driver lock and only hold the per-VM lock.

Over time though, our code has got more & more complicated to the
point where we have to hold the big QEMU driver lock in the vast
majority of methods. We mitigate this by releasing the locks when
sleeping on monitor API calls, but this is still a huge bottleneck.
This is particularly apparent when you look at concurrency when
starting/stopping guests.

This scalability limitation is at a point where it is unacceptable
for us to continue as we do today.

Band-aids no longer suffice. To fix this for the long term, we need
to dramatically change the locking approach we use in the QEMU driver.
The only way we can achieve this is by dramatically changing the way
we update/access QEMU driver state.

The core problem is that the qemu driver struct holds a vast array
of (often unrelated) data, with differing access patterns. It is
clear that a single lock is not a suitable level of granularity for
this. Looking at what is in the struct we can classify data into a
number of buckets

 1. Read-only data that never changes for lifetime of libvirtd.

     - char *configDir
     - char *libDir
     - bool privileged;
     - const char *uri;
     - virThreadPoolPtr workerPool

 2. Read-only data that never changes for as long as the config
    file is not reloaded. (Currently equivalent to previous bucket
    since we don't support reloading qemu.conf - we need to support
    that in the future)

      - uid_t user;
      - uid_t group;
      - int dynamicOwnership;
      - unsigned int vncTLS :1;
      - unsigned int vncSASL :1;
      - char *vncListen;

 3. Read-write data that changes at arbitrary times

      - virDomainObjList domains
      - size_t nactive
      - pciDeviceList *activePciHostdevs;
      - usbDeviceList *activeUsbHostdevs;
      - virHashTablePtr closeCallbacks;

My proposal for dealing with things is as follows

 1. Read-only data that never changes for lifetime of libvirtd.

    Turn the current driver mutex into a driver RW-lock. All API
    calls will always acquire a read-lock at start, hold it for
    the lifetime of their execution and release it at the end.
    API calls will never directly acquire write locks.

    The QEMU driver startup / shutdown global initializers will
    acquire write-locks. This ensures the daemon can't shutdown
    while any APIs are being executed.

 2. Read-only data that never changes for as long as the config
    file is not reloaded.

    Move all of this data out into a new virQEMUDriverConfigPtr
    struct, which is an instance of virObject. The virQEMUDriverPtr
    will hold the primary reference to the config. The contents
    of this object struct will be considered immutable once

    When an API needs to access config file, it will obtain a
    reference on the config object. Obtaining the reference
    will involve acquiring & releasing the driver lock.

    If the QEMU driver needs to reload the config, it will populate
    a completely new virQEMUDriverConfigPtr instance, and unref
    the existing one.

    Thus access to data in virQEMUDriverConfigPtr can be completely
    lockless once an instance has been acquired, despite the possiblity
    of the config being updated at an arbitrary time.

    cf  RCU (read-copy-update)

 3. Read-write data that changes at arbitrary times.

    All data that can be changed must be stored in a dedicated
    virObject based instance. Each object must provide its own
    internal locking mechanisms targetted to the type of data
    being stored.

    Some objects may need some re-architecting to allow them to
    operate effectively without the protection of the long lived
    QEMU driver lock. For example during domain startup, we rely
    on the QEMU driver lock to protect against races between the
    time we check for an existing VM with (name,uuid), and the
    time we actually finish starting the new VM & store it in
    the domain list.  To deal with this the virDomainObjList
    will need to have some concept of a 'reserved name,uuid'
    so safety is ensured, despite not holding a lock for the whole
    start operation.

So I lied slightly when I said this was the death of the big QEMU
driver lock. The big QEMU driver lock still exists, but API calls
only ever need to have read-locks. Write-locks are only held for
libvirtd startup/shutdown, and for the tiny time window it takes
to grab a reference to a virQEMUDriverConfigPtr.

Access to config params is completely lockless, even allowing for
their live update.

All the remaining exclusive locks will be pushed down into individual
objects which need them, hopefully ensuring high concurrency of

Implementing this all is a non-trivial job, so I envisage the following
order of attack

 1. Create the virQEMUDriverConfigPtr object & move config file
    parameters into that.

 2. Encapsulte all read-writable state into objects with dedicated

 3. Turn QEMU driver mutex into a read-write lock

 4. Convert all APIs to only hold read-locks on QEMU driver.

|: http://berrange.com      -o-    http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org              -o-             http://virt-manager.org :|
|: http://autobuild.org       -o-         http://search.cpan.org/~danberr/ :|
|: http://entangle-photo.org       -o-       http://live.gnome.org/gtk-vnc :|

[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]