Commit aaea1bab authored by Jakub Kicinski's avatar Jakub Kicinski
Browse files

Merge branch 's390-ctcm-updates-2020-11-30' 

Julian Wiedmann says:

====================
s390/ctcm: updates 2020-11-30

Some rare ctcm updates by Sebastian, who cleans up all places where
in_interrupt() was used to determine the correct GFP_* mask for
allocations.
In the first three patches we can get rid of those allocations entirely,
as they just end up being copied into the skb.
====================

Link: https://lore.kernel.org/r/20201130100950.42051-1-jwi@linux.ibm.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parents 2bf7d377 8f4b6e35

drivers/s390/net/ctcm_fsms.c

+4 −11
Original line number Diff line number Diff line
@@ -1303,12 +1303,10 @@ static void ctcmpc_chx_txdone(fsm_instance *fi, int event, void *arg) 
	/* p_header points to the last one we handled */

	if (p_header)

		p_header->pdu_flag |= PDU_LAST;	/*Say it's the last one*/

	header = kzalloc(TH_HEADER_LENGTH, gfp_type());

	if (!header) {

		spin_unlock(&ch->collect_lock);

		fsm_event(priv->mpcg->fsm, MPCG_EVENT_INOP, dev);

				goto done;

	}



	header = skb_push(ch->trans_skb, TH_HEADER_LENGTH);

	memset(header, 0, TH_HEADER_LENGTH);



	header->th_ch_flag = TH_HAS_PDU;  /* Normal data */

	ch->th_seq_num++;

	header->th_seq_num = ch->th_seq_num;
@@ -1316,11 +1314,6 @@ static void ctcmpc_chx_txdone(fsm_instance *fi, int event, void *arg) 
	CTCM_PR_DBGDATA("%s: ToVTAM_th_seq= %08x\n" ,

					__func__, ch->th_seq_num);



	memcpy(skb_push(ch->trans_skb, TH_HEADER_LENGTH), header,

		TH_HEADER_LENGTH);	/* put the TH on the packet */



	kfree(header);



	CTCM_PR_DBGDATA("%s: trans_skb len:%04x \n",

		       __func__, ch->trans_skb->len);

	CTCM_PR_DBGDATA("%s: up-to-50 bytes of trans_skb "

drivers/s390/net/ctcm_main.c

+14 −54
Original line number Diff line number Diff line
@@ -623,25 +623,10 @@ static void ctcmpc_send_sweep_req(struct channel *rch) 
				goto nomem;

	}



	header = kmalloc(TH_SWEEP_LENGTH, gfp_type());



	if (!header) {

		dev_kfree_skb_any(sweep_skb);

		/* rc = -ENOMEM; */

				goto nomem;

	}



	header->th.th_seg	= 0x00 ;

	header = skb_put_zero(sweep_skb, TH_SWEEP_LENGTH);

	header->th.th_ch_flag	= TH_SWEEP_REQ;  /* 0x0f */

	header->th.th_blk_flag	= 0x00;

	header->th.th_is_xid	= 0x00;

	header->th.th_seq_num	= 0x00;

	header->sw.th_last_seq	= ch->th_seq_num;



	skb_put_data(sweep_skb, header, TH_SWEEP_LENGTH);



	kfree(header);



	netif_trans_update(dev);

	skb_queue_tail(&ch->sweep_queue, sweep_skb);
