LXD 3.19 has been released

stgraber · January 16, 2020, 8:56pm

Introduction

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!

Enjoy!

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.

Highlights

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
config:
  user.user-data: |
    #cloud-config
    ssh_pwauth: yes
    apt_mirror: http://us.archive.ubuntu.com/ubuntu/
    users:
      - 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
devices:
  config:
    source: cloud-init:config
    type: disk
name: vm
used_by:

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
Password: 
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# ./install.sh 
Created symlink /etc/systemd/system/multi-user.target.wants/lxd-agent.service → /lib/systemd/system/lxd-agent.service.
Created symlink /etc/systemd/system/multi-user.target.wants/lxd-agent-9p.service → /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
Ips:
  enp5s0:	inet	10.166.11.3
  enp5s0:	inet6	2001:470:b368:4242:216:3eff:fed2:cd5
  enp5s0:	inet6	fe80::216:3eff:fed2:cd5
  lo:	inet	127.0.0.1
  lo:	inet6	::1
Resources:
  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:
    enp5s0:
      Bytes received: 1.71kB
      Bytes sent: 1.94kB
      Packets received: 14
      Packets sent: 18
    lo:
      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=10.255.243.155
Device eth0 added to c1
stgraber@castiana:~$ lxc start c1
stgraber@castiana:~$ lxc list c1
+------+---------+-----------------------+------+-----------+-----------+
| NAME |  STATE  |         IPV4          | IPV6 |   TYPE    | SNAPSHOTS |
+------+---------+-----------------------+------+-----------+-----------+
| c1   | RUNNING | 10.255.243.155 (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
properties:
  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
profiles:
- default

stgraber@castiana:~$ lxc image edit a722a8eb4d31

stgraber@castiana:~$ lxc image show a722a8eb4d31
auto_update: true
properties:
  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
profiles:
- 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:
  libfreetype6
Use 'apt autoremove' to remove it.
The following NEW packages will be installed:
  fuse2fs
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 http://archive.ubuntu.com/ubuntu 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
root@vm02:~#

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   | https://240.0.200.92:8443  | YES      | ONLINE | fully operational | aarch64      |
+---------------+----------------------------+----------+--------+-------------------+--------------+
| bos01-ppc64el | https://240.0.202.246:8443 | YES      | ONLINE | fully operational | ppc64le      |
+---------------+----------------------------+----------+--------+-------------------+--------------+
| bos01-s390x   | https://240.0.203.11:8443  | YES      | ONLINE | fully operational | s390x        |
+---------------+----------------------------+----------+--------+-------------------+--------------+
| bos02-arm64   | https://240.0.204.139:8443 | NO       | ONLINE | fully operational | aarch64      |
+---------------+----------------------------+----------+--------+-------------------+--------------+
| bos02-ppc64el | https://240.0.206.145:8443 | NO       | ONLINE | fully operational | ppc64le      |
+---------------+----------------------------+----------+--------+-------------------+--------------+
| bos02-s390x   | https://240.0.207.35:8443  | 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 contributing.md
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 debugging.md 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 security.md from README.md
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
clustering.md: 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 volatile.idmap.next
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
Enable SQLITE_CONFIG_MULTITHREAD
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 database_update.sh to database.sh
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 contributing.md
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.

Downloads

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

stgraber · January 17, 2020, 2:34am

The snap is available in the candidate channel with release to stable planned for Wednesday.

We’re using this longer than usual window to try and get as much testing as possible on the candidate build, allowing us to track down and fix bugs reported by early adopters.

If you have a staging or test system, we’d strongly recommend you try the candidate build on it and report any upgrade or runtime issue you may notice. Of particular interest is anything related to storage as we’ve entirely replaced our storage logic in this release.

roka · January 17, 2020, 3:14am

Can I use Interception of the mount system call to mount NFS file system in container?

It will be great if you can give me one example.

stgraber · January 17, 2020, 3:36am

I don’t see why this wouldn’t work though it’s not something we have specifically tested. Something like the example in the release post but with the correct filesystem name may work.

Note that system call interception requires very recent versions of the kernel (5.3) and liblxc (3.2.1) as well as a snapshot of current upstream seccomp.

The edge snap run on a system with the latest available kernel should work, the stable/candidate snap may be lacking some pieces (though we did backport quite a few things as needed for Travis CI).

stgraber · January 19, 2020, 12:07am

10 posts were split to a new topic: VM failure on btrfs

atomlab · January 17, 2020, 5:45pm

I don’t quite understand wich virtualization technology using for vm machines? kvm?

tomp · January 17, 2020, 5:51pm

Yes that is correct, via qemu.

TomvB · January 17, 2020, 7:32pm

VM support! Awesome! Is useful for routers, such as opnsense and pfsense.

Falstaff · January 20, 2020, 4:15am

Great release; the VM and routed nictype were long-awaited features!

Silentphantom62 · January 22, 2020, 12:19am

Fantastic features @stgraber. We mainly use the LTS branch in our PROD environments. When can we expect these features to be pushed to the LTS branch?

simos · January 22, 2020, 8:52am

The LTS versions are feature-freezed.

The next LTS is LXD 4.0, and will be released in April together with Ubuntu 20.04 LTS.
It will have all current features and anything that will make it until April.
That is why it is important to report issues now and get critical features included before the new freeze.

bodleytunes · January 23, 2020, 1:08pm

Hi,
Looks good!
Is it possible yet to create and then attach extra drives to the vm, say as qcow2 files, so the vm sees them appear as something like /dev/vda /dev/vdb
Cheers,
Jon.

stgraber · January 23, 2020, 1:55pm

LXD 3.19 is now slowly rolling out to all our stable channel users.

We’ve included all bugfixes since the 3.19 release and all regressions we’re aware of have been fixed at this time.

Silentphantom62 · January 24, 2020, 8:06pm

Great that it’s being pushed to the stable release but on our production setup we want to stick to the LTS versions to be rock solid. What do you suggest?

stgraber · January 24, 2020, 9:57pm

We maintain several snap tracks that you can see with snap info lxd.
2.0 and 3.0 are LTS tracks, the others are feature releases and so are only supported until the next is released. The last feature release was 3.18, current is 3.19.

Note that you cannot downgrade LXD. So if you are on above 3.0.x, you are not on LTS and cannot go back to LTS without reinstalling the snap.

If you are on a particular LXD release and want to stick to it, you can use our auto-generate release channels rather than use stable. Using 3.18/stable would be keeping you on 3.18, same with 3.19/stable.

roka · January 28, 2020, 2:26am

With auto-update the system updated to 3.19 but then lxd daemon became unresponsive. Do we need to restart the system with 3.19 upgrade?

I believe the database upgrade resulted in a lock and lxd daemon cannot respond.

stgraber · January 28, 2020, 9:05pm

No, the only case where a reboot is required is if you’ve hit some unrecoverable kernel bug. For all other cases, this shouldn’t be needed.

You’re mentioning DB getting locked, is that in a LXD cluster or a standalone node?

roka · January 29, 2020, 1:27am

I solved the problem by by restarting the lxd daemon and waiting for 2-3 hours and it started working. Probably DB blocked. It’s the first time I tried a test system with projects. On production systems I disabled auto-update from snap due to earlier issues, so wanted to reconfirm. Thanks for the help.

zacksiri · January 30, 2020, 11:03am

How did you disable auto-update I would like to do this as well.