net: rmnet_data: Enhance logging macros to remove duplicated code

Logging macros now enforce that function names are printed, and
newlines are inserted at the end. The start of log messages are
now standardize.

CRs-Fixed: 600629
Change-Id: I91dae00c331af80954b93eba1f7be2889c569276
Signed-off-by: Harout Hedeshian <harouth@codeaurora.org>

7 files changed, 129 insertions, 150 deletions

diff --git a/net/rmnet_data/rmnet_data_config.c b/net/rmnet_data/rmnet_data_config.c
index 5a92893f67b3..2eca68b4b665 100644
--- a/net/rmnet_data/rmnet_data_config.c
+++ b/net/rmnet_data/rmnet_data_config.c
@@ -77,13 +77,13 @@ int rmnet_config_init(void)
 	int rc;
 	nl_socket_handle = _rmnet_config_start_netlink();
 	if (!nl_socket_handle) {
-		LOGE("%s(): Failed to init netlink socket\n", __func__);
+		LOGE("%s", "Failed to init netlink socket");
 		return RMNET_INIT_ERROR;
 	}
 
 	rc = register_netdevice_notifier(&rmnet_dev_notifier);
 	if (rc != 0) {
-		LOGE("%s(): Failed to register device notifier\n", __func__);
+		LOGE("Failed to register device notifier; rc=%d", rc);
 		/* TODO: Cleanup the nl socket */
 		return RMNET_INIT_ERROR;
 	}
@@ -438,8 +438,7 @@ static void _rmnet_netlink_add_del_vnd_tc_flow
 								tc_flow_id);
 		break;
 	default:
-		LOGM("%s(): called with unhandled command %d\n",
-		     __func__, command);
+		LOGM("Called with unhandled command %d", command);
 		resp_rmnet->return_code = RMNET_CONFIG_INVALID_REQUEST;
 		break;
 	}
@@ -463,8 +462,7 @@ void rmnet_config_netlink_msg_handler(struct sk_buff *skb)
 	nlmsg_header = (struct nlmsghdr *) skb->data;
 	rmnet_header = (struct rmnet_nl_msg_s *) nlmsg_data(nlmsg_header);
 
-	LOGL("%s(): Netlink message pid=%d, seq=%d, length=%d, rmnet_type=%d\n",
-		__func__,
+	LOGL("Netlink message pid=%d, seq=%d, length=%d, rmnet_type=%d",
 		nlmsg_header->nlmsg_pid,
 		nlmsg_header->nlmsg_seq,
 		nlmsg_header->nlmsg_len,
@@ -477,7 +475,7 @@ void rmnet_config_netlink_msg_handler(struct sk_buff *skb)
 				 GFP_KERNEL);
 
 	if (!skb_response) {
-		LOGH("%s(): Failed to allocate response buffer\n", __func__);
+		LOGH("%s", "Failed to allocate response buffer");
 		return;
 	}
 
@@ -576,7 +574,7 @@ void rmnet_config_netlink_msg_handler(struct sk_buff *skb)
 	}
 	rtnl_unlock();
 	nlmsg_unicast(nl_socket_handle, skb_response, return_pid);
-	LOGD("%s(): Done processing command\n", __func__);
+	LOGD("%s", "Done processing command");
 
 }
 
@@ -603,7 +601,7 @@ int rmnet_unassociate_network_device(struct net_device *dev)
 	struct rmnet_logical_ep_conf_s *epconfig_l;
 	ASSERT_RTNL();
 
-	LOGL("%s(%s);", __func__, dev->name);
+	LOGL("(%s);", dev->name);
 
 	if (!dev)
 		return RMNET_CONFIG_NO_SUCH_DEVICE;
