@@ -26,7 +26,7 @@ github.com/imdario/mergo v0.3.5

 golang.org/x/sync fd80eb99c8f653c847d294a001bdf2a3a6f768f5

 # buildkit

-github.com/moby/buildkit dbf67a691ce77023a0a5ce9b005298631f8bbb4e

+github.com/moby/buildkit cce2080ddbe4698912f2290892b247c83627efa8

 github.com/tonistiigi/fsutil 8abad97ee3969cdf5e9c367f46adba2c212b3ddb

 github.com/grpc-ecosystem/grpc-opentracing 8e809c8a86450a29b90dcc9efbf062d0fe6d9746

 github.com/opentracing/opentracing-go 1361b9cd60be79c4c3a7fa9841b3c132e40066a7

@@ -542,8 +542,9 @@ func (m *ListWorkersResponse) GetRecord() []*WorkerRecord {

 }

 type WorkerRecord struct {

-	ID     string            `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`

-	Labels map[string]string `protobuf:"bytes,2,rep,name=Labels" json:"Labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`

+	ID        string            `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`

+	Labels    map[string]string `protobuf:"bytes,2,rep,name=Labels" json:"Labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`

+	Platforms []pb.Platform     `protobuf:"bytes,3,rep,name=platforms" json:"platforms"`

 }

 func (m *WorkerRecord) Reset()                    { *m = WorkerRecord{} }

@@ -565,6 +566,13 @@ func (m *WorkerRecord) GetLabels() map[string]string {

 	return nil

 }

+func (m *WorkerRecord) GetPlatforms() []pb.Platform {

+	if m != nil {

+		return m.Platforms

+	}

+	return nil

+}

+

 func init() {

 	proto.RegisterType((*PruneRequest)(nil), "moby.buildkit.v1.PruneRequest")

 	proto.RegisterType((*DiskUsageRequest)(nil), "moby.buildkit.v1.DiskUsageRequest")

@@ -1650,6 +1658,18 @@ func (m *WorkerRecord) MarshalTo(dAtA []byte) (int, error) {

 			i += copy(dAtA[i:], v)

 		}

 	}

+	if len(m.Platforms) > 0 {

+		for _, msg := range m.Platforms {

+			dAtA[i] = 0x1a

+			i++

+			i = encodeVarintControl(dAtA, i, uint64(msg.Size()))

+			n, err := msg.MarshalTo(dAtA[i:])

+			if err != nil {

+				return 0, err

+			}

+			i += n

+		}

+	}

 	return i, nil

 }

@@ -1979,6 +1999,12 @@ func (m *WorkerRecord) Size() (n int) {

 			n += mapEntrySize + 1 + sovControl(uint64(mapEntrySize))

 		}

 	}

+	if len(m.Platforms) > 0 {

+		for _, e := range m.Platforms {

+			l = e.Size()

+			n += 1 + l + sovControl(uint64(l))

+		}

+	}

 	return n

 }

@@ -4663,6 +4689,37 @@ func (m *WorkerRecord) Unmarshal(dAtA []byte) error {

 			}

 			m.Labels[mapkey] = mapvalue

 			iNdEx = postIndex

+		case 3:

+			if wireType != 2 {

+				return fmt.Errorf("proto: wrong wireType = %d for field Platforms", wireType)

+			}

+			var msglen int

+			for shift := uint(0); ; shift += 7 {

+				if shift >= 64 {

+					return ErrIntOverflowControl

+				}

+				if iNdEx >= l {

+					return io.ErrUnexpectedEOF

+				}

+				b := dAtA[iNdEx]

+				iNdEx++

+				msglen |= (int(b) & 0x7F) << shift

+				if b < 0x80 {

+					break

+				}

+			}

+			if msglen < 0 {

+				return ErrInvalidLengthControl

+			}

+			postIndex := iNdEx + msglen

+			if postIndex > l {

+				return io.ErrUnexpectedEOF

+			}

+			m.Platforms = append(m.Platforms, pb.Platform{})

