Patches backported from the upstream repository.

commit 6d2e07353d042b845da60dc6e3a20a71932678d0

Author: Miroslav Lichvar <mlichvar@redhat.com>

Date:   Tue Mar 8 11:46:58 2022 +0100

    rtnl: Fix rtnl_rtattr_parse() to process max attribute.

    Initialize the whole array passed to rtnl_rtattr_parse() and don't

    ignore the last attribute with the maximum value. This will be needed to

    get the ETHTOOL_A_PHC_VCLOCKS_INDEX attribute.

    Signed-off-by: Miroslav Lichvar <mlichvar@redhat.com>

    Acked-by: Hangbin Liu <liuhangbin@gmail.com>

diff --git a/rtnl.c b/rtnl.c

index b7a2667..b02e07d 100644

--- a/rtnl.c

+++ b/rtnl.c

@@ -178,10 +178,10 @@ static int rtnl_rtattr_parse(struct rtattr *tb[], int max, struct rtattr *rta, i

 {

 	unsigned short type;

-	memset(tb, 0, sizeof(struct rtattr *) * max);

+	memset(tb, 0, sizeof(struct rtattr *) * (max + 1));

 	while (RTA_OK(rta, len)) {

 		type = rta->rta_type;

-		if ((type < max) && (!tb[type]))

+		if ((type <= max) && (!tb[type]))

 			tb[type] = rta;

 		rta = RTA_NEXT(rta, len);

 	}

@@ -200,8 +200,8 @@ static inline int rtnl_nested_rtattr_parse(struct rtattr *tb[], int max, struct

 static int rtnl_linkinfo_parse(int master_index, struct rtattr *rta)

 {

-	struct rtattr *linkinfo[IFLA_INFO_MAX];

-	struct rtattr *bond[IFLA_BOND_MAX];

+	struct rtattr *linkinfo[IFLA_INFO_MAX+1];

+	struct rtattr *bond[IFLA_BOND_MAX+1];

 	int index = -1;

 	char *kind;

commit 8c557a7c7e5eebc6f0d7e1de44c53791fba265c1

Author: Miroslav Lichvar <mlichvar@redhat.com>

Date:   Tue Mar 8 11:46:59 2022 +0100

    rtnl: Add function to detect virtual clocks.

    Add a function using ethtool netlink to check whether a PHC is a virtual

    clock of an interface.

    Signed-off-by: Miroslav Lichvar <mlichvar@redhat.com>

    Acked-by: Hangbin Liu <liuhangbin@gmail.com>

diff --git a/incdefs.sh b/incdefs.sh

index 19e620e..21333e5 100755

--- a/incdefs.sh

+++ b/incdefs.sh

@@ -86,6 +86,10 @@ kernel_flags()

 	if grep -q HWTSTAMP_TX_ONESTEP_P2P ${prefix}${tstamp}; then

 		printf " -DHAVE_ONESTEP_P2P"

 	fi

+

+	if grep -q SOF_TIMESTAMPING_BIND_PHC ${prefix}${tstamp}; then

+		printf " -DHAVE_VCLOCKS"

+	fi

 }

 flags="$(user_flags)$(kernel_flags)"

diff --git a/missing.h b/missing.h

index 35eaf15..3df7bd1 100644

--- a/missing.h

+++ b/missing.h

@@ -251,6 +251,107 @@ enum {

 #define NLA_TYPE_MAX (__NLA_TYPE_MAX - 1)

 #endif /*NLA_TYPE_MAX*/

+#ifndef ETHTOOL_GENL_NAME

+#define ETHTOOL_GENL_NAME "ethtool"

+#define ETHTOOL_GENL_VERSION 1

+#endif

+

+#ifndef HAVE_VCLOCKS

+enum {

+	ETHTOOL_MSG_USER_NONE,

+	ETHTOOL_MSG_STRSET_GET,

+	ETHTOOL_MSG_LINKINFO_GET,

+	ETHTOOL_MSG_LINKINFO_SET,

+	ETHTOOL_MSG_LINKMODES_GET,

+	ETHTOOL_MSG_LINKMODES_SET,

+	ETHTOOL_MSG_LINKSTATE_GET,

+	ETHTOOL_MSG_DEBUG_GET,

+	ETHTOOL_MSG_DEBUG_SET,

+	ETHTOOL_MSG_WOL_GET,

+	ETHTOOL_MSG_WOL_SET,

+	ETHTOOL_MSG_FEATURES_GET,

+	ETHTOOL_MSG_FEATURES_SET,

+	ETHTOOL_MSG_PRIVFLAGS_GET,

+	ETHTOOL_MSG_PRIVFLAGS_SET,

+	ETHTOOL_MSG_RINGS_GET,

+	ETHTOOL_MSG_RINGS_SET,

+	ETHTOOL_MSG_CHANNELS_GET,

+	ETHTOOL_MSG_CHANNELS_SET,

+	ETHTOOL_MSG_COALESCE_GET,

+	ETHTOOL_MSG_COALESCE_SET,

+	ETHTOOL_MSG_PAUSE_GET,

+	ETHTOOL_MSG_PAUSE_SET,

+	ETHTOOL_MSG_EEE_GET,

+	ETHTOOL_MSG_EEE_SET,

+	ETHTOOL_MSG_TSINFO_GET,

+	ETHTOOL_MSG_CABLE_TEST_ACT,

+	ETHTOOL_MSG_CABLE_TEST_TDR_ACT,

+	ETHTOOL_MSG_TUNNEL_INFO_GET,

+	ETHTOOL_MSG_FEC_GET,

+	ETHTOOL_MSG_FEC_SET,

+	ETHTOOL_MSG_MODULE_EEPROM_GET,

+	ETHTOOL_MSG_STATS_GET,

+	ETHTOOL_MSG_PHC_VCLOCKS_GET,

+};

+

+enum {

+	ETHTOOL_MSG_KERNEL_NONE,

+	ETHTOOL_MSG_STRSET_GET_REPLY,

+	ETHTOOL_MSG_LINKINFO_GET_REPLY,

+	ETHTOOL_MSG_LINKINFO_NTF,

+	ETHTOOL_MSG_LINKMODES_GET_REPLY,

+	ETHTOOL_MSG_LINKMODES_NTF,

+	ETHTOOL_MSG_LINKSTATE_GET_REPLY,

+	ETHTOOL_MSG_DEBUG_GET_REPLY,

+	ETHTOOL_MSG_DEBUG_NTF,

+	ETHTOOL_MSG_WOL_GET_REPLY,

+	ETHTOOL_MSG_WOL_NTF,

+	ETHTOOL_MSG_FEATURES_GET_REPLY,

+	ETHTOOL_MSG_FEATURES_SET_REPLY,

+	ETHTOOL_MSG_FEATURES_NTF,

+	ETHTOOL_MSG_PRIVFLAGS_GET_REPLY,

+	ETHTOOL_MSG_PRIVFLAGS_NTF,

+	ETHTOOL_MSG_RINGS_GET_REPLY,

+	ETHTOOL_MSG_RINGS_NTF,

+	ETHTOOL_MSG_CHANNELS_GET_REPLY,

+	ETHTOOL_MSG_CHANNELS_NTF,

+	ETHTOOL_MSG_COALESCE_GET_REPLY,

+	ETHTOOL_MSG_COALESCE_NTF,

+	ETHTOOL_MSG_PAUSE_GET_REPLY,

+	ETHTOOL_MSG_PAUSE_NTF,

+	ETHTOOL_MSG_EEE_GET_REPLY,

+	ETHTOOL_MSG_EEE_NTF,

+	ETHTOOL_MSG_TSINFO_GET_REPLY,

+	ETHTOOL_MSG_CABLE_TEST_NTF,

+	ETHTOOL_MSG_CABLE_TEST_TDR_NTF,

+	ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY,

+	ETHTOOL_MSG_FEC_GET_REPLY,

+	ETHTOOL_MSG_FEC_NTF,

+	ETHTOOL_MSG_MODULE_EEPROM_GET_REPLY,

+	ETHTOOL_MSG_STATS_GET_REPLY,

+	ETHTOOL_MSG_PHC_VCLOCKS_GET_REPLY,

+};

+

+enum {

+	ETHTOOL_A_HEADER_UNSPEC,

+	ETHTOOL_A_HEADER_DEV_INDEX,		/* u32 */

+	ETHTOOL_A_HEADER_DEV_NAME,		/* string */

+	ETHTOOL_A_HEADER_FLAGS,			/* u32 - ETHTOOL_FLAG_* */

+	__ETHTOOL_A_HEADER_CNT,

+	ETHTOOL_A_HEADER_MAX = __ETHTOOL_A_HEADER_CNT - 1

+};

+

+enum {

+	ETHTOOL_A_PHC_VCLOCKS_UNSPEC,

+	ETHTOOL_A_PHC_VCLOCKS_HEADER,			/* nest - _A_HEADER_* */

+	ETHTOOL_A_PHC_VCLOCKS_NUM,			/* u32 */

+	ETHTOOL_A_PHC_VCLOCKS_INDEX,			/* array, s32 */

+	__ETHTOOL_A_PHC_VCLOCKS_CNT,

+	ETHTOOL_A_PHC_VCLOCKS_MAX = (__ETHTOOL_A_PHC_VCLOCKS_CNT - 1)

+};

+

+#endif /* HAVE_VCLOCKS */

+

 #ifdef __UCLIBC__

 #if (_XOPEN_SOURCE >= 600 || _POSIX_C_SOURCE >= 200112L) && \

diff --git a/rtnl.c b/rtnl.c

index b02e07d..a8999b2 100644

--- a/rtnl.c

+++ b/rtnl.c

@@ -19,6 +19,9 @@

 #include <asm/types.h>

 #include <sys/socket.h> /* Must come before linux/netlink.h on some systems. */

 #include <linux/netlink.h>

+#ifdef HAVE_VCLOCKS

+#include <linux/ethtool_netlink.h>

+#endif

 #include <linux/rtnetlink.h>

 #include <linux/genetlink.h>

 #include <linux/if_team.h>

@@ -465,3 +468,85 @@ no_info:

 	nl_close(fd);

 	return index;

 }

+

+static int rtnl_search_vclocks(struct rtattr *attr, int phc_index)

+{

+	int i, len = RTA_PAYLOAD(attr);

+

+	for (i = 0; i < len / sizeof (__s32); i++) {

+		if (((__s32 *)RTA_DATA(attr))[i] == phc_index)

+			return 1;

+	}

+

+	return 0;

+}

+

+int rtnl_iface_has_vclock(const char *device, int phc_index)

+{

+	struct rtattr *tb[ETHTOOL_A_PHC_VCLOCKS_MAX + 1];

+	int index, fd, gf_id, len, ret = 0;

+	struct genlmsghdr *gnlh;

+	struct nlmsghdr *nlh;

+	char msg[BUF_SIZE];

+	struct {

+		struct nlattr attr;

+		uint32_t index;

+	} req;

+

+	index = if_nametoindex(device);

+

+	fd = nl_open(NETLINK_GENERIC);

+	if (fd < 0)

+		return 0;

+

+	gf_id = genl_get_family_id(fd, ETHTOOL_GENL_NAME);

+	if (gf_id < 0) {

+		pr_debug("ethtool netlink not supported");

+		goto no_info;

+	}

+

+	req.attr.nla_len = sizeof(req);

+	req.attr.nla_type = ETHTOOL_A_HEADER_DEV_INDEX;

+	req.index = index;

+

+	len = genl_send_msg(fd, gf_id, ETHTOOL_MSG_PHC_VCLOCKS_GET,

+			    ETHTOOL_GENL_VERSION,

+			    NLA_F_NESTED | ETHTOOL_A_PHC_VCLOCKS_HEADER, 

+			    &req, sizeof(req));

+

+	if (len < 0) {

+		pr_err("send vclock request failed: %m");

+		goto no_info;

+	}

+

+	len = recv(fd, msg, sizeof(msg), 0);

+	if (len < 0) {

+		pr_err("recv vclock failed: %m");

+		goto no_info;

+	}

+

+	for (nlh = (struct nlmsghdr *) msg; NLMSG_OK(nlh, len);

+	     nlh = NLMSG_NEXT(nlh, len)) {

+		if (nlh->nlmsg_type != gf_id)

+			continue;

+

+		gnlh = (struct genlmsghdr *) NLMSG_DATA(nlh);

+		if (gnlh->cmd != ETHTOOL_MSG_PHC_VCLOCKS_GET_REPLY)

+			continue;

+

+		if (rtnl_rtattr_parse(tb, ETHTOOL_A_PHC_VCLOCKS_MAX,

+				      (struct rtattr *) GENLMSG_DATA(msg),

+				      NLMSG_PAYLOAD(nlh, GENL_HDRLEN)))

+			continue;

+

+		if (tb[ETHTOOL_A_PHC_VCLOCKS_INDEX]) {

+			ret = rtnl_search_vclocks(tb[ETHTOOL_A_PHC_VCLOCKS_INDEX],

+						  phc_index);

+			break;

+		}

+	}

+

+no_info:

+	nl_close(fd);

+	return ret;

+}

diff --git a/rtnl.h b/rtnl.h

index 8fef4a9..96fee29 100644

--- a/rtnl.h

+++ b/rtnl.h

@@ -59,6 +59,15 @@ int rtnl_link_query(int fd, const char *device);

  */

 int rtnl_link_status(int fd, const char *device, rtnl_callback cb, void *ctx);

+/**

+ * Check if the PHC is a virtual clock of the interface (i.e. sockets bound to

+ * the interface also need to be bound to the clock).

+ * @param device    Name of the interface.

+ * @param phc_index Index of the clock to check.

+ * @return          1 if true, otherwise 0.

+ */

+int rtnl_iface_has_vclock(const char *device, int phc_index);

+

 /**

  * Open a RT netlink socket for monitoring link state.

  * @return    A valid socket, or -1 on error.

commit 5477078bf5c9ef050c3bcb037f856b693f1247e7

Author: Miroslav Lichvar <mlichvar@redhat.com>

Date:   Tue Mar 8 11:47:00 2022 +0100

    Add support for binding sockets to virtual clocks.

    With the latest kernels it is possible to create virtual PHCs on top of

    a free-running physical PHC. In order for the application to get

    timestamps captured by the clock which it is controlling, it needs to

    bind its sockets to the clock using a new field in the SO_TIMESTAMPING

    option.

    Extend the interface structure with the vclock index and modify the

    transport code to pass it to sk_timestamping_init() to bind the sockets

    to the clock.

    Signed-off-by: Miroslav Lichvar <mlichvar@redhat.com>

diff --git a/interface.c b/interface.c

index 65bdff0..445a270 100644

--- a/interface.c

+++ b/interface.c

@@ -12,6 +12,7 @@ struct interface {

 	char name[MAX_IFNAME_SIZE + 1];

 	char ts_label[MAX_IFNAME_SIZE + 1];

 	struct sk_ts_info ts_info;

+	int vclock;

 };

 struct interface *interface_create(const char *name)

@@ -23,6 +24,7 @@ struct interface *interface_create(const char *name)

 		return NULL;

 	}

 	strncpy(iface->name, name, MAX_IFNAME_SIZE);

+	iface->vclock = -1;

 	return iface;

 }

@@ -76,3 +78,13 @@ bool interface_tsmodes_supported(struct interface *iface, int modes)

 	}

 	return false;

 }

+

+void interface_set_vclock(struct interface *iface, int vclock)

+{

+	iface->vclock = vclock;

+}

+

+int interface_get_vclock(struct interface *iface)

+{

+	return iface->vclock;

+}

diff --git a/interface.h b/interface.h

index 8bf2727..752f4f1 100644

--- a/interface.h

+++ b/interface.h

@@ -91,4 +91,18 @@ bool interface_tsinfo_valid(struct interface *iface);

  */

 bool interface_tsmodes_supported(struct interface *iface, int modes);

+/**

+ * Set the vclock (virtual PHC) to be used for timestamping on an interface.

+ * @param iface  The interface of interest.

+ * @param vclock The index of the vclock.

+ */

+void interface_set_vclock(struct interface *iface, int vclock);

+

+/**

+ * Get the vclock index set for the interface.

+ * @param iface  The interface of interest.

+ * @return       The index of the vclock, or -1 if not set.

+ */

+int interface_get_vclock(struct interface *iface);

+

 #endif

diff --git a/missing.h b/missing.h

index 3df7bd1..c5194f4 100644

--- a/missing.h

+++ b/missing.h

@@ -62,6 +62,17 @@ enum {

 };

 #endif

+#ifndef HAVE_VCLOCKS

+enum {

+	SOF_TIMESTAMPING_BIND_PHC = (1 << 15),

+};

+

+struct so_timestamping {

+	int flags;

+	int bind_phc;

+};

+#endif

+

 #ifdef PTP_EXTTS_REQUEST2

 #define PTP_EXTTS_REQUEST_FAILED "PTP_EXTTS_REQUEST2 failed: %m"

 #else

diff --git a/raw.c b/raw.c

index 0bd15b0..ce64684 100644

--- a/raw.c

+++ b/raw.c

@@ -243,7 +243,8 @@ static int raw_open(struct transport *t, struct interface *iface,

 	if (gfd < 0)

 		goto no_general;

-	if (sk_timestamping_init(efd, name, ts_type, TRANS_IEEE_802_3))

+	if (sk_timestamping_init(efd, name, ts_type, TRANS_IEEE_802_3,

+				 interface_get_vclock(iface)))

 		goto no_timestamping;

 	if (sk_general_init(gfd))

diff --git a/sk.c b/sk.c

index 8be0708..b55d6b5 100644

--- a/sk.c

+++ b/sk.c

@@ -447,9 +447,10 @@ int sk_set_priority(int fd, int family, uint8_t dscp)

 }

 int sk_timestamping_init(int fd, const char *device, enum timestamp_type type,

-			 enum transport_type transport)

+			 enum transport_type transport, int vclock)

 {

 	int err, filter1, filter2 = 0, flags, tx_type = HWTSTAMP_TX_ON;

+	struct so_timestamping timestamping;

 	switch (type) {

 	case TS_SOFTWARE:

@@ -509,8 +510,14 @@ int sk_timestamping_init(int fd, const char *device, enum timestamp_type type,

 			return err;

 	}

+	if (vclock >= 0)

+		flags |= SOF_TIMESTAMPING_BIND_PHC;

+

+	timestamping.flags = flags;

+	timestamping.bind_phc = vclock;

+

 	if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING,

-		       &flags, sizeof(flags)) < 0) {

+		       &timestamping, sizeof(timestamping)) < 0) {

 		pr_err("ioctl SO_TIMESTAMPING failed: %m");

 		return -1;

 	}

diff --git a/sk.h b/sk.h

index 04d26ee..486dbc4 100644

--- a/sk.h

+++ b/sk.h

@@ -124,10 +124,11 @@ int sk_set_priority(int fd, int family, uint8_t dscp);

  * @param device      The name of the network interface to configure.

  * @param type        The requested flavor of time stamping.

  * @param transport   The type of transport used.

+ * @param vclock      Index of the virtual PHC, or -1 for the physical clock.

  * @return            Zero on success, non-zero otherwise.

  */

 int sk_timestamping_init(int fd, const char *device, enum timestamp_type type,

-			 enum transport_type transport);

+			 enum transport_type transport, int vclock);

 /**

  * Limits the time that RECVMSG(2) will poll while waiting for the tx timestamp

diff --git a/udp.c b/udp.c

index 826bd12..7c9402e 100644

--- a/udp.c

+++ b/udp.c

@@ -179,7 +179,8 @@ static int udp_open(struct transport *t, struct interface *iface,

 	if (gfd < 0)

 		goto no_general;

-	if (sk_timestamping_init(efd, interface_label(iface), ts_type, TRANS_UDP_IPV4))

+	if (sk_timestamping_init(efd, interface_label(iface), ts_type, TRANS_UDP_IPV4,

+				 interface_get_vclock(iface)))

 		goto no_timestamping;

 	if (sk_general_init(gfd))

diff --git a/udp6.c b/udp6.c

index ba5482e..bde1710 100644

--- a/udp6.c

+++ b/udp6.c

@@ -196,7 +196,8 @@ static int udp6_open(struct transport *t, struct interface *iface,

 	if (gfd < 0)

 		goto no_general;

-	if (sk_timestamping_init(efd, interface_label(iface), ts_type, TRANS_UDP_IPV6))

+	if (sk_timestamping_init(efd, interface_label(iface), ts_type,

+				 TRANS_UDP_IPV6, interface_get_vclock(iface)))

 		goto no_timestamping;

 	if (sk_general_init(gfd))

commit daaaff6b553290cf09284b0cc7756b9e24358ace

Author: Miroslav Lichvar <mlichvar@redhat.com>

Date:   Tue Mar 8 11:47:01 2022 +0100

    config: Add port-specific phc_index option.

    Allow the PHC index to be configured for each port. The default value is

    -1, which enables the original behavior using the PHC specified by -p or

    the index from ETHTOOL_GET_TS_INFO.

    (Rebased to 3.1.1)

    Signed-off-by: Miroslav Lichvar <mlichvar@redhat.com>

diff --git a/clock.c b/clock.c

index 49bd4a9..67b3372 100644

--- a/clock.c

+++ b/clock.c

@@ -900,7 +900,7 @@ struct clock *clock_create(enum clock_type type, struct config *config,

 	char ts_label[IF_NAMESIZE], phc[32], *tmp;

 	enum timestamp_type timestamping;

 	int fadj = 0, max_adj = 0, sw_ts;

-	int phc_index, required_modes = 0;

+	int phc_index, conf_phc_index, required_modes = 0;

 	struct clock *c = &the_clock;

 	const char *uds_ifname;

 	struct port *p;

@@ -1018,6 +1018,8 @@ struct clock *clock_create(enum clock_type type, struct config *config,

 	iface = STAILQ_FIRST(&config->interfaces);

+	conf_phc_index = config_get_int(config, interface_name(iface), "phc_index");

+

 	/* determine PHC Clock index */

 	if (config_get_int(config, NULL, "free_running")) {

 		phc_index = -1;

@@ -1027,6 +1029,8 @@ struct clock *clock_create(enum clock_type type, struct config *config,

 		if (1 != sscanf(phc_device, "/dev/ptp%d", &phc_index)) {

 			phc_index = -1;

 		}

+	} else if (conf_phc_index >= 0) {

+		phc_index = conf_phc_index;

 	} else if (interface_tsinfo_valid(iface)) {

 		phc_index = interface_phc_index(iface);

 	} else {

diff --git a/config.c b/config.c

index ef5e833..0613eda 100644

--- a/config.c

+++ b/config.c

@@ -282,6 +282,7 @@ struct config_item config_tab[] = {

 	PORT_ITEM_INT("operLogPdelayReqInterval", 0, INT8_MIN, INT8_MAX),

 	PORT_ITEM_INT("operLogSyncInterval", 0, INT8_MIN, INT8_MAX),

 	PORT_ITEM_INT("path_trace_enabled", 0, 0, 1),

+	PORT_ITEM_INT("phc_index", -1, -1, INT_MAX),

 	GLOB_ITEM_DBL("pi_integral_const", 0.0, 0.0, DBL_MAX),

 	GLOB_ITEM_DBL("pi_integral_exponent", 0.4, -DBL_MAX, DBL_MAX),

 	GLOB_ITEM_DBL("pi_integral_norm_max", 0.3, DBL_MIN, 2.0),

diff --git a/configs/default.cfg b/configs/default.cfg

index 8c19129..45888d5 100644

--- a/configs/default.cfg

+++ b/configs/default.cfg

@@ -103,6 +103,7 @@ delay_filter_length	10

 egressLatency		0

 ingressLatency		0

 boundary_clock_jbod	0

+phc_index		-1

 #

 # Clock description

 #

diff --git a/port.c b/port.c

index d26b87f..7912ee6 100644

--- a/port.c

+++ b/port.c

@@ -3057,7 +3057,9 @@ struct port *port_open(const char *phc_device,

 		goto err_port;

 	}

-	p->phc_index = phc_index;

+	p->phc_index = config_get_int(cfg, interface_name(interface), "phc_index");

+	if (p->phc_index < 0)

+		p->phc_index = phc_index;

 	p->jbod = config_get_int(cfg, interface_name(interface), "boundary_clock_jbod");

 	transport = config_get_int(cfg, interface_name(interface), "network_transport");

 	p->master_only = config_get_int(cfg, interface_name(interface), "masterOnly");

@@ -3080,8 +3082,8 @@ struct port *port_open(const char *phc_device,

 		; /* UDS cannot have a PHC. */

 	} else if (!interface_tsinfo_valid(interface)) {

 		pr_warning("port %d: get_ts_info not supported", number);

-	} else if (phc_index >= 0 &&

-		   phc_index != interface_phc_index(interface)) {

+	} else if (p->phc_index >= 0 &&

+		   p->phc_index != interface_phc_index(interface)) {

 		if (p->jbod) {

 			pr_warning("port %d: just a bunch of devices", number);

 			p->phc_index = interface_phc_index(interface);

diff --git a/ptp4l.8 b/ptp4l.8

index b179b81..fc73e84 100644

--- a/ptp4l.8

+++ b/ptp4l.8

@@ -365,6 +365,11 @@ collection of clocks must be synchronized by an external program, for

 example phc2sys(8) in "automatic" mode.

 The default is 0 (disabled).

 .TP

+.B phc_index

+Specifies the index of the PHC to be used for synchronization with hardware

+timestamping. The default is -1, which means the index will be set to the PHC

+associated with the interface, or the device specified by the \fB-p\fP option.

+.TP

 .B udp_ttl

 Specifies the Time to live (TTL) value for IPv4 multicast messages and the hop

 limit for IPv6 multicast messages. This option is only relevant with the IPv4

commit bb50991e8b9ecbcea53abbd0164a51e3e0bfe246

Author: Miroslav Lichvar <mlichvar@redhat.com>

Date:   Tue Mar 8 11:47:02 2022 +0100

    port: Check for virtual clocks.

    If the PHC specified with the phc_index or -p option is a virtual clock

    of the interface, bind sockets to the virtual clock instead of the real

    clock to get correct timestamps.

    (Rebased to 3.1.1)

    Signed-off-by: Miroslav Lichvar <mlichvar@redhat.com>

diff --git a/port.c b/port.c

index 7912ee6..b4dcd1b 100644

--- a/port.c

+++ b/port.c

@@ -3084,7 +3084,12 @@ struct port *port_open(const char *phc_device,

 		pr_warning("port %d: get_ts_info not supported", number);

 	} else if (p->phc_index >= 0 &&

 		   p->phc_index != interface_phc_index(interface)) {

-		if (p->jbod) {

+		if (rtnl_iface_has_vclock(interface_name(interface),

+					  p->phc_index)) {

+			pr_info("port %d: /dev/ptp%d is virtual clock",

+				number, p->phc_index);

+			interface_set_vclock(interface, p->phc_index);

+		} else if (p->jbod) {

 			pr_warning("port %d: just a bunch of devices", number);

 			p->phc_index = interface_phc_index(interface);

 		} else if (phc_device) {

diff --git a/ptp4l.8 b/ptp4l.8

index fc73e84..d0446d5 100644

--- a/ptp4l.8

+++ b/ptp4l.8

@@ -367,8 +367,11 @@ The default is 0 (disabled).

 .TP

 .B phc_index

 Specifies the index of the PHC to be used for synchronization with hardware

-timestamping. The default is -1, which means the index will be set to the PHC

-associated with the interface, or the device specified by the \fB-p\fP option.

+timestamping. This option is useful with virtual clocks running on top of a

+free-running physical clock (created by writing to

+/sys/class/ptp/ptp*/n_vclocks).

+The default is -1, which means the index will be set to the PHC associated with

+the interface, or the device specified by the \fB-p\fP option.

 .TP

 .B udp_ttl

 Specifies the Time to live (TTL) value for IPv4 multicast messages and the hop

commit 2b1657a65c0f3c880a0b9982401d419108560a1f

Author: Miroslav Lichvar <mlichvar@redhat.com>

Date:   Tue Mar 8 11:47:03 2022 +0100

    tlv: Add PORT_HWCLOCK_NP.

    Add a new command to get the PHC index associated with the port. This

    will be needed for phc2sys -a to use the correct PHC for synchronization

    if ptp4l is using a virtual clock.

    The TLV also contains a flag indicating a virtual clock.

    To follow the PORT_PROPERTIES_NP access policy, PORT_HWCLOCK_NP is

    limited to the UDS-RW port.

    (Rebased to 3.1.1)

    Signed-off-by: Miroslav Lichvar <mlichvar@redhat.com>

diff --git a/clock.c b/clock.c

index 67b3372..39df135 100644

--- a/clock.c

+++ b/clock.c

@@ -1482,6 +1482,7 @@ int clock_manage(struct clock *c, struct port *p, struct ptp_message *msg)

 	switch (mgt->id) {

 	case TLV_PORT_PROPERTIES_NP:

+	case TLV_PORT_HWCLOCK_NP:

 		if (p != c->uds_rw_port) {

 			/* Only the UDS-RW port allowed. */

 			clock_management_send_error(p, msg, TLV_NOT_SUPPORTED);

diff --git a/pmc.c b/pmc.c

index 65d1d61..3832f0d 100644

--- a/pmc.c

+++ b/pmc.c

@@ -144,6 +144,7 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)

 	struct subscribe_events_np *sen;

 	struct management_tlv_datum *mtd;

 	struct port_properties_np *ppn;

+	struct port_hwclock_np *phn;

 	struct timePropertiesDS *tp;

 	struct management_tlv *mgt;

 	struct time_status_np *tsn;

@@ -487,6 +488,16 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)

 			pcp->stats.txMsgType[SIGNALING],

 			pcp->stats.txMsgType[MANAGEMENT]);

 		break;

+	case TLV_PORT_HWCLOCK_NP:

+		phn = (struct port_hwclock_np *) mgt->data;

+		fprintf(fp, "PORT_HWCLOCK_NP "

+			IFMT "portIdentity            %s"

+			IFMT "phcIndex                %d"

+			IFMT "flags                   %hhu",

+			pid2str(&phn->portIdentity),

+			phn->phc_index,

+			phn->flags);

+		break;

 	case TLV_LOG_ANNOUNCE_INTERVAL:

 		mtd = (struct management_tlv_datum *) mgt->data;

 		fprintf(fp, "LOG_ANNOUNCE_INTERVAL "

diff --git a/pmc_common.c b/pmc_common.c

index f07f6f6..756edf5 100644

--- a/pmc_common.c

+++ b/pmc_common.c

@@ -132,6 +132,7 @@ struct management_id idtab[] = {

 	{ "PORT_DATA_SET_NP", TLV_PORT_DATA_SET_NP, do_set_action },

 	{ "PORT_STATS_NP", TLV_PORT_STATS_NP, do_get_action },

 	{ "PORT_PROPERTIES_NP", TLV_PORT_PROPERTIES_NP, do_get_action },

+	{ "PORT_HWCLOCK_NP", TLV_PORT_HWCLOCK_NP, do_get_action },

 };

 static void do_get_action(struct pmc *pmc, int action, int index, char *str)

diff --git a/port.c b/port.c

index b4dcd1b..e309b98 100644

--- a/port.c

+++ b/port.c

@@ -797,6 +797,7 @@ static int port_management_fill_response(struct port *target,

 	struct management_tlv_datum *mtd;

 	struct clock_description *desc;

 	struct port_properties_np *ppn;

+	struct port_hwclock_np *phn;

 	struct port_stats_np *psn;

 	struct management_tlv *tlv;

 	struct port_ds_np *pdsnp;

@@ -961,6 +962,14 @@ static int port_management_fill_response(struct port *target,

 		psn->stats = target->stats;

 		datalen = sizeof(*psn);

 		break;

+	case TLV_PORT_HWCLOCK_NP:

+		phn = (struct port_hwclock_np *)tlv->data;

+		phn->portIdentity = target->portIdentity;

+		phn->phc_index = target->phc_index;

+		phn->flags = interface_get_vclock(target->iface) >= 0 ?

+			PORT_HWCLOCK_VCLOCK : 0;

+		datalen = sizeof(*phn);

+		break;

 	default:

 		/* The caller should *not* respond to this message. */

 		tlv_extra_recycle(extra);

diff --git a/tlv.c b/tlv.c

index 738e404..38aeb80 100644

--- a/tlv.c

+++ b/tlv.c

@@ -123,6 +123,7 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,

 	struct grandmaster_settings_np *gsn;

 	struct subscribe_events_np *sen;

 	struct port_properties_np *ppn;

+	struct port_hwclock_np *phn;

 	struct port_stats_np *psn;

 	struct mgmt_clock_description *cd;

 	int extra_len = 0, len;

@@ -326,6 +327,14 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,

 			ntohs(psn->portIdentity.portNumber);

 		extra_len = sizeof(struct port_stats_np);

 		break;

+	case TLV_PORT_HWCLOCK_NP:

+		if (data_len < sizeof(struct port_hwclock_np))

+			goto bad_length;

+		phn = (struct port_hwclock_np *)m->data;

+		phn->portIdentity.portNumber = ntohs(phn->portIdentity.portNumber);

+		phn->phc_index = ntohl(phn->phc_index);

+		extra_len = sizeof(struct port_hwclock_np);

+		break;

 	case TLV_SAVE_IN_NON_VOLATILE_STORAGE:

 	case TLV_RESET_NON_VOLATILE_STORAGE:

 	case TLV_INITIALIZE:

@@ -352,6 +361,7 @@ static void mgt_pre_send(struct management_tlv *m, struct tlv_extra *extra)

 	struct defaultDS *dds;

 	struct currentDS *cds;

 	struct parentDS *pds;

+	struct port_hwclock_np *phn;

 	struct timePropertiesDS *tp;

 	struct portDS *p;

 	struct port_ds_np *pdsnp;

@@ -437,6 +447,11 @@ static void mgt_pre_send(struct management_tlv *m, struct tlv_extra *extra)

 		psn->portIdentity.portNumber =

 			htons(psn->portIdentity.portNumber);

 		break;

+	case TLV_PORT_HWCLOCK_NP:

+		phn = (struct port_hwclock_np *)m->data;

+		phn->portIdentity.portNumber = htons(phn->portIdentity.portNumber);

+		phn->phc_index = htonl(phn->phc_index);

+		break;

 	}

 }

diff --git a/tlv.h b/tlv.h

index a205119..5ac3d7c 100644

--- a/tlv.h

+++ b/tlv.h

@@ -125,6 +125,7 @@ enum management_action {

 #define TLV_PORT_DATA_SET_NP				0xC002

 #define TLV_PORT_PROPERTIES_NP				0xC004

 #define TLV_PORT_STATS_NP				0xC005

+#define TLV_PORT_HWCLOCK_NP				0xC009

 /* Management error ID values */

 #define TLV_RESPONSE_TOO_BIG				0x0001

@@ -144,6 +145,9 @@ enum management_action {

 #define CANCEL_UNICAST_MAINTAIN_GRANT	(1 << 1)

 #define GRANT_UNICAST_RENEWAL_INVITED	(1 << 0)

+/* Flags in PORT_HWCLOCK_NP */

+#define PORT_HWCLOCK_VCLOCK		(1 << 0)

+

 struct ack_cancel_unicast_xmit_tlv {

 	Enumeration16   type;

 	UInteger16      length;

@@ -344,6 +348,12 @@ struct port_properties_np {

 	struct PTPText interface;

 } PACKED;

+struct port_hwclock_np {

+	struct PortIdentity portIdentity;

+	Integer32 phc_index;

+	UInteger8 flags;

+} PACKED;

+

 struct port_stats_np {

 	struct PortIdentity portIdentity;

 	struct PortStats stats;

commit a64a45a0eedec82376fd9dab4d960b6fa652513e

Author: Miroslav Lichvar <mlichvar@redhat.com>

Date:   Tue Mar 8 11:47:04 2022 +0100

    phc2sys: Use PHC index from PORT_HWCLOCK_NP.

    When running in the automatic mode, get the PHC index of the port

    from PORT_HWCLOCK_NP instead of calling sk_get_ts_info(). This allows

    phc2sys -a to synchronize (to) a virtual clock.

    (Rebased to 3.1.1)

    Signed-off-by: Miroslav Lichvar <mlichvar@redhat.com>

diff --git a/phc2sys.c b/phc2sys.c

index a36cbe0..adbe37d 100644

--- a/phc2sys.c

+++ b/phc2sys.c

@@ -135,7 +135,8 @@ static void run_pmc_events(struct phc2sys_private *priv);

 static int normalize_state(int state);

 static int run_pmc_port_properties(struct phc2sys_private *priv,

 				   int timeout, unsigned int port,

-				   int *state, int *tstamping, char *iface);

+				   int *state, int *tstamping, int *phc_index,

+				   char *iface);

 static struct servo *servo_add(struct phc2sys_private *priv,

 			       struct clock *clock)

@@ -172,14 +173,21 @@ static struct servo *servo_add(struct phc2sys_private *priv,

 	return servo;

 }

-static struct clock *clock_add(struct phc2sys_private *priv, char *device)

+static struct clock *clock_add(struct phc2sys_private *priv, char *device,

+			       int phc_index)

 {

 	struct clock *c;

 	clockid_t clkid = CLOCK_INVALID;

-	int phc_index = -1;

+	char phc_device[19];

 	if (device) {

-		clkid = posix_clock_open(device, &phc_index);

+		if (phc_index >= 0) {

+			snprintf(phc_device, sizeof(phc_device), "/dev/ptp%d",

+				 phc_index);

+			clkid = posix_clock_open(phc_device, &phc_index);