Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 83654923 authored by Subash Abhinov Kasiviswanathan's avatar Subash Abhinov Kasiviswanathan
Browse files

net: rmnet_data: Update snapshot of driver 



This is a snapshot of the rmnet_data driver taken as of msm-4.9
commit 2698fe946b6f9e ("net: rmnet_data: Remove invalid error
message").

CRs-Fixed: 2156182
Change-Id: Ibab410518ca6981a868980082acfe739ad49b298
Signed-off-by: default avatarSubash Abhinov Kasiviswanathan <subashab@codeaurora.org>
parent b4dff52f

net/rmnet_data/rmnet_data_config.c

+19 −1
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 
#include "rmnet_data_vnd.h"

#include "rmnet_data_private.h"

#include "rmnet_data_trace.h"

#include "rmnet_map.h"



RMNET_LOG_MODULE(RMNET_DATA_LOGMASK_CONFIG);
@@ -869,7 +870,8 @@ int rmnet_associate_network_device(struct net_device *dev) 
	conf->dev = dev;

	spin_lock_init(&conf->agg_lock);

	config->recycle = kfree_skb;



	hrtimer_init(&conf->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

	conf->hrtimer.function = rmnet_map_flush_packet_queue;

	rc = netdev_rx_handler_register(dev, rmnet_rx_handler, config);



	if (rc) {
@@ -1232,6 +1234,22 @@ static void rmnet_force_unassociate_device(struct net_device *dev) 
	config = _rmnet_get_phys_ep_config(dev);



	if (config) {

		unsigned long flags;



		hrtimer_cancel(&config->hrtimer);

		spin_lock_irqsave(&config->agg_lock, flags);

		if (config->agg_state == RMNET_MAP_TXFER_SCHEDULED) {

			if (config->agg_skb) {

				kfree_skb(config->agg_skb);

				config->agg_skb = NULL;

				config->agg_count = 0;

				memset(&config->agg_time, 0,

				       sizeof(struct timespec));

			}

			config->agg_state = RMNET_MAP_AGG_IDLE;

		}

		spin_unlock_irqrestore(&config->agg_lock, flags);



		cfg = &config->local_ep;



		if (cfg && cfg->refcount)

net/rmnet_data/rmnet_data_config.h

+2 −0
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
#include <linux/time.h>

#include <linux/spinlock.h>

#include <net/rmnet_config.h>

#include <linux/hrtimer.h>



#ifndef _RMNET_DATA_CONFIG_H_

#define _RMNET_DATA_CONFIG_H_
@@ -83,6 +84,7 @@ struct rmnet_phys_ep_config { 
	u8 agg_count;

	struct timespec agg_time;

	struct timespec agg_last;

	struct hrtimer hrtimer;

};



int rmnet_config_init(void);

net/rmnet_data/rmnet_data_handlers.c

+70 −62
Original line number Diff line number Diff line
@@ -184,19 +184,35 @@ static rx_handler_result_t rmnet_bridge_handler 
	return RX_HANDLER_CONSUMED;

}



#ifdef NET_SKBUFF_DATA_USES_OFFSET

static void rmnet_reset_mac_header(struct sk_buff *skb)

/* RX/TX Fixup */



/* rmnet_vnd_rx_fixup() - Virtual Network Device receive fixup hook

 * @skb:        Socket buffer ("packet") to modify

 * @dev:        Virtual network device

 *

 * Additional VND specific packet processing for ingress packets

 *

 * Return: void

 */

static void rmnet_vnd_rx_fixup(struct sk_buff *skb, struct net_device *dev)

{

	skb->mac_header = 0;

	skb->mac_len = 0;

	dev->stats.rx_packets++;

	dev->stats.rx_bytes += skb->len;

}

#else

static void rmnet_reset_mac_header(struct sk_buff *skb)



/* rmnet_vnd_tx_fixup() - Virtual Network Device transmic fixup hook

 * @skb:      Socket buffer ("packet") to modify

 * @dev:      Virtual network device

 *

 * Additional VND specific packet processing for egress packets

 *

 * Return: void

 */

static void rmnet_vnd_tx_fixup(struct sk_buff *skb, struct net_device *dev)

{

	skb->mac_header = skb->network_header;

	skb->mac_len = 0;

	dev->stats.tx_packets++;

	dev->stats.tx_bytes += skb->len;

}

#endif /*NET_SKBUFF_DATA_USES_OFFSET*/



/* rmnet_check_skb_can_gro() - Check is skb can be passed through GRO handler

 *
@@ -321,42 +337,33 @@ static rx_handler_result_t __rmnet_deliver_skb 


	trace___rmnet_deliver_skb(skb);

	switch (ep->rmnet_mode) {

	case RMNET_EPMODE_NONE:

		return RX_HANDLER_PASS;



	case RMNET_EPMODE_BRIDGE:

		return rmnet_bridge_handler(skb, ep);



	case RMNET_EPMODE_VND:

		skb_reset_transport_header(skb);

		skb_reset_network_header(skb);

		switch (rmnet_vnd_rx_fixup(skb, skb->dev)) {

		case RX_HANDLER_CONSUMED:

			return RX_HANDLER_CONSUMED;

		rmnet_vnd_rx_fixup(skb, skb->dev);



		case RX_HANDLER_PASS:

		skb->pkt_type = PACKET_HOST;

			rmnet_reset_mac_header(skb);

		skb_set_mac_header(skb, 0);



		if (rmnet_check_skb_can_gro(skb) &&

		    (skb->dev->features & NETIF_F_GRO)) {

			napi = get_current_napi_context();

				if (napi) {



			skb_size = skb->len;

			gro_res = napi_gro_receive(napi, skb);

			trace_rmnet_gro_downlink(gro_res);

					rmnet_optional_gro_flush(napi, ep,

								 skb_size);

				} else {

					WARN_ONCE(1, "current napi is NULL\n");

					netif_receive_skb(skb);

				}

			rmnet_optional_gro_flush(napi, ep, skb_size);

		} else{

			netif_receive_skb(skb);

		}

		return RX_HANDLER_CONSUMED;

		}



	case RMNET_EPMODE_NONE:

		return RX_HANDLER_PASS;



	case RMNET_EPMODE_BRIDGE:

		return rmnet_bridge_handler(skb, ep);



	default:

		LOGD("Unknown ep mode %d", ep->rmnet_mode);

		rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_DELIVER_NO_EP);
@@ -441,15 +448,6 @@ static rx_handler_result_t _rmnet_map_ingress_handler 


	ep = &config->muxed_ep[mux_id];



	if (!ep->refcount) {

		LOGD("Packet on %s:%d; has no logical endpoint config",

		     skb->dev->name, mux_id);



		rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_MAPINGRESS_MUX_NO_EP);

		return RX_HANDLER_CONSUMED;

	}



	if (config->ingress_data_format & RMNET_INGRESS_FORMAT_DEMUXING)

	skb->dev = ep->egress_dev;



	if ((config->ingress_data_format & RMNET_INGRESS_FORMAT_MAP_CKSUMV3) ||
@@ -462,6 +460,7 @@ static rx_handler_result_t _rmnet_map_ingress_handler 
			skb->ip_summed |= CHECKSUM_UNNECESSARY;

		else if (ckresult !=

			 RMNET_MAP_CHECKSUM_ERR_UNKNOWN_IP_VERSION &&

			 ckresult != RMNET_MAP_CHECKSUM_VALIDATION_FAILED &&

			 ckresult != RMNET_MAP_CHECKSUM_ERR_UNKNOWN_TRANSPORT &&

			 ckresult != RMNET_MAP_CHECKSUM_VALID_FLAG_NOT_SET &&

			 ckresult != RMNET_MAP_CHECKSUM_FRAGMENTED_PACKET) {
@@ -495,17 +494,13 @@ static rx_handler_result_t rmnet_map_ingress_handler 
	(struct sk_buff *skb, struct rmnet_phys_ep_config *config)

{

	struct sk_buff *skbn;

	int rc, co = 0;

	int rc;



	if (config->ingress_data_format & RMNET_INGRESS_FORMAT_DEAGGREGATION) {

		trace_rmnet_start_deaggregation(skb);

		while ((skbn = rmnet_map_deaggregate(skb, config)) != 0) {

			_rmnet_map_ingress_handler(skbn, config);

			co++;

		}

		trace_rmnet_end_deaggregation(skb, co);

		LOGD("De-aggregated %d packets", co);

		rmnet_stats_deagg_pkts(co);

		rmnet_kfree_skb(skb, RMNET_STATS_SKBFREE_MAPINGRESS_AGGBUF);

		rc = RX_HANDLER_CONSUMED;

	} else {
@@ -537,12 +532,16 @@ static int rmnet_map_egress_handler(struct sk_buff *skb, 
{

	int required_headroom, additional_header_length, ckresult;

	struct rmnet_map_header_s *map_header;

	int non_linear_skb;

	int csum_required = (config->egress_data_format &

			     RMNET_EGRESS_FORMAT_MAP_CKSUMV3) ||

			    (config->egress_data_format &

			     RMNET_EGRESS_FORMAT_MAP_CKSUMV4);



	additional_header_length = 0;



	required_headroom = sizeof(struct rmnet_map_header_s);

	if ((config->egress_data_format & RMNET_EGRESS_FORMAT_MAP_CKSUMV3) ||

	    (config->egress_data_format & RMNET_EGRESS_FORMAT_MAP_CKSUMV4)) {

	if (csum_required) {

		required_headroom +=

			sizeof(struct rmnet_map_ul_checksum_header_s);

		additional_header_length +=
@@ -557,17 +556,19 @@ static int rmnet_map_egress_handler(struct sk_buff *skb, 
		return 1;

	}



	if ((config->egress_data_format & RMNET_EGRESS_FORMAT_MAP_CKSUMV3) ||

	    (config->egress_data_format & RMNET_EGRESS_FORMAT_MAP_CKSUMV4)) {

	if (csum_required) {

		ckresult = rmnet_map_checksum_uplink_packet

				(skb, orig_dev, config->egress_data_format);

		trace_rmnet_map_checksum_uplink_packet(orig_dev, ckresult);

		rmnet_stats_ul_checksum(ckresult);

	}



	non_linear_skb = (orig_dev->features & NETIF_F_GSO) &&

			 skb_is_nonlinear(skb);



	if ((!(config->egress_data_format &

	    RMNET_EGRESS_FORMAT_AGGREGATION)) ||

	    ((orig_dev->features & NETIF_F_GSO) && skb_is_nonlinear(skb)))

	    RMNET_EGRESS_FORMAT_AGGREGATION)) || csum_required ||

	    non_linear_skb)

		map_header = rmnet_map_add_map_header

		(skb, additional_header_length, RMNET_MAP_NO_PAD_BYTES);

	else
@@ -590,6 +591,13 @@ static int rmnet_map_egress_handler(struct sk_buff *skb, 
	skb->protocol = htons(ETH_P_MAP);



	if (config->egress_data_format & RMNET_EGRESS_FORMAT_AGGREGATION) {

		if (rmnet_ul_aggregation_skip(skb, required_headroom))

			return RMNET_MAP_SUCCESS;



		if (non_linear_skb)

			if (unlikely(__skb_linearize(skb)))

				return RMNET_MAP_SUCCESS;



		rmnet_map_aggregate(skb, config);

		return RMNET_MAP_CONSUMED;

	}
@@ -720,6 +728,9 @@ void rmnet_egress_handler(struct sk_buff *skb, 
	LOGD("Packet going out on %s with egress format 0x%08X",

	     skb->dev->name, config->egress_data_format);



	if (ep->rmnet_mode == RMNET_EPMODE_VND)

		rmnet_vnd_tx_fixup(skb, orig_dev);



	if (config->egress_data_format & RMNET_EGRESS_FORMAT_MAP) {

		switch (rmnet_map_egress_handler(skb, config, ep, orig_dev)) {

		case RMNET_MAP_CONSUMED:
@@ -737,9 +748,6 @@ void rmnet_egress_handler(struct sk_buff *skb, 
		}

	}



	if (ep->rmnet_mode == RMNET_EPMODE_VND)

		rmnet_vnd_tx_fixup(skb, orig_dev);



	rmnet_print_packet(skb, skb->dev->name, 't');

	trace_rmnet_egress_handler(skb);

net/rmnet_data/rmnet_data_stats.c

+1 −25
Original line number Diff line number Diff line
@@ -41,11 +41,6 @@ unsigned long int queue_xmit[RMNET_STATS_QUEUE_XMIT_MAX * 2]; 
module_param_array(queue_xmit, ulong, 0, 0444);

MODULE_PARM_DESC(queue_xmit, "SKBs queued for transmit");



static DEFINE_SPINLOCK(rmnet_deagg_count);

unsigned long int deagg_count[RMNET_STATS_AGG_MAX];

module_param_array(deagg_count, ulong, 0, 0444);

MODULE_PARM_DESC(deagg_count, "SKBs De-aggregated");



static DEFINE_SPINLOCK(rmnet_agg_count);

unsigned long int agg_count[RMNET_STATS_AGG_MAX];

module_param_array(agg_count, ulong, 0, 0444);
@@ -72,17 +67,8 @@ void rmnet_kfree_skb(struct sk_buff *skb, unsigned int reason) 
	skb_free[reason]++;

	spin_unlock_irqrestore(&rmnet_skb_free_lock, flags);



	if (likely(skb)) {

		struct rmnet_phys_ep_conf_s *config;



		config = (struct rmnet_phys_ep_conf_s *)rcu_dereference

			 (skb->dev->rx_handler_data);

		if (likely(config))

			config->recycle(skb);

		else

	kfree_skb(skb);

}

}



void rmnet_stats_queue_xmit(int rc, unsigned int reason)

{
@@ -108,16 +94,6 @@ void rmnet_stats_agg_pkts(int aggcount) 
	spin_unlock_irqrestore(&rmnet_agg_count, flags);

}



void rmnet_stats_deagg_pkts(int aggcount)

{

	unsigned long flags;



	spin_lock_irqsave(&rmnet_deagg_count, flags);

	deagg_count[RMNET_STATS_AGG_BUFF]++;

	deagg_count[RMNET_STATS_AGG_PKT] += aggcount;

	spin_unlock_irqrestore(&rmnet_deagg_count, flags);

}



void rmnet_stats_dl_checksum(unsigned int rc)

{

	unsigned long flags;

net/rmnet_data/rmnet_data_stats.h

+0 −1
Original line number Diff line number Diff line
@@ -24,7 +24,6 @@ enum rmnet_skb_free_e { 
	RMNET_STATS_SKBFREE_DELIVER_NO_EP,

	RMNET_STATS_SKBFREE_IPINGRESS_NO_EP,

	RMNET_STATS_SKBFREE_MAPINGRESS_BAD_MUX,

	RMNET_STATS_SKBFREE_MAPINGRESS_MUX_NO_EP,

	RMNET_STATS_SKBFREE_MAPINGRESS_AGGBUF,

	RMNET_STATS_SKBFREE_INGRESS_NOT_EXPECT_MAPD,

	RMNET_STATS_SKBFREE_INGRESS_NOT_EXPECT_MAPC,