merge with current code from my internal tree.

Macro renaming, additional documentation, and various bugfixes.
Should compile a a module on both stable/10 and head

Author: Luigi Rizzo

bsd_nlsock.c

@@ -82,7 +82,7 @@ int
 bsd_netlink_send_msg(struct socket *so, struct mbuf *m)
 {
 	D("m %p proto %d pid %d plen %d so %p", _P32(m),
-		_MP(m), NETLINK_CB(m).portid, m->m_pkthdr.len, _P32(so));
+	    _M_NLPROTO(m), NETLINK_CB(m).portid, m->m_pkthdr.len, _P32(so));
 	return netisr_queue(NETISR_NETLINK, m);
 }
 
@@ -149,7 +149,7 @@ raw_input_netlink_cb(struct mbuf *m, struct sockproto *proto,
 	msg = mtod(m, struct nlmsghdr *);
 
 	D("m %p proto %d src_portid %d dst_portid %d ty %d so_portid %d len %d so %p",
-		_P32(m), _MP(m), NETLINK_CB(m).portid,
+		_P32(m), _M_NLPROTO(m), NETLINK_CB(m).portid,
 		msg->nlmsg_pid, msg->nlmsg_type,
 		key, m->m_pkthdr.len, _P32(so));
 	/* return 0 on match, 1 on fail */
@@ -175,11 +175,11 @@ netlink_input(struct mbuf *m)
 		.nl_family = PF_NETLINK,
 		.nl_pid = 0  /* comes from the kernel */ };
 	struct sockproto nl_proto = {
-		.sp_family = PF_NETLINK, .sp_protocol = _MP(m)};
+		.sp_family = PF_NETLINK, .sp_protocol = _M_NLPROTO(m)};
 
 	D("m %p proto %d src_portid %d len %d",
-		_P32(m), _MP(m), NETLINK_CB(m).portid, m->m_pkthdr.len);
-	_MP(m) = 0; // clear protocol in case it is not zero
+	    _P32(m), _M_NLPROTO(m), NETLINK_CB(m).portid, m->m_pkthdr.len);
+	_M_NLPROTO(m) = 0; // clear protocol in case it is not zero
 	D("calling input proto");
 	/* the dispatcher matches sockets using raw_input_netlink_cb(),
 	 * and replicates messages as needed.
@@ -380,10 +380,10 @@ netlink_output(struct mbuf *m, struct socket *so NLO_EXTRA )
 	rp = sotorawcb(so);
 	proto = rp->rcb_proto.sp_protocol;
 	/* save protocol and portid into the mbuf */
-	_MP(m) = proto;
+	_M_NLPROTO(m) = proto;
 	NETLINK_CB(m).portid = so->nl_src_portid;
 	D("so %p m %p m_portid %d m_proto %d plen %d len %d",
-		_P32(so), _P32(m), NETLINK_CB(m).portid, _MP(m),
+		_P32(so), _P32(m), NETLINK_CB(m).portid, _M_NLPROTO(m),
 		m->m_pkthdr.len, m->m_len);
 	ret = netlink_receive_packet(m, so, proto);
 	D("returns %d", ret);

genetlink.c

@@ -156,32 +156,19 @@ void *
 genlmsg_put(struct mbuf *m, uint32_t portid, uint32_t seq,
 	struct genl_family *family, int flags, uint8_t cmd)
 {
-	struct a {
-		union {
-			struct nlmsghdr n;
-			char pad[NLMSG_HDRLEN];
-		} n;
-		union {
-			struct genlmsghdr g;
-			char pad[NLMSG_HDRLEN];
-		} g;
-	} *hdr;
-	int need = NLMSG_HDRLEN + GENL_HDRLEN + family->hdrsize;
-	void *ret;
-
-	if (m->m_pkthdr.len + need > _ML(m))
-		return NULL;
-
-	hdr = (struct a *)_MC(m);
-	bzero(hdr, sizeof(struct a));
-	hdr->n.n.nlmsg_type = family->id;
-	hdr->n.n.nlmsg_flags = flags;
-	hdr->n.n.nlmsg_seq = seq;
-	hdr->n.n.nlmsg_pid = portid;
-	hdr->g.g.cmd = cmd; // XXX what about version and reserved
-	ret = _MC(m) + NLMSG_HDRLEN + GENL_HDRLEN; // return value
-	m->m_pkthdr.len += need;
-	return ret;
+	struct nlmsghdr *nlh;
+	struct genlmsghdr *g;
+
+	nlh = nlmsg_put(m, portid, seq, family->id,
+		GENL_HDRLEN + family->hdrsize, flags);
+	if (nlh == NULL)
+		return nlh; /* no space */
+	g = nlmsg_data(nlh);
+	g->cmd = cmd;
+	g->version = family->version;
+	g->reserved = 0;
+
+	return g;
 }
 
 // XXX check