@@ -680,24 +665,16 @@ static int ctcmpc_transmit_skb(struct channel *ch, struct sk_buff *skb) 
	if ((fsm_getstate(ch->fsm) != CTC_STATE_TXIDLE) || grp->in_sweep) {

		spin_lock_irqsave(&ch->collect_lock, saveflags);

		refcount_inc(&skb->users);

		p_header = kmalloc(PDU_HEADER_LENGTH, gfp_type());



		if (!p_header) {

			spin_unlock_irqrestore(&ch->collect_lock, saveflags);

				goto nomem_exit;

		}



		p_header->pdu_offset = skb->len;

		p_header = skb_push(skb, PDU_HEADER_LENGTH);

		p_header->pdu_offset = skb->len - PDU_HEADER_LENGTH;

		p_header->pdu_proto = 0x01;

		p_header->pdu_flag = 0x00;

		if (be16_to_cpu(skb->protocol) == ETH_P_SNAP) {

			p_header->pdu_flag |= PDU_FIRST | PDU_CNTL;

			p_header->pdu_flag = PDU_FIRST | PDU_CNTL;

		} else {

			p_header->pdu_flag |= PDU_FIRST;

			p_header->pdu_flag = PDU_FIRST;

		}

		p_header->pdu_seq = 0;

		memcpy(skb_push(skb, PDU_HEADER_LENGTH), p_header,

		       PDU_HEADER_LENGTH);



		CTCM_PR_DEBUG("%s(%s): Put on collect_q - skb len: %04x \n"

				"pdu header and data for up to 32 bytes:\n",
@@ -706,7 +683,6 @@ static int ctcmpc_transmit_skb(struct channel *ch, struct sk_buff *skb) 


		skb_queue_tail(&ch->collect_queue, skb);

		ch->collect_len += skb->len;

		kfree(p_header);



		spin_unlock_irqrestore(&ch->collect_lock, saveflags);

			goto done;
@@ -736,23 +712,15 @@ static int ctcmpc_transmit_skb(struct channel *ch, struct sk_buff *skb) 
		}

	}



	p_header = kmalloc(PDU_HEADER_LENGTH, gfp_type());



	if (!p_header)

		goto nomem_exit;



	p_header->pdu_offset = skb->len;

	p_header = skb_push(skb, PDU_HEADER_LENGTH);

	p_header->pdu_offset = skb->len - PDU_HEADER_LENGTH;

	p_header->pdu_proto = 0x01;

	p_header->pdu_flag = 0x00;

	p_header->pdu_seq = 0;

	if (be16_to_cpu(skb->protocol) == ETH_P_SNAP) {

		p_header->pdu_flag |= PDU_FIRST | PDU_CNTL;

		p_header->pdu_flag = PDU_FIRST | PDU_CNTL;

	} else {

		p_header->pdu_flag |= PDU_FIRST;

		p_header->pdu_flag = PDU_FIRST;

	}

	memcpy(skb_push(skb, PDU_HEADER_LENGTH), p_header, PDU_HEADER_LENGTH);



	kfree(p_header);



	if (ch->collect_len > 0) {

		spin_lock_irqsave(&ch->collect_lock, saveflags);
@@ -768,25 +736,17 @@ static int ctcmpc_transmit_skb(struct channel *ch, struct sk_buff *skb) 


	ch->prof.txlen += skb->len - PDU_HEADER_LENGTH;



	header = kmalloc(TH_HEADER_LENGTH, gfp_type());

	if (!header)

		goto nomem_exit;

	/* put the TH on the packet */

	header = skb_push(skb, TH_HEADER_LENGTH);

	memset(header, 0, TH_HEADER_LENGTH);



	header->th_seg = 0x00;

	header->th_ch_flag = TH_HAS_PDU;  /* Normal data */

	header->th_blk_flag = 0x00;

	header->th_is_xid = 0x00;          /* Just data here */

	ch->th_seq_num++;

	header->th_seq_num = ch->th_seq_num;



	CTCM_PR_DBGDATA("%s(%s) ToVTAM_th_seq= %08x\n" ,

		       __func__, dev->name, ch->th_seq_num);



	/* put the TH on the packet */

	memcpy(skb_push(skb, TH_HEADER_LENGTH), header, TH_HEADER_LENGTH);



	kfree(header);



	CTCM_PR_DBGDATA("%s(%s): skb len: %04x\n - pdu header and data for "

			"up to 32 bytes sent to vtam:\n",

				__func__, dev->name, skb->len);
@@ -943,7 +903,7 @@ static int ctcmpc_tx(struct sk_buff *skb, struct net_device *dev) 
		CTCM_D3_DUMP((char *)skb->data, min_t(int, 32, skb->len));



		len =  skb->len + TH_HEADER_LENGTH + PDU_HEADER_LENGTH;

		newskb = __dev_alloc_skb(len, gfp_type() | GFP_DMA);

		newskb = __dev_alloc_skb(len, GFP_ATOMIC | GFP_DMA);



		if (!newskb) {

			CTCM_DBF_TEXT_(MPC_TRACE, CTC_DBF_ERROR,
@@ -1361,7 +1321,7 @@ static int add_channel(struct ccw_device *cdev, enum ctcm_channel_types type, 


	ch->protocol = priv->protocol;

	if (IS_MPC(priv)) {

		ch->discontact_th = kzalloc(TH_HEADER_LENGTH, gfp_type());

		ch->discontact_th = kzalloc(TH_HEADER_LENGTH, GFP_KERNEL);

		if (ch->discontact_th == NULL)

					goto nomem_return;

drivers/s390/net/ctcm_main.h

+0 −5
Original line number Diff line number Diff line
@@ -298,11 +298,6 @@ struct mpc_group *ctcmpc_init_mpc_group(struct ctcm_priv *priv); 
/* test if struct ctcm_priv of struct net_device has MPC protocol setting */

#define IS_MPCDEV(dev) IS_MPC((struct ctcm_priv *)dev->ml_priv)



static inline gfp_t gfp_type(void)

{

	return in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;

}



/*

 * Definition of our link level header.

 */

drivers/s390/net/ctcm_mpc.c

+6 −33
Original line number Diff line number Diff line
@@ -655,24 +655,10 @@ static void ctcmpc_send_sweep_resp(struct channel *rch) 
		goto done;

	}



	header = kmalloc(sizeof(struct th_sweep), gfp_type());



	if (!header) {

		dev_kfree_skb_any(sweep_skb);

		goto done;

	}



	header->th.th_seg	= 0x00 ;

	header = skb_put_zero(sweep_skb, TH_SWEEP_LENGTH);

	header->th.th_ch_flag	= TH_SWEEP_RESP;

	header->th.th_blk_flag	= 0x00;

	header->th.th_is_xid	= 0x00;

	header->th.th_seq_num	= 0x00;

	header->sw.th_last_seq	= ch->th_seq_num;



	skb_put_data(sweep_skb, header, TH_SWEEP_LENGTH);



	kfree(header);



	netif_trans_update(dev);

	skb_queue_tail(&ch->sweep_queue, sweep_skb);
@@ -1177,7 +1163,7 @@ static void ctcmpc_unpack_skb(struct channel *ch, struct sk_buff *pskb) 
			skb_pull(pskb, new_len); /* point to next PDU */

		}

	} else {

		mpcginfo = kmalloc(sizeof(struct mpcg_info), gfp_type());

		mpcginfo = kmalloc(sizeof(struct mpcg_info), GFP_ATOMIC);

		if (mpcginfo == NULL)

					goto done;
@@ -2062,7 +2048,6 @@ static void mpc_action_rcvd_xid7(fsm_instance *fsm, int event, void *arg) 
 */

static int mpc_send_qllc_discontact(struct net_device *dev)

{

	__u32	new_len	= 0;

	struct sk_buff   *skb;

	struct qllc      *qllcptr;

	struct ctcm_priv *priv = dev->ml_priv;
@@ -2093,31 +2078,19 @@ static int mpc_send_qllc_discontact(struct net_device *dev) 
	case MPCG_STATE_FLOWC:

	case MPCG_STATE_READY:

		grp->send_qllc_disc = 2;

		new_len = sizeof(struct qllc);

		qllcptr = kzalloc(new_len, gfp_type() | GFP_DMA);

		if (qllcptr == NULL) {

			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,

				"%s(%s): qllcptr allocation error",

						CTCM_FUNTAIL, dev->name);

			return -ENOMEM;

		}



		qllcptr->qllc_address = 0xcc;

		qllcptr->qllc_commands = 0x03;



		skb = __dev_alloc_skb(new_len, GFP_ATOMIC);



		skb = __dev_alloc_skb(sizeof(struct qllc), GFP_ATOMIC);

		if (skb == NULL) {

			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,

				"%s(%s): skb allocation error",

						CTCM_FUNTAIL, dev->name);

			priv->stats.rx_dropped++;

			kfree(qllcptr);

			return -ENOMEM;

		}



		skb_put_data(skb, qllcptr, new_len);

		kfree(qllcptr);

		qllcptr = skb_put(skb, sizeof(struct qllc));

		qllcptr->qllc_address = 0xcc;

		qllcptr->qllc_commands = 0x03;



		if (skb_headroom(skb) < 4) {

			CTCM_DBF_TEXT_(MPC_ERROR, CTC_DBF_ERROR,

CRA Git | Maintained and supported by SUSTech CRA and CCSE