+			if err := m.Platforms[len(m.Platforms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {

+				return err

+			}

+			iNdEx = postIndex

 		default:

 			iNdEx = preIndex

 			skippy, err := skipControl(dAtA[iNdEx:])

@@ -4792,80 +4849,81 @@ var (

 func init() { proto.RegisterFile("control.proto", fileDescriptorControl) }

 var fileDescriptorControl = []byte{

-	// 1192 bytes of a gzipped FileDescriptorProto

-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xcd, 0x6e, 0x23, 0x45,

-	0x10, 0x66, 0x6c, 0xc7, 0x3f, 0x65, 0x27, 0x0a, 0x0d, 0xac, 0x46, 0x03, 0x24, 0x66, 0x00, 0xc9,

-	0x8a, 0x76, 0xc7, 0xd9, 0xc0, 0x22, 0xc8, 0x61, 0xb5, 0xeb, 0x78, 0x11, 0x89, 0x12, 0xb1, 0x74,

-	0x36, 0xac, 0xc4, 0x6d, 0x6c, 0x77, 0xbc, 0xa3, 0xd8, 0xd3, 0xa6, 0xbb, 0x27, 0xda, 0xf0, 0x14,

-	0x1c, 0xb8, 0xf2, 0x14, 0x1c, 0x38, 0x73, 0x40, 0xda, 0x23, 0x67, 0x0e, 0x59, 0x94, 0x3b, 0x3c,

-	0x03, 0xea, 0x9f, 0xb1, 0xdb, 0x1e, 0xe7, 0xc7, 0xd9, 0x53, 0xba, 0x3a, 0x5f, 0x7d, 0x53, 0x5d,

-	0x5f, 0xb9, 0xaa, 0x60, 0xb9, 0x4b, 0x63, 0xc1, 0xe8, 0x20, 0x18, 0x31, 0x2a, 0x28, 0x5a, 0x1d,

-	0xd2, 0xce, 0x59, 0xd0, 0x49, 0xa2, 0x41, 0xef, 0x24, 0x12, 0xc1, 0xe9, 0x7d, 0xef, 0x5e, 0x3f,

-	0x12, 0x2f, 0x92, 0x4e, 0xd0, 0xa5, 0xc3, 0x66, 0x9f, 0xf6, 0x69, 0x53, 0x01, 0x3b, 0xc9, 0xb1,

-	0xb2, 0x94, 0xa1, 0x4e, 0x9a, 0xc0, 0x5b, 0xef, 0x53, 0xda, 0x1f, 0x90, 0x09, 0x4a, 0x44, 0x43,

-	0xc2, 0x45, 0x38, 0x1c, 0x19, 0xc0, 0x5d, 0x8b, 0x4f, 0x7e, 0xac, 0x99, 0x7e, 0xac, 0xc9, 0xe9,

-	0xe0, 0x94, 0xb0, 0xe6, 0xa8, 0xd3, 0xa4, 0x23, 0xae, 0xd1, 0xfe, 0x0a, 0xd4, 0x9e, 0xb2, 0x24,

-	0x26, 0x98, 0xfc, 0x98, 0x10, 0x2e, 0xfc, 0x0d, 0x58, 0x6d, 0x47, 0xfc, 0xe4, 0x88, 0x87, 0xfd,

-	0xf4, 0x0e, 0xdd, 0x81, 0xe2, 0x71, 0x34, 0x10, 0x84, 0xb9, 0x4e, 0xdd, 0x69, 0x54, 0xb0, 0xb1,

-	0xfc, 0x3d, 0x78, 0xdb, 0xc2, 0xf2, 0x11, 0x8d, 0x39, 0x41, 0x0f, 0xa0, 0xc8, 0x48, 0x97, 0xb2,

-	0x9e, 0xeb, 0xd4, 0xf3, 0x8d, 0xea, 0xd6, 0x87, 0xc1, 0xec, 0x8b, 0x03, 0xe3, 0x20, 0x41, 0xd8,

-	0x80, 0xfd, 0x3f, 0x72, 0x50, 0xb5, 0xee, 0xd1, 0x0a, 0xe4, 0x76, 0xdb, 0xe6, 0x7b, 0xb9, 0xdd,

-	0x36, 0x72, 0xa1, 0x74, 0x90, 0x88, 0xb0, 0x33, 0x20, 0x6e, 0xae, 0xee, 0x34, 0xca, 0x38, 0x35,

-	0xd1, 0xbb, 0xb0, 0xb4, 0x1b, 0x1f, 0x71, 0xe2, 0xe6, 0xd5, 0xbd, 0x36, 0x10, 0x82, 0xc2, 0x61,

-	0xf4, 0x13, 0x71, 0x0b, 0x75, 0xa7, 0x91, 0xc7, 0xea, 0x2c, 0xdf, 0xf1, 0x34, 0x64, 0x24, 0x16,

-	0xee, 0x92, 0x7e, 0x87, 0xb6, 0x50, 0x0b, 0x2a, 0x3b, 0x8c, 0x84, 0x82, 0xf4, 0x1e, 0x0b, 0xb7,

-	0x58, 0x77, 0x1a, 0xd5, 0x2d, 0x2f, 0xd0, 0x69, 0x0e, 0xd2, 0x34, 0x07, 0xcf, 0xd2, 0x34, 0xb7,

-	0xca, 0xaf, 0xce, 0xd7, 0xdf, 0xfa, 0xf9, 0xf5, 0xba, 0x83, 0x27, 0x6e, 0xe8, 0x11, 0xc0, 0x7e,

-	0xc8, 0xc5, 0x11, 0x57, 0x24, 0xa5, 0x6b, 0x49, 0x0a, 0x8a, 0xc0, 0xf2, 0x41, 0x6b, 0x00, 0x2a,

-	0x01, 0x3b, 0x34, 0x89, 0x85, 0x5b, 0x56, 0x71, 0x5b, 0x37, 0xa8, 0x0e, 0xd5, 0x36, 0xe1, 0x5d,

-	0x16, 0x8d, 0x44, 0x44, 0x63, 0xb7, 0xa2, 0x9e, 0x60, 0x5f, 0xf9, 0xbf, 0x14, 0xa0, 0x76, 0x28,

-	0x35, 0x4e, 0x85, 0x5b, 0x85, 0x3c, 0x26, 0xc7, 0x26, 0x8b, 0xf2, 0x88, 0x02, 0x80, 0x36, 0x39,

-	0x8e, 0xe2, 0x48, 0x71, 0xe4, 0x54, 0x98, 0x2b, 0xc1, 0xa8, 0x13, 0x4c, 0x6e, 0xb1, 0x85, 0x40,

-	0x1e, 0x94, 0x9f, 0xbc, 0x1c, 0x51, 0x26, 0xc5, 0xcf, 0x2b, 0x9a, 0xb1, 0x8d, 0x9e, 0xc3, 0x72,

-	0x7a, 0x7e, 0x2c, 0x04, 0xe3, 0x6e, 0x41, 0x09, 0x7e, 0x3f, 0x2b, 0xb8, 0x1d, 0x54, 0x30, 0xe5,

-	0xf3, 0x24, 0x16, 0xec, 0x0c, 0x4f, 0xf3, 0x48, 0xad, 0x0f, 0x09, 0xe7, 0x32, 0x42, 0x2d, 0x54,

-	0x6a, 0xca, 0x70, 0xbe, 0x66, 0x34, 0x16, 0x24, 0xee, 0x29, 0xa1, 0x2a, 0x78, 0x6c, 0xcb, 0x70,

-	0xd2, 0xb3, 0x0e, 0xa7, 0x74, 0xa3, 0x70, 0xa6, 0x7c, 0x4c, 0x38, 0x53, 0x77, 0x68, 0x1b, 0x96,

-	0x76, 0xc2, 0xee, 0x0b, 0xa2, 0x34, 0xa9, 0x6e, 0xad, 0x65, 0x09, 0xd5, 0xbf, 0xbf, 0x55, 0x22,

-	0xf0, 0x56, 0x41, 0x96, 0x07, 0xd6, 0x2e, 0xde, 0x23, 0x40, 0xd9, 0xf7, 0x4a, 0x5d, 0x4e, 0xc8,

-	0x59, 0xaa, 0xcb, 0x09, 0x39, 0x93, 0x45, 0x7c, 0x1a, 0x0e, 0x12, 0x5d, 0xdc, 0x15, 0xac, 0x8d,

-	0xed, 0xdc, 0x97, 0x8e, 0x64, 0xc8, 0x86, 0xb8, 0x08, 0x83, 0xff, 0xda, 0x81, 0x9a, 0x1d, 0x21,

-	0xfa, 0x00, 0x2a, 0x3a, 0xa8, 0x49, 0x71, 0x4c, 0x2e, 0x64, 0x1d, 0xee, 0x0e, 0x8d, 0xc1, 0xdd,

-	0x5c, 0x3d, 0xdf, 0xa8, 0x60, 0xeb, 0x06, 0x7d, 0x07, 0x55, 0x0d, 0xd6, 0x59, 0xce, 0xab, 0x2c,

-	0x37, 0xaf, 0x4e, 0x4a, 0x60, 0x79, 0xe8, 0x1c, 0xdb, 0x1c, 0xde, 0x43, 0x58, 0x9d, 0x05, 0x2c,

-	0xf4, 0xc2, 0xdf, 0x1d, 0x58, 0x36, 0xa2, 0x9a, 0x2e, 0x14, 0xa6, 0x8c, 0x84, 0xa5, 0x77, 0xa6,

-	0x1f, 0x3d, 0xb8, 0xb4, 0x1e, 0x34, 0x2c, 0x98, 0xf5, 0xd3, 0xf1, 0x66, 0xe8, 0xbc, 0x1d, 0x78,

-	0x6f, 0x2e, 0x74, 0xa1, 0xc8, 0x3f, 0x82, 0xe5, 0x43, 0x11, 0x8a, 0x84, 0x5f, 0xfa, 0x93, 0xf5,

-	0x7f, 0x73, 0x60, 0x25, 0xc5, 0x98, 0xd7, 0x7d, 0x0e, 0xe5, 0x53, 0xc2, 0x04, 0x79, 0x49, 0xb8,

-	0x79, 0x95, 0x9b, 0x7d, 0xd5, 0xf7, 0x0a, 0x81, 0xc7, 0x48, 0xb4, 0x0d, 0x65, 0xae, 0x78, 0x88,

-	0x96, 0x75, 0x6e, 0x29, 0x6b, 0x2f, 0xf3, 0xbd, 0x31, 0x1e, 0x35, 0xa1, 0x30, 0xa0, 0xfd, 0x54,

-	0xed, 0xf7, 0x2f, 0xf3, 0xdb, 0xa7, 0x7d, 0xac, 0x80, 0xfe, 0x79, 0x0e, 0x8a, 0xfa, 0x0e, 0xed,

-	0x41, 0xb1, 0x17, 0xf5, 0x09, 0x17, 0xfa, 0x55, 0xad, 0x2d, 0xf9, 0x03, 0xf9, 0xfb, 0x7c, 0x7d,

-	0xc3, 0x1a, 0x54, 0x74, 0x44, 0x62, 0x39, 0x28, 0xc3, 0x28, 0x26, 0x8c, 0x37, 0xfb, 0xf4, 0x9e,

-	0x76, 0x09, 0xda, 0xea, 0x0f, 0x36, 0x0c, 0x92, 0x2b, 0x8a, 0x47, 0x89, 0x30, 0x85, 0x79, 0x3b,

-	0x2e, 0xcd, 0x20, 0x47, 0x44, 0x1c, 0x0e, 0x89, 0xe9, 0x6b, 0xea, 0x2c, 0x47, 0x44, 0x57, 0xd6,

-	0x6d, 0x4f, 0x0d, 0x8e, 0x32, 0x36, 0x16, 0xda, 0x86, 0x12, 0x17, 0x21, 0x13, 0xa4, 0xa7, 0x5a,

-	0xd2, 0x4d, 0x7a, 0x7b, 0xea, 0x80, 0x1e, 0x42, 0xa5, 0x4b, 0x87, 0xa3, 0x01, 0x91, 0xde, 0xc5,

-	0x1b, 0x7a, 0x4f, 0x5c, 0x64, 0xf5, 0x10, 0xc6, 0x28, 0x53, 0x53, 0xa5, 0x82, 0xb5, 0xe1, 0xff,

-	0x97, 0x83, 0x9a, 0x2d, 0x56, 0x66, 0x62, 0xee, 0x41, 0x51, 0x4b, 0xaf, 0xab, 0xee, 0x76, 0xa9,

-	0xd2, 0x0c, 0x73, 0x53, 0xe5, 0x42, 0xa9, 0x9b, 0x30, 0x35, 0x4e, 0xf5, 0x90, 0x4d, 0x4d, 0x19,

-	0xb0, 0xa0, 0x22, 0x1c, 0xa8, 0x54, 0xe5, 0xb1, 0x36, 0xe4, 0x94, 0x1d, 0xaf, 0x2a, 0x8b, 0x4d,

-	0xd9, 0xb1, 0x9b, 0x2d, 0x43, 0xe9, 0x8d, 0x64, 0x28, 0x2f, 0x2c, 0x83, 0xff, 0xa7, 0x03, 0x95,

-	0x71, 0x95, 0x5b, 0xd9, 0x75, 0xde, 0x38, 0xbb, 0x53, 0x99, 0xc9, 0xdd, 0x2e, 0x33, 0x77, 0xa0,

-	0xc8, 0x05, 0x23, 0xe1, 0x50, 0x69, 0x94, 0xc7, 0xc6, 0x92, 0xfd, 0x64, 0xc8, 0xfb, 0x4a, 0xa1,

-	0x1a, 0x96, 0x47, 0xdf, 0x87, 0x5a, 0xeb, 0x4c, 0x10, 0x7e, 0x40, 0xb8, 0x5c, 0x2e, 0xa4, 0xb6,

-	0xbd, 0x50, 0x84, 0xea, 0x1d, 0x35, 0xac, 0xce, 0xfe, 0x5d, 0x40, 0xfb, 0x11, 0x17, 0xcf, 0x29,

-	0x3b, 0x21, 0x8c, 0xcf, 0xdb, 0x03, 0xf3, 0xd6, 0x1e, 0x78, 0x00, 0xef, 0x4c, 0xa1, 0x4d, 0x97,

-	0xfa, 0x62, 0x66, 0x13, 0x9c, 0xd3, 0x6d, 0xb4, 0xcb, 0xcc, 0x2a, 0xf8, 0xab, 0x03, 0x35, 0xfb,

-	0x1f, 0x99, 0xca, 0x6e, 0x41, 0x71, 0x3f, 0xec, 0x90, 0x41, 0xda, 0xc6, 0x36, 0xae, 0x26, 0x0e,

-	0x34, 0x58, 0xf7, 0x71, 0xe3, 0xe9, 0x7d, 0x05, 0x55, 0xeb, 0x7a, 0x91, 0x9e, 0xbd, 0xf5, 0x6f,

-	0x1e, 0x4a, 0x3b, 0x7a, 0xa9, 0x47, 0xcf, 0xa0, 0x32, 0x5e, 0x81, 0x91, 0x9f, 0x8d, 0x63, 0x76,

-	0x97, 0xf6, 0x3e, 0xbe, 0x12, 0x63, 0x32, 0xf7, 0x0d, 0x2c, 0xa9, 0xa5, 0x1c, 0xcd, 0x49, 0x99,

-	0xbd, 0xad, 0x7b, 0x57, 0x2f, 0xd7, 0x9b, 0x8e, 0x64, 0x52, 0xd3, 0x6d, 0x1e, 0x93, 0xbd, 0x06,

-	0x79, 0xeb, 0xd7, 0x8c, 0x45, 0x74, 0x00, 0x45, 0xd3, 0x68, 0xe6, 0x41, 0xed, 0x19, 0xe6, 0xd5,

-	0x2f, 0x07, 0x68, 0xb2, 0x4d, 0x07, 0x1d, 0x8c, 0x77, 0xbc, 0x79, 0xa1, 0xd9, 0x05, 0xea, 0x5d,

-	0xf3, 0xff, 0x86, 0xb3, 0xe9, 0xa0, 0x1f, 0xa0, 0x6a, 0x95, 0x20, 0xfa, 0x24, 0xeb, 0x92, 0xad,

-	0x67, 0xef, 0xd3, 0x6b, 0x50, 0x3a, 0xd8, 0x56, 0xed, 0xd5, 0xc5, 0x9a, 0xf3, 0xd7, 0xc5, 0x9a,

-	0xf3, 0xcf, 0xc5, 0x9a, 0xd3, 0x29, 0xaa, 0x5f, 0xe4, 0x67, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff,

-	0x4d, 0x94, 0x5a, 0xb6, 0xd8, 0x0d, 0x00, 0x00,

+	// 1214 bytes of a gzipped FileDescriptorProto

+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4f, 0x6f, 0x1b, 0x55,

+	0x10, 0x67, 0x6d, 0xc7, 0xf6, 0x8e, 0x9d, 0x28, 0x3c, 0xa0, 0x5a, 0x2d, 0x90, 0x98, 0x05, 0x24,

+	0xab, 0x6a, 0xd7, 0x69, 0xa0, 0x08, 0x72, 0xa8, 0x5a, 0xc7, 0x45, 0x24, 0x4a, 0x44, 0xd8, 0x34,

+	0x54, 0xe2, 0xb6, 0xb6, 0x5f, 0xdc, 0x55, 0xd6, 0xfb, 0x96, 0xf7, 0x9e, 0xa3, 0x86, 0x4f, 0xc1,

+	0x81, 0x6f, 0xc2, 0x81, 0x33, 0x07, 0xa4, 0xde, 0xe0, 0xcc, 0x21, 0x45, 0xb9, 0xc3, 0x67, 0x40,

+	0xef, 0xcf, 0xda, 0xcf, 0x5e, 0xe7, 0x8f, 0xd3, 0x93, 0xdf, 0xcc, 0xfe, 0xe6, 0xb7, 0xf3, 0x66,

+	0x66, 0x67, 0xc6, 0xb0, 0xdc, 0x23, 0x09, 0xa7, 0x24, 0xf6, 0x53, 0x4a, 0x38, 0x41, 0xab, 0x43,

+	0xd2, 0x3d, 0xf3, 0xbb, 0xa3, 0x28, 0xee, 0x9f, 0x44, 0xdc, 0x3f, 0x7d, 0xe0, 0xde, 0x1f, 0x44,

+	0xfc, 0xc5, 0xa8, 0xeb, 0xf7, 0xc8, 0xb0, 0x35, 0x20, 0x03, 0xd2, 0x92, 0xc0, 0xee, 0xe8, 0x58,

+	0x4a, 0x52, 0x90, 0x27, 0x45, 0xe0, 0xae, 0x0f, 0x08, 0x19, 0xc4, 0x78, 0x82, 0xe2, 0xd1, 0x10,

+	0x33, 0x1e, 0x0e, 0x53, 0x0d, 0xb8, 0x67, 0xf0, 0x89, 0x97, 0xb5, 0xb2, 0x97, 0xb5, 0x18, 0x89,

+	0x4f, 0x31, 0x6d, 0xa5, 0xdd, 0x16, 0x49, 0x99, 0x42, 0x7b, 0x2b, 0x50, 0x3f, 0xa0, 0xa3, 0x04,

+	0x07, 0xf8, 0xc7, 0x11, 0x66, 0xdc, 0xbb, 0x0b, 0xab, 0x9d, 0x88, 0x9d, 0x1c, 0xb1, 0x70, 0x90,

+	0xe9, 0xd0, 0x1d, 0x28, 0x1f, 0x47, 0x31, 0xc7, 0xd4, 0xb1, 0x1a, 0x56, 0xd3, 0x0e, 0xb4, 0xe4,

+	0xed, 0xc2, 0xdb, 0x06, 0x96, 0xa5, 0x24, 0x61, 0x18, 0x3d, 0x84, 0x32, 0xc5, 0x3d, 0x42, 0xfb,

+	0x8e, 0xd5, 0x28, 0x36, 0x6b, 0x9b, 0x1f, 0xfa, 0xb3, 0x37, 0xf6, 0xb5, 0x81, 0x00, 0x05, 0x1a,

+	0xec, 0xfd, 0x5e, 0x80, 0x9a, 0xa1, 0x47, 0x2b, 0x50, 0xd8, 0xe9, 0xe8, 0xf7, 0x15, 0x76, 0x3a,

+	0xc8, 0x81, 0xca, 0xfe, 0x88, 0x87, 0xdd, 0x18, 0x3b, 0x85, 0x86, 0xd5, 0xac, 0x06, 0x99, 0x88,

+	0xde, 0x85, 0xa5, 0x9d, 0xe4, 0x88, 0x61, 0xa7, 0x28, 0xf5, 0x4a, 0x40, 0x08, 0x4a, 0x87, 0xd1,

+	0x4f, 0xd8, 0x29, 0x35, 0xac, 0x66, 0x31, 0x90, 0x67, 0x71, 0x8f, 0x83, 0x90, 0xe2, 0x84, 0x3b,

+	0x4b, 0xea, 0x1e, 0x4a, 0x42, 0x6d, 0xb0, 0xb7, 0x29, 0x0e, 0x39, 0xee, 0x3f, 0xe1, 0x4e, 0xb9,

+	0x61, 0x35, 0x6b, 0x9b, 0xae, 0xaf, 0xc2, 0xec, 0x67, 0x61, 0xf6, 0x9f, 0x65, 0x61, 0x6e, 0x57,

+	0x5f, 0x9d, 0xaf, 0xbf, 0xf5, 0xf3, 0xeb, 0x75, 0x2b, 0x98, 0x98, 0xa1, 0xc7, 0x00, 0x7b, 0x21,

+	0xe3, 0x47, 0x4c, 0x92, 0x54, 0xae, 0x25, 0x29, 0x49, 0x02, 0xc3, 0x06, 0xad, 0x01, 0xc8, 0x00,

+	0x6c, 0x93, 0x51, 0xc2, 0x9d, 0xaa, 0xf4, 0xdb, 0xd0, 0xa0, 0x06, 0xd4, 0x3a, 0x98, 0xf5, 0x68,

+	0x94, 0xf2, 0x88, 0x24, 0x8e, 0x2d, 0xaf, 0x60, 0xaa, 0xbc, 0x5f, 0x4a, 0x50, 0x3f, 0x14, 0x39,

+	0xce, 0x12, 0xb7, 0x0a, 0xc5, 0x00, 0x1f, 0xeb, 0x28, 0x8a, 0x23, 0xf2, 0x01, 0x3a, 0xf8, 0x38,

+	0x4a, 0x22, 0xc9, 0x51, 0x90, 0x6e, 0xae, 0xf8, 0x69, 0xd7, 0x9f, 0x68, 0x03, 0x03, 0x81, 0x5c,

+	0xa8, 0x3e, 0x7d, 0x99, 0x12, 0x2a, 0x92, 0x5f, 0x94, 0x34, 0x63, 0x19, 0x3d, 0x87, 0xe5, 0xec,

+	0xfc, 0x84, 0x73, 0xca, 0x9c, 0x92, 0x4c, 0xf8, 0x83, 0x7c, 0xc2, 0x4d, 0xa7, 0xfc, 0x29, 0x9b,

+	0xa7, 0x09, 0xa7, 0x67, 0xc1, 0x34, 0x8f, 0xc8, 0xf5, 0x21, 0x66, 0x4c, 0x78, 0xa8, 0x12, 0x95,

+	0x89, 0xc2, 0x9d, 0xaf, 0x29, 0x49, 0x38, 0x4e, 0xfa, 0x32, 0x51, 0x76, 0x30, 0x96, 0x85, 0x3b,

+	0xd9, 0x59, 0xb9, 0x53, 0xb9, 0x91, 0x3b, 0x53, 0x36, 0xda, 0x9d, 0x29, 0x1d, 0xda, 0x82, 0xa5,

+	0xed, 0xb0, 0xf7, 0x02, 0xcb, 0x9c, 0xd4, 0x36, 0xd7, 0xf2, 0x84, 0xf2, 0xf1, 0xb7, 0x32, 0x09,

+	0xac, 0x5d, 0x12, 0xe5, 0x11, 0x28, 0x13, 0xf7, 0x31, 0xa0, 0xfc, 0x7d, 0x45, 0x5e, 0x4e, 0xf0,

+	0x59, 0x96, 0x97, 0x13, 0x7c, 0x26, 0x8a, 0xf8, 0x34, 0x8c, 0x47, 0xaa, 0xb8, 0xed, 0x40, 0x09,

+	0x5b, 0x85, 0x2f, 0x2d, 0xc1, 0x90, 0x77, 0x71, 0x11, 0x06, 0xef, 0xb5, 0x05, 0x75, 0xd3, 0x43,

+	0xf4, 0x01, 0xd8, 0xca, 0xa9, 0x49, 0x71, 0x4c, 0x14, 0xa2, 0x0e, 0x77, 0x86, 0x5a, 0x60, 0x4e,

+	0xa1, 0x51, 0x6c, 0xda, 0x81, 0xa1, 0x41, 0xdf, 0x41, 0x4d, 0x81, 0x55, 0x94, 0x8b, 0x32, 0xca,

+	0xad, 0xab, 0x83, 0xe2, 0x1b, 0x16, 0x2a, 0xc6, 0x26, 0x87, 0xfb, 0x08, 0x56, 0x67, 0x01, 0x0b,

+	0xdd, 0xf0, 0x37, 0x0b, 0x96, 0x75, 0x52, 0x75, 0x17, 0x0a, 0x33, 0x46, 0x4c, 0x33, 0x9d, 0xee,

+	0x47, 0x0f, 0x2f, 0xad, 0x07, 0x05, 0xf3, 0x67, 0xed, 0x94, 0xbf, 0x39, 0x3a, 0x77, 0x1b, 0xde,

+	0x9b, 0x0b, 0x5d, 0xc8, 0xf3, 0x8f, 0x60, 0xf9, 0x90, 0x87, 0x7c, 0xc4, 0x2e, 0xfd, 0x64, 0xbd,

+	0x5f, 0x2d, 0x58, 0xc9, 0x30, 0xfa, 0x76, 0x9f, 0x43, 0xf5, 0x14, 0x53, 0x8e, 0x5f, 0x62, 0xa6,

+	0x6f, 0xe5, 0xe4, 0x6f, 0xf5, 0xbd, 0x44, 0x04, 0x63, 0x24, 0xda, 0x82, 0x2a, 0x93, 0x3c, 0x58,

+	0xa5, 0x75, 0x6e, 0x29, 0x2b, 0x2b, 0xfd, 0xbe, 0x31, 0x1e, 0xb5, 0xa0, 0x14, 0x93, 0x41, 0x96,

+	0xed, 0xf7, 0x2f, 0xb3, 0xdb, 0x23, 0x83, 0x40, 0x02, 0xbd, 0xf3, 0x02, 0x94, 0x95, 0x0e, 0xed,

+	0x42, 0xb9, 0x1f, 0x0d, 0x30, 0xe3, 0xea, 0x56, 0xed, 0x4d, 0xf1, 0x81, 0xfc, 0x7d, 0xbe, 0x7e,

+	0xd7, 0x18, 0x54, 0x24, 0xc5, 0x89, 0x18, 0x94, 0x61, 0x94, 0x60, 0xca, 0x5a, 0x03, 0x72, 0x5f,

+	0x99, 0xf8, 0x1d, 0xf9, 0x13, 0x68, 0x06, 0xc1, 0x15, 0x25, 0xe9, 0x88, 0xeb, 0xc2, 0xbc, 0x1d,

+	0x97, 0x62, 0x10, 0x23, 0x22, 0x09, 0x87, 0x58, 0xf7, 0x35, 0x79, 0x16, 0x23, 0xa2, 0x27, 0xea,

+	0xb6, 0x2f, 0x07, 0x47, 0x35, 0xd0, 0x12, 0xda, 0x82, 0x0a, 0xe3, 0x21, 0xe5, 0xb8, 0x2f, 0x5b,

+	0xd2, 0x4d, 0x7a, 0x7b, 0x66, 0x80, 0x1e, 0x81, 0xdd, 0x23, 0xc3, 0x34, 0xc6, 0xc2, 0xba, 0x7c,

+	0x43, 0xeb, 0x89, 0x89, 0xa8, 0x1e, 0x4c, 0x29, 0xa1, 0x72, 0xaa, 0xd8, 0x81, 0x12, 0xbc, 0xff,

+	0x0a, 0x50, 0x37, 0x93, 0x95, 0x9b, 0x98, 0xbb, 0x50, 0x56, 0xa9, 0x57, 0x55, 0x77, 0xbb, 0x50,

+	0x29, 0x86, 0xb9, 0xa1, 0x72, 0xa0, 0xd2, 0x1b, 0x51, 0x39, 0x4e, 0xd5, 0x90, 0xcd, 0x44, 0xe1,

+	0x30, 0x27, 0x3c, 0x8c, 0x65, 0xa8, 0x8a, 0x81, 0x12, 0xc4, 0x94, 0x1d, 0xaf, 0x2a, 0x8b, 0x4d,

+	0xd9, 0xb1, 0x99, 0x99, 0x86, 0xca, 0x1b, 0xa5, 0xa1, 0xba, 0x70, 0x1a, 0xbc, 0x3f, 0x2c, 0xb0,

+	0xc7, 0x55, 0x6e, 0x44, 0xd7, 0x7a, 0xe3, 0xe8, 0x4e, 0x45, 0xa6, 0x70, 0xbb, 0xc8, 0xdc, 0x81,

+	0x32, 0xe3, 0x14, 0x87, 0x43, 0x99, 0xa3, 0x62, 0xa0, 0x25, 0xd1, 0x4f, 0x86, 0x6c, 0x20, 0x33,

+	0x54, 0x0f, 0xc4, 0xd1, 0xf3, 0xa0, 0xde, 0x3e, 0xe3, 0x98, 0xed, 0x63, 0x26, 0x96, 0x0b, 0x91,

+	0xdb, 0x7e, 0xc8, 0x43, 0x79, 0x8f, 0x7a, 0x20, 0xcf, 0xde, 0x3d, 0x40, 0x7b, 0x11, 0xe3, 0xcf,

+	0x09, 0x3d, 0xc1, 0x94, 0xcd, 0xdb, 0x03, 0x8b, 0xc6, 0x1e, 0xb8, 0x0f, 0xef, 0x4c, 0xa1, 0x75,

+	0x97, 0xfa, 0x62, 0x66, 0x13, 0x9c, 0xd3, 0x6d, 0x94, 0xc9, 0xcc, 0x2a, 0xf8, 0xa7, 0x05, 0x75,

+	0xf3, 0x41, 0xae, 0xb2, 0xdb, 0x50, 0xde, 0x0b, 0xbb, 0x38, 0xce, 0xda, 0xd8, 0xdd, 0xab, 0x89,

+	0x7d, 0x05, 0x56, 0x7d, 0x5c, 0x5b, 0xa2, 0x0d, 0xb0, 0xd3, 0x38, 0xe4, 0xc7, 0x84, 0x0e, 0xb3,

+	0xae, 0x56, 0x17, 0x7b, 0xd0, 0x81, 0x56, 0xea, 0x31, 0x3e, 0x01, 0xb9, 0x5f, 0x41, 0xcd, 0x20,

+	0x5a, 0xa4, 0xcb, 0x6f, 0xfe, 0x5b, 0x84, 0xca, 0xb6, 0xfa, 0x1b, 0x80, 0x9e, 0x81, 0x3d, 0x5e,

+	0x9a, 0x91, 0x97, 0xf7, 0x7c, 0x76, 0xfb, 0x76, 0x3f, 0xbe, 0x12, 0xa3, 0x63, 0xfd, 0x0d, 0x2c,

+	0xc9, 0x35, 0x1e, 0xcd, 0x09, 0xb2, 0xb9, 0xdf, 0xbb, 0x57, 0xaf, 0xe3, 0x1b, 0x96, 0x60, 0x92,

+	0xf3, 0x70, 0x1e, 0x93, 0xb9, 0x38, 0xb9, 0xeb, 0xd7, 0x0c, 0x52, 0xb4, 0x0f, 0x65, 0xdd, 0x9a,

+	0xe6, 0x41, 0xcd, 0xa9, 0xe7, 0x36, 0x2e, 0x07, 0x28, 0xb2, 0x0d, 0x0b, 0xed, 0x8f, 0xb7, 0xc2,

+	0x79, 0xae, 0x99, 0x25, 0xed, 0x5e, 0xf3, 0xbc, 0x69, 0x6d, 0x58, 0xe8, 0x07, 0xa8, 0x19, 0x45,

+	0x8b, 0x3e, 0xc9, 0x9b, 0xe4, 0xbf, 0x00, 0xf7, 0xd3, 0x6b, 0x50, 0xca, 0xd9, 0x76, 0xfd, 0xd5,

+	0xc5, 0x9a, 0xf5, 0xd7, 0xc5, 0x9a, 0xf5, 0xcf, 0xc5, 0x9a, 0xd5, 0x2d, 0xcb, 0x6f, 0xf8, 0xb3,

+	0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0x86, 0xd4, 0x0f, 0xa1, 0x0a, 0x0e, 0x00, 0x00,

 }

@@ -118,4 +118,5 @@ message ListWorkersResponse {

 message WorkerRecord {

 	string ID = 1;

 	map<string, string> Labels = 2;

+	repeated pb.Platform platforms = 3 [(gogoproto.nullable) = false];

 }

@@ -17,7 +17,7 @@ import (

 )

 var (

-	errLocked   = errors.New("locked")

+	ErrLocked   = errors.New("locked")

 	errNotFound = errors.New("not found")

 	errInvalid  = errors.New("invalid")

 )

@@ -122,7 +122,7 @@ func (cm *cacheManager) get(ctx context.Context, id string, fromSnapshotter bool

 	if rec.mutable {

 		if len(rec.refs) != 0 {

-			return nil, errors.Wrapf(errLocked, "%s is locked", id)

+			return nil, errors.Wrapf(ErrLocked, "%s is locked", id)

 		}

 		if rec.equalImmutable != nil {

 			return rec.equalImmutable.ref(), nil

@@ -279,12 +279,12 @@ func (cm *cacheManager) GetMutable(ctx context.Context, id string) (MutableRef,

 	}

 	if len(rec.refs) != 0 {

-		return nil, errors.Wrapf(errLocked, "%s is locked", id)

+		return nil, errors.Wrapf(ErrLocked, "%s is locked", id)

 	}

 	if rec.equalImmutable != nil {

 		if len(rec.equalImmutable.refs) != 0 {

-			return nil, errors.Wrapf(errLocked, "%s is locked", id)

+			return nil, errors.Wrapf(ErrLocked, "%s is locked", id)

 		}

 		delete(cm.records, rec.equalImmutable.ID())

 		if err := rec.equalImmutable.remove(ctx, false); err != nil {

@@ -513,7 +513,7 @@ func (cm *cacheManager) DiskUsage(ctx context.Context, opt client.DiskUsageInfo)

 }

 func IsLocked(err error) bool {

-	return errors.Cause(err) == errLocked

+	return errors.Cause(err) == ErrLocked

 }

 func IsNotFound(err error) bool {

@@ -5,7 +5,6 @@ import (

 	"crypto/tls"

 	"crypto/x509"

 	"io/ioutil"

-	"time"

 	"github.com/grpc-ecosystem/grpc-opentracing/go/otgrpc"

 	controlapi "github.com/moby/buildkit/api/services/control"

@@ -23,7 +22,7 @@ type Client struct {

 type ClientOpt interface{}

 // New returns a new buildkit client. Address can be empty for the system-default address.

-func New(address string, opts ...ClientOpt) (*Client, error) {

+func New(ctx context.Context, address string, opts ...ClientOpt) (*Client, error) {

 	gopts := []grpc.DialOption{

 		grpc.WithDialer(dialer),

 		grpc.FailOnNonTempDialError(true),

@@ -54,9 +53,6 @@ func New(address string, opts ...ClientOpt) (*Client, error) {

 		address = appdefaults.Address

 	}

-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)

-	defer cancel()

-

 	conn, err := grpc.DialContext(ctx, address, gopts...)

 	if err != nil {

 		return nil, errors.Wrapf(err, "failed to dial %q . make sure buildkitd is running", address)

@@ -17,8 +17,8 @@ type Meta struct {

 	ProxyEnv *ProxyEnv

 }

-func NewExecOp(root Output, meta Meta, readOnly bool, md OpMetadata) *ExecOp {

-	e := &ExecOp{meta: meta, cachedOpMetadata: md}

+func NewExecOp(root Output, meta Meta, readOnly bool, c Constraints) *ExecOp {

+	e := &ExecOp{meta: meta, constraints: c}

 	rootMount := &mount{

 		target:   pb.RootMount,

 		source:   root,

@@ -28,32 +28,35 @@ func NewExecOp(root Output, meta Meta, readOnly bool, md OpMetadata) *ExecOp {

 	if readOnly {

 		e.root = root

 	} else {

-		e.root = &output{vertex: e, getIndex: e.getMountIndexFn(rootMount)}

+		o := &output{vertex: e, getIndex: e.getMountIndexFn(rootMount)}

+		if p := c.Platform; p != nil {

+			o.platform = p

+		}

+		e.root = o

 	}

 	rootMount.output = e.root

-

 	return e

 }

 type mount struct {

-	target   string

-	readonly bool

-	source   Output

-	output   Output

-	selector string

-	cacheID  string

-	tmpfs    bool

+	target       string

+	readonly     bool

+	source       Output

+	output       Output

+	selector     string

+	cacheID      string

+	tmpfs        bool

+	cacheSharing CacheMountSharingMode

 	// hasOutput bool

 }

 type ExecOp struct {

-	root             Output

-	mounts           []*mount

-	meta             Meta

-	cachedPBDigest   digest.Digest

-	cachedPB         []byte

-	cachedOpMetadata OpMetadata

-	isValidated      bool

+	MarshalCache

+	root        Output

+	mounts      []*mount

+	meta        Meta

+	constraints Constraints

+	isValidated bool

 }

 func (e *ExecOp) AddMount(target string, source Output, opt ...MountOption) Output {

@@ -70,9 +73,13 @@ func (e *ExecOp) AddMount(target string, source Output, opt ...MountOption) Outp

 	} else if m.tmpfs {

 		m.output = &output{vertex: e, err: errors.Errorf("tmpfs mount for %s can't be used as a parent", target)}

 	} else {

-		m.output = &output{vertex: e, getIndex: e.getMountIndexFn(m)}

+		o := &output{vertex: e, getIndex: e.getMountIndexFn(m)}

+		if p := e.constraints.Platform; p != nil {

+			o.platform = p

+		}

+		m.output = o

 	}

-	e.cachedPB = nil

+	e.Store(nil, nil, nil)

 	e.isValidated = false

 	return m.output

 }

@@ -107,9 +114,9 @@ func (e *ExecOp) Validate() error {

 	return nil

 }

-func (e *ExecOp) Marshal() (digest.Digest, []byte, *OpMetadata, error) {

-	if e.cachedPB != nil {

-		return e.cachedPBDigest, e.cachedPB, &e.cachedOpMetadata, nil

+func (e *ExecOp) Marshal(c *Constraints) (digest.Digest, []byte, *pb.OpMetadata, error) {

+	if e.Cached(c) {

+		return e.Load()

 	}

 	if err := e.Validate(); err != nil {

 		return "", nil, nil, err

@@ -137,10 +144,9 @@ func (e *ExecOp) Marshal() (digest.Digest, []byte, *OpMetadata, error) {

 		}

 	}

-	pop := &pb.Op{

-		Op: &pb.Op_Exec{

-			Exec: peo,

-		},

+	pop, md := MarshalConstraints(c, &e.constraints)

+	pop.Op = &pb.Op_Exec{

+		Exec: peo,

 	}

 	outIndex := 0

@@ -150,7 +156,7 @@ func (e *ExecOp) Marshal() (digest.Digest, []byte, *OpMetadata, error) {

 			if m.tmpfs {

 				return "", nil, nil, errors.Errorf("tmpfs mounts must use scratch")

 			}

-			inp, err := m.source.ToInput()

+			inp, err := m.source.ToInput(c)

 			if err != nil {

 				return "", nil, nil, err

 			}

@@ -190,6 +196,14 @@ func (e *ExecOp) Marshal() (digest.Digest, []byte, *OpMetadata, error) {

 			pm.CacheOpt = &pb.CacheOpt{

 				ID: m.cacheID,

 			}

+			switch m.cacheSharing {

+			case CacheMountShared:

+				pm.CacheOpt.Sharing = pb.CacheSharingOpt_SHARED

+			case CacheMountPrivate:

+				pm.CacheOpt.Sharing = pb.CacheSharingOpt_PRIVATE

+			case CacheMountLocked:

+				pm.CacheOpt.Sharing = pb.CacheSharingOpt_LOCKED

+			}

 		}

 		if m.tmpfs {

 			pm.MountType = pb.MountType_TMPFS

@@ -201,9 +215,8 @@ func (e *ExecOp) Marshal() (digest.Digest, []byte, *OpMetadata, error) {

 	if err != nil {

 		return "", nil, nil, err

 	}

-	e.cachedPBDigest = digest.FromBytes(dt)

-	e.cachedPB = dt

-	return e.cachedPBDigest, dt, &e.cachedOpMetadata, nil

+	e.Store(dt, md, c)

+	return e.Load()

 }

 func (e *ExecOp) Output() Output {

@@ -273,9 +286,10 @@ func SourcePath(src string) MountOption {

 	}

 }

-func AsPersistentCacheDir(id string) MountOption {

+func AsPersistentCacheDir(id string, sharing CacheMountSharingMode) MountOption {

 	return func(m *mount) {

 		m.cacheID = id

+		m.cacheSharing = sharing

 	}

 }

@@ -366,7 +380,7 @@ func WithProxy(ps ProxyEnv) RunOption {

 }

 type ExecInfo struct {

-	opMetaWrapper

+	constraintsWrapper

 	State          State

 	Mounts         []MountInfo

 	ReadonlyRootFS bool

@@ -385,3 +399,11 @@ type ProxyEnv struct {

 	FtpProxy   string

 	NoProxy    string

 }

+

+type CacheMountSharingMode int

+

+const (

+	CacheMountShared CacheMountSharingMode = iota

+	CacheMountPrivate

+	CacheMountLocked

+)

@@ -12,6 +12,7 @@ import (

 	"github.com/moby/buildkit/util/contentutil"

 	"github.com/moby/buildkit/util/imageutil"

 	digest "github.com/opencontainers/go-digest"

+	specs "github.com/opencontainers/image-spec/specs-go/v1"

 )

 var defaultImageMetaResolver llb.ImageMetaResolver

@@ -22,12 +23,12 @@ var WithDefault = llb.ImageOptionFunc(func(ii *llb.ImageInfo) {

 })

 type imageMetaResolverOpts struct {

-	platform string

+	platform *specs.Platform

 }

 type ImageMetaResolverOpt func(o *imageMetaResolverOpts)

-func WithPlatform(p string) ImageMetaResolverOpt {

+func WithDefaultPlatform(p *specs.Platform) ImageMetaResolverOpt {

 	return func(o *imageMetaResolverOpts) {

 		o.platform = p

 	}

@@ -59,7 +60,7 @@ func Default() llb.ImageMetaResolver {

 type imageMetaResolver struct {

 	resolver remotes.Resolver

 	buffer   contentutil.Buffer

-	platform string

+	platform *specs.Platform

 	locker   *locker.Locker

 	cache    map[string]resolveResult

 }

@@ -69,7 +70,7 @@ type resolveResult struct {

 	dgst   digest.Digest

 }

-func (imr *imageMetaResolver) ResolveImageConfig(ctx context.Context, ref string) (digest.Digest, []byte, error) {

+func (imr *imageMetaResolver) ResolveImageConfig(ctx context.Context, ref string, platform *specs.Platform) (digest.Digest, []byte, error) {

 	imr.locker.Lock(ref)

 	defer imr.locker.Unlock(ref)

@@ -77,7 +78,11 @@ func (imr *imageMetaResolver) ResolveImageConfig(ctx context.Context, ref string

 		return res.dgst, res.config, nil

 	}

-	dgst, config, err := imageutil.Config(ctx, ref, imr.resolver, imr.buffer, imr.platform)

+	if platform == nil {

+		platform = imr.platform

+	}

+

+	dgst, config, err := imageutil.Config(ctx, ref, imr.resolver, imr.buffer, platform)

 	if err != nil {

 		return "", nil, err

 	}

@@ -4,6 +4,7 @@ import (

 	"io"

 	"io/ioutil"

+	"github.com/containerd/containerd/platforms"

 	"github.com/moby/buildkit/solver/pb"

 	digest "github.com/opencontainers/go-digest"

 )

@@ -12,11 +13,11 @@ import (

 // Corresponds to the Definition structure defined in solver/pb.Definition.

 type Definition struct {

 	Def      [][]byte

-	Metadata map[digest.Digest]OpMetadata

+	Metadata map[digest.Digest]pb.OpMetadata

 }

 func (def *Definition) ToPB() *pb.Definition {

-	md := make(map[digest.Digest]OpMetadata)

+	md := make(map[digest.Digest]pb.OpMetadata)

 	for k, v := range def.Metadata {

 		md[k] = v

 	}

@@ -28,14 +29,12 @@ func (def *Definition) ToPB() *pb.Definition {

 func (def *Definition) FromPB(x *pb.Definition) {

 	def.Def = x.Def

-	def.Metadata = make(map[digest.Digest]OpMetadata)

+	def.Metadata = make(map[digest.Digest]pb.OpMetadata)

 	for k, v := range x.Metadata {

 		def.Metadata[k] = v

 	}

 }

-type OpMetadata = pb.OpMetadata

-

 func WriteTo(def *Definition, w io.Writer) error {

 	b, err := def.ToPB().Marshal()

 	if err != nil {

@@ -58,3 +57,56 @@ func ReadFrom(r io.Reader) (*Definition, error) {

 	def.FromPB(&pbDef)

 	return &def, nil

 }

+

+func MarshalConstraints(base, override *Constraints) (*pb.Op, *pb.OpMetadata) {

+	c := *base

+	c.WorkerConstraints = append([]string{}, c.WorkerConstraints...)

+

+	if p := override.Platform; p != nil {

+		c.Platform = p

+	}

+

+	for _, wc := range override.WorkerConstraints {

+		c.WorkerConstraints = append(c.WorkerConstraints, wc)

+	}

+

+	c.Metadata = mergeMetadata(c.Metadata, override.Metadata)

+

+	if c.Platform == nil {

+		defaultPlatform := platforms.Normalize(platforms.DefaultSpec())

+		c.Platform = &defaultPlatform

+	}

+

+	return &pb.Op{

+		Platform: &pb.Platform{

+			OS:           c.Platform.OS,

+			Architecture: c.Platform.Architecture,

+			Variant:      c.Platform.Variant,

+			OSVersion:    c.Platform.OSVersion,

+			OSFeatures:   c.Platform.OSFeatures,

+		},

+		Constraints: &pb.WorkerConstraints{

+			Filter: c.WorkerConstraints,

+		},

+	}, &c.Metadata

+}

+

+type MarshalCache struct {

+	digest      digest.Digest

+	dt          []byte

+	md          *pb.OpMetadata

+	constraints *Constraints

+}

+

+func (mc *MarshalCache) Cached(c *Constraints) bool {

+	return mc.dt != nil && mc.constraints == c

+}

+func (mc *MarshalCache) Load() (digest.Digest, []byte, *pb.OpMetadata, error) {

+	return mc.digest, mc.dt, mc.md, nil

+}

+func (mc *MarshalCache) Store(dt []byte, md *pb.OpMetadata, c *Constraints) {

+	mc.digest = digest.FromBytes(dt)

+	mc.dt = dt

+	mc.md = md

+	mc.constraints = c

+}

@@ -4,16 +4,19 @@ import (

 	"fmt"

 	"path"

+	"github.com/containerd/containerd/platforms"

 	"github.com/google/shlex"

+	specs "github.com/opencontainers/image-spec/specs-go/v1"

 )

 type contextKeyT string

 var (

-	keyArgs = contextKeyT("llb.exec.args")

-	keyDir  = contextKeyT("llb.exec.dir")

-	keyEnv  = contextKeyT("llb.exec.env")

-	keyUser = contextKeyT("llb.exec.user")

+	keyArgs     = contextKeyT("llb.exec.args")

+	keyDir      = contextKeyT("llb.exec.dir")

+	keyEnv      = contextKeyT("llb.exec.env")

+	keyUser     = contextKeyT("llb.exec.user")

+	keyPlatform = contextKeyT("llb.platform")

 )

 func addEnv(key, value string) StateOption {

@@ -106,6 +109,21 @@ func shlexf(str string, v ...interface{}) StateOption {

 	}

 }

+func platform(p specs.Platform) StateOption {

+	return func(s State) State {

+		return s.WithValue(keyPlatform, platforms.Normalize(p))

+	}

+}

+

+func getPlatform(s State) *specs.Platform {

+	v := s.Value(keyPlatform)

+	if v != nil {

+		p := v.(specs.Platform)

+		return &p

+	}

+	return nil

+}

+

 type EnvList []KeyValue

 type KeyValue struct {

@@ -4,6 +4,7 @@ import (

 	"context"

 	digest "github.com/opencontainers/go-digest"

+	specs "github.com/opencontainers/image-spec/specs-go/v1"

 )

 func WithMetaResolver(mr ImageMetaResolver) ImageOption {

@@ -13,5 +14,5 @@ func WithMetaResolver(mr ImageMetaResolver) ImageOption {

 }

 type ImageMetaResolver interface {

-	ResolveImageConfig(ctx context.Context, ref string) (digest.Digest, []byte, error)

+	ResolveImageConfig(ctx context.Context, ref string, platform *specs.Platform) (digest.Digest, []byte, error)

 }

@@ -15,22 +15,21 @@ import (

 )

 type SourceOp struct {

-	id               string

-	attrs            map[string]string

-	output           Output

-	cachedPBDigest   digest.Digest

-	cachedPB         []byte

-	cachedOpMetadata OpMetadata

-	err              error

+	MarshalCache

+	id          string

+	attrs       map[string]string

+	output      Output

+	constraints Constraints

+	err         error

 }

-func NewSource(id string, attrs map[string]string, md OpMetadata) *SourceOp {

+func NewSource(id string, attrs map[string]string, c Constraints) *SourceOp {

 	s := &SourceOp{

-		id:               id,

-		attrs:            attrs,

-		cachedOpMetadata: md,

+		id:          id,

+		attrs:       attrs,

+		constraints: c,

 	}

-	s.output = &output{vertex: s}

+	s.output = &output{vertex: s, platform: c.Platform}

 	return s

 }

@@ -44,26 +43,26 @@ func (s *SourceOp) Validate() error {

 	return nil

 }

-func (s *SourceOp) Marshal() (digest.Digest, []byte, *OpMetadata, error) {

-	if s.cachedPB != nil {

-		return s.cachedPBDigest, s.cachedPB, &s.cachedOpMetadata, nil

+func (s *SourceOp) Marshal(constraints *Constraints) (digest.Digest, []byte, *pb.OpMetadata, error) {

+	if s.Cached(constraints) {

+		return s.Load()

 	}

 	if err := s.Validate(); err != nil {

 		return "", nil, nil, err

 	}

-	proto := &pb.Op{

-		Op: &pb.Op_Source{

-			Source: &pb.SourceOp{Identifier: s.id, Attrs: s.attrs},

-		},

+	proto, md := MarshalConstraints(constraints, &s.constraints)

+

+	proto.Op = &pb.Op_Source{

+		Source: &pb.SourceOp{Identifier: s.id, Attrs: s.attrs},

 	}

 	dt, err := proto.Marshal()

 	if err != nil {

 		return "", nil, nil, err

 	}

-	s.cachedPB = dt

-	s.cachedPBDigest = digest.FromBytes(dt)

-	return s.cachedPBDigest, dt, &s.cachedOpMetadata, nil

+

+	s.Store(dt, md, constraints)

+	return s.Load()

 }

 func (s *SourceOp) Output() Output {

@@ -74,10 +73,6 @@ func (s *SourceOp) Inputs() []Output {

 	return nil

 }

-func Source(id string) State {

-	return NewState(NewSource(id, nil, OpMetadata{}).Output())

-}

-

 func Image(ref string, opts ...ImageOption) State {

 	r, err := reference.ParseNormalizedNamed(ref)

 	if err == nil {

@@ -87,12 +82,12 @@ func Image(ref string, opts ...ImageOption) State {

 	for _, opt := range opts {

 		opt.SetImageOption(&info)

 	}

-	src := NewSource("docker-image://"+ref, nil, info.Metadata()) // controversial

+	src := NewSource("docker-image://"+ref, nil, info.Constraints) // controversial

 	if err != nil {

 		src.err = err

 	}

 	if info.metaResolver != nil {

-		_, dt, err := info.metaResolver.ResolveImageConfig(context.TODO(), ref)

+		_, dt, err := info.metaResolver.ResolveImageConfig(context.TODO(), ref, info.Constraints.Platform)

 		if err != nil {

 			src.err = err

 		} else {

@@ -136,7 +131,7 @@ func (fn ImageOptionFunc) SetImageOption(ii *ImageInfo) {

 }

 type ImageInfo struct {

-	opMetaWrapper

+	constraintsWrapper

 	metaResolver ImageMetaResolver

 }

@@ -169,7 +164,7 @@ func Git(remote, ref string, opts ...GitOption) State {

 	if url != "" {

 		attrs[pb.AttrFullRemoteURL] = url

 	}

-	source := NewSource("git://"+id, attrs, gi.Metadata())

+	source := NewSource("git://"+id, attrs, gi.Constraints)

 	return NewState(source.Output())

 }

@@ -183,7 +178,7 @@ func (fn gitOptionFunc) SetGitOption(gi *GitInfo) {

 }

 type GitInfo struct {

-	opMetaWrapper

+	constraintsWrapper

 	KeepGitDir bool

 }

@@ -220,7 +215,7 @@ func Local(name string, opts ...LocalOption) State {

 		attrs[pb.AttrSharedKeyHint] = gi.SharedKeyHint

 	}

-	source := NewSource("local://"+name, attrs, gi.Metadata())

+	source := NewSource("local://"+name, attrs, gi.Constraints)

 	return NewState(source.Output())

 }

@@ -280,7 +275,7 @@ func SharedKeyHint(h string) LocalOption {

 }

 type LocalInfo struct {

-	opMetaWrapper

+	constraintsWrapper

 	SessionID       string

 	IncludePatterns string

 	ExcludePatterns string

@@ -310,12 +305,12 @@ func HTTP(url string, opts ...HTTPOption) State {

 		attrs[pb.AttrHTTPGID] = strconv.Itoa(hi.GID)

 	}

-	source := NewSource(url, attrs, hi.Metadata())

+	source := NewSource(url, attrs, hi.Constraints)

 	return NewState(source.Output())

 }