*: rename zlog_fer -> flog_err

Signed-off-by: Quentin Young <qlyoung@cumulusnetworks.com>

31 files changed, 204 insertions, 204 deletions

diff --git a/zebra/if_ioctl.c b/zebra/if_ioctl.c
index 7045d51283..3e7a87d0a2 100644
--- a/zebra/if_ioctl.c
+++ b/zebra/if_ioctl.c
@@ -176,14 +176,14 @@ static int if_getaddrs(void)
 
 	ret = getifaddrs(&ifap);
 	if (ret != 0) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL, "getifaddrs(): %s",
+		flog_err(LIB_ERR_SYSTEM_CALL, "getifaddrs(): %s",
 			  safe_strerror(errno));
 		return -1;
 	}
 
 	for (ifapfree = ifap; ifap; ifap = ifap->ifa_next) {
 		if (ifap->ifa_addr == NULL) {
-			zlog_ferr(
+			flog_err(
 				LIB_ERR_INTERFACE,
 				"%s: nonsensical ifaddr with NULL ifa_addr, ifname %s",
 				__func__,
@@ -193,7 +193,7 @@ static int if_getaddrs(void)
 
 		ifp = if_lookup_by_name(ifap->ifa_name, VRF_DEFAULT);
 		if (ifp == NULL) {
-			zlog_ferr(LIB_ERR_INTERFACE,
+			flog_err(LIB_ERR_INTERFACE,
 				  "if_getaddrs(): Can't lookup interface %s\n",
 				  ifap->ifa_name);
 			continue;
diff --git a/zebra/if_ioctl_solaris.c b/zebra/if_ioctl_solaris.c
index 64412fba92..3b3064490e 100644
--- a/zebra/if_ioctl_solaris.c
+++ b/zebra/if_ioctl_solaris.c
@@ -60,7 +60,7 @@ static int interface_list_ioctl(int af)
 	char *buf = NULL;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 
 	sock = socket(af, SOCK_DGRAM, 0);
 	if (sock < 0) {
@@ -69,7 +69,7 @@ static int interface_list_ioctl(int af)
 			  safe_strerror(errno));
 
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 		return -1;
 	}
@@ -81,7 +81,7 @@ calculate_lifc_len: /* must hold privileges to enter here */
 	save_errno = errno;
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	if (ret < 0) {
 		zlog_warn("interface_list_ioctl: SIOCGLIFNUM failed %s",
@@ -111,7 +111,7 @@ calculate_lifc_len: /* must hold privileges to enter here */
 	lifconf.lifc_buf = buf;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 
 	ret = ioctl(sock, SIOCGLIFCONF, &lifconf);
 
@@ -123,13 +123,13 @@ calculate_lifc_len: /* must hold privileges to enter here */
 		zlog_warn("SIOCGLIFCONF: %s", safe_strerror(errno));
 
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 		goto end;
 	}
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	/* Allocate interface. */
 	lifreq = lifconf.lifc_req;
diff --git a/zebra/if_netlink.c b/zebra/if_netlink.c
index 26aef2bb0a..e09d30a207 100644
--- a/zebra/if_netlink.c
+++ b/zebra/if_netlink.c
@@ -80,7 +80,7 @@ static void set_ifindex(struct interface *ifp, ifindex_t ifi_index,
 	if (((oifp = if_lookup_by_index_per_ns(zns, ifi_index)) != NULL)
 	    && (oifp != ifp)) {
 		if (ifi_index == IFINDEX_INTERNAL)
-			zlog_ferr(
+			flog_err(
 				LIB_ERR_INTERFACE,
 				"Netlink is setting interface %s ifindex to reserved internal value %u",
 				ifp->name, ifi_index);
@@ -90,7 +90,7 @@ static void set_ifindex(struct interface *ifp, ifindex_t ifi_index,
 					"interface index %d was renamed from %s to %s",
 					ifi_index, oifp->name, ifp->name);
 			if (if_is_up(oifp))
-				zlog_ferr(
+				flog_err(
 					LIB_ERR_INTERFACE,
 					"interface rename detected on up interface: index %d was renamed from %s to %s, results are uncertain!",
 					ifi_index, oifp->name, ifp->name);
@@ -310,7 +310,7 @@ static void netlink_vrf_change(struct nlmsghdr *h, struct rtattr *tb,
 		vrf = vrf_get((vrf_id_t)ifi->ifi_index,
 			      name); // It would create vrf
 		if (!vrf) {
-			zlog_ferr(LIB_ERR_INTERFACE, "VRF %s id %u not created",
+			flog_err(LIB_ERR_INTERFACE, "VRF %s id %u not created",
 				  name, ifi->ifi_index);
 			return;
 		}
@@ -332,7 +332,7 @@ static void netlink_vrf_change(struct nlmsghdr *h, struct rtattr *tb,
 
 		/* Enable the created VRF. */
 		if (!vrf_enable(vrf)) {
-			zlog_ferr(LIB_ERR_INTERFACE,
+			flog_err(LIB_ERR_INTERFACE,
 				  "Failed to enable VRF %s id %u", name,
 				  ifi->ifi_index);
 			return;
@@ -376,7 +376,7 @@ static int get_iflink_speed(struct interface *interface)
 
 	/* use ioctl to get IP address of an interface */
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	sd = vrf_socket(PF_INET, SOCK_DGRAM, IPPROTO_IP, interface->vrf_id,
 			NULL);
 	if (sd < 0) {
@@ -388,7 +388,7 @@ static int get_iflink_speed(struct interface *interface)
 	/* Get the current link state for the interface */
 	rc = vrf_ioctl(interface->vrf_id, sd, SIOCETHTOOL, (char *)&ifdata);
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	if (rc < 0) {
 		if (IS_ZEBRA_DEBUG_KERNEL)
 			zlog_debug(
@@ -917,7 +917,7 @@ int netlink_interface_addr(struct nlmsghdr *h, ns_id_t ns_id, int startup)
 
 	ifp = if_lookup_by_index_per_ns(zns, ifa->ifa_index);
 	if (ifp == NULL) {
-		zlog_ferr(
+		flog_err(
 			LIB_ERR_INTERFACE,
 			"netlink_interface_addr can't find interface by index %d",
 			ifa->ifa_index);
diff --git a/zebra/interface.c b/zebra/interface.c
index 9811badfc4..763931d350 100644
--- a/zebra/interface.c
+++ b/zebra/interface.c
@@ -719,7 +719,7 @@ void if_delete_update(struct interface *ifp)
 	struct zebra_if *zif;
 
 	if (if_is_up(ifp)) {
-		zlog_ferr(
+		flog_err(
 			LIB_ERR_INTERFACE,
 			"interface %s vrf %u index %d is still up while being deleted.",
 			ifp->name, ifp->vrf_id, ifp->ifindex);
diff --git a/zebra/ioctl.c b/zebra/ioctl.c
index aee3abf31a..842b96d756 100644
--- a/zebra/ioctl.c
+++ b/zebra/ioctl.c
@@ -56,21 +56,21 @@ int if_ioctl(unsigned long request, caddr_t buffer)
 	int err = 0;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	sock = socket(AF_INET, SOCK_DGRAM, 0);
 	if (sock < 0) {
 		int save_errno = errno;
 
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
-		zlog_ferr(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
 			  safe_strerror(save_errno));
 		exit(1);
 	}
 	if ((ret = ioctl(sock, request, buffer)) < 0)
 		err = errno;
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	close(sock);
 
 	if (ret < 0) {
@@ -88,14 +88,14 @@ int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id)
 	int err = 0;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	sock = vrf_socket(AF_INET, SOCK_DGRAM, 0, vrf_id, NULL);
 	if (sock < 0) {
 		int save_errno = errno;
 
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
-		zlog_ferr(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
 			  safe_strerror(save_errno));
 		exit(1);
 	}
@@ -103,7 +103,7 @@ int vrf_if_ioctl(unsigned long request, caddr_t buffer, vrf_id_t vrf_id)
 	if (ret < 0)
 		err = errno;
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	close(sock);
 
 	if (ret < 0) {
@@ -121,14 +121,14 @@ static int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
 	int err = 0;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	sock = socket(AF_INET6, SOCK_DGRAM, 0);
 	if (sock < 0) {
 		int save_errno = errno;
 
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
-		zlog_ferr(LIB_ERR_SOCKET,
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_SOCKET,
 			  "Cannot create IPv6 datagram socket: %s",
 			  safe_strerror(save_errno));
 		exit(1);
@@ -137,7 +137,7 @@ static int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
 	if ((ret = ioctl(sock, request, buffer)) < 0)
 		err = errno;
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	close(sock);
 
 	if (ret < 0) {
@@ -415,7 +415,7 @@ void if_get_flags(struct interface *ifp)
 
 	ret = vrf_if_ioctl(SIOCGIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL,
+		flog_err(LIB_ERR_SYSTEM_CALL,
 			  "vrf_if_ioctl(SIOCGIFFLAGS) failed: %s",
 			  safe_strerror(errno));
 		return;
@@ -434,7 +434,7 @@ void if_get_flags(struct interface *ifp)
 
 		/* Seems not all interfaces implement this ioctl */
 		if (if_ioctl(SIOCGIFMEDIA, (caddr_t)&ifmr) < 0)
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "if_ioctl(SIOCGIFMEDIA) failed: %s",
 				  safe_strerror(errno));
 		else if (ifmr.ifm_status & IFM_AVALID) /* Link state is valid */
diff --git a/zebra/ioctl_solaris.c b/zebra/ioctl_solaris.c
index 1e24e3fbf6..09e9213cca 100644
--- a/zebra/ioctl_solaris.c
+++ b/zebra/ioctl_solaris.c
@@ -59,14 +59,14 @@ int if_ioctl(unsigned long request, caddr_t buffer)
 	int err;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 
 	sock = socket(AF_INET, SOCK_DGRAM, 0);
 	if (sock < 0) {
 		int save_errno = errno;
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
-		zlog_ferr(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
 			  safe_strerror(save_errno));
 		exit(1);
 	}
@@ -75,7 +75,7 @@ int if_ioctl(unsigned long request, caddr_t buffer)
 		err = errno;
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	close(sock);
 
@@ -94,14 +94,14 @@ int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
 	int err;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 
 	sock = socket(AF_INET6, SOCK_DGRAM, 0);
 	if (sock < 0) {
 		int save_errno = errno;
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
-		zlog_ferr(LIB_ERR_SOCKET,
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_SOCKET,
 			  "Cannot create IPv6 datagram socket: %s",
 			  safe_strerror(save_errno));
 		exit(1);
@@ -111,7 +111,7 @@ int if_ioctl_ipv6(unsigned long request, caddr_t buffer)
 		err = errno;
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	close(sock);
 
diff --git a/zebra/ipforward_proc.c b/zebra/ipforward_proc.c
index feafbb27cf..fc27624410 100644
--- a/zebra/ipforward_proc.c
+++ b/zebra/ipforward_proc.c
@@ -78,14 +78,14 @@ int ipforward_on(void)
 	FILE *fp;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
 			  safe_strerror(errno));
 
 	fp = fopen(proc_ipv4_forwarding, "w");
 
 	if (fp == NULL) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES,
+			flog_err(LIB_ERR_PRIVILEGES,
 				  "Can't lower privileges, %s",
 				  safe_strerror(errno));
 		return -1;
@@ -96,7 +96,7 @@ int ipforward_on(void)
 	fclose(fp);
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
 			  safe_strerror(errno));
 
 	return ipforward();
@@ -107,14 +107,14 @@ int ipforward_off(void)
 	FILE *fp;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
 			  safe_strerror(errno));
 
 	fp = fopen(proc_ipv4_forwarding, "w");
 
 	if (fp == NULL) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES,
+			flog_err(LIB_ERR_PRIVILEGES,
 				  "Can't lower privileges, %s",
 				  safe_strerror(errno));
 		return -1;
@@ -125,7 +125,7 @@ int ipforward_off(void)
 	fclose(fp);
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
 			  safe_strerror(errno));
 
 	return ipforward();
@@ -161,14 +161,14 @@ int ipforward_ipv6_on(void)
 	FILE *fp;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
 			  safe_strerror(errno));
 
 	fp = fopen(proc_ipv6_forwarding, "w");
 
 	if (fp == NULL) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES,
+			flog_err(LIB_ERR_PRIVILEGES,
 				  "Can't lower privileges, %s",
 				  safe_strerror(errno));
 		return -1;
@@ -179,7 +179,7 @@ int ipforward_ipv6_on(void)
 	fclose(fp);
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
 			  safe_strerror(errno));
 
 	return ipforward_ipv6();
@@ -191,14 +191,14 @@ int ipforward_ipv6_off(void)
 	FILE *fp;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
 			  safe_strerror(errno));
 
 	fp = fopen(proc_ipv6_forwarding, "w");
 
 	if (fp == NULL) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES,
+			flog_err(LIB_ERR_PRIVILEGES,
 				  "Can't lower privileges, %s",
 				  safe_strerror(errno));
 		return -1;
@@ -209,7 +209,7 @@ int ipforward_ipv6_off(void)
 	fclose(fp);
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
 			  safe_strerror(errno));
 
 	return ipforward_ipv6();
diff --git a/zebra/ipforward_solaris.c b/zebra/ipforward_solaris.c
index 9fc46b25da..43b1fac5f8 100644
--- a/zebra/ipforward_solaris.c
+++ b/zebra/ipforward_solaris.c
@@ -70,7 +70,7 @@ static int solaris_nd(const int cmd, const char *parameter, const int value)
 	else if (cmd == ND_GET)
 		snprintf(nd_buf, ND_BUFFER_SIZE, "%s", parameter);
 	else {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL,
+		flog_err(LIB_ERR_SYSTEM_CALL,
 			  "internal error - inappropriate command given to "
 			  "solaris_nd()%s:%d",
 			  __FILE__, __LINE__);
@@ -83,20 +83,20 @@ static int solaris_nd(const int cmd, const char *parameter, const int value)
 	strioctl.ic_dp = nd_buf;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "solaris_nd: Can't raise privileges");
 	if ((fd = open(device, O_RDWR)) < 0) {
 		zlog_warn("failed to open device %s - %s", device,
 			  safe_strerror(errno));
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES,
+			flog_err(LIB_ERR_PRIVILEGES,
 				  "solaris_nd: Can't lower privileges");
 		return -1;
 	}
 	if (ioctl(fd, I_STR, &strioctl) < 0) {
 		int save_errno = errno;
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES,
+			flog_err(LIB_ERR_PRIVILEGES,
 				  "solaris_nd: Can't lower privileges");
 		close(fd);
 		zlog_warn("ioctl I_STR failed on device %s - %s", device,
@@ -105,7 +105,7 @@ static int solaris_nd(const int cmd, const char *parameter, const int value)
 	}
 	close(fd);
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "solaris_nd: Can't lower privileges");
 
 	if (cmd == ND_GET) {
diff --git a/zebra/ipforward_sysctl.c b/zebra/ipforward_sysctl.c
index 8e34ed73bc..f0eaa1acea 100644
--- a/zebra/ipforward_sysctl.c
+++ b/zebra/ipforward_sysctl.c
@@ -55,15 +55,15 @@ int ipforward_on(void)
 
 	len = sizeof ipforwarding;
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	if (sysctl(mib, MIB_SIZ, NULL, NULL, &ipforwarding, len) < 0) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 		zlog_warn("Can't set ipforwarding on");
 		return -1;
 	}
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	return ipforwarding;
 }
 
@@ -74,15 +74,15 @@ int ipforward_off(void)
 
 	len = sizeof ipforwarding;
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	if (sysctl(mib, MIB_SIZ, NULL, NULL, &ipforwarding, len) < 0) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 		zlog_warn("Can't set ipforwarding on");
 		return -1;
 	}
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	return ipforwarding;
 }
 
@@ -102,15 +102,15 @@ int ipforward_ipv6(void)
 
 	len = sizeof ip6forwarding;
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	if (sysctl(mib_ipv6, MIB_SIZ, &ip6forwarding, &len, 0, 0) < 0) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 		zlog_warn("can't get ip6forwarding value");
 		return -1;
 	}
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	return ip6forwarding;
 }
 
@@ -121,15 +121,15 @@ int ipforward_ipv6_on(void)
 
 	len = sizeof ip6forwarding;
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	if (sysctl(mib_ipv6, MIB_SIZ, NULL, NULL, &ip6forwarding, len) < 0) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 		zlog_warn("can't get ip6forwarding value");
 		return -1;
 	}
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	return ip6forwarding;
 }
 
@@ -140,15 +140,15 @@ int ipforward_ipv6_off(void)
 
 	len = sizeof ip6forwarding;
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	if (sysctl(mib_ipv6, MIB_SIZ, NULL, NULL, &ip6forwarding, len) < 0) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+			flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 		zlog_warn("can't get ip6forwarding value");
 		return -1;
 	}
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	return ip6forwarding;
 }
 
diff --git a/zebra/irdp_main.c b/zebra/irdp_main.c
index 8efbdcf480..630eee5929 100644
--- a/zebra/irdp_main.c
+++ b/zebra/irdp_main.c
@@ -82,7 +82,7 @@ int irdp_sock_init(void)
 	int sock;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "irdp_sock_init: could not raise privs, %s",
 			  safe_strerror(errno));
 
@@ -90,7 +90,7 @@ int irdp_sock_init(void)
 	save_errno = errno;
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "irdp_sock_init: could not lower privs, %s",
 			  safe_strerror(errno));
 
diff --git a/zebra/irdp_packet.c b/zebra/irdp_packet.c
index 31467e51e0..c36c958973 100644
--- a/zebra/irdp_packet.c
+++ b/zebra/irdp_packet.c
@@ -95,13 +95,13 @@ static void parse_irdp_packet(char *p, int len, struct interface *ifp)
 	src = ip->ip_src;
 
 	if (len != iplen) {
-		zlog_ferr(ZEBRA_ERR_IRDP_LEN_MISMATCH,
+		flog_err(ZEBRA_ERR_IRDP_LEN_MISMATCH,
 			  "IRDP: RX length doesnt match IP length");
 		return;
 	}
 
 	if (iplen < ICMP_MINLEN) {
-		zlog_ferr(ZEBRA_ERR_IRDP_LEN_MISMATCH,
+		flog_err(ZEBRA_ERR_IRDP_LEN_MISMATCH,
 			  "IRDP: RX ICMP packet too short from %s\n",
 			  inet_ntoa(src));
 		return;
@@ -112,7 +112,7 @@ static void parse_irdp_packet(char *p, int len, struct interface *ifp)
 	 +
 	 len of IP-header) 14+20 */
 	if (iplen > IRDP_RX_BUF - 34) {
-		zlog_ferr(ZEBRA_ERR_IRDP_LEN_MISMATCH,
+		flog_err(ZEBRA_ERR_IRDP_LEN_MISMATCH,
 			  "IRDP: RX ICMP packet too long from %s\n",
 			  inet_ntoa(src));
 		return;
diff --git a/zebra/kernel_netlink.c b/zebra/kernel_netlink.c
index de0e8af664..e9f440832a 100644
--- a/zebra/kernel_netlink.c
+++ b/zebra/kernel_netlink.c
@@ -163,7 +163,7 @@ static int netlink_recvbuf(struct nlsock *nl, uint32_t newsize)
 
 	ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &oldsize, &oldlen);
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "Can't get %s receive buffer size: %s", nl->name,
 			  safe_strerror(errno));
 		return -1;
@@ -171,18 +171,18 @@ static int netlink_recvbuf(struct nlsock *nl, uint32_t newsize)
 
 	/* Try force option (linux >= 2.6.14) and fall back to normal set */
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "routing_socket: Can't raise privileges");
 	ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUFFORCE, &nl_rcvbufsize,
 			 sizeof(nl_rcvbufsize));
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "routing_socket: Can't lower privileges");
 	if (ret < 0)
 		ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF,
 				 &nl_rcvbufsize, sizeof(nl_rcvbufsize));
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "Can't set %s receive buffer size: %s", nl->name,
 			  safe_strerror(errno));
 		return -1;
@@ -190,7 +190,7 @@ static int netlink_recvbuf(struct nlsock *nl, uint32_t newsize)
 
 	ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &newsize, &newlen);
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "Can't get %s receive buffer size: %s", nl->name,
 			  safe_strerror(errno));
 		return -1;
@@ -212,13 +212,13 @@ static int netlink_socket(struct nlsock *nl, unsigned long groups,
 	int save_errno;
 
 	if (zserv_privs.change(ZPRIVS_RAISE)) {
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 		return -1;
 	}
 
 	sock = ns_socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE, ns_id);
 	if (sock < 0) {
-		zlog_ferr(LIB_ERR_SOCKET, "Can't open %s socket: %s", nl->name,
+		flog_err(LIB_ERR_SOCKET, "Can't open %s socket: %s", nl->name,
 			  safe_strerror(errno));
 		return -1;
 	}
@@ -231,10 +231,10 @@ static int netlink_socket(struct nlsock *nl, unsigned long groups,
 	ret = bind(sock, (struct sockaddr *)&snl, sizeof snl);
 	save_errno = errno;
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "Can't bind %s socket to group 0x%x: %s", nl->name,
 			  snl.nl_groups, safe_strerror(save_errno));
 		close(sock);
@@ -245,7 +245,7 @@ static int netlink_socket(struct nlsock *nl, unsigned long groups,
 	namelen = sizeof snl;
 	ret = getsockname(sock, (struct sockaddr *)&snl, (socklen_t *)&namelen);
 	if (ret < 0 || namelen != sizeof snl) {
-		zlog_ferr(LIB_ERR_SOCKET, "Can't get %s socket name: %s",
+		flog_err(LIB_ERR_SOCKET, "Can't get %s socket name: %s",
 			  nl->name, safe_strerror(errno));
 		close(sock);
 		return -1;
@@ -297,7 +297,7 @@ static int netlink_information_fetch(struct nlmsghdr *h, ns_id_t ns_id,
 		 * this message type or not ask for
 		 * it to be sent up to us
 		 */
-		zlog_ferr(ZEBRA_ERR_UNKNOWN_NLMSG,
+		flog_err(ZEBRA_ERR_UNKNOWN_NLMSG,
 			  "Unknown netlink nlmsg_type %s(%d) vrf %u\n",
 			  nl_msg_type_to_str(h->nlmsg_type), h->nlmsg_type,
 			  ns_id);
@@ -707,7 +707,7 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
 				continue;
 			if (errno == EWOULDBLOCK || errno == EAGAIN)
 				break;
-			zlog_ferr(ZEBRA_ERR_RECVMSG_OVERRUN,
+			flog_err(ZEBRA_ERR_RECVMSG_OVERRUN,
 				  "%s recvmsg overrun: %s", nl->name,
 				  safe_strerror(errno));
 			/*
@@ -720,12 +720,12 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
 		}
 
 		if (status == 0) {
-			zlog_ferr(LIB_ERR_SOCKET, "%s EOF", nl->name);
+			flog_err(LIB_ERR_SOCKET, "%s EOF", nl->name);
 			return -1;
 		}
 
 		if (msg.msg_namelen != sizeof snl) {
-			zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+			flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
 				  "%s sender address length error: length %d",
 				  nl->name, msg.msg_namelen);
 			return -1;
@@ -800,7 +800,7 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
 
 				if (h->nlmsg_len
 				    < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
-					zlog_ferr(
+					flog_err(
 						ZEBRA_ERR_NETLINK_LENGTH_ERROR,
 						"%s error: message truncated",
 						nl->name);
@@ -855,7 +855,7 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
 							err->msg.nlmsg_seq,
 							err->msg.nlmsg_pid);
 				} else
-					zlog_ferr(
+					flog_err(
 						ZEBRA_ERR_UNEXPECTED_MESSAGE,
 						"%s error: %s, type=%s(%u), seq=%u, pid=%u",
 						nl->name,
@@ -896,12 +896,12 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
 
 		/* After error care. */
 		if (msg.msg_flags & MSG_TRUNC) {
-			zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+			flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
 				  "%s error: message truncated", nl->name);
 			continue;
 		}
 		if (status) {
-			zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+			flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
 				  "%s error: data remnant size %d", nl->name,
 				  status);
 			return -1;
@@ -958,11 +958,11 @@ int netlink_talk(int (*filter)(struct nlmsghdr *, ns_id_t, int startup),
 
 	/* Send message to netlink interface. */
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	status = sendmsg(nl->sock, &msg, 0);
 	save_errno = errno;
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND) {
 		zlog_debug("%s: >> netlink message dump [sent]", __func__);
@@ -970,7 +970,7 @@ int netlink_talk(int (*filter)(struct nlmsghdr *, ns_id_t, int startup),
 	}
 
 	if (status < 0) {
-		zlog_ferr(LIB_ERR_SOCKET, "netlink_talk sendmsg() error: %s",
+		flog_err(LIB_ERR_SOCKET, "netlink_talk sendmsg() error: %s",
 			  safe_strerror(save_errno));
 		return -1;
 	}
@@ -994,7 +994,7 @@ int netlink_request(struct nlsock *nl, struct nlmsghdr *n)
 
 	/* Check netlink socket. */
 	if (nl->sock < 0) {
-		zlog_ferr(LIB_ERR_SOCKET, "%s socket isn't active.", nl->name);
+		flog_err(LIB_ERR_SOCKET, "%s socket isn't active.", nl->name);
 		return -1;
 	}
 
@@ -1008,7 +1008,7 @@ int netlink_request(struct nlsock *nl, struct nlmsghdr *n)
 
 	/* Raise capabilities and send message, then lower capabilities. */
 	if (zserv_privs.change(ZPRIVS_RAISE)) {
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 		return -1;
 	}
 
@@ -1017,10 +1017,10 @@ int netlink_request(struct nlsock *nl, struct nlmsghdr *n)
 	save_errno = errno;
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET, "%s sendto failed: %s", nl->name,
+		flog_err(LIB_ERR_SOCKET, "%s sendto failed: %s", nl->name,
 			  safe_strerror(save_errno));
 		return -1;
 	}
@@ -1095,7 +1095,7 @@ void kernel_init(struct zebra_ns *zns)
 
 	/* Register kernel socket. */
 	if (fcntl(zns->netlink.sock, F_SETFL, O_NONBLOCK) < 0)
-		zlog_ferr(LIB_ERR_SOCKET, "Can't set %s socket flags: %s",
+		flog_err(LIB_ERR_SOCKET, "Can't set %s socket flags: %s",
 			  zns->netlink.name, safe_strerror(errno));
 
 	if (fcntl(zns->netlink_cmd.sock, F_SETFL, O_NONBLOCK) < 0)
diff --git a/zebra/kernel_socket.c b/zebra/kernel_socket.c
index 9e4f09f0e8..79721cf87a 100644
--- a/zebra/kernel_socket.c
+++ b/zebra/kernel_socket.c
@@ -409,7 +409,7 @@ int ifm_read(struct if_msghdr *ifm)
 
 	/* paranoia: sanity check structure */
 	if (ifm->ifm_msglen < sizeof(struct if_msghdr)) {
-		zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+		flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
 			  "ifm_read: ifm->ifm_msglen %d too short\n",
 			  ifm->ifm_msglen);
 		return -1;
@@ -1386,7 +1386,7 @@ static int kernel_read(struct thread *thread)
 static void routing_socket(struct zebra_ns *zns)
 {
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "routing_socket: Can't raise privileges");
 
 	routing_sock =
@@ -1394,7 +1394,7 @@ static void routing_socket(struct zebra_ns *zns)
 
 	if (routing_sock < 0) {
 		if (zserv_privs.change(ZPRIVS_LOWER))
-			zlog_ferr(LIB_ERR_PRIVILEGES,
+			flog_err(LIB_ERR_PRIVILEGES,
 				  "routing_socket: Can't lower privileges");
 		zlog_warn("Can't init kernel routing socket");
 		return;
@@ -1408,7 +1408,7 @@ static void routing_socket(struct zebra_ns *zns)
 	  zlog_warn ("Can't set O_NONBLOCK to routing socket");*/
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "routing_socket: Can't lower privileges");
 
 	/* kernel_read needs rewrite. */
diff --git a/zebra/label_manager.c b/zebra/label_manager.c
index c6a32343d9..e53764c770 100644
--- a/zebra/label_manager.c
+++ b/zebra/label_manager.c
@@ -83,7 +83,7 @@ static int relay_response_back(void)
 	ret = zclient_read_header(src, zclient->sock, &size, &marker, &version,
 				  &vrf_id, &resp_cmd);
 	if (ret < 0 && errno != EAGAIN) {
-		zlog_ferr(ZEBRA_ERR_LM_RESPONSE,
+		flog_err(ZEBRA_ERR_LM_RESPONSE,
 			  "Error reading Label Manager response: %s",
 			  strerror(errno));
 		return -1;
@@ -103,7 +103,7 @@ static int relay_response_back(void)
 	/* lookup the client to relay the msg to */
 	zserv = zserv_find_client(proto, instance);
 	if (!zserv) {
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_LM_NO_SUCH_CLIENT,
 			"Error relaying LM response: can't find client %s, instance %u",
 			proto_str, instance);
@@ -119,7 +119,7 @@ static int relay_response_back(void)
 	/* send response back */
 	ret = writen(zserv->sock, dst->data, stream_get_endp(dst));
 	if (ret <= 0) {
-		zlog_ferr(ZEBRA_ERR_LM_RELAY_FAILED,
+		flog_err(ZEBRA_ERR_LM_RELAY_FAILED,
 			  "Error relaying LM response to %s instance %u: %s",
 			  proto_str, instance, strerror(errno));
 		return -1;
@@ -187,7 +187,7 @@ int zread_relay_label_manager_request(int cmd, struct zserv *zserv,
 	unsigned short instance;
 
 	if (zclient->sock < 0) {
-		zlog_ferr(ZEBRA_ERR_LM_NO_SOCKET,
+		flog_err(ZEBRA_ERR_LM_NO_SOCKET,
 			  "Unable to relay LM request: no socket");
 		reply_error(cmd, zserv, vrf_id);
 		return -1;
@@ -216,7 +216,7 @@ int zread_relay_label_manager_request(int cmd, struct zserv *zserv,
 
 	/* check & set client instance if unset */
 	if (zserv->instance && zserv->instance != instance) {
-		zlog_ferr(ZEBRA_ERR_LM_BAD_INSTANCE,
+		flog_err(ZEBRA_ERR_LM_BAD_INSTANCE,
 			  "Client instance(%u) != msg instance(%u)",
 			  zserv->instance, instance);
 		return -1;
@@ -239,7 +239,7 @@ int zread_relay_label_manager_request(int cmd, struct zserv *zserv,
 	/* Send request to external label manager */
 	ret = writen(zclient->sock, dst->data, stream_get_endp(dst));
 	if (ret <= 0) {
-		zlog_ferr(ZEBRA_ERR_LM_RELAY_FAILED,
+		flog_err(ZEBRA_ERR_LM_RELAY_FAILED,
 			  "Error relaying LM request from %s instance %u: %s",
 			  proto_str, instance, strerror(errno));
 		reply_error(cmd, zserv, vrf_id);
@@ -269,7 +269,7 @@ static int lm_zclient_connect(struct thread *t)
 		return 0;
 
 	if (zclient_socket_connect(zclient) < 0) {
-		zlog_ferr(ZEBRA_ERR_LM_CLIENT_CONNECTION_FAILED,
+		flog_err(ZEBRA_ERR_LM_CLIENT_CONNECTION_FAILED,
 			  "Error connecting synchronous zclient!");
 		thread_add_timer(zebrad.master, lm_zclient_connect, zclient,
 				 CONNECTION_DELAY, &zclient->t_connect);
@@ -401,7 +401,7 @@ struct label_manager_chunk *assign_label_chunk(uint8_t proto,
 				     ->end
 			     + 1;
 	if (lmc->start > MPLS_LABEL_UNRESERVED_MAX - size + 1) {
-		zlog_ferr(ZEBRA_ERR_LM_EXHAUSTED_LABELS,
+		flog_err(ZEBRA_ERR_LM_EXHAUSTED_LABELS,
 			  "Reached max labels. Start: %u, size: %u", lmc->start,
 			  size);
 		XFREE(MTYPE_LM_CHUNK, lmc);
@@ -441,7 +441,7 @@ int release_label_chunk(uint8_t proto, unsigned short instance, uint32_t start,
 		if (lmc->end != end)
 			continue;
 		if (lmc->proto != proto || lmc->instance != instance) {
-			zlog_ferr(ZEBRA_ERR_LM_DAEMON_MISMATCH,
+			flog_err(ZEBRA_ERR_LM_DAEMON_MISMATCH,
 				  "%s: Daemon mismatch!!", __func__);
 			continue;
 		}
@@ -452,7 +452,7 @@ int release_label_chunk(uint8_t proto, unsigned short instance, uint32_t start,
 		break;
 	}
 	if (ret != 0)
-		zlog_ferr(ZEBRA_ERR_LM_UNRELEASED_CHUNK,
+		flog_err(ZEBRA_ERR_LM_UNRELEASED_CHUNK,
 			  "%s: Label chunk not released!!", __func__);
 
 	return ret;
diff --git a/zebra/main.c b/zebra/main.c
index 9453e54b61..5e7c69382f 100644
--- a/zebra/main.c
+++ b/zebra/main.c
@@ -289,7 +289,7 @@ int main(int argc, char **argv)
 			multipath_num = atoi(optarg);
 			if (multipath_num > MULTIPATH_NUM
 			    || multipath_num <= 0) {
-				zlog_ferr(
+				flog_err(
 					ZEBRA_ERR_BAD_MULTIPATH_NUM,
 					"Multipath Number specified must be less than %d and greater than 0",
 					MULTIPATH_NUM);
diff --git a/zebra/rt_socket.c b/zebra/rt_socket.c
index e629e7387d..8910aa8f60 100644
--- a/zebra/rt_socket.c
+++ b/zebra/rt_socket.c
@@ -212,7 +212,7 @@ static int kernel_rtm_ipv4(int cmd, const struct prefix *p,
 			 */
 			case ZEBRA_ERR_RTEXIST:
 				if (cmd != RTM_ADD)
-					zlog_ferr(
+					flog_err(
 						LIB_ERR_SYSTEM_CALL,
 						"%s: rtm_write() returned %d for command %d",
 						__func__, error, cmd);
@@ -226,7 +226,7 @@ static int kernel_rtm_ipv4(int cmd, const struct prefix *p,
 			case ZEBRA_ERR_RTNOEXIST:
 			case ZEBRA_ERR_RTUNREACH:
 			default:
-				zlog_ferr(
+				flog_err(
 					LIB_ERR_SYSTEM_CALL,
 					"%s: %s: rtm_write() unexpectedly returned %d for command %s",
 					__func__,
@@ -404,7 +404,7 @@ enum dp_req_result kernel_route_rib(struct route_node *rn,
 	}
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 
 	if (old)
 		route |= kernel_rtm(RTM_DELETE, p, old);
@@ -413,7 +413,7 @@ enum dp_req_result kernel_route_rib(struct route_node *rn,
 		route |= kernel_rtm(RTM_ADD, p, new);
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	if (new) {
 		kernel_route_rib_pass_fail(
diff --git a/zebra/rtadv.c b/zebra/rtadv.c
index 03eb1566a6..c76a0df261 100644
--- a/zebra/rtadv.c
+++ b/zebra/rtadv.c
@@ -374,7 +374,7 @@ static void rtadv_send_packet(int sock, struct interface *ifp)
 
 	ret = sendmsg(sock, &msg, 0);
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "%s(%u): Tx RA failed, socket %u error %d (%s)",
 			  ifp->name, ifp->ifindex, sock, errno,
 			  safe_strerror(errno));
@@ -631,14 +631,14 @@ static int rtadv_make_socket(ns_id_t ns_id)
 	struct icmp6_filter filter;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "rtadv_make_socket: could not raise privs, %s",
 			  safe_strerror(errno));
 
 	sock = ns_socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6, ns_id);
 
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "rtadv_make_socket: could not lower privs, %s",
 			  safe_strerror(errno));
 
diff --git a/zebra/rule_socket.c b/zebra/rule_socket.c
index e06906ff44..620410de04 100644
--- a/zebra/rule_socket.c
+++ b/zebra/rule_socket.c
@@ -44,14 +44,14 @@
 
 enum dp_req_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
 {
-	zlog_ferr(LIB_ERR_UNAVAILABLE, "%s not Implemented for this platform",
+	flog_err(LIB_ERR_UNAVAILABLE, "%s not Implemented for this platform",
 		  __PRETTY_FUNCTION__);
 	return DP_REQUEST_FAILURE;
 }
 
 enum dp_req_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
 {
-	zlog_ferr(LIB_ERR_UNAVAILABLE, "%s not Implemented for this platform",
+	flog_err(LIB_ERR_UNAVAILABLE, "%s not Implemented for this platform",
 		  __PRETTY_FUNCTION__);
 	return DP_REQUEST_FAILURE;
 }
diff --git a/zebra/table_manager.c b/zebra/table_manager.c
index ecff9bd85d..43b5c7d59e 100644
--- a/zebra/table_manager.c
+++ b/zebra/table_manager.c
@@ -147,7 +147,7 @@ struct table_manager_chunk *assign_table_chunk(uint8_t proto, uint16_t instance,
 #endif /* SUNOS_5 */
 	tmc->start = start;
 	if (RT_TABLE_ID_UNRESERVED_MAX - size  + 1 < start) {
-		zlog_ferr(ZEBRA_ERR_TM_EXHAUSTED_IDS,
+		flog_err(ZEBRA_ERR_TM_EXHAUSTED_IDS,
 			  "Reached max table id. Start/Size %u/%u", start,
 			  size);
 		XFREE(MTYPE_TM_CHUNK, tmc);
@@ -186,7 +186,7 @@ int release_table_chunk(uint8_t proto, uint16_t instance, uint32_t start,
 		if (tmc->end != end)
 			continue;
 		if (tmc->proto != proto || tmc->instance != instance) {
-			zlog_ferr(ZEBRA_ERR_TM_DAEMON_MISMATCH,
+			flog_err(ZEBRA_ERR_TM_DAEMON_MISMATCH,
 				  "%s: Daemon mismatch!!", __func__);
 			continue;
 		}
@@ -196,7 +196,7 @@ int release_table_chunk(uint8_t proto, uint16_t instance, uint32_t start,
 		break;
 	}
 	if (ret != 0)
-		zlog_ferr(ZEBRA_ERR_TM_UNRELEASED_CHUNK,
+		flog_err(ZEBRA_ERR_TM_UNRELEASED_CHUNK,
 			  "%s: Table chunk not released!!", __func__);
 
 	return ret;
diff --git a/zebra/zapi_msg.c b/zebra/zapi_msg.c
index 369dcfeec8..a74c6bc4bf 100644
--- a/zebra/zapi_msg.c
+++ b/zebra/zapi_msg.c
@@ -1058,7 +1058,7 @@ static void zread_rnh_register(ZAPI_HANDLER_ARGS)
 			STREAM_GET(&p.u.prefix6, s, IPV6_MAX_BYTELEN);
 			l += IPV6_MAX_BYTELEN;
 		} else {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_UNKNOWN_FAMILY,
 				"rnh_register: Received unknown family type %d\n",
 				p.family);
@@ -1137,7 +1137,7 @@ static void zread_rnh_unregister(ZAPI_HANDLER_ARGS)
 			STREAM_GET(&p.u.prefix6, s, IPV6_MAX_BYTELEN);
 			l += IPV6_MAX_BYTELEN;
 		} else {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_UNKNOWN_FAMILY,
 				"rnh_register: Received unknown family type %d\n",
 				p.family);
@@ -1174,7 +1174,7 @@ static void zread_fec_register(ZAPI_HANDLER_ARGS)
 	 * registration
 	 */
 	if (hdr->length < ZEBRA_MIN_FEC_LENGTH) {
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_IRDP_LEN_MISMATCH,
 			"fec_register: Received a fec register of hdr->length %d, it is of insufficient size to properly decode",
 			hdr->length);
@@ -1186,7 +1186,7 @@ static void zread_fec_register(ZAPI_HANDLER_ARGS)
 		memset(&p, 0, sizeof(p));
 		STREAM_GETW(s, p.family);
 		if (p.family != AF_INET && p.family != AF_INET6) {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_UNKNOWN_FAMILY,
 				"fec_register: Received unknown family type %d\n",
 				p.family);
@@ -1234,7 +1234,7 @@ static void zread_fec_unregister(ZAPI_HANDLER_ARGS)
 	 * fec unregistration
 	 */
 	if (hdr->length < ZEBRA_MIN_FEC_LENGTH) {
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_IRDP_LEN_MISMATCH,
 			"fec_unregister: Received a fec unregister of hdr->length %d, it is of insufficient size to properly decode",
 			hdr->length);
@@ -1249,7 +1249,7 @@ static void zread_fec_unregister(ZAPI_HANDLER_ARGS)
 		memset(&p, 0, sizeof(p));
 		STREAM_GETW(s, p.family);
 		if (p.family != AF_INET && p.family != AF_INET6) {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_UNKNOWN_FAMILY,
 				"fec_unregister: Received unknown family type %d\n",
 				p.family);
@@ -2382,7 +2382,7 @@ static void zread_table_manager_connect(struct zserv *client,
 
 	/* accept only dynamic routing protocols */
 	if ((proto >= ZEBRA_ROUTE_MAX) || (proto <= ZEBRA_ROUTE_STATIC)) {
-		zlog_ferr(ZEBRA_ERR_TM_WRONG_PROTO,
+		flog_err(ZEBRA_ERR_TM_WRONG_PROTO,
 			  "client %d has wrong protocol %s", client->sock,
 			  zebra_route_string(proto));
 		zsend_table_manager_connect_response(client, vrf_id, 1);
@@ -2422,7 +2422,7 @@ static void zread_label_manager_connect(struct zserv *client,
 
 	/* accept only dynamic routing protocols */
 	if ((proto >= ZEBRA_ROUTE_MAX) || (proto <= ZEBRA_ROUTE_STATIC)) {
-		zlog_ferr(ZEBRA_ERR_TM_WRONG_PROTO,
+		flog_err(ZEBRA_ERR_TM_WRONG_PROTO,
 			  "client %d has wrong protocol %s", client->sock,
 			  zebra_route_string(proto));
 		zsend_label_manager_connect_response(client, vrf_id, 1);
@@ -2452,7 +2452,7 @@ static int msg_client_id_mismatch(const char *op, struct zserv *client,
 				  uint8_t proto, unsigned int instance)
 {
 	if (proto != client->proto) {
-		zlog_ferr(ZEBRA_ERR_PROTO_OR_INSTANCE_MISMATCH,
+		flog_err(ZEBRA_ERR_PROTO_OR_INSTANCE_MISMATCH,
 			  "%s: msg vs client proto mismatch, client=%u msg=%u",
 			  op, client->proto, proto);
 		/* TODO: fail when BGP sets proto and instance */
@@ -2460,7 +2460,7 @@ static int msg_client_id_mismatch(const char *op, struct zserv *client,
 	}
 
 	if (instance != client->instance) {
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_PROTO_OR_INSTANCE_MISMATCH,
 			"%s: msg vs client instance mismatch, client=%u msg=%u",
 			op, client->instance, instance);
@@ -2496,7 +2496,7 @@ static void zread_get_label_chunk(struct zserv *client, struct stream *msg,
 
 	lmc = assign_label_chunk(client->proto, client->instance, keep, size);
 	if (!lmc)
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_LM_CANNOT_ASSIGN_CHUNK,
 			"Unable to assign Label Chunk of size %u to %s instance %u",
 			size, zebra_route_string(client->proto),
@@ -2555,7 +2555,7 @@ static void zread_label_manager_request(ZAPI_HANDLER_ARGS)
 		else {
 			/* Sanity: don't allow 'unidentified' requests */
 			if (!client->proto) {
-				zlog_ferr(
+				flog_err(
 					ZEBRA_ERR_LM_ALIENS,
 					"Got label request from an unidentified client");
 				return;
@@ -2584,7 +2584,7 @@ static void zread_get_table_chunk(struct zserv *client, struct stream *msg,
 
 	tmc = assign_table_chunk(client->proto, client->instance, size);
 	if (!tmc)
-		zlog_ferr(ZEBRA_ERR_TM_CANNOT_ASSIGN_CHUNK,
+		flog_err(ZEBRA_ERR_TM_CANNOT_ASSIGN_CHUNK,
 			  "%s: Unable to assign Table Chunk of size %u",
 			  __func__, size);
 	else
@@ -2623,7 +2623,7 @@ static void zread_table_manager_request(ZAPI_HANDLER_ARGS)
 	else {
 		/* Sanity: don't allow 'unidentified' requests */
 		if (!client->proto) {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_TM_ALIENS,
 				"Got table request from an unidentified client");
 			return;
diff --git a/zebra/zebra_fpm.c b/zebra/zebra_fpm.c
index 8b1463c9bc..1cb14abbf9 100644
--- a/zebra/zebra_fpm.c
+++ b/zebra/zebra_fpm.c
@@ -1518,7 +1518,7 @@ static inline void zfpm_init_message_format(const char *format)
 
 	if (!strcmp("netlink", format)) {
 		if (!have_netlink) {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_NETLINK_NOT_AVAILABLE,
 				"FPM netlink message format is not available");
 			return;
@@ -1529,7 +1529,7 @@ static inline void zfpm_init_message_format(const char *format)
 
 	if (!strcmp("protobuf", format)) {
 		if (!have_protobuf) {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_PROTOBUF_NOT_AVAILABLE,
 				"FPM protobuf message format is not available");
 			return;
diff --git a/zebra/zebra_mpls.c b/zebra/zebra_mpls.c
index a778dc9af8..cd41537a1b 100644
--- a/zebra/zebra_mpls.c
+++ b/zebra/zebra_mpls.c
@@ -918,7 +918,7 @@ static wq_item_status lsp_process(struct work_queue *wq, void *data)
 			UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
 			switch (kernel_add_lsp(lsp)) {
 			case DP_REQUEST_QUEUED:
-				zlog_ferr(
+				flog_err(
 					ZEBRA_ERR_DP_INVALID_RC,
 					"No current DataPlane interfaces can return this, please fix");
 				break;
@@ -935,7 +935,7 @@ static wq_item_status lsp_process(struct work_queue *wq, void *data)
 
 			switch (kernel_del_lsp(lsp)) {
 			case DP_REQUEST_QUEUED:
-				zlog_ferr(
+				flog_err(
 					ZEBRA_ERR_DP_INVALID_RC,
 					"No current DataPlane interfaces can return this, please fix");
 				break;
@@ -975,7 +975,7 @@ static wq_item_status lsp_process(struct work_queue *wq, void *data)
 
 			switch (kernel_upd_lsp(lsp)) {
 			case DP_REQUEST_QUEUED:
-				zlog_ferr(
+				flog_err(
 					ZEBRA_ERR_DP_INVALID_RC,
 					"No current DataPlane interfaces can return this, please fix");
 				break;
@@ -1055,7 +1055,7 @@ static int lsp_processq_add(zebra_lsp_t *lsp)
 		return 0;
 
 	if (zebrad.lsp_process_q == NULL) {
-		zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+		flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
 			  "%s: work_queue does not exist!", __func__);
 		return -1;
 	}
@@ -1698,7 +1698,7 @@ static int mpls_processq_init(struct zebra_t *zebra)
 {
 	zebra->lsp_process_q = work_queue_new(zebra->master, "LSP processing");
 	if (!zebra->lsp_process_q) {
-		zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+		flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
 			  "%s: could not initialise work queue!", __func__);
 		return -1;
 	}
@@ -1834,7 +1834,7 @@ int zebra_mpls_fec_register(struct zebra_vrf *zvrf, struct prefix *p,
 		fec = fec_add(table, p, MPLS_INVALID_LABEL, 0, label_index);
 		if (!fec) {
 			prefix2str(p, buf, BUFSIZ);
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_FEC_ADD_FAILED,
 				"Failed to add FEC %s upon register, client %s",
 				buf, zebra_route_string(client->proto));
@@ -1915,7 +1915,7 @@ int zebra_mpls_fec_unregister(struct zebra_vrf *zvrf, struct prefix *p,
 	fec = fec_find(table, p);
 	if (!fec) {
 		prefix2str(p, buf, BUFSIZ);
-		zlog_ferr(ZEBRA_ERR_FEC_RM_FAILED,
+		flog_err(ZEBRA_ERR_FEC_RM_FAILED,
 			  "Failed to find FEC %s upon unregister, client %s",
 			  buf, zebra_route_string(client->proto));
 		return -1;
@@ -2047,7 +2047,7 @@ int zebra_mpls_static_fec_add(struct zebra_vrf *zvrf, struct prefix *p,
 			      MPLS_INVALID_LABEL_INDEX);
 		if (!fec) {
 			prefix2str(p, buf, BUFSIZ);
-			zlog_ferr(ZEBRA_ERR_FEC_ADD_FAILED,
+			flog_err(ZEBRA_ERR_FEC_ADD_FAILED,
 				  "Failed to add FEC %s upon config", buf);
 			return -1;
 		}
@@ -2095,7 +2095,7 @@ int zebra_mpls_static_fec_del(struct zebra_vrf *zvrf, struct prefix *p)
 	fec = fec_find(table, p);
 	if (!fec) {
 		prefix2str(p, buf, BUFSIZ);
-		zlog_ferr(ZEBRA_ERR_FEC_RM_FAILED,
+		flog_err(ZEBRA_ERR_FEC_RM_FAILED,
 			  "Failed to find FEC %s upon delete", buf);
 		return -1;
 	}
diff --git a/zebra/zebra_mpls_openbsd.c b/zebra/zebra_mpls_openbsd.c
index 91e1d7118d..1591063131 100644
--- a/zebra/zebra_mpls_openbsd.c
+++ b/zebra/zebra_mpls_openbsd.c
@@ -118,13 +118,13 @@ static int kernel_send_rtmsg_v4(int action, mpls_label_t in_label,
 	}
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	ret = writev(kr_state.fd, iov, iovcnt);
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	if (ret == -1)
-		zlog_ferr(LIB_ERR_SOCKET, "%s: %s", __func__,
+		flog_err(LIB_ERR_SOCKET, "%s: %s", __func__,
 			  safe_strerror(errno));
 
 	return ret;
@@ -227,13 +227,13 @@ static int kernel_send_rtmsg_v6(int action, mpls_label_t in_label,
 	}
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	ret = writev(kr_state.fd, iov, iovcnt);
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	if (ret == -1)
-		zlog_ferr(LIB_ERR_SOCKET, "%s: %s", __func__,
+		flog_err(LIB_ERR_SOCKET, "%s: %s", __func__,
 			  safe_strerror(errno));
 
 	return ret;
@@ -401,7 +401,7 @@ static int kmpw_install(struct zebra_pw *pw)
 	strlcpy(ifr.ifr_name, pw->ifname, sizeof(ifr.ifr_name));
 	ifr.ifr_data = (caddr_t)&imr;
 	if (ioctl(kr_state.ioctl_fd, SIOCSETMPWCFG, &ifr) == -1) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
+		flog_err(LIB_ERR_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
 			  safe_strerror(errno));
 		return -1;
 	}
@@ -419,7 +419,7 @@ static int kmpw_uninstall(struct zebra_pw *pw)
 	strlcpy(ifr.ifr_name, pw->ifname, sizeof(ifr.ifr_name));
 	ifr.ifr_data = (caddr_t)&imr;
 	if (ioctl(kr_state.ioctl_fd, SIOCSETMPWCFG, &ifr) == -1) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
+		flog_err(LIB_ERR_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
 			  safe_strerror(errno));
 		return -1;
 	}
diff --git a/zebra/zebra_netns_id.c b/zebra/zebra_netns_id.c
index 698ac2986f..119bff0b7b 100644
--- a/zebra/zebra_netns_id.c
+++ b/zebra/zebra_netns_id.c
@@ -88,7 +88,7 @@ static int send_receive(int sock, struct nlmsghdr *nlh, unsigned int seq,
 	ret = sendto(sock, (const void *)nlh, (size_t)nlh->nlmsg_len, 0,
 		     (struct sockaddr *)&snl, (socklen_t)sizeof(snl));
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET, "netlink( %u) sendmsg() error: %s",
+		flog_err(LIB_ERR_SOCKET, "netlink( %u) sendmsg() error: %s",
 			  sock, safe_strerror(errno));
 		return -1;
 	}
@@ -109,18 +109,18 @@ static int send_receive(int sock, struct nlmsghdr *nlh, unsigned int seq,
 	};
 	ret = recvmsg(sock, &msg, 0);
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "netlink recvmsg: error %d (errno %u)", ret, errno);
 		return -1;
 	}
 	if (msg.msg_flags & MSG_TRUNC) {
-		zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+		flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
 			  "netlink recvmsg : error message truncated");
 		return -1;
 	}
 	/* nlh already points to buf */
 	if (nlh->nlmsg_seq != seq) {
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_NETLINK_BAD_SEQUENCE,
 			"netlink recvmsg: bad sequence number %x (expected %x)",
 			seq, nlh->nlmsg_seq);
@@ -175,7 +175,7 @@ ns_id_t zebra_ns_id_get(const char *netnspath)
 	/* netlink socket */
 	sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
 	if (sock < 0) {
-		zlog_ferr(LIB_ERR_SOCKET, "netlink( %u) socket() error: %s",
+		flog_err(LIB_ERR_SOCKET, "netlink( %u) socket() error: %s",
 			  sock, safe_strerror(errno));
 		close(fd);
 		return NS_UNKNOWN;
@@ -186,7 +186,7 @@ ns_id_t zebra_ns_id_get(const char *netnspath)
 	snl.nl_pid = 0; /* AUTO PID */
 	ret = bind(sock, (struct sockaddr *)&snl, sizeof(snl));
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "netlink( %u) socket() bind error: %s", sock,
 			  safe_strerror(errno));
 		close(sock);
@@ -261,7 +261,7 @@ ns_id_t zebra_ns_id_get(const char *netnspath)
 
 	if (ret <= 0) {
 		if (errno != EEXIST && ret != 0) {
-			zlog_ferr(
+			flog_err(
 				LIB_ERR_SOCKET,
 				"netlink( %u) recvfrom() error 2 when reading: %s",
 				fd, safe_strerror(errno));
diff --git a/zebra/zebra_netns_notify.c b/zebra/zebra_netns_notify.c
index 8195e493f3..2b2da599a8 100644
--- a/zebra/zebra_netns_notify.c
+++ b/zebra/zebra_netns_notify.c
@@ -77,10 +77,10 @@ static void zebra_ns_notify_create_context_from_entry_name(const char *name)
 		return;
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	ns_id = zebra_ns_id_get(netnspath);
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	if (ns_id == NS_UNKNOWN)
 		return;
 	ns_id_external = ns_map_nsid_with_external(ns_id, true);
@@ -98,11 +98,11 @@ static void zebra_ns_notify_create_context_from_entry_name(const char *name)
 		return;
 	}
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	ret = vrf_netns_handler_create(NULL, vrf, netnspath,
 				       ns_id_external, ns_id);
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	if (ret != CMD_SUCCESS) {
 		zlog_warn("NS notify : failed to create NS %s", netnspath);
 		ns_map_nsid_with_external(ns_id, false);
@@ -170,19 +170,19 @@ static int zebra_ns_ready_read(struct thread *t)
 	if (--zns_info->retries == 0)
 		stop_retry = 1;
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	err = ns_switch_to_netns(netnspath);
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	if (err < 0)
 		return zebra_ns_continue_read(zns_info, stop_retry);
 
 	/* go back to default ns */
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	err = ns_switchback_to_initial();
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	if (err < 0)
 		return zebra_ns_continue_read(zns_info, stop_retry);
 
diff --git a/zebra/zebra_ns.c b/zebra/zebra_ns.c
index 8676d3aec8..7bf5ced934 100644
--- a/zebra/zebra_ns.c
+++ b/zebra/zebra_ns.c
@@ -316,10 +316,10 @@ int zebra_ns_init(void)
 	dzns = zebra_ns_alloc();
 
 	if (zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 	ns_id = zebra_ns_id_get_default();
 	if (zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 	ns_id_external = ns_map_nsid_with_external(ns_id, true);
 	ns_init_management(ns_id_external, ns_id);
 
diff --git a/zebra/zebra_ptm.c b/zebra/zebra_ptm.c
index 6e2880ea09..b71234be04 100644
--- a/zebra/zebra_ptm.c
+++ b/zebra/zebra_ptm.c
@@ -504,7 +504,7 @@ static int zebra_ptm_handle_bfd_msg(void *arg, void *in_ctxt,
 			dest_str, src_str);
 
 	if (str2prefix(dest_str, &dest_prefix) == 0) {
-		zlog_ferr(ZEBRA_ERR_PREFIX_PARSE_ERROR,
+		flog_err(ZEBRA_ERR_PREFIX_PARSE_ERROR,
 			  "%s: Peer addr %s not found", __func__, dest_str);
 		return -1;
 	}
@@ -512,7 +512,7 @@ static int zebra_ptm_handle_bfd_msg(void *arg, void *in_ctxt,
 	memset(&src_prefix, 0, sizeof(struct prefix));
 	if (strcmp(ZEBRA_PTM_INVALID_SRC_IP, src_str)) {
 		if (str2prefix(src_str, &src_prefix) == 0) {
-			zlog_ferr(ZEBRA_ERR_PREFIX_PARSE_ERROR,
+			flog_err(ZEBRA_ERR_PREFIX_PARSE_ERROR,
 				  "%s: Local addr %s not found", __func__,
 				  src_str);
 			return -1;
diff --git a/zebra/zebra_rib.c b/zebra/zebra_rib.c
index 993f1baf56..b477cd4706 100644
--- a/zebra/zebra_rib.c
+++ b/zebra/zebra_rib.c
@@ -1126,12 +1126,12 @@ void rib_install_kernel(struct route_node *rn, struct route_entry *re,
 	hook_call(rib_update, rn, "installing in kernel");
 	switch (kernel_route_rib(rn, p, src_p, old, re)) {
 	case DP_REQUEST_QUEUED:
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_DP_INVALID_RC,
 			"No current known DataPlane interfaces can return this, please fix");
 		break;
 	case DP_REQUEST_FAILURE:
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_DP_INSTALL_FAIL,
 			"No current known Rib Install Failure cases, please fix");
 		break;
@@ -1166,12 +1166,12 @@ void rib_uninstall_kernel(struct route_node *rn, struct route_entry *re)
 	hook_call(rib_update, rn, "uninstalling from kernel");
 	switch (kernel_route_rib(rn, p, src_p, re, NULL)) {
 	case DP_REQUEST_QUEUED:
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_DP_INVALID_RC,
 			"No current known DataPlane interfaces can return this, please fix");
 		break;
 	case DP_REQUEST_FAILURE:
-		zlog_ferr(
+		flog_err(
 			ZEBRA_ERR_DP_INSTALL_FAIL,
 			"No current known RIB Install Failure cases, please fix");
 		break;
@@ -1945,7 +1945,7 @@ void rib_queue_add(struct route_node *rn)
 	}
 
 	if (zebrad.ribq == NULL) {
-		zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+		flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
 			  "%s: work_queue does not exist!", __func__);
 		return;
 	}
@@ -2001,7 +2001,7 @@ static void rib_queue_init(struct zebra_t *zebra)
 
 	if (!(zebra->ribq =
 		      work_queue_new(zebra->master, "route_node processing"))) {
-		zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+		flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
 			  "%s: could not initialise work queue!", __func__);
 		return;
 	}
@@ -2015,7 +2015,7 @@ static void rib_queue_init(struct zebra_t *zebra)
 	zebra->ribq->spec.hold = ZEBRA_RIB_PROCESS_HOLD_TIME;
 
 	if (!(zebra->mq = meta_queue_new())) {
-		zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+		flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
 			  "%s: could not initialise meta queue!", __func__);
 		return;
 	}
@@ -2243,7 +2243,7 @@ void rib_lookup_and_dump(struct prefix_ipv4 *p, vrf_id_t vrf_id)
 	/* Lookup table.  */
 	table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id);
 	if (!table) {
-		zlog_ferr(ZEBRA_ERR_TABLE_LOOKUP_FAILED,
+		flog_err(ZEBRA_ERR_TABLE_LOOKUP_FAILED,
 			  "%s:%u zebra_vrf_table() returned NULL", __func__,
 			  vrf_id);
 		return;
@@ -2291,7 +2291,7 @@ void rib_lookup_and_pushup(struct prefix_ipv4 *p, vrf_id_t vrf_id)
 	rib_dest_t *dest;
 
 	if (NULL == (table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id))) {
-		zlog_ferr(ZEBRA_ERR_TABLE_LOOKUP_FAILED,
+		flog_err(ZEBRA_ERR_TABLE_LOOKUP_FAILED,
 			  "%s:%u zebra_vrf_table() returned NULL", __func__,
 			  vrf_id);
 		return;
diff --git a/zebra/zebra_rnh.c b/zebra/zebra_rnh.c
index 6f742e8f13..156600c105 100644
--- a/zebra/zebra_rnh.c
+++ b/zebra/zebra_rnh.c
@@ -858,7 +858,7 @@ static int send_client(struct rnh *rnh, struct zserv *client, rnh_type_t type,
 		stream_put(s, &rn->p.u.prefix6, IPV6_MAX_BYTELEN);
 		break;
 	default:
-		zlog_ferr(ZEBRA_ERR_RNH_UNKNOWN_FAMILY,
+		flog_err(ZEBRA_ERR_RNH_UNKNOWN_FAMILY,
 			  "%s: Unknown family (%d) notification attempted\n",
 			  __FUNCTION__, rn->p.family);
 		break;
diff --git a/zebra/zebra_vxlan.c b/zebra/zebra_vxlan.c
index 8e1d5f9670..d979be4a36 100644
--- a/zebra/zebra_vxlan.c
+++ b/zebra/zebra_vxlan.c
@@ -1802,7 +1802,7 @@ static int zvni_gw_macip_add(struct interface *ifp, zebra_vni_t *zvni,
 	if (!mac) {
 		mac = zvni_mac_add(zvni, macaddr);
 		if (!mac) {
-			zlog_ferr(ZEBRA_ERR_MAC_ADD_FAILED,
+			flog_err(ZEBRA_ERR_MAC_ADD_FAILED,
 				  "Failed to add MAC %s intf %s(%u) VID %u",
 				  prefix_mac2str(macaddr, buf, sizeof(buf)),
 				  ifp->name, ifp->ifindex, vxl->access_vlan);
@@ -1822,7 +1822,7 @@ static int zvni_gw_macip_add(struct interface *ifp, zebra_vni_t *zvni,
 	if (!n) {
 		n = zvni_neigh_add(zvni, ip, macaddr);
 		if (!n) {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_MAC_ADD_FAILED,
 				"Failed to add neighbor %s MAC %s intf %s(%u) -> VNI %u",
 				ipaddr2str(ip, buf2, sizeof(buf2)),
@@ -2086,7 +2086,7 @@ static int zvni_local_neigh_update(zebra_vni_t *zvni,
 		/* New neighbor - create */
 		n = zvni_neigh_add(zvni, ip, macaddr);
 		if (!n) {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_MAC_ADD_FAILED,
 				"Failed to add neighbor %s MAC %s intf %s(%u) -> VNI %u",
 				ipaddr2str(ip, buf2, sizeof(buf2)),
@@ -3903,7 +3903,7 @@ static int zebra_vxlan_handle_vni_transition(struct zebra_vrf *zvrf, vni_t vni,
 
 		/* Delete the hash entry. */
 		if (zvni_del(zvni)) {
-			zlog_ferr(ZEBRA_ERR_VNI_DEL_FAILED,
+			flog_err(ZEBRA_ERR_VNI_DEL_FAILED,
 				  "Failed to del VNI hash %p, VNI %u", zvni,
 				  zvni->vni);
 			return -1;
@@ -5279,7 +5279,7 @@ void zebra_vxlan_remote_macip_add(ZAPI_HANDLER_ARGS)
 		zvtep = zvni_vtep_find(zvni, &vtep_ip);
 		if (!zvtep) {
 			if (zvni_vtep_add(zvni, &vtep_ip) == NULL) {
-				zlog_ferr(
+				flog_err(
 					ZEBRA_ERR_VTEP_ADD_FAILED,
 					"Failed to add remote VTEP, VNI %u zvni %p",
 					vni, zvni);
@@ -5687,7 +5687,7 @@ int zebra_vxlan_local_mac_add_update(struct interface *ifp,
 	if (!mac) {
 		mac = zvni_mac_add(zvni, macaddr);
 		if (!mac) {
-			zlog_ferr(ZEBRA_ERR_MAC_ADD_FAILED,
+			flog_err(ZEBRA_ERR_MAC_ADD_FAILED,
 				  "Failed to add MAC %s intf %s(%u) VID %u",
 				  prefix_mac2str(macaddr, buf, sizeof(buf)),
 				  ifp->name, ifp->ifindex, vid);
@@ -5846,7 +5846,7 @@ void zebra_vxlan_remote_vtep_add(ZAPI_HANDLER_ARGS)
 		/* Locate VNI hash entry - expected to exist. */
 		zvni = zvni_lookup(vni);
 		if (!zvni) {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_VTEP_ADD_FAILED,
 				"Failed to locate VNI hash upon remote VTEP ADD, VNI %u",
 				vni);
@@ -5855,7 +5855,7 @@ void zebra_vxlan_remote_vtep_add(ZAPI_HANDLER_ARGS)
 
 		ifp = zvni->vxlan_if;
 		if (!ifp) {
-			zlog_ferr(
+			flog_err(
 				ZEBRA_ERR_VTEP_ADD_FAILED,
 				"VNI %u hash %p doesn't have intf upon remote VTEP ADD",
 				zvni->vni, zvni);
@@ -5874,7 +5874,7 @@ void zebra_vxlan_remote_vtep_add(ZAPI_HANDLER_ARGS)
 			continue;
 
 		if (zvni_vtep_add(zvni, &vtep_ip) == NULL) {
-			zlog_ferr(ZEBRA_ERR_VTEP_ADD_FAILED,
+			flog_err(ZEBRA_ERR_VTEP_ADD_FAILED,
 				  "Failed to add remote VTEP, VNI %u zvni %p",
 				  vni, zvni);
 			continue;
@@ -6295,7 +6295,7 @@ int zebra_vxlan_if_del(struct interface *ifp)
 
 		/* Delete the hash entry. */
 		if (zvni_del(zvni)) {
-			zlog_ferr(ZEBRA_ERR_VNI_DEL_FAILED,
+			flog_err(ZEBRA_ERR_VNI_DEL_FAILED,
 				  "Failed to del VNI hash %p, IF %s(%u) VNI %u",
 				  zvni, ifp->name, ifp->ifindex, zvni->vni);
 			return -1;
@@ -6511,7 +6511,7 @@ int zebra_vxlan_if_add(struct interface *ifp)
 		if (!zvni) {
 			zvni = zvni_add(vni);
 			if (!zvni) {
-				zlog_ferr(
+				flog_err(
 					ZEBRA_ERR_VNI_ADD_FAILED,
 					"Failed to add VNI hash, IF %s(%u) VNI %u",
 					ifp->name, ifp->ifindex, vni);
diff --git a/zebra/zserv.c b/zebra/zserv.c
index 3b802ba51e..553331867c 100644
--- a/zebra/zserv.c
+++ b/zebra/zserv.c
@@ -793,7 +793,7 @@ void zserv_start(char *path)
 	zserv_privs.change(ZPRIVS_LOWER);
 
 	if (sa.ss_family != AF_UNIX && zserv_privs.change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
 
 	ret = bind(zebrad.sock, (struct sockaddr *)&sa, sa_len);
 	if (ret < 0) {
@@ -806,7 +806,7 @@ void zserv_start(char *path)
 		return;
 	}
 	if (sa.ss_family != AF_UNIX && zserv_privs.change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+		flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
 
 	ret = listen(zebrad.sock, 5);
 	if (ret < 0) {