Back to the news overview

LXD 3.19 has been released

16th of January 2020


The LXD team is very excited to announce the release of LXD 3.19!

This is a jam packed release, including one huge feature we've been working on for the past few months, virtual machine support! It's now possible to run LXD on a system and manage both containers and virtual machines through the exact same CLI, API or even as part of a cluster deployment!

We also have a lot of other features, user experience improvements and fixes in this release, quite possibly making it our busiest release yet!


PS: This release took quite a bit longer than our usual one month development cycle. This delay was caused by us wanting to complete the majority of our storage layer re-implementation as well as landing the virtual machine support based on top of it. We expect the next couple of LXD releases to come out on an accelerated cadence ahead of the big LXD 4.0 release in March/April.


Virtual machine support

No doubt the main highlight of this release is the initial support for running virtual machines through LXD.

This is exactly what it sounds like. You can now mix and match system containers and virtual machines.
Those virtual machines are also created from images, stored on the same storage pools as containers, connected to the same networks and even share configuration through profiles.

Interacting with a running virtual machine can be made almost identical to interacting with a container thanks to the LXD agent which when running inside a virtual machine allows the use of the standard exec, file and info features.

This is early work and we have a lot more pieces yet to be implemented, but as it stands, virtual machines can be created from Ubuntu images (with more distributions to come) or PXE booted.

All virtual machines run UEFI with secure boot enabled and we have support for configuring the number of cores and memory allocation as well as whether to use dedicated hugepages for memory backing.
Cloud-init configuration can be exposed to the VM through a config drive or by using the agent if backed into an image.

Here is a basic example of creating an Ubuntu 18.04 VM, installing the agent and querying details and getting a shell inside it:

stgraber@castiana:~$ lxc profile create vm
stgraber@castiana:~$ lxc profile edit vm
stgraber@castiana:~$ lxc profile show vm
  user.user-data: |
    ssh_pwauth: yes
      - name: ubuntu
        passwd: "$6$s.wXDkoGmU5md$d.vxMQSvtcs1I7wUG4SLgUhmarY7BR.5lusJq1D9U9EnHK2LJx18x90ipsg0g3Jcomfp0EoGAZYfgvT22qGFl/"
        lock_passwd: false
        groups: lxd
        shell: /bin/bash
        sudo: ALL=(ALL) NOPASSWD:ALL
description: VM specific configuration
    source: cloud-init:config
    type: disk
name: vm

stgraber@castiana:~$ lxc launch ubuntu:18.04 v1 --vm --profile default --profile vm
Creating v1
Starting v1

stgraber@castiana:~$ lxc console v1
To detach from the console, press: <ctrl>+a q

Ubuntu 18.04.3 LTS v1 ttyS0

v1 login: ubuntu
Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)

ubuntu@v1:~$ sudo -i
root@v1:~# mount -t 9p config /mnt/
root@v1:~# cd /mnt/
root@v1:/mnt# ./ 
Created symlink /etc/systemd/system/ → /lib/systemd/system/lxd-agent.service.
Created symlink /etc/systemd/system/ → /lib/systemd/system/lxd-agent-9p.service.

LXD agent has been installed, reboot to confirm setup.
To start it now, unmount this filesystem and run: systemctl start lxd-agent-9p lxd-agent
root@v1:/mnt# reboot

stgraber@castiana:~$ lxc info v1
Name: v1
Location: none
Remote: unix://
Architecture: x86_64
Created: 2020/01/17 02:23 UTC
Status: Running
Type: virtual-machine
Profiles: default, vm
Pid: 2490333
  enp5s0:   inet
  enp5s0:   inet6   2001:470:b368:4242:216:3eff:fed2:cd5
  enp5s0:   inet6   fe80::216:3eff:fed2:cd5
  lo:   inet
  lo:   inet6   ::1
  Processes: 22
  Disk usage:
    root: 23.51MB
  CPU usage:
    CPU usage (in seconds): 6
  Memory usage:
    Memory (current): 179.20MB
    Memory (peak): 201.19MB
  Network usage:
      Bytes received: 1.71kB
      Bytes sent: 1.94kB
      Packets received: 14
      Packets sent: 18
      Bytes received: 6.19kB
      Bytes sent: 6.19kB
      Packets received: 84
      Packets sent: 84

stgraber@castiana:~$ lxc exec v1 bash
root@v1:~# ps aux | grep lxd
root       787  1.5  1.6 747700 16300 ?        Ssl  02:25   0:00 /run/lxd_config/9p/lxd-agent
root      1024  0.0  0.0  14856  1004 pts/0    S+   02:26   0:00 grep --color=auto lxd

Reworked storage layer

As part of the virtual machine work, we have completely rewritten our storage layer.
This was done partly to add support for storing the block devices backing the virtual machines and to cleanup a lot of cruft that's been accumulating over the years and evolution of the storage layer.

This has no user visible repercussions, if it works properly, the new logic should be acting exactly like the old one, though possibly with quite a few less bugs.

It is now easier than ever to add support for a new storage driver and thanks to good abstractions having been put in place, the vast majority of the storage operations now use shared logic, significantly reducing code duplication and risk of duplicated bugs throughout the codebase.

As with any work of this magnitude, there will be bugs. We will try to be as reactive as we can to address any issue reported to us and would strongly recommend testing LXD 3.19 on some less important systems through the candidate channel ahead of it hitting stable.

Contributions by students of the University of Texas

A number of group of students from the University of Texas in Austin have been contributing LXD features as part of an assignment in their virtualization class.

For this release, this includes:

  • Multi architecture clustering
  • Direct attach of Ceph rbd/fs volumes
  • Attaching profiles to images
  • Custom mount options for disk devices
  • LVM striping (partial work superseded by the re-implementation of the storage layer)

A number more are currently being polished and will be included in the next LXD release.

The LXD team really enjoyed those contributions and interacting with new contributors to the project and are wishing all the best to the participating students!

Other new features

Device keys as lxc list columns

It is now possible to define additional columns in lxc list to show the value of device configuration keys.

For example:

stgraber@castiana:~$ lxc list -c nst,config:image.os:OS,devices:eth0.parent:BRIDGE
|  NAME  |  STATE  |      TYPE       |   OS   | BRIDGE |
| maas01 | STOPPED | CONTAINER       | ubuntu | lxdbr0 |
| v1     | STOPPED | VIRTUAL-MACHINE | ubuntu | lxdbr0 |
| v2     | STOPPED | VIRTUAL-MACHINE | ubuntu | lxdbr0 |
| v3     | STOPPED | VIRTUAL-MACHINE |        | lxdbr0 |

Routed networking mode

A new routed mode (nictype) for network interfaces is now supported.
This requires a very recent feature of underlying liblxc and will effectively setup a point to point link between the container and host and will then route an IP to the container over it.

stgraber@castiana:~$ lxc config device add c1 eth0 nic nictype=routed ipv4.address=
Device eth0 added to c1
stgraber@castiana:~$ lxc start c1
stgraber@castiana:~$ lxc list c1
| NAME |  STATE  |         IPV4          | IPV6 |   TYPE    | SNAPSHOTS |
| c1   | RUNNING | (eth0) |      | CONTAINER | 0         |

Direct attach of Ceph RBD or FS to containers

For those users who have existing RBD or FS volumes on Ceph which aren't managed by LXD itself and so cannot be attached through a traditional disk device, it is now possible to attach such a volume directly to a container.

This is done with special values for the source config key of disk devices.

Examples include:
- source=ceph-rbd:pool/volume
- source=ceph-fs:fs/path

Additionally some configuration keys were added to select the Ceph cluster and user.

  • ceph.cluster_name
  • ceph.user_name

Custom mount options for disk devices

A new raw.mount_options config key was added to disk devices.
It takes an arbitrary list of comma separated mount options to be used when attaching the disk to the container.

Attaching profiles to images

A set of profiles can now be attached to profiles. Any new instance created from that image will be using that set of profiles rather than the default profile.

This is configured through lxc image edit and is kept as images auto-update.

stgraber@castiana:~$ lxc image show a722a8eb4d31
auto_update: true
  architecture: amd64
  description: Alpine 3.8 amd64 (20200116_13:00)
  os: Alpine
  release: "3.8"
  serial: "20200116_13:00"
  type: squashfs
public: false
expires_at: 1969-12-31T19:00:00-05:00
- default

stgraber@castiana:~$ lxc image edit a722a8eb4d31

stgraber@castiana:~$ lxc image show a722a8eb4d31
auto_update: true
  architecture: amd64
  description: Alpine 3.8 amd64 (20200116_13:00)
  os: Alpine
  release: "3.8"
  serial: "20200116_13:00"
  type: squashfs
public: false
expires_at: 1969-12-31T19:00:00-05:00
- blah

stgraber@castiana:~$ lxc launch a722a8eb4d31 a1
Creating a1
Starting a1

stgraber@castiana:~$ lxc info a1 | grep Profiles
Profiles: blah

Interception of the mount system call

Our system call interception layer has been extended to support intercepting the mount syscall.

This can be used to allow normally restricted filesystems to be mounted inside unprivileged containers, but maybe more importantly, it allows for transparent redirection of mount calls to FUSE drivers.

The new configuration options are:
- security.syscalls.intercept.mount (enable/disable the feature)
- security.syscalls.intercept.mount.allowed (list of filesystems to allow mounting)
- security.syscalls.intercept.mount.fuse (list of filesystems to redirect to FUSE)
- security.syscalls.intercept.mount.shift (whether to automatically setup a shiftfs layer)

WARNING: You should never grant the allowed permission to a container that you don't completely trust. This directly exposes your container to the kernel superblock parser and can be used to attack the kernel, crashing the host or even breaking out of the container.

Here is an example of both mounting through by allowing ext4 as well as then using FUSE as a much safer alternative:

root@vm02:~# lxc launch ubuntu:18.04 c1
Creating c1
Starting c1

root@vm02:~# mkfs.ext4 /dev/sdb
mke2fs 1.44.1 (24-Mar-2018)
Discarding device blocks: done                            
Creating filesystem with 2621440 4k blocks and 655360 inodes
Filesystem UUID: 134bc6d4-e7d3-4db1-a3aa-a398c1acff85
Superblock backups stored on blocks: 
    32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632

Allocating group tables: done                            
Writing inode tables: done                            
Creating journal (16384 blocks): done
Writing superblocks and filesystem accounting information: done

root@vm02:~# lxc config device add c1 sdb unix-block path=/dev/sdb
Device sdb added to c1

root@vm02:~# lxc exec c1 -- mount /dev/sdb /mnt
mount: /mnt: permission denied.

root@vm02:~# lxc config set c1 security.syscalls.intercept.mount true
root@vm02:~# lxc config set c1 security.syscalls.intercept.mount.shift true
root@vm02:~# lxc config set c1 security.syscalls.intercept.mount.allowed ext4
root@vm02:~# lxc restart c1

root@vm02:~# lxc exec c1 -- mount /dev/sdb /mnt
root@vm02:~# lxc exec c1 -- ls -lh /mnt
total 16K
drwx------ 2 root root 16K Jan 17 01:56 lost+found

root@vm02:~# lxc exec c1 -- apt-get install -y fuse2fs
Reading package lists... Done
Building dependency tree       
Reading state information... Done
The following package was automatically installed and is no longer required:
Use 'apt autoremove' to remove it.
The following NEW packages will be installed:
0 upgraded, 1 newly installed, 0 to remove and 4 not upgraded.
Need to get 28.8 kB of archives.
After this operation, 143 kB of additional disk space will be used.
Get:1 bionic-updates/universe amd64 fuse2fs amd64     1.44.1-1ubuntu1.2 [28.8 kB]
Fetched 28.8 kB in 0s (117 kB/s)
Selecting previously unselected package fuse2fs.
(Reading database ... 28654 files and directories currently installed.)
Preparing to unpack .../fuse2fs_1.44.1-1ubuntu1.2_amd64.deb ...
Unpacking fuse2fs (1.44.1-1ubuntu1.2) ...
Setting up fuse2fs (1.44.1-1ubuntu1.2) ...
Processing triggers for man-db (2.8.3-2ubuntu0.1) ...

