Commit 9c9f261d authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'nla_align-set-4' 



Nicolas Dichtel says:

====================
netlink: align attributes when needed (patchset #3)

This is the continuation (series #3) of the work done to align netlink
attributes when these attributes contain some 64-bit fields.

It's the last patchset from what I've seen.

The last user of nla_put_u64() is block/drbd. This module does not use
standard netlink API (see all the stuff in include/linux/genl_magic_struct.h
and include/linux/genl_magic_func.h). I didn't modify it because it's seems
hard to do it whithout testing and fully understanding the context (for
example, why include/linux/drbd_genl.h is not part of uapi?).
Any thoughts?
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents fab7b629 9854518e

Documentation/networking/gen_stats.txt

+4 −2
Original line number Diff line number Diff line
@@ -33,7 +33,8 @@ my_dumping_routine(struct sk_buff *skb, ...) 
{

	struct gnet_dump dump;



	if (gnet_stats_start_copy(skb, TCA_STATS2, &mystruct->lock, &dump) < 0)

	if (gnet_stats_start_copy(skb, TCA_STATS2, &mystruct->lock, &dump,

				  TCA_PAD) < 0)

		goto rtattr_failure;



	if (gnet_stats_copy_basic(&dump, &mystruct->bstats) < 0 ||
@@ -56,7 +57,8 @@ existing TLV types. 
my_dumping_routine(struct sk_buff *skb, ...)

{

    if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS,

		TCA_XSTATS, &mystruct->lock, &dump) < 0)

				     TCA_XSTATS, &mystruct->lock, &dump,

				     TCA_PAD) < 0)

		goto rtattr_failure;

	...

}

drivers/net/macsec.c

+88 −33
Original line number Diff line number Diff line
@@ -1405,9 +1405,10 @@ static sci_t nla_get_sci(const struct nlattr *nla) 
	return (__force sci_t)nla_get_u64(nla);

}



static int nla_put_sci(struct sk_buff *skb, int attrtype, sci_t value)

static int nla_put_sci(struct sk_buff *skb, int attrtype, sci_t value,

		       int padattr)

{

	return nla_put_u64(skb, attrtype, (__force u64)value);

	return nla_put_u64_64bit(skb, attrtype, (__force u64)value, padattr);

}



static struct macsec_tx_sa *get_txsa_from_nl(struct net *net,
@@ -2131,16 +2132,36 @@ static int copy_rx_sc_stats(struct sk_buff *skb, 
		sum.InPktsUnusedSA    += tmp.InPktsUnusedSA;

	}



	if (nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_OCTETS_VALIDATED, sum.InOctetsValidated) ||

	    nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_OCTETS_DECRYPTED, sum.InOctetsDecrypted) ||

	    nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_UNCHECKED, sum.InPktsUnchecked) ||

	    nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_DELAYED, sum.InPktsDelayed) ||

	    nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_OK, sum.InPktsOK) ||

	    nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_INVALID, sum.InPktsInvalid) ||

	    nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_LATE, sum.InPktsLate) ||

	    nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_NOT_VALID, sum.InPktsNotValid) ||

	    nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_NOT_USING_SA, sum.InPktsNotUsingSA) ||

	    nla_put_u64(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_UNUSED_SA, sum.InPktsUnusedSA))

	if (nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_OCTETS_VALIDATED,

			      sum.InOctetsValidated,

			      MACSEC_RXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_OCTETS_DECRYPTED,

			      sum.InOctetsDecrypted,

			      MACSEC_RXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_UNCHECKED,

			      sum.InPktsUnchecked,

			      MACSEC_RXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_DELAYED,

			      sum.InPktsDelayed,

			      MACSEC_RXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_OK,

			      sum.InPktsOK,

			      MACSEC_RXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_INVALID,

			      sum.InPktsInvalid,

			      MACSEC_RXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_LATE,

			      sum.InPktsLate,

			      MACSEC_RXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_NOT_VALID,

			      sum.InPktsNotValid,

			      MACSEC_RXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_NOT_USING_SA,

			      sum.InPktsNotUsingSA,

			      MACSEC_RXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_RXSC_STATS_ATTR_IN_PKTS_UNUSED_SA,

			      sum.InPktsUnusedSA,

			      MACSEC_RXSC_STATS_ATTR_PAD))

		return -EMSGSIZE;



	return 0;