linux/netlink.h

@@ -87,48 +87,13 @@ struct socket;
 struct mbuf;	/* we must be compilable with an opaque type */
 
 /*
- * Some mbuf pkthdr fields have special meaning when used with netlink:
- *
- *	FIELD	MACRO		DESCRIPTION
- *
- * 	rcvif	_MA()		linear buffer, possibly external
- *	fibnum	_ML()		linear buffer length
- *	len	--		current write offset
- *	flowid	NETLINK_CB()	src_portid, 32 bit
- *	rsstype	_MP()		protocol (NETLINK_GENERIC etc.)
- *
- * In more detail:
- *
- * 1. netlink messages are built incrementally in a linear buffer of
- * predefined size. This is a poor match with mbuf chains,
- * which may be split and have no predefined size.
- * Hence we use two mbuf fields (see above, _MA() and _ML() )
- * for the linear buffer pointer and max len,
- * and use m_pkthdr.len to record the space used so far
- * (remember of course to copy back and fix things before sending).
- * These are abstracted by the three macros _MA)(), _ML() and _MC()
- * _MA() and _ML() are cleared when passing the buffer back to the kernel
- *
- * 2. The protocol is mapped through _MP(m) into rsstype, and is used
- * in netlink_input()
- *
- * 3. sk_buff have a 48-byte "control buffer" (cb) to carry aux info.
- * In netlink this is wrapped by NETLINK_CB() into a pointer to a
- * struct netlink_skb_parms.
- * We need at least the portid, the source port for
- * messages coming from userspace, which in turn is used to locate the
- * destination socket when building a reply.
- * Netlink messages do not need flowid, so we store the portid there.
- * 
+ * Some mbuf pkthdr fields have special meaning when used with netlink
+ * messages, see netlink.c (only used there, except NETLINK_CB()
  */
 
 #ifndef __COMPAT_MBUF_TYPE /* mappings only work in native systems */
 
-#define _MA(m)  (m)->m_pkthdr.rcvif   /* linear buffer pointer */
-#define _ML(m)  ((m)->m_pkthdr.fibnum)  /* max length, 16 bit */
-#define _MC(m)  ((char *)_MA(m) + (m)->m_pkthdr.len) /* cur data ptr */
-
-#define _MP(m)  ((m)->m_pkthdr.rsstype)  /* netlink proto, 8 bit */
+#define _M_NLPROTO(m)  ((m)->m_pkthdr.rsstype)  /* netlink proto, 8 bit */
 
 #define NETLINK_CB(_m)	(*(struct netlink_skb_parms*)&((_m)->m_pkthdr.flowid))
 
@@ -154,12 +119,20 @@ CTASSERT(sizeof(struct netlink_skb_parms) <= sizeof(uint32_t));
 
 /* TODO: this function is not really remapped.
  * It is just a stub that logs the error
+ *
+ * The function should report error to broadcast listeners.
+ * sock is the kernel netlink socket, pid is the process to skip,
+ * group is the broadcast group that should receive the error,
+ * err is the error code (on linux is negative, the info
+ * is sent to receivers as a positive value.
+ * Returns the number of recipients.
  */
 #include <sys/syslog.h> /* LOG_INFO */
-static inline void
+static inline int
 netlink_set_err(void *sock, uint32_t pid, uint32_t group, int err)
 {
 	log(LOG_INFO, "Netlink set err, func:%s\n", __func__);
+	return 0;
 }
 
 /*

linux/uapi_genetlink.h

@@ -55,6 +55,10 @@ struct genlmsghdr {
 
 #define GENL_HDRLEN		NLMSG_ALIGN(sizeof(struct genlmsghdr))
 
+#ifdef CTASSERT
+CTASSERT(GENL_HDRLEN == sizeof(struct genlmsghdr));
+#endif
+
 /**************************************************************************
  * Controller
  **************************************************************************/

net/genetlink.h

