Bump vendor containerd/containerd version

Signed-off-by: Brandon Lum <lumjjb@gmail.com>

vendor.conf

@@ -44,7 +44,7 @@ github.com/containerd/ttrpc 92c8520ef9f86600c650dd540266a007bf03670f
 github.com/containerd/go-runc a5c2862aed5e6358b305b0e16bfce58e0549b1cd
 github.com/containerd/fifo bda0ff6ed73c67bfb5e62bc9c697f146b7fd7f13
 github.com/containerd/continuity f2a389ac0a02ce21c09edd7344677a601970f41c
-github.com/containerd/containerd 1fb1d93212af763bd481b476293040b1566ae00b
+github.com/containerd/containerd 0a1f2b40642e54ed06cd0a22cdf6025cbe70853c
 github.com/containerd/console 8375c3424e4d7b114e8a90a4a40c8e1b40d1d4e6
 github.com/containerd/cgroups fada802a7909d430bd17126fd6e4bbf5716f2bcd
 github.com/beorn7/perks 4c0e84591b9aa9e6dcfdf3e020114cd81f89d5f9

vendor/github.com/containerd/containerd/api/services/snapshots/v1/snapshots.pb.go

@@ -777,6 +777,45 @@ func (m *UsageResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_UsageResponse proto.InternalMessageInfo
 
+type CleanupRequest struct {
+	Snapshotter          string   `protobuf:"bytes,1,opt,name=snapshotter,proto3" json:"snapshotter,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CleanupRequest) Reset()      { *m = CleanupRequest{} }
+func (*CleanupRequest) ProtoMessage() {}
+func (*CleanupRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cfc0ddf12791f168, []int{17}
+}
+func (m *CleanupRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *CleanupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_CleanupRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalTo(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *CleanupRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CleanupRequest.Merge(m, src)
+}
+func (m *CleanupRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *CleanupRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_CleanupRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CleanupRequest proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterEnum("containerd.services.snapshots.v1.Kind", Kind_name, Kind_value)
 	proto.RegisterType((*PrepareSnapshotRequest)(nil), "containerd.services.snapshots.v1.PrepareSnapshotRequest")
@@ -800,6 +839,7 @@ func init() {
 	proto.RegisterType((*ListSnapshotsResponse)(nil), "containerd.services.snapshots.v1.ListSnapshotsResponse")
 	proto.RegisterType((*UsageRequest)(nil), "containerd.services.snapshots.v1.UsageRequest")
 	proto.RegisterType((*UsageResponse)(nil), "containerd.services.snapshots.v1.UsageResponse")
+	proto.RegisterType((*CleanupRequest)(nil), "containerd.services.snapshots.v1.CleanupRequest")
 }
 
 func init() {
@@ -807,71 +847,73 @@ func init() {
 }
 
 var fileDescriptor_cfc0ddf12791f168 = []byte{
-	// 1022 bytes of a gzipped FileDescriptorProto
+	// 1047 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4f, 0x6f, 0x1a, 0x47,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0x4f, 0x6f, 0x1b, 0x45,
-	0x14, 0x67, 0x61, 0x8d, 0xc3, 0xc3, 0x76, 0xe9, 0x04, 0x13, 0xb4, 0xad, 0xf0, 0x8a, 0x43, 0x65,
+	0x14, 0xf7, 0xda, 0x5b, 0x27, 0x79, 0x4e, 0x82, 0x99, 0x3a, 0xae, 0xb5, 0x20, 0x67, 0xe5, 0x03,
-	0xf5, 0xb0, 0x9b, 0x50, 0x35, 0x71, 0xe2, 0x4b, 0x31, 0xa6, 0x15, 0x76, 0xec, 0x54, 0x1b, 0xdb,
+	0x8a, 0x38, 0xec, 0xb6, 0x46, 0xb4, 0x69, 0x73, 0xc1, 0x71, 0x0c, 0x72, 0xd2, 0xa4, 0x68, 0xf3,
-	0x89, 0xd3, 0xaa, 0xd1, 0x1a, 0x06, 0xbc, 0x82, 0xdd, 0xa5, 0xcc, 0x40, 0x44, 0x2b, 0x55, 0x3d,
+	0xa7, 0x4d, 0x41, 0x54, 0x1b, 0x7b, 0xec, 0xac, 0xec, 0xfd, 0x83, 0x67, 0xec, 0xca, 0x20, 0x21,
-	0x46, 0x3e, 0xf5, 0x0b, 0xf8, 0xd4, 0x7e, 0x88, 0xaa, 0x9f, 0xc0, 0xc7, 0x1e, 0x7b, 0x6a, 0x1b,
+	0x8e, 0x55, 0x4e, 0x7c, 0x81, 0x9c, 0xe0, 0x43, 0x20, 0x3e, 0x41, 0x8e, 0x48, 0x5c, 0x38, 0x01,
-	0x7f, 0x89, 0x9e, 0xfa, 0x47, 0x33, 0x3b, 0x0b, 0x18, 0x53, 0xb1, 0xac, 0xc9, 0x6d, 0x66, 0x67,
+	0xcd, 0x97, 0xe0, 0x84, 0x40, 0x33, 0x3b, 0xeb, 0x7f, 0x71, 0xe5, 0xb5, 0x6b, 0x6e, 0x33, 0x3b,
-	0xde, 0xef, 0xfd, 0xde, 0xef, 0xcd, 0x7b, 0x33, 0x0b, 0x3b, 0x0d, 0x8b, 0x9e, 0x76, 0x4f, 0xb4,
+	0xf3, 0xde, 0xfb, 0xbd, 0xdf, 0x9b, 0xf7, 0x9b, 0x59, 0xd8, 0xad, 0x5b, 0xf4, 0xbc, 0x7d, 0xa6,
-	0xaa, 0x6b, 0xeb, 0x55, 0xd7, 0xa1, 0xa6, 0xe5, 0xe0, 0x4e, 0x6d, 0x74, 0x68, 0xb6, 0x2d, 0x9d,
+	0x55, 0x5c, 0x5b, 0xaf, 0xb8, 0x0e, 0x35, 0x2d, 0x07, 0xb7, 0xaa, 0x83, 0x43, 0xd3, 0xb3, 0x74,
-	0xe0, 0x4e, 0xcf, 0xaa, 0x62, 0xa2, 0x13, 0xc7, 0x6c, 0x93, 0x53, 0x97, 0x12, 0xbd, 0x77, 0x6f,
+	0x82, 0x5b, 0x1d, 0xab, 0x82, 0x89, 0x4e, 0x1c, 0xd3, 0x23, 0xe7, 0x2e, 0x25, 0x7a, 0xe7, 0x5e,
-	0x38, 0xd1, 0xda, 0x1d, 0x97, 0xba, 0x48, 0x1d, 0x5a, 0x69, 0xbe, 0x85, 0x36, 0xdc, 0xd4, 0xbb,
+	0x7f, 0xa2, 0x79, 0x2d, 0x97, 0xba, 0x48, 0xed, 0x5b, 0x69, 0x81, 0x85, 0xd6, 0xdf, 0xd4, 0xb9,
-	0xa7, 0xa4, 0x1b, 0x6e, 0xc3, 0xe5, 0x9b, 0x75, 0x36, 0xf2, 0xec, 0x94, 0xf7, 0x1a, 0xae, 0xdb,
+	0xa7, 0xa4, 0xea, 0x6e, 0xdd, 0xe5, 0x9b, 0x75, 0x36, 0xf2, 0xed, 0x94, 0xf7, 0xea, 0xae, 0x5b,
-	0x68, 0x61, 0x9d, 0xcf, 0x4e, 0xba, 0x75, 0x1d, 0xdb, 0x6d, 0xda, 0x17, 0x8b, 0xea, 0xf8, 0x62,
+	0x6f, 0x62, 0x9d, 0xcf, 0xce, 0xda, 0x35, 0x1d, 0xdb, 0x1e, 0xed, 0x8a, 0x45, 0x75, 0x74, 0xb1,
-	0xdd, 0xc2, 0xad, 0xda, 0x4b, 0xdb, 0x24, 0x4d, 0xb1, 0x63, 0x6d, 0x7c, 0x07, 0xb5, 0x6c, 0x4c,
+	0x66, 0xe1, 0x66, 0xf5, 0x85, 0x6d, 0x92, 0x86, 0xd8, 0xb1, 0x3e, 0xba, 0x83, 0x5a, 0x36, 0x26,
-	0xa8, 0x69, 0xb7, 0xc5, 0x86, 0xfb, 0x81, 0x62, 0xa4, 0xfd, 0x36, 0x26, 0xba, 0xed, 0x76, 0x1d,
+	0xd4, 0xb4, 0x3d, 0xb1, 0xe1, 0x7e, 0xa8, 0x1c, 0x69, 0xd7, 0xc3, 0x44, 0xb7, 0xdd, 0xb6, 0x43,
-	0xea, 0xd9, 0xe5, 0xff, 0x96, 0x20, 0xf3, 0x79, 0x07, 0xb7, 0xcd, 0x0e, 0x7e, 0x2a, 0xa2, 0x30,
+	0x7d, 0xbb, 0xdc, 0x3f, 0x12, 0xa4, 0x3f, 0x6f, 0x61, 0xcf, 0x6c, 0xe1, 0x43, 0x91, 0x85, 0x81,
-	0xf0, 0xd7, 0x5d, 0x4c, 0x28, 0x52, 0x21, 0xe9, 0x07, 0x46, 0x71, 0x27, 0x2b, 0xa9, 0xd2, 0x7a,
+	0xbf, 0x6e, 0x63, 0x42, 0x91, 0x0a, 0x89, 0x20, 0x31, 0x8a, 0x5b, 0x19, 0x49, 0x95, 0x36, 0x96,
-	0xc2, 0x18, 0xfd, 0x84, 0x52, 0x10, 0x6b, 0xe2, 0x7e, 0x36, 0xca, 0x57, 0xd8, 0x10, 0x65, 0x20,
+	0x8c, 0xc1, 0x4f, 0x28, 0x09, 0xb1, 0x06, 0xee, 0x66, 0xa2, 0x7c, 0x85, 0x0d, 0x51, 0x1a, 0xe2,
-	0xce, 0xa0, 0x1c, 0x9a, 0x8d, 0xf1, 0x8f, 0x62, 0x86, 0xbe, 0x84, 0x78, 0xcb, 0x3c, 0xc1, 0x2d,
+	0xcc, 0x95, 0x43, 0x33, 0x31, 0xfe, 0x51, 0xcc, 0xd0, 0x97, 0x10, 0x6f, 0x9a, 0x67, 0xb8, 0x49,
-	0x92, 0x95, 0xd5, 0xd8, 0x7a, 0xb2, 0xb0, 0xad, 0x4d, 0xd3, 0x51, 0x9b, 0xcc, 0x4a, 0x7b, 0xcc,
+	0x32, 0xb2, 0x1a, 0xdb, 0x48, 0xe4, 0x77, 0xb4, 0x49, 0x3c, 0x6a, 0xe3, 0x51, 0x69, 0x8f, 0xb9,
-	0x61, 0xca, 0x0e, 0xed, 0xf4, 0x0d, 0x81, 0xa9, 0x3c, 0x84, 0xe4, 0xc8, 0x67, 0x9f, 0x96, 0x34,
+	0x9b, 0x92, 0x43, 0x5b, 0x5d, 0x43, 0xf8, 0x54, 0x1e, 0x42, 0x62, 0xe0, 0x73, 0x00, 0x4b, 0xea,
-	0xa4, 0x95, 0x86, 0x85, 0x9e, 0xd9, 0xea, 0x62, 0x41, 0xd5, 0x9b, 0x3c, 0x8a, 0x6e, 0x48, 0xf9,
+	0xc3, 0x4a, 0xc1, 0xad, 0x8e, 0xd9, 0x6c, 0x63, 0x01, 0xd5, 0x9f, 0x3c, 0x8a, 0x6e, 0x4a, 0xb9,
-	0x1d, 0xb8, 0x73, 0xcd, 0x11, 0x69, 0xbb, 0x0e, 0xc1, 0x48, 0x87, 0x38, 0x57, 0x8a, 0x64, 0x25,
+	0x5d, 0xb8, 0x73, 0x23, 0x10, 0xf1, 0x5c, 0x87, 0x60, 0xa4, 0x43, 0x9c, 0x33, 0x45, 0x32, 0x12,
-	0xce, 0xf9, 0xce, 0x28, 0x67, 0xae, 0xa4, 0xb6, 0xc7, 0xd6, 0x0d, 0xb1, 0x2d, 0xff, 0x97, 0x04,
+	0xc7, 0x7c, 0x67, 0x10, 0x33, 0x67, 0x52, 0xdb, 0x67, 0xeb, 0x86, 0xd8, 0x96, 0xfb, 0x5b, 0x82,
-	0xb7, 0x8f, 0x2c, 0xfc, 0xea, 0x6d, 0x0a, 0x79, 0x3c, 0x26, 0x64, 0x71, 0xba, 0x90, 0x13, 0x28,
+	0xdb, 0x27, 0x16, 0x7e, 0xf9, 0x7f, 0x12, 0x79, 0x3a, 0x42, 0x64, 0x61, 0x32, 0x91, 0x63, 0x20,
-	0xcd, 0x5b, 0xc5, 0xcf, 0x20, 0x7d, 0xd5, 0x4b, 0x58, 0x09, 0x4b, 0xb0, 0xcc, 0x3f, 0x90, 0x1b,
+	0xcd, 0x9b, 0xc5, 0xcf, 0x20, 0x35, 0x1c, 0x65, 0x56, 0x0a, 0x8b, 0xb0, 0xc2, 0x3f, 0x90, 0xb7,
-	0x68, 0x97, 0x2f, 0xc2, 0x8a, 0x0f, 0x12, 0x96, 0xc7, 0x2e, 0xac, 0x1a, 0xd8, 0x76, 0x7b, 0xf3,
+	0xe0, 0x2e, 0x57, 0x80, 0xd5, 0xc0, 0xc9, 0xac, 0x38, 0xf6, 0x60, 0xcd, 0xc0, 0xb6, 0xdb, 0x99,
-	0x28, 0x0a, 0x76, 0x2e, 0x56, 0x4b, 0xae, 0x6d, 0x5b, 0x74, 0x76, 0x34, 0x04, 0xb2, 0x63, 0xda,
+	0x47, 0x53, 0xb0, 0x73, 0xb1, 0x56, 0x74, 0x6d, 0xdb, 0xa2, 0xd3, 0x7b, 0x43, 0x20, 0x3b, 0xa6,
-	0xbe, 0xe4, 0x7c, 0xec, 0x7b, 0x88, 0x0d, 0x33, 0xf3, 0xc5, 0xd8, 0xa9, 0x28, 0x4d, 0x3f, 0x15,
+	0x1d, 0x50, 0xce, 0xc7, 0x41, 0x84, 0x58, 0xbf, 0x32, 0x5f, 0x8c, 0x9c, 0x8a, 0xe2, 0xe4, 0x53,
-	0x13, 0x09, 0xcd, 0xfb, 0x5c, 0x54, 0xe0, 0xf6, 0x53, 0x6a, 0xd2, 0x79, 0x88, 0xf8, 0x6f, 0x14,
+	0x31, 0x16, 0xd0, 0xbc, 0xcf, 0x45, 0x19, 0x6e, 0x1f, 0x52, 0x93, 0xce, 0x83, 0xc4, 0x7f, 0xa3,
-	0xe4, 0x8a, 0x53, 0x77, 0x07, 0x8a, 0x48, 0x23, 0x8a, 0x0c, 0xab, 0x25, 0x7a, 0xa5, 0x5a, 0x1e,
+	0x20, 0x97, 0x9d, 0x9a, 0xdb, 0x63, 0x44, 0x1a, 0x60, 0xa4, 0xdf, 0x2d, 0xd1, 0xa1, 0x6e, 0x79,
-	0x81, 0xdc, 0xb4, 0x9c, 0x1a, 0x97, 0x6a, 0xa5, 0xf0, 0xc1, 0x74, 0x55, 0x76, 0x2d, 0xa7, 0x66,
+	0x04, 0x72, 0xc3, 0x72, 0xaa, 0x9c, 0xaa, 0xd5, 0xfc, 0x07, 0x93, 0x59, 0xd9, 0xb3, 0x9c, 0xaa,
-	0x70, 0x1b, 0x54, 0x02, 0xa8, 0x76, 0xb0, 0x49, 0x71, 0xed, 0xa5, 0x49, 0xb3, 0xb2, 0x2a, 0xad,
+	0xc1, 0x6d, 0x50, 0x11, 0xa0, 0xd2, 0xc2, 0x26, 0xc5, 0xd5, 0x17, 0x26, 0xcd, 0xc8, 0xaa, 0xb4,
-	0x27, 0x0b, 0x8a, 0xe6, 0xf5, 0x61, 0xcd, 0xef, 0xc3, 0xda, 0x81, 0xdf, 0x87, 0xb7, 0x6e, 0x5d,
+	0x91, 0xc8, 0x2b, 0x9a, 0xaf, 0xc3, 0x5a, 0xa0, 0xc3, 0xda, 0x51, 0xa0, 0xc3, 0xdb, 0x8b, 0x57,
-	0xfc, 0xbe, 0x16, 0xf9, 0xe1, 0x8f, 0x35, 0xc9, 0x48, 0x08, 0xbb, 0x22, 0x65, 0x20, 0xdd, 0x76,
+	0x7f, 0xac, 0x47, 0x7e, 0xf8, 0x73, 0x5d, 0x32, 0x96, 0x84, 0x5d, 0x81, 0x32, 0x27, 0x6d, 0xaf,
-	0xcd, 0x07, 0x59, 0x98, 0x05, 0x44, 0xd8, 0x15, 0x29, 0xda, 0x19, 0x64, 0x37, 0xce, 0xb3, 0x5b,
+	0x1a, 0x38, 0xb9, 0x35, 0x8d, 0x13, 0x61, 0x57, 0xa0, 0x68, 0xb7, 0x57, 0xdd, 0x38, 0xaf, 0x6e,
-	0x98, 0x1e, 0x07, 0x53, 0x6a, 0xde, 0xc9, 0x7c, 0x0e, 0xe9, 0xab, 0xc9, 0x14, 0xc5, 0xf5, 0x09,
+	0x7e, 0x72, 0x1e, 0x8c, 0xa9, 0x79, 0x17, 0xf3, 0x19, 0xa4, 0x86, 0x8b, 0x29, 0x9a, 0xeb, 0x13,
-	0xc8, 0x96, 0x53, 0x77, 0x39, 0x48, 0x32, 0x88, 0xc8, 0x8c, 0xdc, 0x96, 0xcc, 0x22, 0x35, 0xb8,
+	0x90, 0x2d, 0xa7, 0xe6, 0x72, 0x27, 0x89, 0x30, 0x24, 0x33, 0x70, 0xdb, 0x32, 0xcb, 0xd4, 0xe0,
-	0x65, 0xfe, 0x67, 0x09, 0x56, 0x0f, 0x79, 0xb8, 0xb3, 0x9f, 0x14, 0xdf, 0x7b, 0x34, 0xac, 0x77,
+	0x96, 0xb9, 0x9f, 0x25, 0x58, 0x3b, 0xe6, 0xe9, 0x4e, 0x7f, 0x52, 0x82, 0xe8, 0xd1, 0x59, 0xa3,
-	0xb4, 0x09, 0x49, 0x4f, 0x6b, 0x7e, 0xe1, 0xf2, 0xb3, 0x32, 0x29, 0x49, 0x9f, 0xb2, 0x3b, 0x79,
+	0xa3, 0x2d, 0x48, 0xf8, 0x5c, 0xf3, 0x0b, 0x97, 0x9f, 0x95, 0x71, 0x45, 0xfa, 0x94, 0xdd, 0xc9,
-	0xcf, 0x24, 0x4d, 0x43, 0xa4, 0x94, 0x8d, 0xf3, 0x2f, 0x20, 0x33, 0xce, 0x7c, 0x6e, 0xb2, 0x18,
+	0xfb, 0x26, 0x69, 0x18, 0xa2, 0xa4, 0x6c, 0x9c, 0x7b, 0x0e, 0xe9, 0x51, 0xe4, 0x73, 0xa3, 0xc5,
-	0x90, 0x7e, 0x6c, 0x91, 0x81, 0xe0, 0x33, 0xf4, 0xc4, 0x2c, 0x2c, 0xd6, 0xad, 0x16, 0xc5, 0x1d,
+	0x80, 0xd4, 0x63, 0x8b, 0xf4, 0x08, 0x9f, 0x42, 0x13, 0x33, 0xb0, 0x50, 0xb3, 0x9a, 0x14, 0xb7,
-	0x92, 0x8d, 0xaa, 0xb1, 0xf5, 0x84, 0xe1, 0x4f, 0xf3, 0xc7, 0xb0, 0x3a, 0x86, 0x79, 0x8d, 0x6e,
+	0x48, 0x26, 0xaa, 0xc6, 0x36, 0x96, 0x8c, 0x60, 0x9a, 0x3b, 0x85, 0xb5, 0x11, 0x9f, 0x37, 0xe0,
-	0x2c, 0x24, 0xdd, 0x2d, 0x58, 0x3a, 0x24, 0x66, 0x03, 0xdf, 0xa4, 0xca, 0x37, 0x61, 0x59, 0x60,
+	0xc6, 0x66, 0x84, 0xbb, 0x0d, 0xcb, 0xc7, 0xc4, 0xac, 0xe3, 0xb7, 0xe9, 0xf2, 0x2d, 0x58, 0x11,
-	0x08, 0x5a, 0x08, 0x64, 0x62, 0x7d, 0xe3, 0x55, 0x7b, 0xcc, 0xe0, 0x63, 0x56, 0xed, 0x96, 0xe3,
+	0x3e, 0x04, 0x2c, 0x04, 0x32, 0xb1, 0xbe, 0xf1, 0xbb, 0x3d, 0x66, 0xf0, 0x31, 0xeb, 0x76, 0xcb,
-	0xd6, 0x30, 0xe1, 0x96, 0x31, 0x43, 0xcc, 0x3e, 0x7c, 0x2d, 0x81, 0xcc, 0x0a, 0x18, 0xbd, 0x0f,
+	0x71, 0xab, 0x98, 0x70, 0xcb, 0x98, 0x21, 0x66, 0xb9, 0x3c, 0xac, 0x16, 0x9b, 0xd8, 0x74, 0xda,
-	0x8b, 0x87, 0xfb, 0xbb, 0xfb, 0x4f, 0x9e, 0xed, 0xa7, 0x22, 0xca, 0x3b, 0x67, 0xe7, 0x6a, 0x92,
+	0x5e, 0x68, 0x08, 0x1f, 0xbe, 0x92, 0x40, 0x66, 0x4d, 0x8f, 0xde, 0x87, 0x85, 0xe3, 0x83, 0xbd,
-	0x7d, 0x3e, 0x74, 0x9a, 0x8e, 0xfb, 0xca, 0x41, 0x19, 0x90, 0x8f, 0x2a, 0xe5, 0x67, 0x29, 0x49,
+	0x83, 0x27, 0x4f, 0x0f, 0x92, 0x11, 0xe5, 0x9d, 0x8b, 0x4b, 0x35, 0xc1, 0x3e, 0x1f, 0x3b, 0x0d,
-	0x59, 0x3a, 0x3b, 0x57, 0x6f, 0xb1, 0x25, 0x76, 0x79, 0x21, 0x05, 0xe2, 0xc5, 0xd2, 0x41, 0xe5,
+	0xc7, 0x7d, 0xe9, 0xa0, 0x34, 0xc8, 0x27, 0xe5, 0xd2, 0xd3, 0xa4, 0xa4, 0x2c, 0x5f, 0x5c, 0xaa,
-	0xa8, 0x9c, 0x8a, 0x2a, 0x2b, 0x67, 0xe7, 0x2a, 0xb0, 0x95, 0x62, 0x95, 0x5a, 0x3d, 0x8c, 0x54,
+	0x8b, 0x6c, 0x89, 0x5d, 0x78, 0x48, 0x81, 0x78, 0xa1, 0x78, 0x54, 0x3e, 0x29, 0x25, 0xa3, 0xca,
-	0x48, 0x94, 0x9e, 0xec, 0xed, 0x55, 0x0e, 0x0e, 0xca, 0xdb, 0xa9, 0x98, 0xf2, 0xee, 0xd9, 0xb9,
+	0xea, 0xc5, 0xa5, 0x0a, 0x6c, 0xa5, 0x50, 0xa1, 0x56, 0x07, 0x23, 0x15, 0x96, 0x8a, 0x4f, 0xf6,
-	0xba, 0xcc, 0x96, 0xbd, 0x2e, 0x4a, 0x71, 0x4d, 0x59, 0x7a, 0xfd, 0x63, 0x2e, 0xf2, 0xcb, 0x4f,
+	0xf7, 0xcb, 0x47, 0x47, 0xa5, 0x9d, 0x64, 0x4c, 0x79, 0xf7, 0xe2, 0x52, 0x5d, 0x61, 0xcb, 0xbe,
-	0x39, 0xce, 0xa0, 0xf0, 0xcf, 0x22, 0x24, 0x06, 0x1a, 0xa3, 0xef, 0x60, 0x51, 0x3c, 0x32, 0xd0,
+	0xf2, 0x52, 0x5c, 0x55, 0x96, 0x5f, 0xfd, 0x98, 0x8d, 0xfc, 0xf2, 0x53, 0x96, 0x23, 0xc8, 0xff,
-	0x46, 0xd8, 0x87, 0x8f, 0xf2, 0x30, 0x84, 0xa5, 0x10, 0xb1, 0x0b, 0x32, 0x8f, 0xf0, 0xe3, 0x50,
+	0xb6, 0x08, 0x4b, 0xbd, 0xba, 0xa0, 0xef, 0x60, 0x41, 0x3c, 0x4c, 0xd0, 0xe6, 0xac, 0x8f, 0x25,
-	0x8f, 0x05, 0xe5, 0xfe, 0xac, 0x66, 0xc2, 0x6d, 0x13, 0xe2, 0xde, 0x3d, 0x8c, 0xf4, 0xe9, 0x08,
+	0xe5, 0xe1, 0x0c, 0x96, 0x82, 0xf8, 0x36, 0xc8, 0x3c, 0xc3, 0x8f, 0x67, 0x7a, 0x60, 0x28, 0xf7,
-	0x57, 0xae, 0x7d, 0xe5, 0x6e, 0x70, 0x03, 0xe1, 0xec, 0x18, 0xe2, 0x5e, 0x32, 0xd0, 0x83, 0x90,
+	0xa7, 0x35, 0x13, 0x61, 0x1b, 0x10, 0xf7, 0xef, 0x6e, 0xa4, 0x4f, 0xf6, 0x30, 0xf4, 0x54, 0x50,
-	0x97, 0x9f, 0x92, 0xb9, 0x56, 0xf3, 0x65, 0xf6, 0x48, 0x67, 0xd0, 0xde, 0x63, 0x20, 0x08, 0xf4,
+	0xee, 0x86, 0x37, 0x10, 0xc1, 0x4e, 0x21, 0xee, 0x17, 0x03, 0x3d, 0x98, 0xf1, 0xc2, 0x54, 0xd2,
-	0xc4, 0x67, 0xc3, 0xff, 0x42, 0x77, 0x41, 0x66, 0x3d, 0x35, 0x48, 0x66, 0x26, 0x5c, 0xa4, 0x41,
+	0x37, 0x74, 0xa2, 0xc4, 0x1e, 0xf6, 0xcc, 0xb5, 0xff, 0x80, 0x08, 0xe3, 0x7a, 0xec, 0x53, 0xe3,
-	0x32, 0x33, 0xb1, 0x65, 0x7f, 0x0b, 0x71, 0xaf, 0x6b, 0x05, 0x89, 0x68, 0x62, 0x67, 0x56, 0x36,
+	0x8d, 0xae, 0xdb, 0x20, 0x33, 0x1d, 0x0e, 0x53, 0x99, 0x31, 0x97, 0x6f, 0x98, 0xca, 0x8c, 0x95,
-	0x66, 0x37, 0x14, 0xce, 0xfb, 0x20, 0xb3, 0x16, 0x84, 0x02, 0x90, 0x9f, 0xd4, 0xfe, 0x94, 0x07,
+	0xf9, 0x6f, 0x21, 0xee, 0x2b, 0x5d, 0x98, 0x8c, 0xc6, 0xaa, 0xb9, 0xb2, 0x39, 0xbd, 0xa1, 0x08,
-	0x33, 0xdb, 0x79, 0x8e, 0xef, 0x4a, 0xe8, 0x14, 0x16, 0x78, 0x7b, 0x41, 0x5a, 0x00, 0xf6, 0x23,
+	0xde, 0x05, 0x99, 0xc9, 0x16, 0x0a, 0x01, 0x7e, 0x9c, 0x64, 0x2a, 0x0f, 0xa6, 0xb6, 0xf3, 0x03,
-	0xbd, 0x4c, 0xd1, 0x03, 0xef, 0xf7, 0x7c, 0x6d, 0x7d, 0x75, 0xf1, 0x26, 0x17, 0xf9, 0xed, 0x4d,
+	0xdf, 0x95, 0xd0, 0x39, 0xdc, 0xe2, 0x92, 0x84, 0xb4, 0x10, 0xe8, 0x07, 0xf4, 0x4f, 0xd1, 0x43,
-	0x2e, 0xf2, 0xfd, 0x65, 0x4e, 0xba, 0xb8, 0xcc, 0x49, 0xbf, 0x5e, 0xe6, 0xa4, 0x3f, 0x2f, 0x73,
+	0xef, 0x17, 0x49, 0x1e, 0xc2, 0x82, 0xd0, 0x2f, 0x14, 0xe2, 0x2c, 0x0f, 0x4b, 0xdd, 0x9b, 0x4e,
-	0xd2, 0x8b, 0xed, 0xf0, 0x7f, 0xa3, 0x9b, 0x83, 0xc9, 0xf3, 0xc8, 0x49, 0x9c, 0x1f, 0xa5, 0x8f,
+	0xcb, 0xf6, 0x57, 0x57, 0xaf, 0xb3, 0x91, 0xdf, 0x5f, 0x67, 0x23, 0xdf, 0x5f, 0x67, 0xa5, 0xab,
-	0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x3b, 0x8b, 0xa6, 0xa4, 0xde, 0x0e, 0x00, 0x00,
+	0xeb, 0xac, 0xf4, 0xeb, 0x75, 0x56, 0xfa, 0xeb, 0x3a, 0x2b, 0x3d, 0xdf, 0x99, 0xfd, 0xb7, 0x78,
+	0xab, 0x37, 0x79, 0x16, 0x39, 0x8b, 0xf3, 0x88, 0x1f, 0xfd, 0x17, 0x00, 0x00, 0xff, 0xff, 0x20,
+	0x9c, 0x85, 0x7f, 0x67, 0x0f, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -895,6 +937,7 @@ type SnapshotsClient interface {
 	Update(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*UpdateSnapshotResponse, error)
 	List(ctx context.Context, in *ListSnapshotsRequest, opts ...grpc.CallOption) (Snapshots_ListClient, error)
 	Usage(ctx context.Context, in *UsageRequest, opts ...grpc.CallOption) (*UsageResponse, error)
+	Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*types1.Empty, error)
 }
 
 type snapshotsClient struct {
@@ -1009,6 +1052,15 @@ func (c *snapshotsClient) Usage(ctx context.Context, in *UsageRequest, opts ...g
 	return out, nil
 }
 
+func (c *snapshotsClient) Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*types1.Empty, error) {
+	out := new(types1.Empty)
+	err := c.cc.Invoke(ctx, "/containerd.services.snapshots.v1.Snapshots/Cleanup", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // SnapshotsServer is the server API for Snapshots service.
 type SnapshotsServer interface {
 	Prepare(context.Context, *PrepareSnapshotRequest) (*PrepareSnapshotResponse, error)
@@ -1020,6 +1072,7 @@ type SnapshotsServer interface {
 	Update(context.Context, *UpdateSnapshotRequest) (*UpdateSnapshotResponse, error)
 	List(*ListSnapshotsRequest, Snapshots_ListServer) error
 	Usage(context.Context, *UsageRequest) (*UsageResponse, error)
+	Cleanup(context.Context, *CleanupRequest) (*types1.Empty, error)
 }
 
 func RegisterSnapshotsServer(s *grpc.Server, srv SnapshotsServer) {
@@ -1191,6 +1244,24 @@ func _Snapshots_Usage_Handler(srv interface{}, ctx context.Context, dec func(int
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Snapshots_Cleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CleanupRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SnapshotsServer).Cleanup(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/containerd.services.snapshots.v1.Snapshots/Cleanup",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SnapshotsServer).Cleanup(ctx, req.(*CleanupRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Snapshots_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "containerd.services.snapshots.v1.Snapshots",
 	HandlerType: (*SnapshotsServer)(nil),
@@ -1227,6 +1298,10 @@ var _Snapshots_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Usage",
 			Handler:    _Snapshots_Usage_Handler,
 		},
+		{
+			MethodName: "Cleanup",
+			Handler:    _Snapshots_Cleanup_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -1917,6 +1992,33 @@ func (m *UsageResponse) MarshalTo(dAtA []byte) (int, error) {
 	return i, nil
 }
 
+func (m *CleanupRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *CleanupRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Snapshotter) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintSnapshots(dAtA, i, uint64(len(m.Snapshotter)))
+		i += copy(dAtA[i:], m.Snapshotter)
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
 func encodeVarintSnapshots(dAtA []byte, offset int, v uint64) int {
 	for v >= 1<<7 {
 		dAtA[offset] = uint8(v&0x7f | 0x80)
@@ -2299,6 +2401,22 @@ func (m *UsageResponse) Size() (n int) {
 	return n
 }
 
+func (m *CleanupRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Snapshotter)
+	if l > 0 {
+		n += 1 + l + sovSnapshots(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func sovSnapshots(x uint64) (n int) {
 	for {
 		n++
@@ -2561,6 +2679,17 @@ func (this *UsageResponse) String() string {
 	}, "")
 	return s
 }
+func (this *CleanupRequest) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&CleanupRequest{`,
+		`Snapshotter:` + fmt.Sprintf("%v", this.Snapshotter) + `,`,
+		`XXX_unrecognized:` + fmt.Sprintf("%v", this.XXX_unrecognized) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func valueToStringSnapshots(v interface{}) string {
 	rv := reflect.ValueOf(v)
 	if rv.IsNil() {
@@ -5093,6 +5222,92 @@ func (m *UsageResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *CleanupRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowSnapshots
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: CleanupRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CleanupRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Snapshotter", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowSnapshots
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthSnapshots
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthSnapshots
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Snapshotter = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipSnapshots(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthSnapshots
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthSnapshots
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipSnapshots(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

vendor/github.com/containerd/containerd/api/services/snapshots/v1/snapshots.proto

@@ -21,6 +21,7 @@ service Snapshots {
 	rpc Update(UpdateSnapshotRequest) returns (UpdateSnapshotResponse);
 	rpc List(ListSnapshotsRequest) returns (stream ListSnapshotsResponse);
 	rpc Usage(UsageRequest) returns (UsageResponse);
+	rpc Cleanup(CleanupRequest) returns (google.protobuf.Empty);
 }
 
 message PrepareSnapshotRequest {
@@ -160,3 +161,7 @@ message UsageResponse {
 	int64 size = 1;
 	int64 inodes = 2;
 }
+
+message CleanupRequest {
+	string snapshotter = 1;
+}

vendor/github.com/containerd/containerd/archive/tar_unix.go

@@ -176,7 +176,10 @@ func copyDirInfo(fi os.FileInfo, path string) error {
 		return errors.Wrapf(err, "failed to chmod %s", path)
 	}
 
-	timespec := []unix.Timespec{unix.Timespec(fs.StatAtime(st)), unix.Timespec(fs.StatMtime(st))}
+	timespec := []unix.Timespec{
+		unix.NsecToTimespec(syscall.TimespecToNsec(fs.StatAtime(st))),
+		unix.NsecToTimespec(syscall.TimespecToNsec(fs.StatMtime(st))),
+	}
 	if err := unix.UtimesNanoAt(unix.AT_FDCWD, path, timespec, unix.AT_SYMLINK_NOFOLLOW); err != nil {
 		return errors.Wrapf(err, "failed to utime %s", path)
 	}

vendor/github.com/containerd/containerd/filters/parser.go

@@ -209,6 +209,8 @@ func (p *parser) field() (string, error) {
 		return s, nil
 	case tokenQuoted:
 		return p.unquote(pos, s, false)
+	case tokenIllegal:
+		return "", p.mkerr(pos, p.scanner.err)
 	}
 
 	return "", p.mkerr(pos, "expected field or quoted")
@@ -228,6 +230,8 @@ func (p *parser) operator() (operator, error) {
 		default:
 			return 0, p.mkerr(pos, "unsupported operator %q", s)
 		}
+	case tokenIllegal:
+		return 0, p.mkerr(pos, p.scanner.err)
 	}
 
 	return 0, p.mkerr(pos, `expected an operator ("=="|"!="|"~=")`)
@@ -241,6 +245,8 @@ func (p *parser) value(allowAltQuotes bool) (string, error) {
 		return s, nil
 	case tokenQuoted:
 		return p.unquote(pos, s, allowAltQuotes)
+	case tokenIllegal:
+		return "", p.mkerr(pos, p.scanner.err)
 	}
 
 	return "", p.mkerr(pos, "expected value or quoted")

vendor/github.com/containerd/containerd/filters/scanner.go

@@ -17,7 +17,6 @@
 package filters
 
 import (
-	"fmt"
 	"unicode"
 	"unicode/utf8"
 )
@@ -64,6 +63,7 @@ type scanner struct {
 	pos   int
 	ppos  int // bounds the current rune in the string
 	value bool
+	err   string
 }
 
 func (s *scanner) init(input string) {
@@ -82,12 +82,14 @@ func (s *scanner) next() rune {
 	s.ppos += w
 	if r == utf8.RuneError {
 		if w > 0 {
+			s.error("rune error")
 			return tokenIllegal
 		}
 		return tokenEOF
 	}
 
 	if r == 0 {
+		s.error("unexpected null")
 		return tokenIllegal
 	}
 
@@ -114,7 +116,9 @@ chomp:
 	case ch == tokenEOF:
 	case ch == tokenIllegal:
 	case isQuoteRune(ch):
-		s.scanQuoted(ch)
+		if !s.scanQuoted(ch) {
+			return pos, tokenIllegal, s.input[pos:s.ppos]
+		}
 		return pos, tokenQuoted, s.input[pos:s.ppos]
 	case isSeparatorRune(ch):
 		s.value = false
@@ -172,54 +176,64 @@ func (s *scanner) scanValue() {
 	}
 }
 
-func (s *scanner) scanQuoted(quote rune) {
+func (s *scanner) scanQuoted(quote rune) bool {
+	var illegal bool
 	ch := s.next() // read character after quote
 	for ch != quote {
 		if ch == '\n' || ch < 0 {
-			s.error("literal not terminated")
+			s.error("quoted literal not terminated")
-			return
+			return false
 		}
 		if ch == '\\' {
-			ch = s.scanEscape(quote)
+			var legal bool
+			ch, legal = s.scanEscape(quote)
+			if !legal {
+				illegal = true
+			}
 		} else {
 			ch = s.next()
 		}
 	}
+	return !illegal
 }
 
-func (s *scanner) scanEscape(quote rune) rune {
+func (s *scanner) scanEscape(quote rune) (ch rune, legal bool) {
-	ch := s.next() // read character after '/'
+	ch = s.next() // read character after '/'
 	switch ch {
 	case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', quote:
 		// nothing to do
 		ch = s.next()
+		legal = true
 	case '0', '1', '2', '3', '4', '5', '6', '7':
-		ch = s.scanDigits(ch, 8, 3)
+		ch, legal = s.scanDigits(ch, 8, 3)
 	case 'x':
-		ch = s.scanDigits(s.next(), 16, 2)
+		ch, legal = s.scanDigits(s.next(), 16, 2)
 	case 'u':
-		ch = s.scanDigits(s.next(), 16, 4)
+		ch, legal = s.scanDigits(s.next(), 16, 4)
 	case 'U':
-		ch = s.scanDigits(s.next(), 16, 8)
+		ch, legal = s.scanDigits(s.next(), 16, 8)
 	default:
-		s.error("illegal char escape")
+		s.error("illegal escape sequence")
 	}
-	return ch
+	return
 }
 
-func (s *scanner) scanDigits(ch rune, base, n int) rune {
+func (s *scanner) scanDigits(ch rune, base, n int) (rune, bool) {
 	for n > 0 && digitVal(ch) < base {
 		ch = s.next()
 		n--
 	}
 	if n > 0 {
-		s.error("illegal char escape")
+		s.error("illegal numeric escape sequence")
+		return ch, false
 	}
-	return ch
+	return ch, true
 }
 
 func (s *scanner) error(msg string) {
-	fmt.Println("error fixme", msg)
+	if s.err == "" {
+		s.err = msg
+	}
 }
 
 func digitVal(ch rune) int {

vendor/github.com/containerd/containerd/gc/gc.go

@@ -172,7 +172,7 @@ func ConcurrentMark(ctx context.Context, root <-chan Node, refs func(context.Con
 	return seen, nil
 }
 
-// Sweep removes all nodes returned through the channel which are not in
+// Sweep removes all nodes returned through the slice which are not in
 // the reachable set by calling the provided remove function.
 func Sweep(reachable map[Node]struct{}, all []Node, remove func(Node) error) error {
 	// All black objects are now reachable, and all white objects are

vendor/github.com/containerd/containerd/metadata/snapshot.go

@@ -791,18 +791,17 @@ func validateSnapshot(info *snapshots.Info) error {
 	return nil
 }
 
-type cleaner interface {
-	Cleanup(ctx context.Context) error
-}
-
 func (s *snapshotter) garbageCollect(ctx context.Context) (d time.Duration, err error) {
 	s.l.Lock()
 	t1 := time.Now()
 	defer func() {
 		s.l.Unlock()
 		if err == nil {
-			if c, ok := s.Snapshotter.(cleaner); ok {
+			if c, ok := s.Snapshotter.(snapshots.Cleaner); ok {
 				err = c.Cleanup(ctx)
+				if errdefs.IsNotImplemented(err) {
+					err = nil
+				}
 			}
 		}
 		if err == nil {

vendor/github.com/containerd/containerd/mount/mount_linux.go

@@ -19,6 +19,7 @@ package mount
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"path"
 	"strings"
 	"time"
@@ -28,14 +29,27 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-var pagesize = 4096
+var (
+	pagesize              = 4096
+	allowedHelperBinaries = []string{"mount.fuse", "mount.fuse3"}
+)
 
 func init() {
 	pagesize = os.Getpagesize()
 }
 
-// Mount to the provided target path
+// Mount to the provided target path.
+//
+// If m.Type starts with "fuse." or "fuse3.", "mount.fuse" or "mount.fuse3"
+// helper binary is called.
 func (m *Mount) Mount(target string) error {
+	for _, helperBinary := range allowedHelperBinaries {
+		// helperBinary = "mount.fuse", typePrefix = "fuse."
+		typePrefix := strings.TrimPrefix(helperBinary, "mount.") + "."
+		if strings.HasPrefix(m.Type, typePrefix) {
+			return m.mountWithHelper(helperBinary, typePrefix, target)
+		}
+	}
 	var (
 		chdir   string
 		options = m.Options
@@ -92,7 +106,28 @@ func Unmount(target string, flags int) error {
 	return nil
 }
 
+func isFUSE(dir string) (bool, error) {
+	// fuseSuperMagic is defined in statfs(2)
+	const fuseSuperMagic = 0x65735546
+	var st unix.Statfs_t
+	if err := unix.Statfs(dir, &st); err != nil {
+		return false, err
+	}
+	return st.Type == fuseSuperMagic, nil
+}
+
 func unmount(target string, flags int) error {
+	// For FUSE mounts, attempting to execute fusermount helper binary is preferred
+	// https://github.com/containerd/containerd/pull/3765#discussion_r342083514
+	if ok, err := isFUSE(target); err == nil && ok {
+		for _, helperBinary := range []string{"fusermount3", "fusermount"} {
+			cmd := exec.Command(helperBinary, "-u", target)
+			if err := cmd.Run(); err == nil {
+				return nil
+			}
+			// ignore error and try unix.Unmount
+		}
+	}
 	for i := 0; i < 50; i++ {
 		if err := unix.Unmount(target, flags); err != nil {
 			switch err {
@@ -317,3 +352,21 @@ func mountAt(chdir string, source, target, fstype string, flags uintptr, data st
 	}
 	return errors.Wrap(sys.FMountat(f.Fd(), source, target, fstype, flags, data), "failed to mountat")
 }
+
+func (m *Mount) mountWithHelper(helperBinary, typePrefix, target string) error {
+	// helperBinary: "mount.fuse3"
+	// target: "/foo/merged"
+	// m.Type: "fuse3.fuse-overlayfs"
+	// command: "mount.fuse3 overlay /foo/merged -o lowerdir=/foo/lower2:/foo/lower1,upperdir=/foo/upper,workdir=/foo/work -t fuse-overlayfs"
+	args := []string{m.Source, target}
+	for _, o := range m.Options {
+		args = append(args, "-o", o)
+	}
+	args = append(args, "-t", strings.TrimPrefix(m.Type, typePrefix))
+	cmd := exec.Command(helperBinary, args...)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return errors.Wrapf(err, "mount helper [%s %v] failed: %q", helperBinary, args, string(out))
+	}
+	return nil
+}

vendor/github.com/containerd/containerd/platforms/platforms.go

@@ -189,9 +189,8 @@ func Parse(specifier string) (specs.Platform, error) {
 		if isKnownOS(p.OS) {
 			// picks a default architecture
 			p.Architecture = runtime.GOARCH
-			if p.Architecture == "arm" {
+			if p.Architecture == "arm" && cpuVariant != "v7" {
-				// TODO(stevvooe): Resolve arm variant, if not v6 (default)
+				p.Variant = cpuVariant
-				return specs.Platform{}, errors.Wrapf(errdefs.ErrNotImplemented, "arm support not fully implemented")
 			}
 
 			return p, nil

vendor/github.com/containerd/containerd/plugin/plugin_go18.go

@@ -1,4 +1,4 @@
-// +build go1.8,!windows,amd64,!static_build
+// +build go1.8,!windows,amd64,!static_build,!gccgo
 
 /*
    Copyright The containerd Authors.

vendor/github.com/containerd/containerd/plugin/plugin_other.go

@@ -1,4 +1,4 @@
-// +build !go1.8 windows !amd64 static_build
+// +build !go1.8 windows !amd64 static_build gccgo
 
 /*
    Copyright The containerd Authors.

vendor/github.com/containerd/containerd/services/content/contentserver/contentserver.go

@@ -115,7 +115,7 @@ func (s *service) List(req *api.ListContentRequest, session api.Content_ListServ
 
 		return nil
 	}, req.Filters...); err != nil {
-		return err
+		return errdefs.ToGRPC(err)
 	}
 
 	if len(buffer) > 0 {

vendor/github.com/containerd/containerd/services/snapshots/service.go

@@ -255,6 +255,25 @@ func (s *service) Usage(ctx context.Context, ur *snapshotsapi.UsageRequest) (*sn
 	return fromUsage(usage), nil
 }
 
+func (s *service) Cleanup(ctx context.Context, cr *snapshotsapi.CleanupRequest) (*ptypes.Empty, error) {
+	sn, err := s.getSnapshotter(cr.Snapshotter)
+	if err != nil {
+		return nil, err
+	}
+
+	c, ok := sn.(snapshots.Cleaner)
+	if !ok {
+		return nil, errdefs.ToGRPCf(errdefs.ErrNotImplemented, "snapshotter does not implement Cleanup method")
+	}
+
+	err = c.Cleanup(ctx)
+	if err != nil {
+		return nil, errdefs.ToGRPC(err)
+	}
+
+	return empty, nil
+}
+
 func fromKind(kind snapshots.Kind) snapshotsapi.Kind {
 	if kind == snapshots.KindActive {
 		return snapshotsapi.KindActive

vendor/github.com/containerd/containerd/snapshots/proxy/proxy.go

@@ -184,6 +184,13 @@ func (p *proxySnapshotter) Close() error {
 	return nil
 }
 
+func (p *proxySnapshotter) Cleanup(ctx context.Context) error {
+	_, err := p.client.Cleanup(ctx, &snapshotsapi.CleanupRequest{
+		Snapshotter: p.snapshotterName,
+	})
+	return errdefs.FromGRPC(err)
+}
+
 func toKind(kind snapshotsapi.Kind) snapshots.Kind {
 	if kind == snapshotsapi.KindActive {
 		return snapshots.KindActive

vendor/github.com/containerd/containerd/snapshots/snapshotter.go

@@ -341,6 +341,17 @@ type Snapshotter interface {
 	Close() error
 }
 
+// Cleaner defines a type capable of performing asynchronous resource cleanup.
+// The Cleaner interface should be used by snapshotters which implement fast
+// removal and deferred resource cleanup. This prevents snapshots from needing
+// to perform lengthy resource cleanup before acknowledging a snapshot key
+// has been removed and available for re-use. This is also useful when
+// performing multi-key removal with the intent of cleaning up all the
+// resources after each snapshot key has been removed.
+type Cleaner interface {
+	Cleanup(ctx context.Context) error
+}
+
 // Opt allows setting mutable snapshot properties on creation
 type Opt func(info *Info) error
 

vendor/github.com/containerd/containerd/unpacker.go

@@ -191,7 +191,7 @@ EachLayer:
 		case <-fetchC[i-fetchOffset]:
 		}
 
-		diff, err := a.Apply(ctx, desc, mounts)
+		diff, err := a.Apply(ctx, desc, mounts, u.config.ApplyOpts...)
 		if err != nil {
 			abort()
 			return errors.Wrapf(err, "failed to extract layer %s", diffIDs[i])

vendor/github.com/containerd/containerd/vendor.conf

@@ -3,7 +3,7 @@ github.com/BurntSushi/toml                          3012a1dbe2e4bd1391d42b32f057
 github.com/containerd/btrfs                         af5082808c833de0e79c1e72eea9fea239364877
 github.com/containerd/cgroups                       fada802a7909d430bd17126fd6e4bbf5716f2bcd
 github.com/containerd/console                       8375c3424e4d7b114e8a90a4a40c8e1b40d1d4e6
-github.com/containerd/continuity                    f2a389ac0a02ce21c09edd7344677a601970f41c
+github.com/containerd/continuity                    0ec596719c75bfd42908850990acea594b7593ac
 github.com/containerd/fifo                          bda0ff6ed73c67bfb5e62bc9c697f146b7fd7f13
 github.com/containerd/go-runc                       a5c2862aed5e6358b305b0e16bfce58e0549b1cd
 github.com/containerd/ttrpc                         92c8520ef9f86600c650dd540266a007bf03670f