@@ -2169,10 +2190,18 @@ static int copy_tx_sc_stats(struct sk_buff *skb, 
		sum.OutOctetsEncrypted += tmp.OutOctetsEncrypted;

	}



	if (nla_put_u64(skb, MACSEC_TXSC_STATS_ATTR_OUT_PKTS_PROTECTED, sum.OutPktsProtected) ||

	    nla_put_u64(skb, MACSEC_TXSC_STATS_ATTR_OUT_PKTS_ENCRYPTED, sum.OutPktsEncrypted) ||

	    nla_put_u64(skb, MACSEC_TXSC_STATS_ATTR_OUT_OCTETS_PROTECTED, sum.OutOctetsProtected) ||

	    nla_put_u64(skb, MACSEC_TXSC_STATS_ATTR_OUT_OCTETS_ENCRYPTED, sum.OutOctetsEncrypted))

	if (nla_put_u64_64bit(skb, MACSEC_TXSC_STATS_ATTR_OUT_PKTS_PROTECTED,

			      sum.OutPktsProtected,

			      MACSEC_TXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_TXSC_STATS_ATTR_OUT_PKTS_ENCRYPTED,

			      sum.OutPktsEncrypted,

			      MACSEC_TXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_TXSC_STATS_ATTR_OUT_OCTETS_PROTECTED,

			      sum.OutOctetsProtected,

			      MACSEC_TXSC_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_TXSC_STATS_ATTR_OUT_OCTETS_ENCRYPTED,

			      sum.OutOctetsEncrypted,

			      MACSEC_TXSC_STATS_ATTR_PAD))

		return -EMSGSIZE;



	return 0;
@@ -2205,14 +2234,30 @@ static int copy_secy_stats(struct sk_buff *skb, 
		sum.InPktsOverrun    += tmp.InPktsOverrun;

	}



	if (nla_put_u64(skb, MACSEC_SECY_STATS_ATTR_OUT_PKTS_UNTAGGED, sum.OutPktsUntagged) ||

	    nla_put_u64(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_UNTAGGED, sum.InPktsUntagged) ||

	    nla_put_u64(skb, MACSEC_SECY_STATS_ATTR_OUT_PKTS_TOO_LONG, sum.OutPktsTooLong) ||

	    nla_put_u64(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_NO_TAG, sum.InPktsNoTag) ||

	    nla_put_u64(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_BAD_TAG, sum.InPktsBadTag) ||

	    nla_put_u64(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_UNKNOWN_SCI, sum.InPktsUnknownSCI) ||

	    nla_put_u64(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_NO_SCI, sum.InPktsNoSCI) ||

	    nla_put_u64(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_OVERRUN, sum.InPktsOverrun))

	if (nla_put_u64_64bit(skb, MACSEC_SECY_STATS_ATTR_OUT_PKTS_UNTAGGED,

			      sum.OutPktsUntagged,

			      MACSEC_SECY_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_UNTAGGED,

			      sum.InPktsUntagged,

			      MACSEC_SECY_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_SECY_STATS_ATTR_OUT_PKTS_TOO_LONG,

			      sum.OutPktsTooLong,

			      MACSEC_SECY_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_NO_TAG,

			      sum.InPktsNoTag,

			      MACSEC_SECY_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_BAD_TAG,

			      sum.InPktsBadTag,

			      MACSEC_SECY_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_UNKNOWN_SCI,

			      sum.InPktsUnknownSCI,

			      MACSEC_SECY_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_NO_SCI,

			      sum.InPktsNoSCI,

			      MACSEC_SECY_STATS_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_SECY_STATS_ATTR_IN_PKTS_OVERRUN,

			      sum.InPktsOverrun,

			      MACSEC_SECY_STATS_ATTR_PAD))

		return -EMSGSIZE;



	return 0;