@@ -651,7 +649,7 @@ int rmnet_set_ingress_data_format(struct net_device *dev,
 	struct rmnet_phys_ep_conf_s *config;
 	ASSERT_RTNL();
 
-	LOGL("%s(%s,0x%08X);", __func__, dev->name, ingress_data_format);
+	LOGL("(%s,0x%08X);", dev->name, ingress_data_format);
 
 	if (!dev)
 		return RMNET_CONFIG_NO_SUCH_DEVICE;
@@ -688,8 +686,8 @@ int rmnet_set_egress_data_format(struct net_device *dev,
 	struct rmnet_phys_ep_conf_s *config;
 	ASSERT_RTNL();
 
-	LOGL("%s(%s,0x%08X, %d, %d);",
-	     __func__, dev->name, egress_data_format, agg_size, agg_count);
+	LOGL("(%s,0x%08X, %d, %d);",
+	     dev->name, egress_data_format, agg_size, agg_count);
 
 	if (!dev)
 		return RMNET_CONFIG_NO_SUCH_DEVICE;
@@ -726,18 +724,18 @@ int rmnet_associate_network_device(struct net_device *dev)
 	int rc;
 	ASSERT_RTNL();
 
-	LOGL("%s(%s);\n", __func__, dev->name);
+	LOGL("(%s);\n", dev->name);
 
 	if (!dev)
 		return RMNET_CONFIG_NO_SUCH_DEVICE;
 
 	if (_rmnet_is_physical_endpoint_associated(dev)) {
-		LOGM("%s(): %s is already regestered\n", __func__, dev->name);
+		LOGM("%s is already regestered", dev->name);
 		return RMNET_CONFIG_DEVICE_IN_USE;
 	}
 
 	if (rmnet_vnd_is_vnd(dev)) {
-		LOGM("%s(): %s is a vnd\n", __func__, dev->name);
+		LOGM("%s is a vnd", dev->name);
 		return RMNET_CONFIG_INVALID_REQUEST;
 	}
 
@@ -754,8 +752,7 @@ int rmnet_associate_network_device(struct net_device *dev)
 	rc = netdev_rx_handler_register(dev, rmnet_rx_handler, config);
 
 	if (rc) {
-		LOGM("%s(): netdev_rx_handler_register returns %d\n",
-		     __func__, rc);
+		LOGM("netdev_rx_handler_register returns %d", rc);
 		kfree(config);
 		return RMNET_CONFIG_DEVICE_IN_USE;
 	}
@@ -851,7 +848,7 @@ int _rmnet_unset_logical_endpoint_config(struct net_device *dev,
 }
 
 /**
- * rmnet_set_logical_endpoint_config() - Set logical endpoing configuration on a device
+ * rmnet_set_logical_endpoint_config() - Set logical endpoint config on a device
  * @dev:            Device to set endpoint configuration on
  * @config_id:      logical endpoint id on device
  * @rmnet_mode:     endpoint mode. Values from: rmnet_config_endpoint_modes_e
@@ -879,8 +876,8 @@ int rmnet_set_logical_endpoint_config(struct net_device *dev,
 {
 	struct rmnet_logical_ep_conf_s epconfig;
 
-	LOGL("%s(%s, %d, %d, %s);\n",
-	      __func__, dev->name, config_id, rmnet_mode, egress_dev->name);
+	LOGL("(%s, %d, %d, %s);",
+		dev->name, config_id, rmnet_mode, egress_dev->name);
 
 	if (!egress_dev
 	    || ((!_rmnet_is_physical_endpoint_associated(egress_dev))
@@ -914,8 +911,7 @@ int rmnet_set_logical_endpoint_config(struct net_device *dev,
 int rmnet_unset_logical_endpoint_config(struct net_device *dev,
 					int config_id)
 {
-	LOGL("%s(%s, %d);\n",
-	      __func__, dev->name, config_id);
+	LOGL("(%s, %d);", dev->name, config_id);
 
 	if (!dev
 	    || ((!_rmnet_is_physical_endpoint_associated(dev))
@@ -937,7 +933,7 @@ int rmnet_create_vnd(int id)
 {
 	struct net_device *dev;
 	ASSERT_RTNL();
-	LOGL("%s(%d);\n", __func__, id);
+	LOGL("(%d);", id);
 	return rmnet_vnd_create_dev(id, &dev, NULL);
 }
 
@@ -953,7 +949,7 @@ int rmnet_create_vnd_prefix(int id, const char *prefix)
 {
 	struct net_device *dev;
 	ASSERT_RTNL();
-	LOGL("%s(%d, \"%s\");\n", __func__, id, prefix);
+	LOGL("(%d, \"%s\");", id, prefix);
 	return rmnet_vnd_create_dev(id, &dev, prefix);
 }
 
@@ -966,7 +962,7 @@ int rmnet_create_vnd_prefix(int id, const char *prefix)
  */
 int rmnet_free_vnd(int id)
 {
-	LOGL("%s(%d);\n", __func__, id);
+	LOGL("(%d);", id);
 	return rmnet_vnd_free_dev(id);
 }
 
@@ -985,8 +981,7 @@ static void rmnet_force_unassociate_device(struct net_device *dev)
 		BUG();
 
 	if (!_rmnet_is_physical_endpoint_associated(dev)) {
-		LOGM("%s(): Called on unassociated device, skipping\n",
-		     __func__);
+		LOGM("%s", "Called on unassociated device, skipping");
 		return;
 	}
 
@@ -1013,20 +1008,19 @@ int rmnet_config_notify_cb(struct notifier_block *nb,
 	if (!dev)
 		BUG();
 
-	LOGL("%s(..., %lu, %s)\n", __func__, event, dev->name);
+	LOGL("(..., %lu, %s)", event, dev->name);
 
 	switch (event) {
 	case NETDEV_UNREGISTER_FINAL:
 	case NETDEV_UNREGISTER:
 		if (_rmnet_is_physical_endpoint_associated(dev)) {
-			LOGH("%s(): Kernel is trying to unregister %s\n",
-			     __func__, dev->name);
+			LOGH("Kernel is trying to unregister %s", dev->name);
 			rmnet_force_unassociate_device(dev);
 		}
 		break;
 
 	default:
-		LOGD("%s(): Unhandeled event\n", __func__);
+		LOGD("Unhandeled event [%lu]", event);
 		break;
 	}
 
diff --git a/net/rmnet_data/rmnet_data_handlers.c b/net/rmnet_data/rmnet_data_handlers.c
index 68cfac20e80c..e5912d6da3ca 100644
--- a/net/rmnet_data/rmnet_data_handlers.c
+++ b/net/rmnet_data/rmnet_data_handlers.c
@@ -147,8 +147,8 @@ static rx_handler_result_t rmnet_bridge_handler(struct sk_buff *skb,
 					struct rmnet_logical_ep_conf_s *ep)
 {
 	if (!ep->egress_dev) {
-		LOGD("%s(): Missing egress device for packet arriving on %s",
-		      __func__, skb->dev->name);
+		LOGD("Missing egress device for packet arriving on %s",
+		     skb->dev->name);
 		kfree_skb(skb);
 	} else {
 		rmnet_egress_handler(skb, ep);
@@ -192,8 +192,7 @@ static rx_handler_result_t __rmnet_deliver_skb(struct sk_buff *skb,
 		return RX_HANDLER_PASS;
 
 	default:
-		LOGD("%s() unkown ep mode %d", __func__,
-			ep->rmnet_mode);
+		LOGD("Unkown ep mode %d", ep->rmnet_mode);
 		kfree_skb(skb);
 		return RX_HANDLER_CONSUMED;
 	}
@@ -212,16 +211,15 @@ static rx_handler_result_t __rmnet_deliver_skb(struct sk_buff *skb,
 static rx_handler_result_t rmnet_ingress_deliver_packet(struct sk_buff *skb,
 					    struct rmnet_phys_ep_conf_s *config)
 {
-	if (0 == config) {
-		LOGD("%s(): NULL physical EP provided\n",
-			__func__);
+	if (!config) {
+		LOGD("%s", "NULL physical EP provided");
 		kfree_skb(skb);
 		return RX_HANDLER_CONSUMED;
 	}
 
 	if (!(config->local_ep.refcount)) {
-		LOGD("%s(): Packet on %s has no local endpoint configuration\n",
-			__func__, skb->dev->name);
+		LOGD("Packet on %s has no local endpoint configuration",
+			skb->dev->name);
 		kfree_skb(skb);
 		return RX_HANDLER_CONSUMED;
 	}
@@ -258,8 +256,8 @@ static rx_handler_result_t _rmnet_map_ingress_handler(struct sk_buff *skb,
 			- config->tail_spacing;
 
 	if (mux_id >= RMNET_DATA_MAX_LOGICAL_EP) {
-		LOGD("%s(): Got packet on %s with bad mux id %d\n",
-		     __func__, skb->dev->name, mux_id);
+		LOGD("Got packet on %s with bad mux id %d",
+			skb->dev->name, mux_id);
 		kfree_skb(skb);
 			return RX_HANDLER_CONSUMED;
 	}
@@ -267,8 +265,8 @@ static rx_handler_result_t _rmnet_map_ingress_handler(struct sk_buff *skb,
 	ep = &(config->muxed_ep[mux_id]);
 
 	if (!ep->refcount) {
-		LOGD("%s(): Packet on %s:%d; has no logical endpoint config\n",
-		     __func__, skb->dev->name, mux_id);
+		LOGD("Packet on %s:%d; has no logical endpoint config",
+		     skb->dev->name, mux_id);
 
 		kfree_skb(skb);
 			return RX_HANDLER_CONSUMED;
@@ -307,7 +305,7 @@ static rx_handler_result_t rmnet_map_ingress_handler(struct sk_buff *skb,
 
 	if (config->ingress_data_format & RMNET_INGRESS_FORMAT_DEAGGREGATION) {
 		while ((skbn = rmnet_map_deaggregate(skb, config)) != 0) {
-			LOGD("co=%d\n", co);
+			LOGD("co=%d", co);
 			_rmnet_map_ingress_handler(skbn, config);
 			co++;
 		}
@@ -346,12 +344,12 @@ static int rmnet_map_egress_handler(struct sk_buff *skb,
 
 	required_headroom = sizeof(struct rmnet_map_header_s);
 
-	LOGD("%s(): headroom of %d bytes\n", __func__, required_headroom);
+	LOGD("headroom of %d bytes", required_headroom);
 
 	if (skb_headroom(skb) < required_headroom) {
 		if (pskb_expand_head(skb, required_headroom, 0, GFP_KERNEL)) {
-			LOGD("%s(): Failed to add headroom of %d bytes\n",
-			     __func__, required_headroom);
+			LOGD("Failed to add headroom of %d bytes",
+			     required_headroom);
 			return 1;
 		}
 	}
@@ -359,8 +357,7 @@ static int rmnet_map_egress_handler(struct sk_buff *skb,
 	map_header = rmnet_map_add_map_header(skb, additional_header_length);
 
 	if (!map_header) {
-		LOGD("%s(): Failed to add MAP header to egress packet",
-		     __func__);
+		LOGD("%s", "Failed to add MAP header to egress packet");
 		return 1;
 	}
 
@@ -411,8 +408,7 @@ rx_handler_result_t rmnet_ingress_handler(struct sk_buff *skb)
 		rcu_dereference(skb->dev->rx_handler_data);
 
 	if (!config) {
-		LOGD("%s(): %s is not associated with rmnet_data",
-		      __func__, skb->dev->name);
+		LOGD("%s is not associated with rmnet_data", skb->dev->name);
 		kfree_skb(skb);
 		return RX_HANDLER_CONSUMED;
 	}
@@ -433,8 +429,7 @@ rx_handler_result_t rmnet_ingress_handler(struct sk_buff *skb)
 			    & RMNET_INGRESS_FORMAT_MAP_COMMANDS) {
 				rc = rmnet_map_command(skb, config);
 			} else {
-				LOGM("%s(): MAP command packet on %s; %s\n",
-				     __func__, dev->name,
+				LOGM("MAP command packet on %s; %s", dev->name,
 				     "Not configured for MAP commands");
 				kfree_skb(skb);
 				return RX_HANDLER_CONSUMED;
@@ -449,8 +444,8 @@ rx_handler_result_t rmnet_ingress_handler(struct sk_buff *skb)
 				RMNET_EPMODE_BRIDGE) {
 				rc = rmnet_ingress_deliver_packet(skb, config);
 			} else {
-				LOGD("%s(): MAP packet on %s; MAP not set\n",
-				     __func__, dev->name);
+				LOGD("MAP packet on %s; MAP not set",
+					dev->name);
 				kfree_skb(skb);
 				rc = RX_HANDLER_CONSUMED;
 			}
@@ -463,8 +458,8 @@ rx_handler_result_t rmnet_ingress_handler(struct sk_buff *skb)
 			break;
 
 		default:
-			LOGD("%s(): Unknown skb->proto 0x%04X\n",
-				__func__, ntohs(skb->protocol) & 0xFFFF);
+			LOGD("Unknown skb->proto 0x%04X\n",
+				ntohs(skb->protocol) & 0xFFFF);
 			rc = RX_HANDLER_PASS;
 		}
 	}
@@ -509,27 +504,26 @@ void rmnet_egress_handler(struct sk_buff *skb,
 		rcu_dereference(skb->dev->rx_handler_data);
 
 	if (!config) {
-		LOGD("%s(): %s is not associated with rmnet_data",
-		      __func__, skb->dev->name);
+		LOGD("%s is not associated with rmnet_data", skb->dev->name);
 		kfree_skb(skb);
 		return;
 	}
 
-	LOGD("%s(): Packet going out on %s with egress format 0x%08X\n",
-	      __func__, skb->dev->name, config->egress_data_format);
+	LOGD("Packet going out on %s with egress format 0x%08X",
+	     skb->dev->name, config->egress_data_format);
 
 	if (config->egress_data_format & RMNET_EGRESS_FORMAT_MAP) {
 		switch (rmnet_map_egress_handler(skb, config, ep)) {
 		case RMNET_MAP_CONSUMED:
-			LOGD("%s(): MAP process consumed packet\n", __func__);
+			LOGD("%s", "MAP process consumed packet");
 			return;
 
 		case RMNET_MAP_SUCCESS:
 			break;
 
 		default:
-			LOGD("%s(): MAP egress failed on packet on %s",
-			      __func__, skb->dev->name);
+			LOGD("MAP egress failed on packet on %s",
+			     skb->dev->name);
 			kfree_skb(skb);
 			return;
 		}
@@ -540,7 +534,7 @@ void rmnet_egress_handler(struct sk_buff *skb,
 
 	rmnet_print_packet(skb, skb->dev->name, 't');
 	if (dev_queue_xmit(skb) != 0) {
-		LOGD("%s(): Failed to queue packet for transmission on [%s]\n",
-		      __func__, skb->dev->name);
+		LOGD("Failed to queue packet for transmission on [%s]",
+		      skb->dev->name);
 	}
 }
diff --git a/net/rmnet_data/rmnet_data_main.c b/net/rmnet_data/rmnet_data_main.c
index 0f58ba2545f4..d17211434b39 100644
--- a/net/rmnet_data/rmnet_data_main.c
+++ b/net/rmnet_data/rmnet_data_main.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
@@ -43,7 +43,7 @@ static int __init rmnet_init(void)
 	rmnet_config_init();
 	rmnet_vnd_init();
 
-	LOGL("%s", "RMNET Data driver loaded successfully\n");
+	LOGL("%s", "RMNET Data driver loaded successfully");
 	return 0;
 }
 
diff --git a/net/rmnet_data/rmnet_data_private.h b/net/rmnet_data/rmnet_data_private.h
index cb7b80578b99..7ddcad613208 100644
--- a/net/rmnet_data/rmnet_data_private.h
+++ b/net/rmnet_data/rmnet_data_private.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
@@ -43,20 +43,24 @@ extern unsigned int rmnet_data_log_module_mask;
 #define RMNET_DATA_LOGMASK_MAPC    (1<<4)
 
 #define LOGE(fmt, ...) do { if (rmnet_data_log_level & RMNET_LOG_LVL_ERR) \
-			pr_err(fmt, ##__VA_ARGS__); \
+			pr_err("[RMNET:ERR] %s(): " fmt "\n", __func__, \
+				##__VA_ARGS__); \
 			} while (0)
 
 #define LOGH(fmt, ...) do { if (rmnet_data_log_level & RMNET_LOG_LVL_HI) \
-			pr_err(fmt, ##__VA_ARGS__); \
+			pr_err("[RMNET:HI] %s(): " fmt "\n" , __func__, \
+				##__VA_ARGS__); \
 			} while (0)
 
 #define LOGM(fmt, ...) do { if (rmnet_data_log_level & RMNET_LOG_LVL_MED) \
-			pr_warn(fmt, ##__VA_ARGS__); \
+			pr_warn("[RMNET:MED] %s(): " fmt "\n", __func__, \
+				##__VA_ARGS__); \
 			} while (0)
 
 #define LOGL(fmt, ...) do { if (unlikely \
 			(rmnet_data_log_level & RMNET_LOG_LVL_LOW)) \
-			pr_notice(fmt, ##__VA_ARGS__); \
+			pr_notice("[RMNET:LOW] %s(): " fmt "\n", __func__, \
+				##__VA_ARGS__); \
 			} while (0)
 
 /* Don't use pr_debug as it is compiled out of the kernel. We can be sure of
@@ -65,7 +69,8 @@ extern unsigned int rmnet_data_log_module_mask;
 #define LOGD(fmt, ...) do { if (unlikely( \
 			    (rmnet_data_log_level & RMNET_LOG_LVL_DBG) \
 			    && (rmnet_data_log_module_mask & rmnet_mod_mask))) \
-			pr_notice(fmt, ##__VA_ARGS__); \
+			pr_notice("[RMNET:DBG] %s(): " fmt "\n", __func__, \
+				  ##__VA_ARGS__); \
 			} while (0)
 
 #endif /* _RMNET_DATA_PRIVATE_H_ */
diff --git a/net/rmnet_data/rmnet_data_vnd.c b/net/rmnet_data/rmnet_data_vnd.c
index 3fd583fedf12..76e111c17919 100644
--- a/net/rmnet_data/rmnet_data_vnd.c
+++ b/net/rmnet_data/rmnet_data_vnd.c
@@ -217,39 +217,32 @@ static int _rmnet_vnd_do_qos_ioctl(struct net_device *dev,
 	switch (cmd) {
 
 	case RMNET_IOCTL_SET_QOS_ENABLE:
-		LOGM("%s(): RMNET_IOCTL_SET_QOS_ENABLE on %s\n",
-		     __func__, dev->name);
+		LOGM("RMNET_IOCTL_SET_QOS_ENABLE on %s", dev->name);
 		if (!dev_conf->qos_version)
 			dev_conf->qos_version = RMNET_IOCTL_QOS_MODE_6;
 		break;
 
 	case RMNET_IOCTL_SET_QOS_DISABLE:
-		LOGM("%s(): RMNET_IOCTL_SET_QOS_DISABLE on %s\n",
-		     __func__, dev->name);
+		LOGM("RMNET_IOCTL_SET_QOS_DISABLE on %s", dev->name);
 		dev_conf->qos_version = 0;
 		break;
 
 	case RMNET_IOCTL_GET_QOS:           /* Get QoS header state    */
-		LOGM("%s(): RMNET_IOCTL_GET_QOS on %s\n",
-		     __func__, dev->name);
+		LOGM("RMNET_IOCTL_GET_QOS on %s", dev->name);
 		ifr->ifr_ifru.ifru_data =
 		      (void *)(dev_conf->qos_version == RMNET_IOCTL_QOS_MODE_6);
 		break;
 
 	case RMNET_IOCTL_FLOW_ENABLE:
-		LOGL("%s(): RMNET_IOCTL_FLOW_ENABLE on %s\n",
-		     __func__, dev->name);
+		LOGL("RMNET_IOCTL_FLOW_ENABLE on %s", dev->name);
 		tc_qdisc_flow_control(dev, (u32)ifr->ifr_data, 1);
 		break;
 
 	case RMNET_IOCTL_FLOW_DISABLE:
-		LOGL("%s(): RMNET_IOCTL_FLOW_DISABLE on %s\n",
-		     __func__, dev->name);
+		LOGL("RMNET_IOCTL_FLOW_DISABLE on %s", dev->name);
 		tc_qdisc_flow_control(dev, (u32)ifr->ifr_data, 0);
 		break;
 
-
-
 	default:
 		rc = -EINVAL;
 	}
@@ -273,8 +266,8 @@ static void _rmnet_vnd_wq_flow_control(struct work_struct *work)
 	tc_qdisc_flow_control(fcwork->dev, fcwork->tc_handle, fcwork->enable);
 	rtnl_unlock();
 
-	LOGL("%s(): [%s] handle:%08X enable:%d\n",
-	     __func__, fcwork->dev->name, fcwork->tc_handle, fcwork->enable);
+	LOGL("[%s] handle:%08X enable:%d",
+	     fcwork->dev->name, fcwork->tc_handle, fcwork->enable);
 
 	kfree(work);
 }
@@ -311,7 +304,7 @@ static inline int _rmnet_vnd_do_flow_control(struct net_device *dev,
 					     uint32_t tc_handle,
 					     int enable)
 {
-	LOGD("%s(): [%s] called with no QoS support", __func__, dev->name);
+	LOGD("[%s] called with no QoS support", dev->name);
 	return RMNET_VND_FC_NOT_ENABLED;
 }
 #endif /* CONFIG_RMNET_DATA_FC */
@@ -404,29 +397,25 @@ static int rmnet_vnd_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 	switch (cmd) {
 
 	case RMNET_IOCTL_OPEN: /* Do nothing. Support legacy behavior */
-		LOGM("%s(): RMNET_IOCTL_OPEN on %s (ignored)\n",
-		     __func__, dev->name);
+		LOGM("RMNET_IOCTL_OPEN on %s (ignored)", dev->name);
 		break;
 
 	case RMNET_IOCTL_CLOSE: /* Do nothing. Support legacy behavior */
-		LOGM("%s(): RMNET_IOCTL_CLOSE on %s (ignored)\n",
-		     __func__, dev->name);
+		LOGM("RMNET_IOCTL_CLOSE on %s (ignored)", dev->name);
 		break;
 
 	case RMNET_IOCTL_SET_LLP_ETHERNET:
-		LOGM("%s(): RMNET_IOCTL_SET_LLP_ETHERNET on %s (no support)\n",
-		     __func__, dev->name);
+		LOGM("RMNET_IOCTL_SET_LLP_ETHERNET on %s (no support)",
+		     dev->name);
 		rc = -EINVAL;
 		break;
 
 	case RMNET_IOCTL_SET_LLP_IP: /* Do nothing. Support legacy behavior */
-		LOGM("%s(): RMNET_IOCTL_SET_LLP_IP on %s  (ignored)\n",
-		     __func__, dev->name);
+		LOGM("RMNET_IOCTL_SET_LLP_IP on %s (ignored)", dev->name);
 		break;
 
 	case RMNET_IOCTL_GET_LLP: /* Always return IP mode */
-		LOGM("%s(): RMNET_IOCTL_GET_LLP on %s\n",
-		     __func__, dev->name);
+		LOGM("RMNET_IOCTL_GET_LLP on %s", dev->name);
 		ifr->ifr_ifru.ifru_data = (void *)(RMNET_MODE_LLP_IP);
 		break;
 
@@ -435,7 +424,7 @@ static int rmnet_vnd_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 		break;
 
 	default:
-		LOGH("%s(): Unkown IOCTL 0x%08X\n", __func__, cmd);
+		LOGH("Unkown IOCTL 0x%08X", cmd);
 		rc = -EINVAL;
 	}
 
@@ -463,7 +452,7 @@ static const struct net_device_ops rmnet_data_vnd_ops = {
 static void rmnet_vnd_setup(struct net_device *dev)
 {
 	struct rmnet_vnd_private_s *dev_conf;
-	LOGM("%s(): Setting up device %s\n", __func__, dev->name);
+	LOGM("Setting up device %s", dev->name);
 
 	/* Clear out private data */
 	dev_conf = (struct rmnet_vnd_private_s *) netdev_priv(dev);
@@ -555,7 +544,7 @@ int rmnet_vnd_create_dev(int id, struct net_device **new_device,
 		p = scnprintf(dev_prefix, IFNAMSIZ, "%s%%d",
 			  prefix);
 	if (p >= (IFNAMSIZ-1)) {
-		LOGE("%s(): Specified prefix longer than IFNAMSIZ", __func__);
+		LOGE("Specified prefix (%d) longer than IFNAMSIZ", p);
 		return -EINVAL;
 	}
 
@@ -563,16 +552,14 @@ int rmnet_vnd_create_dev(int id, struct net_device **new_device,
 			   dev_prefix,
 			   rmnet_vnd_setup);
 	if (!dev) {
-		LOGE("%s(): Failed to to allocate netdev for id %d",
-		      __func__, id);
+		LOGE("Failed to to allocate netdev for id %d", id);
 		*new_device = 0;
 		return -EINVAL;
 	}
 
 	rc = register_netdevice(dev);
 	if (rc != 0) {
-		LOGE("%s(): Failed to to register netdev [%s]",
-		      __func__, dev->name);
+		LOGE("Failed to to register netdev [%s]", dev->name);
 		free_netdev(dev);
 		*new_device = 0;
 	} else {
@@ -580,7 +567,7 @@ int rmnet_vnd_create_dev(int id, struct net_device **new_device,
 		*new_device = dev;
 	}
 
-	LOGM("%s(): Registered device %s\n", __func__, dev->name);
+	LOGM("Registered device %s", dev->name);
 	return rc;
 }
 
@@ -605,7 +592,7 @@ int rmnet_vnd_free_dev(int id)
 	struct rmnet_logical_ep_conf_s *epconfig_l;
 
 	if ((id < 0) || (id >= RMNET_DATA_MAX_VND) || !rmnet_devices[id]) {
-		LOGM("%s(): Invalid id [%d]\n", __func__, id);
+		LOGM("Invalid id [%d]", id);
 		return RMNET_CONFIG_NO_SUCH_DEVICE;
 	}
 
@@ -641,21 +628,21 @@ int rmnet_vnd_get_name(int id, char *name, int name_len)
 	int p;
 
 	if (!name) {
-		LOGM("%s(): Bad arguments; name buffer null", __func__);
+		LOGM("%s", "Bad arguments; name buffer null");
 		return -EINVAL;
 	}
 
 	if ((id < 0) || (id >= RMNET_DATA_MAX_VND) || !rmnet_devices[id]) {
-		LOGM("%s(): Invalid id [%d]", __func__, id);
+		LOGM("Invalid id [%d]", id);
 		return -EINVAL;
 	}
 
 	p = strlcpy(name, rmnet_devices[id]->name, name_len);
 	if (p >= name_len) {
-		LOGM("%s(): Buffer to small to fit device name", __func__);
+		LOGM("Buffer to small (%d) to fit device name", name_len);
 		return -EINVAL;
 	}
-	LOGL("%s(): Found mapping [%d]->\"%s\"", __func__, id, name);
+	LOGL("Found mapping [%d]->\"%s\"", id, name);
 
 	return 0;
 }
@@ -779,8 +766,8 @@ static int _rmnet_vnd_update_flow_map(uint8_t action,
 				itm->tc_flow_valid[i] = 1;
 				itm->tc_flow_id[i] = tc_flow;
 				rc = RMNET_VND_UPDATE_FLOW_OK;
-				LOGD("%s(): {%p}->tc_flow_id[%d] = %08X\n",
-				     __func__, itm, i, tc_flow);
+				LOGD("{%p}->tc_flow_id[%d]=%08X",
+				     itm, i, tc_flow);
 				break;
 			}
 		}
@@ -795,8 +782,7 @@ static int _rmnet_vnd_update_flow_map(uint8_t action,
 					itm->tc_flow_valid[i] = 0;
 					itm->tc_flow_id[i] = 0;
 					j++;
-					LOGD("%s(): {%p}->tc_flow_id[%d] = 0\n",
-					     __func__, itm, i);
+					LOGD("{%p}->tc_flow_id[%d]=0", itm, i);
 				}
 			} else {
 				j++;
@@ -837,7 +823,7 @@ int rmnet_vnd_add_tc_flow(uint32_t id, uint32_t map_flow, uint32_t tc_flow)
 	unsigned long flags;
 
 	if ((id < 0) || (id >= RMNET_DATA_MAX_VND) || !rmnet_devices[id]) {
-		LOGM("%s(): Invalid id [%d]\n", __func__, id);
+		LOGM("Invalid VND id [%d]", id);
 		return RMNET_CONFIG_NO_SUCH_DEVICE;
 	}
 
@@ -866,7 +852,7 @@ int rmnet_vnd_add_tc_flow(uint32_t id, uint32_t map_flow, uint32_t tc_flow)
 		kmalloc(sizeof(struct rmnet_map_flow_mapping_s), GFP_KERNEL);
 
 	if (!itm) {
-		LOGM("%s(): failure allocating flow mapping\n", __func__);
+		LOGM("%s", "Failure allocating flow mapping");
 		return RMNET_CONFIG_NOMEM;
 	}
 	memset(itm, 0, sizeof(struct rmnet_map_flow_mapping_s));
@@ -885,8 +871,8 @@ int rmnet_vnd_add_tc_flow(uint32_t id, uint32_t map_flow, uint32_t tc_flow)
 	list_add(&(itm->list), &(dev_conf->flow_head));
 	write_unlock_irqrestore(&dev_conf->flow_map_lock, flags);
 
-	LOGD("%s(): Created flow mapping [%s][0x%08X][0x%08X]@%p\n", __func__,
-		     dev->name, itm->map_flow_id, itm->tc_flow_id[0], itm);
+	LOGD("Created flow mapping [%s][0x%08X][0x%08X]@%p",
+	     dev->name, itm->map_flow_id, itm->tc_flow_id[0], itm);
 
 	return RMNET_CONFIG_OK;
 }
@@ -916,7 +902,7 @@ int rmnet_vnd_del_tc_flow(uint32_t id, uint32_t map_flow, uint32_t tc_flow)
 	int rc = RMNET_CONFIG_OK;
 
 	if ((id < 0) || (id >= RMNET_DATA_MAX_VND) || !rmnet_devices[id]) {
-		LOGM("%s(): Invalid id [%d]\n", __func__, id);
+		LOGM("Invalid VND id [%d]", id);
 		return RMNET_CONFIG_NO_SUCH_DEVICE;
 	}
 
@@ -941,8 +927,8 @@ int rmnet_vnd_del_tc_flow(uint32_t id, uint32_t map_flow, uint32_t tc_flow)
 
 	if (r ==  RMNET_VND_UPDATE_FLOW_NO_VALID_LEFT) {
 		if (itm)
-			LOGD("%s(): Removed flow mapping [%s][0x%08X]@%p\n",
-			__func__, dev->name, itm->map_flow_id, itm);
+			LOGD("Removed flow mapping [%s][0x%08X]@%p",
+			     dev->name, itm->map_flow_id, itm);
 		kfree(itm);
 	}
 
@@ -990,16 +976,16 @@ int rmnet_vnd_do_flow_control(struct net_device *dev,
 	itm = _rmnet_vnd_get_flow_map(dev_conf, map_flow_id);
 
 	if (!itm) {
-		LOGL("%s(): Got flow control request for unknown flow %08X\n",
-		     __func__, map_flow_id);
+		LOGL("Got flow control request for unknown flow %08X",
+		     map_flow_id);
 		goto fcdone;
 	}
 	if (v4_seq == 0 || v4_seq >= atomic_read(&(itm->v4_seq))) {
 		atomic_set(&(itm->v4_seq), v4_seq);
 		for (i = 0; i < RMNET_MAP_FLOW_NUM_TC_HANDLE; i++) {
 			if (itm->tc_flow_valid[i] == 1) {
-				LOGD("%s(): Found [%s][0x%08X][%d:0x%08X]\n",
-				     __func__, dev->name, itm->map_flow_id, i,
+				LOGD("Found [%s][0x%08X][%d:0x%08X]",
+				     dev->name, itm->map_flow_id, i,
 				     itm->tc_flow_id[i]);
 
 				_rmnet_vnd_do_flow_control(dev,
@@ -1008,8 +994,8 @@ int rmnet_vnd_do_flow_control(struct net_device *dev,
 			}
 		}
 	} else {
-		LOGD("%s(): Internal seq(%hd) higher than called(%hd)\n",
-		     __func__, atomic_read(&(itm->v4_seq)), v4_seq);
+		LOGD("Internal seq(%hd) higher than called(%hd)",
+		     atomic_read(&(itm->v4_seq)), v4_seq);
 	}
 
 fcdone:
diff --git a/net/rmnet_data/rmnet_map_command.c b/net/rmnet_data/rmnet_map_command.c
index a3a5bfc705dd..56ac41312525 100644
--- a/net/rmnet_data/rmnet_map_command.c
+++ b/net/rmnet_data/rmnet_map_command.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
@@ -61,8 +61,8 @@ static uint8_t rmnet_map_do_flow_control(struct sk_buff *skb,
 	cmd = RMNET_MAP_GET_CMD_START(skb);
 
 	if (mux_id >= RMNET_DATA_MAX_LOGICAL_EP) {
-		LOGD("%s(): Got packet on %s with bad mux id %d\n",
-				__func__, skb->dev->name, mux_id);
+		LOGD("Got packet on %s with bad mux id %d",
+		     skb->dev->name, mux_id);
 		kfree_skb(skb);
 		return RX_HANDLER_CONSUMED;
 	}
@@ -70,8 +70,8 @@ static uint8_t rmnet_map_do_flow_control(struct sk_buff *skb,
 	ep = &(config->muxed_ep[mux_id]);
 
 	if (!ep->refcount) {
-		LOGD("%s(): Packet on %s:%d; has no logical endpoint config\n",
-		     __func__, skb->dev->name, mux_id);
+		LOGD("Packet on %s:%d; has no logical endpoint config",
+		     skb->dev->name, mux_id);
 
 		kfree_skb(skb);
 			return RX_HANDLER_CONSUMED;
@@ -88,8 +88,8 @@ static uint8_t rmnet_map_do_flow_control(struct sk_buff *skb,
 	 * the 2 protocols
 	 */
 	r = rmnet_vnd_do_flow_control(vnd, qos_id, fc_seq, fc_seq, enable);
-	LOGD("%s(): dev:%s, qos_id:0x%08X, ip_family:%hd, fc_seq %hd, en:%d\n",
-	     __func__, skb->dev->name, qos_id, ip_family & 3, fc_seq, enable);
+	LOGD("dev:%s, qos_id:0x%08X, ip_family:%hd, fc_seq %hd, en:%d",
+	     skb->dev->name, qos_id, ip_family & 3, fc_seq, enable);
 
 	if (r)
 		return RMNET_MAP_COMMAND_UNSUPPORTED;
@@ -168,7 +168,7 @@ rx_handler_result_t rmnet_map_command(struct sk_buff *skb,
 
 	default:
 		rmnet_map_command_stats[RMNET_MAP_COMMAND_UNKNOWN]++;
-		LOGM("%s(): Uknown MAP command: %d\n", __func__, command_name);
+		LOGM("Uknown MAP command: %d", command_name);
 		rc = RMNET_MAP_COMMAND_UNSUPPORTED;
 		break;
 	}
diff --git a/net/rmnet_data/rmnet_map_data.c b/net/rmnet_data/rmnet_map_data.c
index d7bda86448fb..b39f906dcaac 100644
--- a/net/rmnet_data/rmnet_map_data.c
+++ b/net/rmnet_data/rmnet_map_data.c
@@ -72,7 +72,7 @@ struct rmnet_map_header_s *rmnet_map_add_map_header(struct sk_buff *skb,
 		return 0;
 
 	padbytes = (uint8_t *) skb_put(skb, padding);
-	LOGD("pad: %d\n", padding);
+	LOGD("pad: %d", padding);
 	memset(padbytes, 0, padding);
 
 	map_header->pkt_len = htons(map_datalen + padding);
@@ -110,7 +110,7 @@ struct sk_buff *rmnet_map_deaggregate(struct sk_buff *skb,
 	packet_len = ntohs(maph->pkt_len) + sizeof(struct rmnet_map_header_s);
 
 	if ((((int)skb->len) - ((int)packet_len)) < 0) {
-		LOGM("%s(): Got malformed packet. Dropping\n", __func__);
+		LOGM("%s", "Got malformed packet. Dropping");
 		return 0;
 	}
 
@@ -118,7 +118,7 @@ struct sk_buff *rmnet_map_deaggregate(struct sk_buff *skb,
 	if (!skbn)
 		return 0;
 
-	LOGD("Trimming to %d bytes\n", packet_len);
+	LOGD("Trimming to %d bytes", packet_len);
 	LOGD("before skbn->len = %d", skbn->len);
 	skb_trim(skbn, packet_len);
 	skb_pull(skb, packet_len);
@@ -127,7 +127,7 @@ struct sk_buff *rmnet_map_deaggregate(struct sk_buff *skb,
 	/* Sanity check */
 	ip_byte = (skbn->data[4]) & 0xF0;
 	if (ip_byte != 0x40 && ip_byte != 0x60) {
-		LOGM("%s() Unknown IP type: 0x%02X\n", __func__, ip_byte);
+		LOGM("Unknown IP type: 0x%02X", ip_byte);
 		kfree_skb(skbn);
 		return 0;
 	}
@@ -154,21 +154,21 @@ static void rmnet_map_flush_packet_queue(struct work_struct *work)
 	skb = 0;
 	real_work = (struct agg_work *)work;
 	config = real_work->config;
-	LOGD("Entering flush thread\n");
+	LOGD("%s", "Entering flush thread");
 	spin_lock_irqsave(&config->agg_lock, flags);
 	if (likely(config->agg_state == RMNET_MAP_TXFER_SCHEDULED)) {
 		if (likely(config->agg_skb)) {
 			/* Buffer may have already been shipped out */
 			if (config->agg_count > 1)
-				LOGL("Agg count: %d\n", config->agg_count);
+				LOGL("Agg count: %d", config->agg_count);
 			skb = config->agg_skb;
 			config->agg_skb = 0;
 		}
 		config->agg_state = RMNET_MAP_AGG_IDLE;
 	} else {
 		/* How did we get here? */
-		LOGE("%s(): Ran queued command when state %s\n",
-			"is idle. State machine likely broken", __func__);
+		LOGE("Ran queued command when state %s",
+			"is idle. State machine likely broken");
 	}
 
 	spin_unlock_irqrestore(&config->agg_lock, flags);
@@ -200,7 +200,7 @@ void rmnet_map_aggregate(struct sk_buff *skb,
 	size = config->egress_agg_size-skb->len;
 
 	if (size < 2000) {
-		LOGL("Invalid length %d\n", size);
+		LOGL("Invalid length %d", size);
 		return;
 	}
 
@@ -222,7 +222,7 @@ new_packet:
 
 	if (skb->len > (config->egress_agg_size - config->agg_skb->len)) {
 		if (config->agg_count > 1)
-			LOGL("Agg count: %d\n", config->agg_count);
+			LOGL("Agg count: %d", config->agg_count);
 		agg_skb = config->agg_skb;
 		config->agg_skb = 0;
 		config->agg_count = 0;
@@ -241,8 +241,8 @@ schedule:
 		work = (struct agg_work *)
 			kmalloc(sizeof(struct agg_work), GFP_ATOMIC);
 		if (!work) {
-			LOGE("%s(): Failed to allocate work item for packet %s",
-			     "transfer. DATA PATH LIKELY BROKEN!\n", __func__);
+			LOGE("Failed to allocate work item for packet %s",
+			     "transfer. DATA PATH LIKELY BROKEN!");
 			config->agg_state = RMNET_MAP_AGG_IDLE;
 			spin_unlock_irqrestore(&config->agg_lock, flags);
 			return;