@@ -153,7 +153,7 @@ genl_register_family(struct genl_family *family)
 int genl_unregister_family(struct genl_family *family);
 
 /*
- * XXX incomplete
+ * XXX incomplete same as netlink_set_err()
  */
 static inline int
 genl_set_err(struct genl_family *fam, struct net *net,
@@ -163,8 +163,7 @@ genl_set_err(struct genl_family *fam, struct net *net,
 		return EINVAL;
 	group += fam->mcgrp_offset;
 	/* we do not support namespaces yet */
-	netlink_set_err(NULL /* net->genl_sock */, portid, group, code);
-	return 0;
+	return netlink_set_err(NULL /* net->genl_sock */, portid, group, code);
 }
 
 /**
@@ -207,6 +206,9 @@ genlmsg_new(size_t payload, int flags)
 static inline void
 genlmsg_cancel(struct mbuf *m, void *hdr)
 {
+	if (hdr)
+		nlmsg_cancel(m, (struct nlmsghdr *)
+		    ((char *)hdr - GENL_HDRLEN - NLMSG_HDRLEN) );
 }
 
 void *genlmsg_put(struct mbuf *m, uint32_t portid, uint32_t seq,

net/netlink.h

@@ -70,6 +70,7 @@ int bsd_netlink_send_msg(struct socket *so, struct mbuf *m);
 int netlink_receive_packet(struct mbuf *, struct socket *, int);
 
 #define M_NETLINK_MULTICAST	M_PROTO1
+#define M_NEGATIVE_ERROR	M_PROTO2
 
 #define	nl_src_portid	so_fibnum
 #define	nl_dst_portid	so_user_cookie
@@ -105,8 +106,46 @@ struct nla_policy {
 	uint16_t        len;
 };
 
+static inline int
+nlmsg_msg_size(int payload_size)
+{
+	return NLMSG_HDRLEN + payload_size;
+}
+
+/*
+ * create a new mbuf for a netlink msg.
+ * Flags includes M_NEGATIVE_ERROR to indicate how we want nla_put()
+ * to return errors (linux clients need negative error values).
+ */
 struct mbuf *nlmsg_new(size_t payload, int flags);
 
+static inline void *
+nlmsg_data(const struct nlmsghdr *nlh)
+{
+	return (unsigned char *)(uintptr_t) nlh + NLMSG_HDRLEN;
+}
+
+void nlmsg_trim(struct mbuf *m, const void *mark); /* in netlink.c */
+
+static inline void
+nlmsg_cancel(struct mbuf *m, struct nlmsghdr *nlh)
+{
+	nlmsg_trim(m, nlh);
+}
+
+int nlmsg_end(struct mbuf *m, struct nlmsghdr *nlh);
+
+struct nlmsghdr *nlmsg_put(struct mbuf *m, uint32_t portid,
+	uint32_t seq, int type, int payload, int flags);
+
+struct genl_info; // XXX
+int nlmsg_reply(struct mbuf *m, struct genl_info *info);
+
+
+/*
+ * kernel routines to manipulate netlink attributes (nla_*)
+ */
+
 /*
  * nla_put() and __nla_put() append data to a nlmsg.
  * __nla_put() does not check for space.
@@ -185,7 +224,12 @@ static inline uint64_t nla_get_u64(const struct nlattr *nla)
 
 struct nlattr *nla_nest_start(struct mbuf *m, int attrtype);
 int nla_nest_end(struct mbuf *m, struct nlattr *start);
-void nla_nest_cancel(struct mbuf *m, struct nlattr* start);
+static inline void
+nla_nest_cancel(struct mbuf *m, struct nlattr* start)
+{
+	nlmsg_trim(m, start);
+}
+
 struct nlattr * nla_reserve(struct mbuf *m, int attrtype, int attrlen);
 #define __nla_reserve nla_reserve
 
@@ -209,12 +253,6 @@ nla_total_size(int payload)
 	return NLA_ALIGN(nla_attr_size(payload));
 }
 
-static inline void *
-nlmsg_data(const struct nlmsghdr *nlh)
-{
-	return (unsigned char *)(uintptr_t) nlh + NLMSG_HDRLEN;
-}
-
 
 
 static inline int
@@ -279,19 +317,35 @@ nla_padlen(int payload)
 #define nla_get_be32 nla_get_u32
 #define nla_get_be64 nla_get_u64
 
-int nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head,
+/*
+ * nla_parse*() should return a negative error on linux,
+ * but we have no way to discriminate the caller.
+ * XXX perhaps introduce bsd_nla_parse*() with the bsd return values.
+ */
+int bsd_nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head,
 		int len, const struct nla_policy *policy);
 
+static inline int
+bsd_nla_parse_nested(struct nlattr *tb[], int maxtype,
+	const struct nlattr *nla, const struct nla_policy *policy)
+{
+	return bsd_nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
+}
+
+static inline int
+nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head,
+		int len, const struct nla_policy *policy)
+{
+	return -nla_parse(tb, maxtype, head, len, policy);
+}
+
 static inline int
 nla_parse_nested(struct nlattr *tb[], int maxtype,
 	const struct nlattr *nla, const struct nla_policy *policy)
 {
-	return nla_parse(tb, maxtype, nla_data(nla), nla_len(nla), policy);
+	return -bsd_nla_parse_nested(tb, maxtype, nla, policy);
 }
 
-int nlmsg_end(struct mbuf *m, struct nlmsghdr *nlh);
-struct genl_info; // XXX
-int nlmsg_reply(struct mbuf *m, struct genl_info *info);
 
 #define nla_memcpy(dest, src, len) \
 	memcpy(dest, nla_data(src), min(len,nla_len(src)))