@@ -2226,8 +2271,11 @@ static int nla_put_secy(struct macsec_secy *secy, struct sk_buff *skb) 
	if (!secy_nest)

		return 1;



	if (nla_put_sci(skb, MACSEC_SECY_ATTR_SCI, secy->sci) ||

	    nla_put_u64(skb, MACSEC_SECY_ATTR_CIPHER_SUITE, DEFAULT_CIPHER_ID) ||

	if (nla_put_sci(skb, MACSEC_SECY_ATTR_SCI, secy->sci,

			MACSEC_SECY_ATTR_PAD) ||

	    nla_put_u64_64bit(skb, MACSEC_SECY_ATTR_CIPHER_SUITE,

			      DEFAULT_CIPHER_ID,

			      MACSEC_SECY_ATTR_PAD) ||

	    nla_put_u8(skb, MACSEC_SECY_ATTR_ICV_LEN, secy->icv_len) ||

	    nla_put_u8(skb, MACSEC_SECY_ATTR_OPER, secy->operational) ||

	    nla_put_u8(skb, MACSEC_SECY_ATTR_PROTECT, secy->protect_frames) ||
@@ -2312,7 +2360,9 @@ static int dump_secy(struct macsec_secy *secy, struct net_device *dev, 


		if (nla_put_u8(skb, MACSEC_SA_ATTR_AN, i) ||

		    nla_put_u32(skb, MACSEC_SA_ATTR_PN, tx_sa->next_pn) ||

		    nla_put_u64(skb, MACSEC_SA_ATTR_KEYID, tx_sa->key.id) ||

		    nla_put_u64_64bit(skb, MACSEC_SA_ATTR_KEYID,

				      tx_sa->key.id,

				      MACSEC_SA_ATTR_PAD) ||

		    nla_put_u8(skb, MACSEC_SA_ATTR_ACTIVE, tx_sa->active)) {

			nla_nest_cancel(skb, txsa_nest);

			nla_nest_cancel(skb, txsa_list);
@@ -2353,7 +2403,8 @@ static int dump_secy(struct macsec_secy *secy, struct net_device *dev, 
		}



		if (nla_put_u8(skb, MACSEC_RXSC_ATTR_ACTIVE, rx_sc->active) ||

		    nla_put_sci(skb, MACSEC_RXSC_ATTR_SCI, rx_sc->sci)) {

		    nla_put_sci(skb, MACSEC_RXSC_ATTR_SCI, rx_sc->sci,

				MACSEC_RXSC_ATTR_PAD)) {

			nla_nest_cancel(skb, rxsc_nest);

			nla_nest_cancel(skb, rxsc_list);

			goto nla_put_failure;
@@ -2413,7 +2464,9 @@ static int dump_secy(struct macsec_secy *secy, struct net_device *dev, 


			if (nla_put_u8(skb, MACSEC_SA_ATTR_AN, i) ||

			    nla_put_u32(skb, MACSEC_SA_ATTR_PN, rx_sa->next_pn) ||

			    nla_put_u64(skb, MACSEC_SA_ATTR_KEYID, rx_sa->key.id) ||

			    nla_put_u64_64bit(skb, MACSEC_SA_ATTR_KEYID,

					      rx_sa->key.id,

					      MACSEC_SA_ATTR_PAD) ||

			    nla_put_u8(skb, MACSEC_SA_ATTR_ACTIVE, rx_sa->active)) {

				nla_nest_cancel(skb, rxsa_nest);

				nla_nest_cancel(skb, rxsc_nest);
@@ -3145,9 +3198,9 @@ static struct net *macsec_get_link_net(const struct net_device *dev) 
static size_t macsec_get_size(const struct net_device *dev)

{

	return 0 +

		nla_total_size(8) + /* SCI */

		nla_total_size_64bit(8) + /* SCI */

		nla_total_size(1) + /* ICV_LEN */

		nla_total_size(8) + /* CIPHER_SUITE */

		nla_total_size_64bit(8) + /* CIPHER_SUITE */

		nla_total_size(4) + /* WINDOW */

		nla_total_size(1) + /* ENCODING_SA */

		nla_total_size(1) + /* ENCRYPT */
@@ -3166,9 +3219,11 @@ static int macsec_fill_info(struct sk_buff *skb, 
	struct macsec_secy *secy = &macsec_priv(dev)->secy;

	struct macsec_tx_sc *tx_sc = &secy->tx_sc;



	if (nla_put_sci(skb, IFLA_MACSEC_SCI, secy->sci) ||

	if (nla_put_sci(skb, IFLA_MACSEC_SCI, secy->sci,

			IFLA_MACSEC_PAD) ||

	    nla_put_u8(skb, IFLA_MACSEC_ICV_LEN, secy->icv_len) ||

	    nla_put_u64(skb, IFLA_MACSEC_CIPHER_SUITE, DEFAULT_CIPHER_ID) ||

	    nla_put_u64_64bit(skb, IFLA_MACSEC_CIPHER_SUITE,

			      DEFAULT_CIPHER_ID, IFLA_MACSEC_PAD) ||

	    nla_put_u8(skb, IFLA_MACSEC_ENCODING_SA, tx_sc->encoding_sa) ||

	    nla_put_u8(skb, IFLA_MACSEC_ENCRYPT, tx_sc->encrypt) ||

	    nla_put_u8(skb, IFLA_MACSEC_PROTECT, secy->protect_frames) ||

drivers/net/wireless/mac80211_hwsim.c

+1 −1
Original line number Diff line number Diff line
@@ -1030,7 +1030,7 @@ static void mac80211_hwsim_tx_frame_nl(struct ieee80211_hw *hw, 
	data->pending_cookie++;

	cookie = data->pending_cookie;

	info->rate_driver_data[0] = (void *)cookie;

	if (nla_put_u64(skb, HWSIM_ATTR_COOKIE, cookie))

	if (nla_put_u64_64bit(skb, HWSIM_ATTR_COOKIE, cookie, HWSIM_ATTR_PAD))

		goto nla_put_failure;



	genlmsg_end(skb, msg_head);

drivers/net/wireless/mac80211_hwsim.h

+1 −0
Original line number Diff line number Diff line
@@ -148,6 +148,7 @@ enum { 
	HWSIM_ATTR_RADIO_NAME,

	HWSIM_ATTR_NO_VIF,

	HWSIM_ATTR_FREQ,

	HWSIM_ATTR_PAD,

	__HWSIM_ATTR_MAX,

};

#define HWSIM_ATTR_MAX (__HWSIM_ATTR_MAX - 1)

fs/quota/netlink.c

+7 −5
Original line number Diff line number Diff line
@@ -47,7 +47,7 @@ void quota_send_warning(struct kqid qid, dev_t dev, 
	void *msg_head;

	int ret;

	int msg_size = 4 * nla_total_size(sizeof(u32)) +

		       2 * nla_total_size(sizeof(u64));

		       2 * nla_total_size_64bit(sizeof(u64));



	/* We have to allocate using GFP_NOFS as we are called from a

	 * filesystem performing write and thus further recursion into
@@ -68,8 +68,9 @@ void quota_send_warning(struct kqid qid, dev_t dev, 
	ret = nla_put_u32(skb, QUOTA_NL_A_QTYPE, qid.type);

	if (ret)

		goto attr_err_out;

	ret = nla_put_u64(skb, QUOTA_NL_A_EXCESS_ID,

			  from_kqid_munged(&init_user_ns, qid));

	ret = nla_put_u64_64bit(skb, QUOTA_NL_A_EXCESS_ID,

				from_kqid_munged(&init_user_ns, qid),

				QUOTA_NL_A_PAD);

	if (ret)

		goto attr_err_out;

	ret = nla_put_u32(skb, QUOTA_NL_A_WARNING, warntype);
@@ -81,8 +82,9 @@ void quota_send_warning(struct kqid qid, dev_t dev, 
	ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MINOR, MINOR(dev));

	if (ret)

		goto attr_err_out;

	ret = nla_put_u64(skb, QUOTA_NL_A_CAUSED_ID,

			  from_kuid_munged(&init_user_ns, current_uid()));

	ret = nla_put_u64_64bit(skb, QUOTA_NL_A_CAUSED_ID,

				from_kuid_munged(&init_user_ns, current_uid()),

				QUOTA_NL_A_PAD);

	if (ret)

		goto attr_err_out;

	genlmsg_end(skb, msg_head);

CRA Git | Maintained and supported by SUSTech CRA and CCSE