root@vm02:~# lxc config unset c1 security.syscalls.intercept.mount.allowed
root@vm02:~# lxc config set c1 security.syscalls.intercept.mount.fuse ext4=/usr/sbin/fuse2fs
root@vm02:~# lxc restart c1

root@vm02:~# lxc exec c1 -- mount /dev/sdb /mnt
root@vm02:~# lxc exec c1 -- ls -lh /mnt
total 128K
drwx------ 2 root root 16K Jan 17 01:56 lost+found
root@vm02:~# lxc exec c1 -- ps aux | grep fuse
root       304  0.0  0.0 170172   788 ?        Ssl  02:00   0:00 /usr/sbin/fuse2fs /dev/sdb /mnt -o dev,suid

Additions to the resources API

Two new fields have been added to the disk entries in the resources API.

  • FirmwareVersion exposes the firmware revision of the network card
  • DeviceID shows a device identifier suitable for lookup under /dev/disk/by-id

An example for a NVME drive now looks like:

stgraber@castiana:~$ lxc query /1.0/resources | jq .storage.disks[0]
  "block_size": 512,
  "device": "259:0",
  "device_id": "nvme-eui.0000000001000000e4d25cafae2e4c00",
  "device_path": "pci-0000:05:00.0-nvme-1",
  "firmware_version": "PSF121C",
  "id": "nvme0n1",
  "model": "INTEL SSDPEKKW256G7",
  "numa_node": 0,
  "partitions": [
      "device": "259:1",
      "id": "nvme0n1p1",
      "partition": 1,
      "read_only": false,
      "size": 52428800
      "device": "259:2",
      "id": "nvme0n1p2",
      "partition": 2,
      "read_only": false,
      "size": 1073741824
      "device": "259:3",
      "id": "nvme0n1p3",
      "partition": 3,
      "read_only": false,
      "size": 254933278208
  "read_only": false,
  "removable": false,
  "rpm": 0,
  "serial": "BTPY63440ARH256D",
  "size": 256060514304,
  "type": "nvme",
  "wwn": "eui.0000000001000000e4d25cafae2e4c00"

Multi-architecture clustering

It is now possible to mix cluster members of different architectures.
LXD will automatically place containers on the right systems based on image architecture.

As a bit of an extreme example, here is a cluster made of 3 different non-Intel architectures:

root@cluster:~# lxc cluster list
|     NAME      |            URL             | DATABASE | STATE  |      MESSAGE      | ARCHITECTURE |
| bos01-arm64   |  | YES      | ONLINE | fully operational | aarch64      |
| bos01-ppc64el | | YES      | ONLINE | fully operational | ppc64le      |
| bos01-s390x   |  | YES      | ONLINE | fully operational | s390x        |
| bos02-arm64   | | NO       | ONLINE | fully operational | aarch64      |
| bos02-ppc64el | | NO       | ONLINE | fully operational | ppc64le      |
| bos02-s390x   |  | NO       | ONLINE | fully operational | s390x        |

Improved clustering setup logic

Prior to this release, when building up a LXD cluster, the first 3 servers to be part of the cluster would act as database nodes, receiving a full copy of the database and starting to vote on database transactions.

This behavior led many to believe that a cluster of just 2 servers was safe to operate despite the number of database members being even, preventing a proper quorum and effectively taking down the entire database should either of the servers go offline.

The new behavior is to keep operating with a single database server until the 3rd server is joined, at which point all 3 servers become database servers.

This will be further improved in LXD 3.20 with the introduction of standby database nodes allowing for multiple database nodes to go offline without the cluster itself going offline.

MAC filtering on unmanaged bridge

The security.mac_filtering configuration key can now be used with nic devices attached to network bridges that aren't managed by LXD itself.

Configurable Ceph data pool name

For those wanting separate OSD pools for their data and metadata, a new configuration key ceph.osd.data_pool_name was added allowing control of where the data should be stored. The metadata will be stored at the pool referenced by ceph.osd.pool_name.

LVM striping support

LVM striping is now supported, it can be configured through the volume.lvm.stripes and volume.lvm.stripes.size.

Initial CGroup2 resource restrictions

A new CGroup abstraction layer was added to LXD as well as an initial mapping for v2 resource controllers. This combined with recent improvements to liblxc should allow for most resource constraints to function in a CGroup V2 environment.

Configurable backup compression at creation time

The compression algorithm used for backups can be configured through backups.compression_algorithm but this is a global setting which will apply to all new backups.

In line with instance publishing (lxc publish), it is now possible to override the compression algorithm of backups at the time of their creation. This is exposed through lxc export --compression-algorithm.

Support for compressing backups and images using squashfs

squashfs can now be selected as compression algorithm for both images and backups.
Prior to this, LXD could consume images compressed through squashfs but couldn't create them itself.

Complete changelog

Here is a complete list of all changes in this release:

Full commit list
  • lxd/cgroup: Adds cgroup package with CPU task balancing functions
  • lxd: Updates to use cgroup package
  • lxd: Changes instance and containerLXC function Id() to ID()
  • lxd: Updates error handling of MakeFSType after stderr split of RunCommand
  • api: Add resources_network_firmware extension
  • shared/api: Add FirmwareVersion to ResourcesNetworkCard
  • lxd/resources/network: Add FirmwareVersion retrieval
  • lxd/container: Adds instanceLoad function
  • lxd: Replaces use of containerLXCLoad with instanceLoad
  • lxc: Changes lxc list and lxc info Type field to show instance type
  • i18n: Update translation templates
  • lxc/{list,info}: Fix type on older LXD
  • lxd/device/disk: Apply limits through post hook
  • lxd/main_migratedumpsuccess: Use fast connection
  • lxd/main_sql: Use fast connection
  • lxd/daemon: Allow internal queries during startup
  • test: Adds host-side MTU veth checks
  • lxd/device/disk: Improvements in disk limits
  • lxd: Fix backup expiry
  • lxd: Fix backup expiry check
  • api: Add backup_compression_algorithm API extension
  • shared/api: Add CompressionAlgorithm to InstanceBackupsPost
  • lxc/export: Add --compression option
  • i18n: Update translation templates
  • lxd/backups: Add support for CompressionAlgorithm
  • lxd: Fix container restore with projects in Ceph
  • test: Add container restore with projects
  • lxd/daemon: Adds daemon package
  • lxd: Updates use of debug and verbose vars in daemon pkg
  • lxd/rsync: Moves rsync functions to own package
  • lxd: Updates usage of moved rsync functions
  • doc: Add ceph.osd.data_pool_name
  • storage/ceph: Implement --data-pool argument
  • scripts: Add ceph.osd.data_pool_name to bash completion
  • api: Add ceph_data_pool_name extension
  • doc: Add commit structure to
  • lxd/cluster: Process upgrade notifications on all members
  • lxd/cluster: Relax upgrade notification target
  • lxd/db: Export GetNodeID
  • lxd/daemon: Skip heartbeat processing during startup
  • lxd/db: Backward compat code for Nodes()
  • lxd/daemon: Set gateway.Cluster during WaitUpgradeNotification
  • lxd/storage/ceph: Fix to work on older releases
  • lxd: Move backup to separate package
  • test: Add backup package to static analysis
  • test: Add project testing to backup
  • lxd/device/nic: Pass --concurrent to ebtables
  • tests: Update ebtables calls
  • fix rendering
  • lxd/sys: Enforce directory permissions
  • lxd/daemon: Bump NOFILE to max on startup
  • lxd/list: Modify parseColumns to allow for the config:KEY:NAME:WIDTH syntax
  • lxd/list: Modify TestColumns to allow for the config:KEY:NAME:WIDTH syntax
  • lxd/cluster: Tweak joining error messages
  • lxd/cluster: Fix already-clustered test
  • lxd/list: Add support for devices:KEY:NAME:WIDTH to parseColumns
  • lxd/list: Add tests to check support for devices:KEY:NAME:WIDTH and config:KEY:NAME:WIDTH in parseColumns
  • lxd/list: Add description in command help section about devices:KEY:NAME:WIDTH and config:KEY:NAME:WIDTH support
  • i18n: Update translation templates
  • lxc/storage/volume: Fix panic when invalid snapshot rename argument supplied
  • shared/util: Removes ExtractSnapshotName
  • lxd: Changes use of ExtractSnapshotName to ContainerGetParentAndSnapshotName
  • lxd/storage/volumes: Removes unused snapshot logic from storagePoolVolumeTypePost
  • seccomp: test for syscall continuation support
  • seccomp: implement syscall continuation for mknod(), mknodat(), and setxattr()
  • unixfd: split into unixfd.{c,h}
  • unixfd: hide symbols
  • Makefile: Switch to tsenart/deadcode
  • lxd/include: Don't include missing file
  • Revert "unixfd: hide symbols"
  • tree-wide: handle _GNU_SOURCE ifdefs correctly
  • Makefile: add "nocache" target
  • tree-wide: rework cgo compilation
  • Add step to trigger reread on loopback device when resizing BTRFS storage pool.
  • lxd/db/storage/pools: StoragePoolVolumeSnapshotsGetType returns StorageVolumeArgs slice
  • lxd/db/storage/pools: Makes StoragePoolVolumeSnapshotsGetType return in volume ID order
  • lxd: Updates use of StoragePoolVolumeSnapshotsGetType return type change
  • seccomp: log syscall arguments
  • package: lxd: add cgo.go
  • package: lxd-p2c: add cgo.go
  • package: seccomp: add cgo.go
  • package: quota: add cgo.go
  • package: storage: add cgo.go
  • package: ucred: add cgo.go
  • package: idmap: add cgo.go
  • package: netutils: add cgo.go
  • package: termios: add cgo.go
  • package: shared: add cgo.go
  • lxd: add cgo hardening flags and fix minor bugs found by them
  • lxd/storage/utils: Add common helpers to utils
  • lxd/storage/volumes/config: Removes functions moved to storage package
  • lxd: Updates use of funcs/vars moved to storage pkg
  • lxd/storage/drivers/utils: Add common functions
  • lxd/storage/drivers/utils: Adds GetVolumeMountPoint and GetPoolMountPoint functions
  • lxd/storage/drivers/utils: Adds DeleteParentSnapshotDirIfEmpty
  • lxd/storage/drivers/utils: Add GetVolumeSnapshotDir
  • lxd/storage/drivers/volume: Adds VolumeType and ContentType definitions
  • lxd/storage/storage: Deprecates pool path function
  • lxd/storage/drivers/errors: Adds storage drivers errors
  • lxd/storage/errors: Adds shared errors for storage
  • lxd/db/storage/pools: Improves comments on StoragePoolVolumeSnapshotsGetType
  • tests: Fixes zfs snapshot restore bug in tests
  • lxd/migration/migration/volumes: Adds migration volume arg types
  • lxd/storage: Removes progress wrapper functions
  • lxd: Update use of migration progress functions
  • seccomp: protect against syscall supervision override
  • client/lxd/storage/volumes: Fixes bug where migration errors were ignored
  • lxc/storage/volume: Adds volume snapshot rename check for same parent volume
  • lxd/storage/quota: Fix bad typing
  • lxd/containers: Return disk usage when stopped
  • lxd/storage/utils: Removes default empty "size" property for dir volumes
  • lxd/storage/utils: Makes dir driver allowed to translate the size property
  • tree-wide: cgo: add -Wunused and fix errors detected by this option
  • tree-wide: cgo: mark some global variables ro
  • lxc/config: Handle config/profile in examples
  • i18n: Update translation templates
  • forksyscall: add acquire_final_creds()
  • seccomp: implement mount syscall interception
  • api: add container_syscall_intercept_mount extension
  • doc: add security.syscalls.intercept.mount
  • scripts: add security.syscalls.intercept.mount to bash completion
  • client: Ignore unresolvable addresses
  • lxd/include: Fix definition of SECCOMP_USER_NOTIF_FLAG_CONTINUE
  • api: Add compression_squashfs extension
  • lxd/cluster: Validate squashfs-tools-ng executables
  • lxd: Modify compressFile() to support SquashFS
  • lxd/networks: Nicer error on misisng IPv6
  • global: Drop -Wcast-align (breaks armhf)
  • lxd: Support SquashFS compressed backup imports
  • lxd: Add SquashFS compressed image publish/export support
  • lxd/device/nic/bridged: Allow MAC filtering on unmanaged bridges
  • test: Adds test for using security.mac_filtering with unmanaged parent
  • doc: fix link to from
  • doc: use HTTPS links for criu and #lxcontainers (they have STS preload)
  • lxd/rsync: Switch to using io.ReadWriteCloser
  • shared: Implement a WebsocketIO ReadWriteCloser abstraction
  • lxd/migration: Introduce ProgressTracker
  • lxd/migration: Switch over to ReadWriteCloser for rsync
  • lxd/devlxd: Fixes event socket close on client disconnect during wait
  • lxd/events/events: Adds context to event listener Wait() function
  • lxd/events: Fixes event socket close on client disconnect during wait
  • lxd/migrate: Close control web socket on disconnect()
  • lxd/migrate/storage/volunes: Always close web socket after migration
  • lxd/storage: Adds interfaces
  • lxd/storage/load: Adds storage pool loader functions
  • lxd/storage/drivers/driver: Adds storage driver load functions
  • lxd/storage/backend/lxd: Adds lxd backend implementation
  • lxd/storage/backend/mock: Adds mock backend implementation
  • lxd/storage/drivers/driver/common: Adds common driver
  • lxd/storage/drivers/driver/dir: Add dir backend
  • lxd/storage/volumes: Links doVolumeCreateOrCopy to use storage pkg
  • test/suites/static/analysis: Updates to recurse storage package
  • lxd/storage/volumes: Links volume delete function to use new storage pkg
  • lxd/storage/utils: Adds VolumeTypeToDBType function
  • lxd/storage/utils: Modifies VolumeValidateConfig to hook into new storage API
  • lxd/storage/utils: Deprecates SupportedPoolTypes
  • lxd/storage/drivers/volume: Adds Volume struct type
  • lxd/storage/volumes: Re-works storagePoolVolumeTypePost into sub-actions
  • lxd/storage/volumes/snapshot: Renames driver import to storagePools
  • lxd/storage/volumes/snapshot: Links rename snapshot volume to new storage pkg
  • lxd/storage/volumes/snapshot: Links snapshot delete to new storage pkg
  • lxd/storage/volumes/snapshot: Links create custom snapshot to new storage pkg
  • lxd/storage/volumes: Moves DB lookup into migration function
  • lxd/migrate/storage/volumes: Links volume migrate functions to new storage pkg
  • lxd/storage/volumes: Linking volume move to new storage pkg
  • lxd/storage/volumes: Adds existing volume checks to storagePoolVolumeTypePost and storagePoolVolumesTypePost
  • lxd/storage/drivers/utils: Adds GetSnapshotVolumeName function
  • lxd/storage/drivers/utils: Renames GetVolumeMountPath and GetPoolMountPath
  • lxd/storage: Updates deprecation notice
  • lxd/storage/drivers/utils/test: Updates tests
  • lxd/storage/utils: Adds validateVolumeCommonRules
  • lxd/migration/migration/volumes: Updates MatchTypes to log offered and our types on mismatch
  • lxd/storage/memorypipe: Adds in-memory bidirectional pipe
  • lxd/migrate/storage/volumes: Updates use of migrate TrackProgress args
  • lxd/storage/backend/lxd: Updates CreateCustomVolumeFromCopy to use migration logic
  • lxd/storage/drivers/driver/common: Improves comment
  • lxd/migration/migration/volumes: Adds TrackProgress bool to MigrationSourceArgs and MigrationTargetArgs
  • lxd/storage/drivers/driver/dir: Updates migration functions to use TrackProgress bool
  • lxd/containers: Push MAAS entry after dev creation
  • lxd/storage/drivers/interface: Modifies ValidateVolume definition
  • lxd/storage/utils: Updates ValidateVolume usage
  • lxd/storage/backend/lxd: Updates use of validate function
  • lxd/storage/drivers/driver/common: Updates validate function
  • lxd/storage/drivers/driver/dir: Updates validation function
  • forksyscall: remove left-over advance_arg() call
  • lxd/migration/migration/volumes: Updates MatchTypes to accept fallback type
  • lxd/migration/storage/volumes: Updates MatchTypes usage
  • lxd/storage/backend/lxd: Updates MatchTypes usage
  • lxc/storage/volumes: Links storagePoolVolumeTypePatch to new storage pkg
  • lxd/storage/volumes/utils: Links storagePoolVolumeUsedByRunningContainersWithProfilesGet to storage pkg
  • lxd/storage/utils: Adds VolumeUsedByInstancesWithProfiles
  • lxd/storage/volumes: Links storagePoolVolumeTypePut to storage pkg
  • lxd/storage/drivers/interface: Updates function definitions
  • lxd/storage/backend: UpdateCustomVolume and RestoreCustomVolume
  • lxd/storage/drivers/driver/dir: Adds UpdateVolume function
  • lxd/storage/volumes: Consistent casing on error messages
  • lxd/storage/utils: Consistent casing on error messages
  • lxd/storage/interfaces: Adds RestoreCustomVolume
  • lxd/storage/drivers/interface: Adds RestoreVolume
  • lxd/storage/drivers/driver/dir: Implements RestoreVolume
  • lxd/storage/backend/mock: Adds RestoreCustomVolume
  • lxd/storage/volumes: Makes storagePoolVolumeTypePut logic consistent with storagePoolVolumeSnapshotTypePut
  • lxd/storage/volumes/snapshot: Moves storagePoolVolumeSnapshotTypePut DB logic
  • lxd/storage/volumes/utils: Removes unused storagePoolVolumeSnapshotUpdate
  • lxd/storage: Use correct operation type
  • lxd/storage/backend/lxd: Adds basic debug logging
  • lxd/storage/backend/mock: Adds logger support
  • lxd/storage/load: Initialises logger
  • lxd/storage/drivers/driver/common: Adds driver logger with pool context
  • lxd/storage/drivers/interface: Updates with pool context logger
  • lxd/storage/utils: Updates VolumeValidateConfig to use update driver loader
  • lxd/storage/load: Updates loaders to support contextual loggers
  • lxd/storage/drivers/load: Updates loaders to support contextual loggers
  • container/lxc: Hooks up root device usage to new storage package
  • lxd/storage/backend/lxd: Updates name of instance arg to inst from i
  • lxd/storage/backend/lxd: Implements GetInstanceUsage
  • lxd/storage/backend/mock: Changes GetInstanceUsage signature
  • lxd/storage/drivers/driver/dir: Implements GetVolumeUsage
  • lxd/storage/drivers/interface: Adds GetVolumeUsage
  • lxd/storage/interfaces: Changes GetInstanceUsage signature
  • lxd/images: Links imageCreateInPool to new storage package
  • lxd/storage/backend/lxd: Implements CreateImage
  • lxd/storage/backend/mock: Updates CreateImage definition
  • lxd/storage/interfaces: Updates CreateImage definition
  • lxd/resources/storage: Improve cdrom handling
  • Bring Go current in Travis
  • lxd/storage/drivers/driver/dir: Adds warnings of ext4 project quota not supported
  • lxd/storage/load: Adds GetPoolByInstanceName
  • lxd/container: Links containerCreateFromImage to new storage layer
  • lxd/containers/post: Moves progress tracker into containerCreateFromImage
  • lxd/images: Removes old unpackImage
  • lxd/storage/backend/lxd: Implements CreateInstanceFromImage
  • lxd/storage/drivers/driver/dir: Switches to using volume.CreateMounthPath()
  • lxd/storage/drivers/volume: Adds CreateMountPath
  • lxd/storage/load: Improves getVolID error when volume not found
  • lxd/storage/utils: Adds InstanceTypeToVolumeType
  • lxd/storage/utils: Adds ImageUnpack
  • test/suites/basic: Updates tests to take into account more secure volume perms
  • lxd: Updates use of driver.ImageUnpack
  • lxd/storage/load: Makes volIDFuncMake project aware
  • lxd/storage/drivers/driver/dir: Ensures old snapshor dir removed in RenameVolume
  • lxd/storage/drivers: Expose BlockBacking property
  • lxd/storage: Pass BlockBacking to ImageUnpack
  • lxd/storage: Change default container permissions to 0100
  • lxd/storage: Implement CreateImage
  • lxd/storage/dir: Don't fail/complain about missing quotas
  • lxd/devices/nic: Handle recent ebtables
  • lxd/rsync: Tweaks Recv's internal synchronisation to avoid race
  • lxd: Minor changes
  • lxd/storage: Fix custom volume with underscores
  • lxd/images: Updates imageCreateInPool to use EnsureImage
  • lxd/storage/backend/lxd: Updates EnsureImage usage and adds more comments
  • lxd/storage/backend/mock: Updates with EnsureImage
  • lxd/storage/interfaces: Renames CreateImage to EnsureImage
  • lxd/storage/load: Adds comments
  • lxd/cluster: add Recover() and ListDatabaseNodes() utilities
  • lxd/storage/drivers: Add mountReadOnly helper
  • lxd/storage/dir: Make snapshot mounts read-only
  • lxd/storage/dir: Only log project quota failures when relevant
  • lxd/container/lxc: Links container Delete() to new storage package
  • lxd/container/lxc: Improves error logging in diskState
  • lxd/storage/backend/lxd: Removes duplicated code from DeleteCustomVolume
  • lxd/storage/backend/lxd: Adds symlink management functions
  • lxd/storage/backend/lxd: Adds Instance and Instance Snapshot delete functions
  • lxd/storage/drivers/driver/dir: Reinstates DeleteParentSnapshotDirIfEmpty for volume and snapshot deletion
  • lxd/storage/drivers/utils: Updates DeleteParentSnapshotDirIfEmpty to also remove symlink
  • lxd/storage/interfaces: Adds IsSnapshot to Instance interface
  • lxd/storage/dir: Don't write to snapshots
  • lxd/container: Fix apply_quota
  • lxd/storage/lvm: Fix version parsing
  • lxd/storage/drivers/driver/dir: Comment grammar consistency
  • lxd/storage/load: Renames GetPoolByInstanceName to GetPoolByInstance
  • lxd/container: Updates use of storagePools.GetPoolByInstance and fallback for container types
  • lxd/storage/drivers/errors: Removes unused error
  • lxc/init: Properly handle errors with --empty
  • lxd/container: Links containerCreateAsEmpty to new storage package
  • lxd/container: Adds revert to containerCreateFromImage
  • lxd/container: containerCreateFromImage comment
  • lxd/storage/drivers/utils: Makes GetVolumeSnapshotDir work with either snapshot or parent vol name
  • lxd/storage/drivers/utils: Removes symlink removal from DeleteParentSnapshotDirIfEmpty
  • lxd/storage/backend/lxd: CreateInstance
  • lxd/storage/backend/lxd: Updates instance snapshot symlink removal
  • lxd/storage/backend/lxd: Updates instance snapshot symlink management functions
  • lxd/container/lxc: Removes TemplateApply() and adds DeferTemplateApply()
  • lxd/containers/post: DeferTemplateApply usage
  • lxd/instance/interface: DeferTemplateApply usage
  • lxd/storage/interfaces: DeferTemplateApply signature
  • lxd/storage: DeferTemplateApply usage
  • lxd/storage/interfaces: Updates instance mount function definitions
  • lxd/storage/backend/mock: Updates instance mount function definitions
  • lxd/storage/backend/lxd: Implements instance mount and unmount functions
  • lxd/operations: Fix remote Wait
  • lxc/query: Fix handling of ?project=
  • lxd/storage/backend/lxd: Instance function comment consistency
  • lxd/device/device/utils/disk: Changes signature of StorageRootFSApplyQuota
  • lxd/device/disk: Updates applyQuota to use error from storage package
  • lxd/storage: Links storageRootFSApplyQuota to new storage package
  • lxd/storage/backend/lxd: SetInstanceQuota
  • lxd/storage/backend/mock: SetInstanceQuota
  • lxd/storage/drivers/dir: Adds SetVolumeQuota and RunningQuotaResize info flag
  • lxd/storage/drivers/interface: SetVolumeQuota signature
  • lxd/storage/drivers/load: Adds RunningQuotaResize to driver Info struct
  • lxd/storage/errors: Adds ErrRunningQuotaResizeNotSupported error
  • lxd/storage/interfaces: SetInstanceQuota signature
  • lxd/container: Links containerConfigureInternal to new storage package
  • lxd/db: Cover all combinations of instance filters
  • lxd/db: Re-generate DB code
  • lxd/storage/drivers: Add locking
  • lxd/storage/drivers: Add cephfs
  • lxd/storage/drivers: Make locks per-pool
  • lxd/storage/cephfs: Fill remaining Info fields
  • lxd/storage/cephfs: Use SetVolumeQuota in UpdateVolume
  • lxd/storage/cephfs: Don't run RemoveAll on snapshots
  • lxd/container/lxc: Links Rename to new storage package
  • lxd/storage/backend/lxd: Reworks symlink functions
  • lxd/storage/cephfs: Simplify rename logic
  • lxd/storage/cephfs: Comment consistency
  • lxd/storage/backend/lxd: RenameInstance
  • lxd/storage/interfaces: Removes unused Path function in Instance interface
  • lxc/move: Fixes instance snapshot rename validation and crash
  • lxd/storage/backend/lxd: RenameInstanceSnapshot
  • lxd/storage/cephfs: Implement GetVolumeUsage
  • lxd/storage/dir: Properly revert snapshots
  • lxd/storage/cephfs: Fix SetVolumeQuota
  • lxd/storage/cephfs: Fix ordering in Copy/Migration
  • Move renderTable to utils.RenderTable()
  • Add new "lxd cluster" sub-command
  • Add clustering_recover integration test
  • add documentation about disaster recovery
  • lxd/storage/dir: Add check for bad source path
  • lxd/storage: Add localOnly handling of create/delete
  • lxd/operations: Support nil state
  • lxd/storage: Switch Create to new logic
  • lxd/storage/utils: Only create needed directories
  • lxd/storage/cephfs: Fix bad config keys
  • lxd/storage: Switch Delete to new logic
  • lxd/storage: Switch Mount to new logic
  • lxd/storage/cephfs: Don't fail if already mounted
  • lxd/api/internal: Updates use of renamed functions
  • lxd/container: Updates return values of instance create and load functions
  • lxc/container: Renames containerCreateFromImage to instanceCreateFromImage
  • lxd/container: Renames containerCreateInternal to instanceCreateInternal
  • lxd/container/lxc: Updates use of renamed c.state.Cluster.InstanceRemove
  • lxd/containers/post: Adds VM support to createFromImage
  • lxd/db/containers: Renames ContainerRemove to InstanceRemove
  • lxd/container: Renames containerCreateAsEmpty to containerCreateAsEmpty
  • lxd/containers/post: Updates use of instanceCreateAsEmpty
  • lxd/storage/backend/lxd: Pass correct content type to storage drivers for VMs
  • lxd/storage/drivers/utils: Unexports deleteParentSnapshotDirIfEmpty
  • lxd/storage/drivers/driver/dir: Updates use of deleteParentSnapshotDirIfEmpty
  • lxd/container/lxc: Updating DB usage to be instance type agnostic
  • lxd/container/post: Updates usage of InstancePool
  • lxd/container/test: Updates instanceCreateInternal usage
  • lxd/api/internal: InstancePath usage
  • lxd/container/lxc: InstancePath usage
  • lxd/storage/backend/lxd: InstancePath usage
  • lxd/storage/storage: Renames ContainerPath to InstancePath
  • lxd/storage/dir: InstancePath usage
  • lxd/storage/zfs: InstancePath usage
  • lxd/container/test: InstancePath usage
  • lxd/db/storage/pools: Adds VM instance type constant and conversion codes
  • lxd/db/containers: Updates pool lookup functions to be instance type agnostic
  • lxd/storage/load: InstancePool usage
  • lxd/db/containers/test: InstancePool usage
  • lxd/storage: InstancePool usage
  • lxd/storage/dir: Don't apply quotas on snapshots
  • lxd/device/nic: Fix race in vlan creation
  • lxd/device/nic: Fix handling of shared vlans
  • lxd/storage/cephfs: Store version globally
  • lxd/storage/drivers: Drop Usable field
  • lxd/storage/drivers: Implement load function
  • lxd/storage/cephfs: Implement load
  • lxc/init: Adds vm flag to init command
  • lxc/copy: copyContainer tweaks
  • lxd/container: Adds support for VM creation to instanceCreateInternal
  • lxd/container: Adds VM support to instanceLoad
  • lxd/storage/drivers/utils: Adds createSparseFile
  • lxd/storage/backend/lxd: Signature and comment tweaks for filler function
  • lxd/storage/drivers/driver/cephfs: filler usage update
  • lxd/storage/drivers/driver/dir: Adds VM support to CreateVolume
  • lxd/storage/drivers/driver/dir: Adds content type checking to some functions
  • lxd/storage/drivers/interface: CreateVolume signature update for filler change
  • lxd/storage/utils: Adds VM type conversion
  • lxd/storage/utils: Updates ImageUnpack to support VM images
  • lxd/storage: Updates ImageUnpack usage
  • lxd/sys/fs: Adds VM dirs
  • lxd/containers: Renames containerDeleteSnapshots to instanceDeleteSnapshots
  • lxd/container/lxc: instanceDeleteSnapshots usage
  • lxd/device/device/utils/network: Adds networkCreateTap
  • lxd/device/nic/bridged: Adds initial support for VM
  • lxd/device/disk: Initial VM support
  • lxd/storage/backend/lxd: GetInstanceDisk implementation
  • lxd/storage/drivers/driver/ceph: GetVolumeDiskPath placeholder
  • lxd/storage/drivers/driver/dir: GetVolumeDiskPath implementation
  • lxd/storage/drivers/interface: Adds GetVolumeDiskPath
  • lxd/container/console: Improves resilience of console checking
  • shared/container: Adds support for vm.uuid volatile key
  • lxd/container: progress meta data
  • lxd/containers/post: createFromImage instances created field
  • lxd/storage/backend/lxd: CreateInstanceFromCopy qcow2 comment
  • i18n: Update translation templates
  • lxd/containers/post: createFromNone VM support
  • lxd: Move IsJSONRequest to util package
  • client: Add vsock support
  • client: Add ConnectLXDHTTP function
  • lxd/vsock: Add vsock HTTP client
  • lxd-agent: Add basic structure
  • lxd-agent: Add state command
  • lxd-agent: Add operations command
  • lxd-agent: Add exec command
  • lxd-agent: Add file command
  • shared/idmap: Fix build tags
  • lxd/util: Restrict sys.go to LXD itself
  • lxd/sys: Restrict to LXD itself
  • lxd/state: Use empty struct when not LXD
  • lxd/response: Split SmartError into LXD/non-LXD
  • lxd/operations: Disconnect from DB on non-LXD
  • lxd/endpoints: Allow building on non-Linux
  • lxd/db: Allow external use without dqlite
  • Fix golint warnings
  • lxd/container: Improves create from imate type mismatch error
  • lxd/container/console: Makes console logic instance type agnostic
  • lxd/container/lxc: Updates Console to return an os.File
  • lxd/instance/interface: Updates Console signature
  • lxd/db/images: Fixes bug in ImageSourceGetCachedFingerprint not applying image type filter
  • shared/cert: Useful comment about cert type on FindOrGenCert
  • lxd/vm/qemu: Initial implementation of VM Qemu instance type
  • client/connection: Simplifies ConnectLXDHTTP
  • lxd/vm/qemu: Adds agent connection setup
  • lxd/vsock: Simplifies HTTPClient
  • lxd/vm/qemu: Implement FilePush for VMs
  • lxd/vm/qemu: Implement FilePull for VMs
  • lxc/storage: Add support for virtual-machine volumes
  • lxd/storage: Add support for virtual-machine volumes
  • lxd/vm: Set WorkingDirectory in unit
  • lxd/vm: Fix TLS authentication to agent
  • lxd-agent: Fix golint
  • lxd-agent: Remove dead code
  • lxd-agent: Function name consistency
  • lxd-agent: Avoid global variables
  • lxd-agent: Load certs from current dir
  • Makefile: Have default build static lxd-p2c
  • Makefile: Add lxd-agent
  • lxd-agent: Port to cobra
  • lxd-agent: Re-order imports
  • lxd/vsock: Switch to single implementation
  • api: Add extention for passing in raw mount options
  • doc/container: added raw_mount_options to disk options
  • lxd/device add support for raw_mount_options for disk device mounts
  • tests: Add test for raw.mount.options for disk device mounts
  • lxc/image: Truncate image files down to size
  • lxd/images: Truncate image files down to size
  • client: Add Disconnect function
  • lxd/vm: Fix UEFI secure boot
  • lxd/vm: Use filepath rather than manual joining
  • lxd/device/nic/ipvlan: removes unused optional "host_name" config field.
  • lxd/device/nic/routed: Adds veth routed NIC device
  • shared/version/api: Adds container_nic_routed API extension
  • doc/containers: Adds routed nic type docs
  • test: Adds routed nic tests
  • seccomp: implement redirection to fuse
  • api: add container_syscall_intercept_mount_fuse extension
  • doc: add security.syscalls.intercept.mount.fuse
  • scripts: add security.syscalls.intercept.mount.fuse
  • lxd/vm: Cleanup config layout
  • lxd/vm: Add an identifying serial device
  • lxd/vm/qemu: Adds missing secure boot EFI firmware error
  • seccomp: only apply shift when it is needed
  • shared/simplestreams: Support disk-kvm.img
  • shared/cert: Make adding of ip/names optional
  • lxc/config: Update to changed cert functions
  • lxd/util: Update to changed cert functions
  • lxd/vm: Update to changed cert functions
  • lxd-agent: Update to changed cert functions
  • lxd-p2c: Update to changed cert functions
  • lxc-to-lxd: Update to changed cert functions
  • seccomp: test flag parsing and log ignored flags
  • shared: Update to changed cert functions
  • seccomp: attach to pid namespace when mounting through fuse
  • lxd-agent: Generate the cloud-init configuration
  • lxd/vm: Use 9p for agent drive
  • lxd/storage: Only use raw images
  • lxd/storage/drivers: Don't return disk type
  • lxd/storage: Don't return disk type
  • lxd: Use raw disk images only
  • lxd/vm: Add install script in 9p
  • lxd/device/disk: Adds support for generating VM config drive
  • lxd/device/nic/bridged: Adds hwaddr to runConf when instance type is VM
  • lxd/vm/qemu: Modifies qemu config generation to support dynamic devices
  • lxd/container: Renames containerValidDevices to instanceValidDevices
  • lxd/device/device/instance: Adds Path() to Instance interface
  • lxd/device/disk: Adds support for generating VM cloud-init config drive
  • lxd: Updates instanceValidDevices usage
  • lxd: Fixes bug in fillNetworkDevice volatile hwaddr generation
  • lxd/vm/qemu: Fix root disk path in device
  • lxd/vm/qemu: Only connect to VM agent to get state if VM is running
  • lxd/vm/qemu: Comment about generateConfigShare meta-data generation
  • lxd/device/unix/common: Device naming functions usage
  • lxd/device/device/utils/generic: Adds generic device naming functions
  • lxd/device/gpu: Device naming functions usage
  • lxd/device/disk: Uses generic device name path functions
  • lxd/device/device/utils/unix: Device naming functions usage
  • lxd/device/device/utils/unix: Removes unused device naming functions
  • lxd/include: Fix SECCOMP_GET_ACTION_AVAIL define
  • lxd/vm: Update systemd units
  • lxd: Cleanup storage volumes properly for VMs
  • lxd/instances: Add /1.0/virtual-machines
  • lxd/storage: Fix GetVolumeSnapshotDir return value
  • lxd/vm: Implement Exec for VMs
  • lxd-agent: Proper logger
  • lxd/container/exec: Don't require cmd to be returned from inst.Exec()
  • lxd-agent/exec: Add buffered channel to prevent deadlock on cmd exit
  • client/lxd: log websocket URL
  • client/lxd/events: Fixes /events connect bug
  • lxd-agent/exec: Fixes go routine leak
  • lxd-agent/daemon: Adds daemon for storing event server to agent
  • lxd-agent/events: Adds /events websocket route to agent
  • lxd/state/notlinux: Adds Events field to non-linux/agent State struct
  • lxd/operations/operations: Adds SetEventServer function
  • lxd/operations: Reinstates sending events when no state
  • lxd-agent/exec: Links daemon's event server to operation
  • lxd-agent: Adds daemon to request
  • lxd: More event socket logging
  • lxd/vm/qemu: Disconnects VM agent after use
  • lxd/vm/qemu: Interactive unbuffered exec console
  • lxd-agent: Add missing setsid call on exec
  • lxd-agent: Fix uid/gid/cwd in exec
  • lxd/agent/exec: More debug status messages for exec handler
  • lxd/container/exec: Updates exec handler to use new inst.Exec signature
  • lxd/container/lxc: Updates Exec() to return a instance.Cmd
  • lxd/instance/interface: Updates Exec() function to be local or remote command agnostic
  • lxd/vm/qemu: Updates Exec() to return instance.Cmd
  • lxd/container/lxc/exec/cmd: Implementation of instance.Cmd for containerLXC
  • lxd/vm/qemu/cmd: Implementation of instance.Cmd for vmQemu
  • lxd/instance/instance/exec/cmd: Cmd interface
  • lxd-agent/exec: Removes \n from logging
  • lxd/vm/qemu: Better error message to users when failing to connect to lxd-agent
  • lxd-agent/exec: Makes the terminal the controlling terminal of the calling process
  • lxd/vm: Make OVMF path configurable
  • lxd/vm/qemu: Comment ending consistency
  • lxd/vm/qemu: Handle deletion of storage volume DB record when reverting VM create
  • lxd/storage/backend/lxd: Adds same pool optimisation to CreateCustomVolumeFromCopy
  • lxd/container: container to instance renames, comment improvements
  • lxd/containers/post: Adds instances field to response from createFromCopy
  • lxd/container: instanceCreateAsCopy rename and revertion logic
  • lxd/container: instanceCreateInternal comment
  • lxd/containers/post: instanceCreateAsCopy usage
  • scripts/bash: Refresh list of commands
  • api: Add container_disk_ceph API extension
  • lxd: Add support for CEPH FS backed disks and CEPH RBD backed disks
  • tests: Add test for CEPH backed disks
  • doc: Add support for CEPH backed disks
  • lxd: Fixing srcPath check for cephs
  • lxd: Correct srcPath check for cephs
  • lxd: Fixing single quote on ceph check
  • lxd/device/disk: Fix mounting cephfs
  • lxd/device/disk: Format blocks a bit
  • tests: Fix typo in cephfs test
  • lxd: Fix ceph_rbd volatile key
  • lxd/storage: Rename storagePoolVolumeUsedByContainersGet
  • lxd/storage: Rename storagePoolVolumeUsedByRunningInstancesWithProfilesGet
  • lxd: Have instanceLoadByProject return all instances
  • lxd/vm: Use leases to get IP
  • lxd/storage/zfs: Fix migration on zfs 0.6
  • lxd/vm/qemu: Removes deprecated Storage() function
  • lxd/instance/instance/interface: Moves Instance interface into instance pkg
  • lxd/instance/interface: Removes old Instance interface
  • lxd: Updates references to Instance interface
  • lxd/storage: Fix DeleteImage return value
  • lxd/storage/cephfs: Properly handle root path
  • lxd/vm: Reverse interface counters
  • lxd/container: Adds operation arg to instanceCreateAsCopy
  • lxd/containers/post: Passes operation to instanceCreateAsCopy
  • lxd/container: Links instanceCreateAsCopy to new storage pkg
  • lxd/container: source snapshot var naming for clarity
  • lxd/storage/interfaces: Exposes ExpandedDevices() on Instance interface
  • lxd/storage/interfaces: Updates Instance migration signatures
  • lxd/storage/interfaces: Changes i arg var to inst to represent Instance
  • lxd/storage/backend/mock: Updates instance migration signatures
  • lxd/db/containers: Removes unused ContainerCreationUpdate replaces with InstanceSnapshotCreationUpdate
  • lxd/migrate/storage/volumes: Fixes typo
  • lxd/migration/interfaces: Removes unused definitions
  • lxd/storage/backend/lxd: Updates CreateInstance to use root disk device config
  • lxd/storage/backend/lxd: Implements CreateInstanceFromCopy
  • lxd/storage/backend/lxd: Updates CreateInstanceFromImage to use instance root disk config
  • lxd/storage/backend/lxd: Implements CreateInstanceFromMigration
  • lxd/storage/backend/lxd: Implements MigrateInstance
  • lxd/storage/backend/lxd: Adds comment to EnsureImage explaining for volume config not needed
  • lxd/storage/backend/lxd: Comment consistency in CreateCustomVolumeFromCopy
  • lxd/storage/backend/lxd: Add comment to MigrateCustomVolume explaining volume config not needed
  • lxd/storage/backend/lxd: Close migration connection on error in CreateCustomVolumeFromMigration
  • lxd/device/device/runconfig: Moves to device/config pkg
  • lxd/instance/instance/interface: Removes device pkg import
  • lxd: Updates use of deviceConfig.RunConfig
  • Use the node ID from the nodes ID table, not the raft one
  • lxd/patches: Fix database roles
  • lxd/container/lxc: Reorders containerLXC Delete() stages
  • lxd/vm/qemu: Makes Delete() aligned with containerLXC's Delete()
  • lxd/container: Removes instanceCompareSnapshots
  • lxd/instance/instance/utils: Adds CompareSnapshots function
  • lxd/container: Updates instance.CompareSnapshots usage
  • lxd/container: Links instanceCreateAsCopy refresh instance to new storage pkg
  • lxd/storage/interfaces: RefreshInstance signature
  • lxd/storage/backend/lxd: Implements RefreshInstance
  • lxd/storage/backend/mock: RefreshInstance placeholder
  • lxd/storage/drivers/interface: Adds RefreshVolume
  • lxd/storage/drivers/driver/cephfs: Adds RefreshVolume placeholder
  • lxd/migration/migration/volumes: Adds Refresh property to VolumeTargetArgs
  • lxd/storage/drivers/driver/dir: RefreshVolume implementation
  • lxd/storage/drivers/volume: Adds Name() function
  • lxd/storage/backend/lxd: Adds HasVolume checks to CreateInstanceFromMigration and CreateInstanceFromCopy
  • lxd/cluster: Only promote to database role if >= 3 members
  • doc/clustering: Document database role during cluster scaling
  • lxd/vm/qemu: Adds storage pool Mount/Unmount calls
  • lxd/device/disk: Prevents error logs about unsupported disk drive on VM stop
  • lxd/vm: Add support for aarch64
  • api: Add virtual-machines API extension
  • shared: Rename ContainerAction to InstanceAction
  • shared: Rename KnownContainerConfigKeys to KnownInstanceConfigKeys
  • shared: Rename ContainerGetParentAndSnapshotName to InstanceGetParentAndSnapshotName
  • lxc: Update for ContainerGetParentAndSnapshotName rename
  • lxd/containers: Update for ContainerAction rename
  • lxd: Update for ContainerGetParentAndSnapshotName rename
  • doc/api-extensions: Fix escaping
  • doc: Rename containers to instances
  • doc/instances: Description consistency
  • doc/instances: Fix escaping and alignment
  • doc/profiles: Update for instances
  • doc: Add containers/virtual-machines pages
  • lxc: Update for KnownInstanceConfigKeys
  • doc/instances: Remove API extensions
  • doc/instances: Add missing volatile keys
  • doc: Add new pages to metadata
  • tests: Update unit and integration tests for cluster join
  • lxd: Add raw.qemu
  • shared: Add raw.qemu
  • doc: Add raw.qemu
  • scripts/bash: Add raw.qemu
  • lxd: Add security.secureboot
  • shared: Add security.secureboot
  • doc: Add security.secureboot
  • scripts/bash: Add security.secureboot
  • lxd: Instance is not container type error consistency
  • lxd/container: Removes container type
  • lxd: Removes use of container type
  • lxd: Renames containerCreateAsSnapshot to instanceCreateAsSnapshot
  • lxd/container/snaphot: Returns instances property in response
  • lxd/container/snapshot: Removes duplicated instance type check
  • lxd/storage: Changes CreateInstanceSnapshot signature to accept source instance
  • lxd: Hooks instanceCreateAsSnapshot up to new storage pkg
  • lxd/storage/drivers/load: Adds RunningSnapshotFreeze to driver Info struct
  • shared/generate: Insert build tag
  • lxd/storage/drivers/driver/dir: Defines dir driver needs freeze during snapshot
  • lxd/storage/backend/lxd: Adds snapshot check to ensureInstanceSymlink
  • lxd/storage/backend/lxd: Implements CreateInstanceSnapshot
  • doc: Documents the VM cloud-init:config drive option
  • lxd-agent: Put /snap/bin in PATH
  • lxd/storage/btrfs: Fix StorageEntitySetQuota
  • seccomp: block new mount API when mount interception is requested
  • lxd/networks: Merge clsuter config on create
  • lxd/networks: Forward config updates
  • lxd/storage: Renames interfaces.go to pool_interface.go
  • lxd/storage/pool/interface: Removes Instance interface
  • lxd/storage: Switches to use instance.Instance interface
  • lxd/container/put: Renames containerSnapRestore to instanceSnapRestore
  • lxd/container/lxc: Links snapshot Restore() to new storage pkg
  • lxd/storage/interfaces: RestoreInstanceSnapshot signature
  • lxd/storage/backend/mock: RestoreInstanceSnapshot signature
  • lxd/storage/backend/lxd: Implements RestoreInstanceSnapshot
  • lxd/container/backup: Comment tweaks and inst var rename
  • lxd/backup: Links backupCreate to new storage pkg
  • lxd/storage/drivers/driver/dir: rsync.LocalCopy return value consistency
  • lxd/storage/backend/lxd: Ensures all instance functions use project aware storage names
  • lxd/storage/backend/lxd: Implements BackupInstance
  • lxd/storage/drivers/interface: Adds BackupVolume
  • lxd/storage/drivers/driver/cephfs: Adds BackupVolume placeholder
  • lxd/storage/drivers/driver/dir: Adds BackupVolume
  • shared/archive/linux: Adds some explanation to DetectCompressionFile
  • lxd/images: Adds more output detail when tar2sqfs fails in compressFile
  • lxd/container: instanceCreateFromBackup restructure so as not to return storage
  • lxd/containers/post: Updates createFromBackup to not need storage returned from instanceCreateFromBackup
  • lxd/images: Fix image pruning with projects
  • lxd/images: Fix VM image export
  • client: Fix VM image export
  • shared: Un-restrict archive.go
  • shared: Add qcow2
  • client: Fix VM image import
  • lxc/image: Detect type on import
  • Rename containers to instances in db views
  • Drive-by fix of UsedBy for networks
  • lxd/vm: Add limits.memory.hugepages
  • shared: Add limits.memory.hugepages
  • doc: Add limits.memory.hugepages
  • scripts/bash: Add limits.memory.hugepages
  • doc/instances: Indicate VM support when applicable
  • shared: Cleanup console on error
  • lxd: Cleanup console on error
  • lxd/console: Improve disconnection handling
  • lxd/vm: Add locking around console
  • Remove accidentally committed testimage.tar.xz
  • Add arch column to nodes table
  • Add NodeAddWithArch() method to add a node with a specific arch
  • lxd/backup/backup/instance/config: Adds instance config backup.yml tools
  • lxd/api/internal: Removes slurpBackupFile and switches to backup.ParseInstanceConfigYamlFile
  • lxd/backup: Removes backupFixStoragePool
  • lxd/containers/post: Updates instanceCreateFromBackup usage
  • lxd/container: Updates instanceCreateFromBackup signature
  • lxd/backup/backup/instance/config: UpdateInstanceConfigStoragePool no longer updates snapshots backup.yaml
  • lxd: Comment improvements
  • lxd/containers/post: Adds storage pool check to createFromBackup
  • lxd/container: Removes storage pool check from instanceCreateFromBackup
  • lxd/backup/backup: Removes squashfs handling from GetInfo
  • lxd/container: Removes squashfs handling from instanceCreateBackup
  • lxd/containers/post: Moves backup restore squashfs handling to createFromBackup
  • Document container launch algorithm on cluster
  • lxd/storage/utils: Adds InstanceContentType
  • lxd/container/post: Cleans up createFromMigration
  • lxd/storage/zfs: Fix pool import
  • lxd/container/lxc: Updates use of backupFile to backup.InstanceConfig
  • lxd/storage/backend/lxd: Implements CreateInstanceFromBackup
  • lxd/storage: Updates CreateInstanceFromBackup signature
  • lxd/container: Updates instanceCreateFromBackup to use new storage pkg
  • lxd/containers/post: Updates instanceCreateFromBackup usage with hooks
  • lxd/backup/backup/instance/config: Updates UpdateInstanceConfigStoragePool to take mount path
  • lxd/container: Updates backup.UpdateInstanceConfigStoragePool usage
  • lxd/storage/backend/lxd: Switches to InstanceContentType function
  • lxd/storage/drivers/interface: RestoreBackupVolume signature
  • lxd/storage/drivers/driver/cephfs: RestoreBackupVolume placeholder
  • lxd/storage/drivers/driver/dir: Moves initial project quota setup to own function
  • lxd/storage/drivers/driver/dir: Implements RestoreBackupVolume
  • lxd/containers/post: Pass state to migration Do function
  • lxd/migrate/container: Restructure of migrationSink.Do()
  • lxd/migrate/storage/volumes: Comment restructure
  • lxd: Pass instance type to instanceLoadNodeAll
  • lxd/vm: Tweak default memory
  • lxd/vm: Add a virtio graphics card
  • lxd/vm: Add ringbuffer on vserial
  • lxd-agent: Add vserial state notification
  • lxd/qmp: Introduce new QMP wrapper
  • tests: Add lxd/qmp to golint
  • lxd/vm: Port to new qmp package
  • lxd/vm: Don't start or reboot the VM
  • lxd/vm: Use agent detection from QMP
  • lxd/vm: Restart monitor on startup
  • lxd/vm: Use shared ringbuf size definition
  • lxd/vm: Implement freeze/unfreeze
  • lxd/vm: Privileged mode doesn't apply
  • client: Add agent version of DeleteInstanceFile
  • lxd/vm: Add FileRemove support
  • lxd/seccomp: Fix golint
  • lxd/daemon: Don't block on RBAC
  • lxd/storage/backend/lxd: Fixes comments
  • lxd/storage/backend/lxd: Adds symlink and revert support to CreateInstanceFromMigration
  • lxd/storage/backend/lxd: Adds optimised migration over image support to CreateInstanceFromMigration
  • lxd/migrate/container: Links migrationSink.Do to new storage pkg
  • lxd/containers/post: Links createFromMigration to new storage pkg
  • lxd/cluster: More reliable event delivery
  • lxd/response: Coding style
  • lxd/operations: Use ForwardedResponse
  • lxd/images: Coding style
  • lxd/cluster: Coding style
  • lxd: Tweak cluster.Connect calls
  • lxd/container/post: Returns instances resources from containerPost
  • lxd/migrate/container: Removes duplicated instance type checks from migrationSourceWs.Do
  • lxd: Removes dependency on instance.DaemonState() from migrationSourceWs
  • lxd/storage: Removes DaemonState() from pool interface
  • lxd/migrate/storage/volumes: Removes unrelated comment
  • lxd/migrate/container: Restructures migrationSourceWs.Do() ready for new storage layer.
  • lxd/storage: Properly handle driver config changes
  • lxd/storage/backend/lxd: Comment typos
  • lxd/storage/drivers/drive/dir: Add support for 2-phase migration
  • lxd/migration/migration/volumes: Adds Live property to VolumeTargetArgs
  • lxd/migrate/container: Add support for 2-phase sync in migrationSink.Do()
  • lxd/migrate/container: Sends refresh request indicator in migration response header
  • lxd/rsync/rsync: Adds more info to error returned in sendSetup
  • lxd/storage/drivers: Adds Config() function to return read-only copy of pool config
  • lxd/container/post: Minor cleanup and instance info output in containerPost
  • lxd/migrate/container: Links migrationSourceWs.Do to new storage pkg
  • lxd/migration/migration/volumes: Adds FinalSync bool to VolumeSourceArgs
  • lxd/storage/backend/lxd: Adds sanity check to MigrateInstance during FinalSync
  • lxc/copy: Updates copyContainer to not modify
  • lxd/util: Add HasFilesystem
  • lxd: Detect built-in shiftfs too
  • api: Add image_profiles extension
  • shared/api: Add image profiles
  • lxc/image: Add support for image profiles
  • lxd/db: Add images_profiles table
  • lxd/images: Add support for image profiles
  • doc/image-handling: Add image profiles
  • lxd/cluster: Fix handling of ceph/cephfs on join
  • tests: Always use force with stop/restart
  • tests: Tighten sleep calls
  • lxc/storage: Fix template apply on cross-pool copy
  • tests: Add tests for image profiles
  • tests: Respect projects in ensure_import_testimage
  • i18n: Update translation template
  • lxd/storage/drivers/driver/types: Moves Info definition and adds VolumeFiller type
  • lxd/storage/drivers/load: Removes non-load related types from this file
  • lxd/storage/drivers/interface: Updates CreateVolumeFromMigration and CreateVolume to use VolumeFiller
  • lxd/storage/drivers/driver/cephfs: Updates CreateVolumeFromMigration and CreateVolume to use VolumeFiller
  • lxd/storage/drivers/driver/dir: Updates CreateVolume to use VolumeFiller
  • lxd/storage/drivers/driver/dir: Updates CreateVolumeFromMigration to accept a pre-VolumeFiller argument
  • lxd/storage/backend/lxd: Updates to use VolumeFillers
  • lxd/backup: Comment consistency
  • lxd/daemon: Adds LXD_SHIFTFS_DISABLE env var to disable shiftfs
  • doc/environment: Documents LXD_SHIFTFS_DISABLE env var
  • lxd/container/lxc: Updates Export to use new storage pkg for mounting
  • shared/containerwriter/container/tar/writer: Fixes bug with rootfs dir not being unshifted
  • lxd/vm: Remove default GPU
  • lxd/vm: Update comment
  • lxd/vm: Record power state
  • lxd/container/lxc: Unexport storageStartSensitive
  • lxd/vm/qemu: Makes mount and unmount functions behave the same as containerLXC's
  • lxd/storage/backend/lxd: Fixes MountInstanceSnapshot/UnmountInstanceSnapshot functions
  • lxd/container/lxc: Links to new storage pkg
  • lxd/container/lxc: Updates containerLXCCreate to init new storage layer
  • lxd/container/lxc: Updates initStorage to warn if init old storage layer when new layer is running
  • lxd/container/lxc: Updates Delete to not use old storage layer when using new storage layer
  • lxd/container/lxc: Updates Update() to detect whether to write backup file without using old storage layer
  • lxd/container/lxc: Updates Migrate to access PreservesInodes from old and new storage layers
  • lxd/vm: Don't use named return variables
  • lxd/resources: Port to new storage API
  • lxd/storage: Fix new storage API handling for snapshots
  • lxd/storage: Remove legacy cephfs implementation
  • lxd/storage/cephfs: Use all monitors on mount
  • lxd/storage: List VM volumes in UsedBy
  • lxd/storage: Fix UsedBy with projects
  • tests: Don't use fixed timestamp
  • lxd/forkdns: Fix help message
  • lxd/forkdns: Fix logging
  • lxd/forkdns: Use clean request messages
  • tests: Fix security test on non-shiftfs
  • lxd/vmqemu: Moves vmqemu files into sub folder for their own package
  • lxd/instance/vmqemu/vm/qemu: Updates VMQemu to exist in own package
  • lxd/instance/vqemu/vm/qemu/cmd: Updates to be in own package
  • lxd/networks: networkGetLeaseAddresses into instance package
  • lxd/backup/backup: Adds New() function
  • lxd: Moves instance load and instance validation functions into instance pkg
  • lxd/vm: Rename vmqemu to qemu
  • lxd/vm: Move qmp under qemu
  • lxd/container: Fix comment
  • lxd/vm: Remove reference to container
  • lxd/networks: Simplify instance hwaddr logic
  • tests: Really fix non-shiftfs security test
  • lxc/image: Rename ARCH to ARCHITECTURE
  • i18n: Update translation templates
  • lxd/instance/qemu: Sets log file to qemu.log
  • lxd/storage/cephfs: Fix rsync migration
  • lxd/container: Cleanup mount logic
  • lxd/container: Remove unused initStorage
  • lxd/import: Fix handling of new drivers
  • lxd/backup: Fix backup creation on new drivers
  • lxd/storage/zfs: Use StoragePool to get pool name
  • tests: Remove pointless loop/check
  • tests: Test copy on cephfs
  • Rename to
  • Don't retry in case of generic I/O errors
  • Add test_database_no_disk_space
  • lxd: Fix backup handling with hyphenated names
  • test/suites/backup: Test hyphenated instance names
  • lxd/cgroup: Add basic cgroup abstraction
  • lxd/container: Add wrapper for cgroup abstraction
  • lxd/container: Port pids.max to cgroup abstraction
  • tests: Always pass --force
  • tests: Use lazy unmount in DB test
  • lxd/instance: Split instance image resolving
  • lxd/state: Expose proxy function
  • lxd/container: Don't crash test on differing state
  • shared/simplestreams: Implement GetAliasArchitectures
  • client: Add arch-dependent aliases
  • client: Add caching options
  • lxd/instance: Implement SuitableArchitectures
  • shared/simplestreams: Implement caching support
  • client: Setup caching for simplestreams
  • lxd/daemon: Remove custom cache implementation
  • lxd/daemon: Port daemon storage to new functions
  • Improve build-from-source instructions to be clearer and also cover building a specific release of LXD.
  • lxd/{device,networks,util}: Move Sysctl to util from device and change usage
  • lxd/{firewall,iptables}: Introduce firewall interface and xtables implementation, add firewall interface to static analysis
  • lxd/{daemon,state}: Firewall struct added to daemon and state
  • lxd/{device,networks}: Switch from iptables to xtables through firewall interface
  • tests: Don't leak storage in ENOSPC test
  • lxd/db: Rename ContainerNames to InstanceNames
  • cgroups: pre-mount on pure-cgroup2 systems with cgroup namespaces
  • lxd/iptables: Fix ebtables handling regression
  • lxd/storage: Port volume attach/detach
  • lxd/storage: Store pool db entry in backend
  • lxd/storage/drivers: Implement Update/Validate
  • lxd/storage: Implement pool updates
  • lxd/storage: Port pool update to new functions
  • lxd/main/forkdns: Adds recursion desired comment that got removed during refactor
  • lxd/instance/qemu/vm/qemu: Adds -no-user-config to qemu start flags
  • lxd/instance/qemu/vm/qemu: Adds chroot flag to qemu start up command
  • lxd/{test,cgroup}: Add cgroup package to static analysis tests
  • daemon: log cgroup layout on startup
  • lxd/instance/qemu/vm/qemu: Implements deviceAdd and deviceRemove
  • shared/simplestreams: Only write cache if configured
  • lxd/vm: Reduce 9p mount access
  • lxd/sys: Expose UnprivUser/UnprivUID
  • lxd/networks: Port to os.UnprivUser
  • lxd/instance/qemu/vm/qemu: Adds -runas flag to qemu
  • lxd/db: Add missing unique key
  • lxd/db: Add upgrade logic for UNIQUE fix
  • lxc/cgroup: Fix bad error handling
  • lxd/storage: Create image volume DB entry
  • lxd/images: Port to new storage functions
  • lxd/storage: Move storage_cgo.go to drivers package
  • lxd/storage/drivers: Add FS and mount functions
  • lxd: Use FS and mount functions from drivers package
  • lxd/storage: Remove FS and mount functions
  • Add basic bridge documentation
  • lxd: Mark container snapshots as such
  • lxd/storage/locking: New storage locking package
  • lxd/storage: Lock image creation
  • lxd/backup: Rename HasBinaryFormat to OptimizedStorage
  • lxd/storage/drivers: Update RestoreBackupVolume signature
  • lxd/storage: Update call to RestoreBackupVolume
  • test/suites: Satisfy shellcheck
  • lxd/storage: Add refresh to MigrationTypes
  • lxd/storage/drivers: Add refresh to MigrationTypes
  • lxd: Update call to MigrationTypes
  • shared: Implemented Background Process Manager
  • shared: Implemented Background Process Manager tests
  • lxd/storage/drivers: Always pass Volume argument
  • lxd/storage/drivers: Use new driver interface
  • lxd/storage: Always pass Volume to drivers
  • lxd/storage: Removes unnecessary argument in backendLXD.create()
  • lxd/storage/backend/lxd: Comment on function description
  • lxd/storage/backend/lxd: Implements UpdateInstance
  • lxd/storage/backend/lxd: Implements UpdateImage
  • lxd/storage/backend/lxd: Adds detectChangedConfig and updates usage
  • lxd/storage/backend/lxd: Switches to StoragePoolVolumeUpdateByProject
  • lxd/db/storage/pools: Replaces StoragePoolVolumeUpdate with StoragePoolVolumeUpdateByProject
  • lxd/storage/volumes: Updates storagePoolVolumeTypePut to be project aware
  • lxd/storage/pool/interface: Adds Update functions for volumes
  • lxd/storage/drivers/driver/common: Only allow size property on custom volumes
  • lxd/storage/backend/mock: Adds Update functions for volumes
  • lxd: Updates StoragePoolVolumeUpdateByProject usage
  • lxd/storage/backend/lxd: Updates Update() to use detectChangedConfig()
  • lxd/storage/backend/lxd: Implements UpdateInstanceSnapshot
  • lxd/storage/backend/lxd: Adds updateVolumeDescriptionOnly
  • lxd/storage/backend/lxd: Adds UpdateCustomVolumeSnapshot
  • lxd/storage/volumes/snapshot: Updates storagePoolVolumeSnapshotTypePut to use new storage pkg
  • lxd/cgroup: Additional resource get/set functions through cgroup abstraction layer
  • lxd/{container_lxc, cgroup}: Use abstraction layer functions for cgroup V1 functionality
  • lxd/cgroup: Return ErrControllerMissing on incomplete V2
  • lxd/storage/dir: Use MountPath
  • lxd/storage/dir: Move vfsResources
  • lxd/storage/common: Add vfsRenameVolume
  • lxd/storage/common: Add vfsVolumeSnapshots
  • lxd/storage/common: Add vfsRenameVolumeSnapshot
  • lxd/storage/common: Simplify vfsRenameVolume
  • lxd/storage: Add createParentSnapshotDirIfMissing
  • doc: Add new developer guide to
  • lxd/storage/cephfs: Cleanup driver
  • lxd/storage: Rename RestoreBackupVolume to CreateVolumeFromBackup
  • lxd/storage/dir: Cleanup driver
  • lxc/storage/utils: Updates validateVolumeCommonRules to accept volume argument
  • lxd/storage/drivers/volume: Exposes BlockBacking property from storage driver via IsBlockBacked()
  • lxd/storage: Updates commonVolRulesFunc usage
  • lxd: Fix order of cgroup initialization
  • lxd/storage/backend/lxd: Adds protection against updating volume properties that cant be changed
  • lxd/storage/drivers/volume: Exposes volume type and content type of Volume
  • lxd/storage/utils: Improves common volume validation
  • lxd/db/storage/pools: Adds StoragePoolNodeVolumeGetTypeIDByProject
  • lxd/storage/utils: Makes VolumeDBCreate project aware
  • lxd/storage/volumes/utils: Updates usage of VolumeDBCreate
  • lxd/storage/backend/lxd: Updates usage of VolumeDBCreate
  • lxd/storage/backend/lxd: Adds instanceRootVolumeConfig
  • lxd/storage/backend/lxd: Updates to use instanceRootVolumeConfig
  • lxd/storage/backend/lxd: Switches to use StoragePoolNodeVolumeGetTypeByProject
  • lxd/storage/backend/lxd: Fixed UpdateInstance's incorrect used volStorageName for DB queries
  • lxd/storage/drivers: Re-order utils
  • lxd/storage: Move BaseDirectories to drivers
  • lxd/storage/cephfs: Don't hardcode directory names
  • lxd/storage/cephfs: Simplify Delete
  • shared: Handle btrfs in IsMountPoint
  • lxd/storage: Allow deletion of missing pools
  • lxd/storage/dir: Move MigrateVolume to common
  • lxd/storage/drivers/interface: Changes load() definition as no longer returns error
  • lxd/storage/drivers/common: Removes calling driver's load() func from init()
  • lxd/storage/drivers/load: Calls driver's load() function from main loader
  • lxd/storage/drivers/driver/cephfs: Fix typo in tool detection
  • lxd/storage/cephfs: Use common functions
  • lxd/storage/common: Add vfsHasVolume
  • lxd/storage/common: Add vfsGetVolumeDiskPath
  • lxd/storage: Always init driver with state/logger
  • lxd/storage: Replace CreateMountPath with EnsureMountPath
  • lxd/storage/cephfs: Use helper functions
  • lxd/storage/dir: Use helper functions
  • lxd/cgroups: enable cgroup2 limit support
  • lxd/storage: Pass state to SupportedDrivers
  • lxd/storage: Expand volume config in newVolume
  • lxd/storage/drivers: Use expanded config
  • lxd/storage/drivers: Don't hardcode default block size
  • lxd/storage/drivers/interface: Comments on pool mount/unmount definitions
  • shared/util: Adds comment to TryRunCommand
  • lxd/storage/backend/lxd: Fixes bug with non-project aware vol storage name in RenameInstance
  • lxd/storage/drivers/utils: Removes implication of project awareness from driver mount point helpers
  • lxd/storage/drivers: Move ensureVolumeBlockFile to utils
  • lxd/storage: Split out backup unpack logic
  • lxd/storage/dir: Fix for consistency
  • lxd/storage/utils: Removes mount helper functions
  • lx/storage/utils: Adds legacy mount functions to main pkg
  • lxd/storage/drivers/utils: Unexports mount helper funcs except TryMount/TryUnmount
  • lxd/patches: Updates to use TryMount/TryUnmount from storage/drivers pkg
  • lxd/storage/drivers/driver/cephfs: TryMount usage
  • lxd/storage/drivers/driver/dir: TryMount usage
  • lxd/storage/btrfs: Updates to use unexported legacy mount functions
  • lxd/storage/ceph: Updates to use legacy unexported mount functions, except TryMount/TryUnmount
  • lxd/storage/lvm: Updates to use legacy unexported mount functions, except TryMount/TryUnmount
  • lxd/storage/zfs/utils: Consistent import name for storage/drivers pkg
  • lxd/storage/drivers: Export Name and Logger
  • lxd/storage/drivers: Introduce genericCopyVolume
  • lxd/storage/drivers: Introduce genericCreateVolumeFromMigration
  • lxd/storage/drivers: Simplify genericBackupUnpack
  • lxd/backup: Adds check for supported instance type when loading storage pool
  • lxd/container: Adds check for supported instance type when restoring backup
  • lxd/container/lxc: Adds check for supported instance type when loading storage pool
  • lxd/migrate/container: Adds check for supported instance type when loading storage pool
  • lxd/storage/drivers: Introduce vfsBackupVolume
  • lxd/storage/drivers: Rename driver_cgo to utils_cgo
  • lxd/storage/drivers: Add releaseLoopDev
  • lxd/storage/utils: Improve error handling in forceUnmount
  • lxd/storage/utils: Add fsUUID
  • lxd/storage/utils: Add tryExists
  • lxd/storage/utils: Add hasFilesystem
  • lxd/storage/drivers: Add btrfs
  • tests: Update exclusion for btrfs
  • Update /operations endpoint API doc
  • lxd/revert: Adds revert helper package for running revert functions in reverse order
  • lxd/revert/revert/test: Adds revert tests
  • lxd/storage/backend/lxd: Updates to use revert pkg rather than custom revertFuncs slice
  • lxd/storage/drivers/driver/dir: Updates to use revert pkg rather than custom revertFuncs slice
  • lxd/storage/drivers/driver/btrfs/volumes: Switches to revert pkg for CreateVolumeFromBackup
  • lxd/storage/drivers/generic: Switches to revert pkg for genericBackupUnpack
  • lxd/storage/utils: Clarifies comment on ImageUnpack
  • lxd/storage/backend/lxd: Typo in error
  • lxd/storage/memorypipe: Increases channel buffer size to allow Close() cleanup
  • lxd/storage/backend/lxd: Close migration send end when error occurs
  • lxd/storage/drivers/volume: Differentiates between volume config and pool config
  • lxd/storage/backend/lxd: Removes expansion of pool's volume config into volume config in newVolume()
  • lxd/storage/backend/lxd: Updates CreateCustomVolumeFromMigration to use Volume.Config() to create DB record
  • lxd/storage/utils: drivers.NewVolume usage
  • lxd/storage/drivers/driver/cephfs/volumes: drivers.NewVolume usage
  • lxd/storage/drivers/driver/cephfs/volumes: vol.ExpandedConfig usage
  • lxd/storage/drivers/driver/cephfs/volumes: Comments
  • lxd/storage/drivers/driver/dir/utils: vol.ExpandedConfig usage
  • lxd/storage/drivers/driver/dir/volumes: Comments
  • lxd/storage/drivers/generic: NewVolume usage
  • lxd/storage/drivers/utils: vol.ExpandedConfig usage
  • lxd/storage/backend/lxd: Ensures VolumeDBCreate uses config from the Volume and not the request
  • lxd/storage/drivers/driver/btrfs/volumes: Fixes usage of NewVolume
  • Use JSON markdown blocks in docs
  • cgroup: shortcut cgroup2 only layouts
  • cgroups: detect blkio.bfq.weight knob
  • lxd/instances: Export FillNetworkDevice
  • doc/networks: Clarify raw.dnsmasq
  • lxc-to-lxd: Set useragent
  • lxd-p2c: Set useragent
  • lxd: Always set user agent
  • shared: Set user-agent in GetRemoteCertificate
  • lxd/storage/drivers: Rename applyQuota to initVolume
  • lxd/storage/drivers: Fix bad ExpandedConfig
  • lxd/storage: Include size in instance update
  • lxd/device/nic/routed: Improves IPv6 forwarding and proxy_ndp sysctl detection
  • doc/instances: Updates routed nic sysctl requirements
  • tests: Updates routed nic tests to enable proxy_ndp on all interfaces
  • lxd/storage/backend/lxd: Switches create to use revert package
  • lxd/storage/drivers/generic: Uses revert package on genericCreateVolumeFromMigration
  • lxd/storage/drivers/generic: Adds refresh arg to genericCopyVolume
  • lxd/storage/drivers: genericCopyVolume updated usage for refresh arg
  • lxd/storage/drivers/driver/dir/volumes: Use SetVolumeQuota from UpdateVolume
  • lxd/storage/backend/lxd: Makes specific lock name for volume EnsureImage action
  • lxd/storage/drivers/volume: Adds UnmountTask function
  • lxd/storage/drivers/utils: Adds volume filesystem shrink and grow functions
  • lxd/storage/drivers/errors: Adds "not supported" error type
  • lxd/container/lxc: Detects storage drivers that dont support volume usage stats
  • tests: Don't leak CEPH pools
  • lxd/storage: Set contentType during image deletion
  • lxd/storage/drivers/generic: Improves genericBackupUnpack
  • lxd/revert: Adds Clone function to revert
  • lxd/storage/drivers/utils: Comments on wipeDirectory
  • lxd/containers/post: Improves comment in createFromBackup
  • lxd/storage/backend/lxd: Adds error checking to MountTask in CreateInstanceFromBackup
  • lxd/storage/pool/interface: Adds UpdateInstanceBackupFile
  • lxd/storage/backend/mock: Adds UpdateInstanceBackupFile
  • lxd/storage/backend/lxd: Implements UpdateInstanceBackupFile
  • lxd/instance/instance/interface: Adds UpdateBackupFile
  • lxd/instance/qemu/vm/qemu: Implements UpdateBackupFile
  • lxd/container/lxc: Implements UpdateBackupFile
  • lxd/container: Switches to inst.UpdateBackupFile()
  • lxd/container/lxc: Switches to inst.UpdateBackupFile()
  • lxd/instance/instance/utils: Deprecates WriteBackupFile function
  • lxd/instance/qemu/vm/qemu: UpdateBackupFile usage
  • lxd/storage: Support deleting snapshots during restore
  • lxd/images: Fix clustering handling on delete
  • tests: Remove un-needed image volume delete
  • lxd/storage: Update driver cache for new drivers
  • Improve websocket doc in container exec
  • lxd/qemu: Fix multiple NICs
  • lxd/storage/drivers/volume: Adds DefaultFilesystem constant of ext4
  • lxd/storage/utils: Uses DefaultFilesystem in VolumeFillDefault
  • lxd/storage/backend/lxd: Updates EnsureImage to detech filesystem changes and regenerate
  • lxd/storage/drivers/utils: Comment on shrinkFileSystem
  • lxd/storage/drivers/utils: Mounts btrfs filesystems during shrinkFileSystem
  • lxd/storage/drivers/utils: Adds regenerateFilesystemUUID functions
  • lxd/storage/drivers: Use standard errors
  • lxd/storage/btrfs: Disable send/receive inside containers
  • lxd/init: Support new storage drivers
  • lxd/storage/drivers: Use standard errors
  • lxd/storage/btrfs: Disable send/receive inside containers
  • lxd/init: Support new storage drivers
  • lxd/migration: Improve multi-pass transfers
  • lxd/storage: Pass VolumeSourceArgs as pointer
  • lxd/storage: Port "zfs" to new driver logic
  • tests: Add zfs to list of new drivers
  • lxd/storage/backend/lxd: Applies root disk quota as part of backup import post hook
  • lxd/storage/backend/lxd: Adds errors.Wrapf around os. and unix. function errors
  • lxd/storage/drivers/driver/btrfs/volumes: tmpVolSuffix usage
  • lxd/storage/drivers/volume: Adds tmpVolSuffix const
  • lxd/storage/drivers/utils: Adds errors.Wrapf to mount/unmount functions
  • lxd/storage/drivers/utils: Adds renegerateFilesystemUUIDNeeded
  • lxd/storage/backend/lxd: Triggers backup file update in BackupInstance and and RenameInstanceSnapshot
  • lxd/storage/backend/lxd: Improves revert in RenameInstance
  • lxd/storage/drivers: Fix comments
  • tests: Fix storage_compatible for zfs
  • lxd/storage/drivers/generic: Adds EnsureMount path calls after mounting volumes
  • lxd/device/disk: Defer instance type check until start time for cloud-init config drive
  • lxd/migrate/container: Merges duplicate multi sync logic and adds comments
  • lxd/storage/drivers/volume: Adds NewVMBlockFilesystemVolume and IsVMBlock functions
  • lxd/storage/drivers/driver/zfs/volumes: VM block function usage
  • lxd/storage/drivers/driver/zfs/utils: Removes unused checkVMBlock
  • lxd/storage/pools: Support non-default project in storagePoolDelete
  • lxd/device/device/instance: Removes interface in place of instance.Instance
  • lxd/container: Replaces device.Instance with instance.Instance
  • lxd/storage: Replaces device.Instance with instance.Instance
  • lxd/device: Replaces device.Instance with instance.Instance
  • lxd/device: Renames d.instance to d.inst to avoid conflicts with instance package
  • lxd/storage: Updates storageRootFSApplyQuota to support VMs
  • lxd/device/disk: Allow VM disks to be updated
  • lxd/storage/drivers/utils: Adds copyDevice function
  • lxd/storage/drivers: Filler logging
  • lxd/storage/drivers/generic: Updates genericCopyVolume to be VM block aware using copyDevice
  • client/lxd/instances: Sends instance type when copying instances
  • lxc: Don't use instance when referring to server
  • lxc: Rename container to instance
  • lxc/info: Fix VM support
  • i18n: Update translation templates
  • lxd/storage/zfs: Fix set on 0.6
  • lxd/storage/drivers: Use errors.Wrap
  • lxd/storage/drivers: Wrap os/ioutil calls
  • api: Add clustering_architecture extension
  • shared/api: Add Architecture to ClusterMember
  • lxd/db: Add Architecture to NodeInfo
  • lxd/cluster: Track member architecture
  • lxc/cluster: Add architecture column in list
  • lxd/storage/backend/lxd: Add project support to GetInstanceUsage
  • lxd/storage/utils: Removes default volume size from VolumeFillDefault
  • test/suites/storage: Updates LVM quota tests to take into account new SI units conversion
  • test/suites/backup: Fixes issue with import testing with LVM
  • tests: Add lvm to list of new drivers
  • lxd/storage/ceph: Fix volume size handling
  • lxd/storage/drivers/utils: Adds loopFilePath function
  • lxd/storage/drivers: Replace repetitive loop path generation with call to loopFilePath
  • lxd/storage/drivers/load: Enables LVM driver
  • lxd/db: Silence normal sql errors
  • lxd/db: Fix image profile copying logic
  • lxd/util: IsAddressCovered takes into account host names
  • lxd/db: Add archs filter to ClusterTx.NodeWithLeastContainers()
  • lxd/instance: make SuitableArchitectures handle snapshots too
  • lxd/containers_post.go: Use cluster architecture in placement
  • lxd/db: Ensure zfs.pool_name is set
  • lxd/storage/drivers/lvm: LVM driver implementation
  • lxd/containers: Use 'instance' key in templates
  • lxc: Fix typo
  • lxc: Bump examples to 18.04
  • i18n: Update translation templates
  • doc: s/container/instance/
  • doc: Bump releases in examples
  • doc/rest-api: Cover the three instance endpoints
  • lxd/instance/qemu/vm/qemu: Adds running disk usage stats to disk state
  • lxd/storage/backend/lxd: Adds VM support to GetInstanceUsage
  • lxd/container: Adds VM support to instanceCreateAsSnapshot
  • lxd/container/snapshot: Adds VM support to containerSnapshotHandler
  • lxd/migration/migration/volumes: Fixes crash when storage driver has no transfer methods
  • lxd/storage/drivers/driver/common: Adds VM support for migration types
  • lxd/storage/drivers/driver/lvm: Adds VM support
  • lxd/storage/drivers/drivers/lvm/utils: VM support
  • lxd/storage/drivers/drivers/lvm/volumes: VM support
  • lxd/instances: Fix creation from simplestreams
  • lxd/db: Fix multi-arch cached images
  • lxd/storage/drivers: Rename drivers_ to driver_
  • lxd/storage/drivers: Implement patch mechanism
  • lxd/storage: Add patch mechanism to backend
  • lxd/patches: Add storage_create_vm
  • Skip updating instances and profiles not using a volume being renamed
  • i18n: Update translations from weblate
  • lxd/storage/btrfs: Fix usage inside containers
  • lxd/storage/backend/lxd: Validate config on pool create
  • shared/instance: Adds IsSize to validate size strings
  • lxd/storage/pools/config: Removes old LVM validation from storagePoolValidateConfig
  • lxd/storage/utils: shared.IsSize usage
  • lxd/storage/load: commonRules usage
  • lxd/storage/utils: commonRules usage
  • lxd/storage/drivers/load: Adds Validators type for common rules
  • lxd/storage/drivers/interface: commonRules usage
  • lxd/storage/drivers: Call d.validatePool in Validate function
  • lxd/storage/drivers/drivers/common: Updates for commonRules
  • lxd/storage/drivera/driver/common: Adds validatePool function
  • lxd/storage/drivers/driver/dir/utils: commonRules usage
  • lxd/storage/drivers/driver/btrfs: pool validation
  • lxd/storage/drivers/driver/zfs: pool validation
  • lxd/storage/drivers/driver/cephfs: pool validation
  • lxd/storage/drivers/driver/common: Improved error messages in validatePool and validateVolume
  • lxd/storage/pools: Fixes empty values for non-compat pools in storagePoolClusterConfigForEtag
  • lxd/storage/pools/config: shared.IsSize usage
  • lxd/storage/pools/config: comment
  • lxd/storage/drivers/driver/lvm: Adds validation
  • doc/api-extension: Fix formatting
  • api: Add resources_disk_id extension
  • shared/api: Add device_id to resources
  • lxd/resources: Add device_id
  • lxd/storage/drivers/driver/lvm: Adds stripe validation
  • lxd/storage/pools/config: Adds volume.lvm.stripes and volume.lvm.stripes.size to pool validation
  • lxd/storage/drivers/driver/lvm/utils: Updates createDefaultThinPool to support stripes
  • lxd/storage/drivers/driver/lvm/utils: Updates createLogicalVolume to support stripes
  • doc/storage: Documents storage_lvm_stripes options
  • doc/api-extensions: trim whitespace
  • doc/api-extensions: Adds storage_lvm_stripes
  • shared/version/api: Adds storage_lvm_stripes extension
  • lxd/storage/btrfs: Fix bad check
  • lxd/containers: Properly setup cgroup writer
  • lxd/cgroup: Fix memory limit handling

Try it for yourself

This new LXD release is already available for you to try on our demo service.


The release tarballs can be found on our download page.

Binary builds are also available for:

  • Linux: snap install lxd
  • MacOS: brew install lxc
  • Windows: choco install lxc