Merge branch 'tipc-improvements-to-group-messaging' (fdb533c3) · Commits · 戴 / test

include/uapi/linux/tipc.h

+3 −4

Original line number	Diff line number	Diff line
		@@ -117,7 +117,6 @@ static inline unsigned int tipc_node(__u32 addr)
		/*
		* Publication scopes when binding port names and port name sequences
		*/

		#define TIPC_ZONE_SCOPE 1
		#define TIPC_CLUSTER_SCOPE 2
		#define TIPC_NODE_SCOPE 3

net/tipc/group.c

+180 −149

Original line number	Diff line number	Diff line
		@@ -49,8 +49,6 @@
		#define ADV_ACTIVE (ADV_UNIT * 12)

		enum mbr_state {
		MBR_QUARANTINED,
		MBR_DISCOVERED,
		MBR_JOINING,
		MBR_PUBLISHED,
		MBR_JOINED,
		@@ -65,7 +63,6 @@ struct tipc_member {
		struct rb_node tree_node;
		struct list_head list;
		struct list_head small_win;
		struct sk_buff *event_msg;
		struct sk_buff_head deferredq;
		struct tipc_group *group;
		u32 node;
		@@ -77,7 +74,6 @@ struct tipc_member {
		u16 bc_rcv_nxt;
		u16 bc_syncpt;
		u16 bc_acked;
		bool usr_pending;
		};

		struct tipc_group {
		@@ -85,13 +81,11 @@ struct tipc_group {
		struct list_head small_win;
		struct list_head pending;
		struct list_head active;
		struct list_head reclaiming;
		struct tipc_nlist dests;
		struct net *net;
		int subid;
		u32 type;
		u32 instance;
		u32 domain;
		u32 scope;
		u32 portid;
		u16 member_cnt;
		@@ -101,11 +95,27 @@ struct tipc_group {
		u16 bc_ackers;
		bool loopback;
		bool events;
		bool open;
		};

		static void tipc_group_proto_xmit(struct tipc_group grp, struct tipc_member m,
		int mtyp, struct sk_buff_head *xmitq);

		bool tipc_group_is_open(struct tipc_group *grp)
		{
		return grp->open;
		}

		static void tipc_group_open(struct tipc_member m, bool wakeup)
		{
		*wakeup = false;
		if (list_empty(&m->small_win))
		return;
		list_del_init(&m->small_win);
		m->group->open = true;
		*wakeup = true;
		}

		static void tipc_group_decr_active(struct tipc_group *grp,
		struct tipc_member *m)
		{
		@@ -139,12 +149,12 @@ u16 tipc_group_bc_snd_nxt(struct tipc_group *grp)

		static bool tipc_group_is_receiver(struct tipc_member *m)
		{
		return m->state != MBR_QUARANTINED && m->state != MBR_LEAVING;
		return m && m->state != MBR_JOINING && m->state != MBR_LEAVING;
		}

		static bool tipc_group_is_sender(struct tipc_member *m)
		{
		return m && m->state >= MBR_JOINED;
		return m && m->state != MBR_JOINING && m->state != MBR_PUBLISHED;
		}

		u32 tipc_group_exclude(struct tipc_group *grp)
		@@ -162,6 +172,8 @@ int tipc_group_size(struct tipc_group *grp)
		struct tipc_group tipc_group_create(struct net net, u32 portid,
		struct tipc_group_req *mreq)
		{
		u32 filter = TIPC_SUB_PORTS \| TIPC_SUB_NO_STATUS;
		bool global = mreq->scope != TIPC_NODE_SCOPE;
		struct tipc_group *grp;
		u32 type = mreq->type;

		@@ -172,22 +184,37 @@ struct tipc_group tipc_group_create(struct net net, u32 portid,
		INIT_LIST_HEAD(&grp->small_win);
		INIT_LIST_HEAD(&grp->active);
		INIT_LIST_HEAD(&grp->pending);
		INIT_LIST_HEAD(&grp->reclaiming);
		grp->members = RB_ROOT;
		grp->net = net;
		grp->portid = portid;
		grp->domain = addr_domain(net, mreq->scope);
		grp->type = type;
		grp->instance = mreq->instance;
		grp->scope = mreq->scope;
		grp->loopback = mreq->flags & TIPC_GROUP_LOOPBACK;
		grp->events = mreq->flags & TIPC_GROUP_MEMBER_EVTS;
		if (tipc_topsrv_kern_subscr(net, portid, type, 0, ~0, &grp->subid))
		filter \|= global ? TIPC_SUB_CLUSTER_SCOPE : TIPC_SUB_NODE_SCOPE;
		if (tipc_topsrv_kern_subscr(net, portid, type, 0, ~0,
		filter, &grp->subid))
		return grp;
		kfree(grp);
		return NULL;
		}

		void tipc_group_join(struct net net, struct tipc_group grp, int *sk_rcvbuf)
		{
		struct rb_root *tree = &grp->members;
		struct tipc_member m, tmp;
		struct sk_buff_head xmitq;

		skb_queue_head_init(&xmitq);
		rbtree_postorder_for_each_entry_safe(m, tmp, tree, tree_node) {
		tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, &xmitq);
		tipc_group_update_member(m, 0);
		}
		tipc_node_distr_xmit(net, &xmitq);
		*sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
		}

		void tipc_group_delete(struct net net, struct tipc_group grp)
		{
		struct rb_root *tree = &grp->members;
		@@ -278,7 +305,7 @@ static void tipc_group_add_to_tree(struct tipc_group *grp,

		static struct tipc_member tipc_group_create_member(struct tipc_group grp,
		u32 node, u32 port,
		int state)
		u32 instance, int state)
		{
		struct tipc_member *m;

		@@ -291,6 +318,7 @@ static struct tipc_member tipc_group_create_member(struct tipc_group grp,
		m->group = grp;
		m->node = node;
		m->port = port;
		m->instance = instance;
		m->bc_acked = grp->bc_snd_nxt - 1;
		grp->member_cnt++;
		tipc_group_add_to_tree(grp, m);
		@@ -299,9 +327,10 @@ static struct tipc_member tipc_group_create_member(struct tipc_group grp,
		return m;
		}

		void tipc_group_add_member(struct tipc_group *grp, u32 node, u32 port)
		void tipc_group_add_member(struct tipc_group *grp, u32 node,
		u32 port, u32 instance)
		{
		tipc_group_create_member(grp, node, port, MBR_DISCOVERED);
		tipc_group_create_member(grp, node, port, instance, MBR_PUBLISHED);
		}

		static void tipc_group_delete_member(struct tipc_group *grp,
		@@ -392,20 +421,20 @@ bool tipc_group_cong(struct tipc_group *grp, u32 dnode, u32 dport,
		int adv, state;

		m = tipc_group_find_dest(grp, dnode, dport);
		*mbr = m;
		if (!m)
		if (!tipc_group_is_receiver(m)) {
		*mbr = NULL;
		return false;
		if (m->usr_pending)
		return true;
		}
		*mbr = m;

		if (m->window >= len)
		return false;
		m->usr_pending = true;

		grp->open = false;

		/* If not fully advertised, do it now to prevent mutual blocking */
		adv = m->advertised;
		state = m->state;
		if (state < MBR_JOINED)
		return true;
		if (state == MBR_JOINED && adv == ADV_IDLE)
		return true;
		if (state == MBR_ACTIVE && adv == ADV_ACTIVE)
		@@ -423,9 +452,10 @@ bool tipc_group_bc_cong(struct tipc_group *grp, int len)
		struct tipc_member *m = NULL;

		/* If prev bcast was replicast, reject until all receivers have acked */
		if (grp->bc_ackers)
		if (grp->bc_ackers) {
		grp->open = false;
		return true;

		}
		if (list_empty(&grp->small_win))
		return false;

		@@ -571,24 +601,34 @@ void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,

		switch (m->state) {
		case MBR_JOINED:
		/* Reclaim advertised space from least active member */
		if (!list_empty(active) && active_cnt >= reclaim_limit) {
		/* First, decide if member can go active */
		if (active_cnt <= max_active) {
		m->state = MBR_ACTIVE;
		list_add_tail(&m->list, active);
		grp->active_cnt++;
		tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
		} else {
		m->state = MBR_PENDING;
		list_add_tail(&m->list, &grp->pending);
		}

		if (active_cnt < reclaim_limit)
		break;

		/* Reclaim from oldest active member, if possible */
		if (!list_empty(active)) {
		rm = list_first_entry(active, struct tipc_member, list);
		rm->state = MBR_RECLAIMING;
		list_move_tail(&rm->list, &grp->reclaiming);
		list_del_init(&rm->list);
		tipc_group_proto_xmit(grp, rm, GRP_RECLAIM_MSG, xmitq);
		}
		/* If max active, become pending and wait for reclaimed space */
		if (active_cnt >= max_active) {
		m->state = MBR_PENDING;
		list_add_tail(&m->list, &grp->pending);
		break;
		}
		/* Otherwise become active */
		m->state = MBR_ACTIVE;
		list_add_tail(&m->list, &grp->active);
		grp->active_cnt++;
		/* Fall through */
		/* Nobody to reclaim from; - revert oldest pending to JOINED */
		pm = list_first_entry(&grp->pending, struct tipc_member, list);
		list_del_init(&pm->list);
		pm->state = MBR_JOINED;
		tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
		break;
		case MBR_ACTIVE:
		if (!list_is_last(&m->list, &grp->active))
		list_move_tail(&m->list, &grp->active);
		@@ -600,12 +640,12 @@ void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,
		if (m->advertised > ADV_IDLE)
		break;
		m->state = MBR_JOINED;
		grp->active_cnt--;
		if (m->advertised < ADV_IDLE) {
		pr_warn_ratelimited("Rcv unexpected msg after REMIT\n");
		tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
		}
		grp->active_cnt--;
		list_del_init(&m->list);

		if (list_empty(&grp->pending))
		return;

		@@ -617,7 +657,6 @@ void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,
		tipc_group_proto_xmit(grp, pm, GRP_ADV_MSG, xmitq);
		break;
		case MBR_RECLAIMING:
		case MBR_DISCOVERED:
		case MBR_JOINING:
		case MBR_LEAVING:
		default:
		@@ -625,6 +664,40 @@ void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,
		}
		}

		static void tipc_group_create_event(struct tipc_group *grp,
		struct tipc_member *m,
		u32 event, u16 seqno,
		struct sk_buff_head *inputq)
		{ u32 dnode = tipc_own_addr(grp->net);
		struct tipc_event evt;
		struct sk_buff *skb;
		struct tipc_msg *hdr;

		evt.event = event;
		evt.found_lower = m->instance;
		evt.found_upper = m->instance;
		evt.port.ref = m->port;
		evt.port.node = m->node;
		evt.s.seq.type = grp->type;
		evt.s.seq.lower = m->instance;
		evt.s.seq.upper = m->instance;

		skb = tipc_msg_create(TIPC_CRITICAL_IMPORTANCE, TIPC_GRP_MEMBER_EVT,
		GROUP_H_SIZE, sizeof(evt), dnode, m->node,
		grp->portid, m->port, 0);
		if (!skb)
		return;

		hdr = buf_msg(skb);
		msg_set_nametype(hdr, grp->type);
		msg_set_grp_evt(hdr, event);
		msg_set_dest_droppable(hdr, true);
		msg_set_grp_bc_seqno(hdr, seqno);
		memcpy(msg_data(hdr), &evt, sizeof(evt));
		TIPC_SKB_CB(skb)->orig_member = m->instance;
		__skb_queue_tail(inputq, skb);
		}

		static void tipc_group_proto_xmit(struct tipc_group grp, struct tipc_member m,
		int mtyp, struct sk_buff_head *xmitq)
		{
		@@ -670,83 +743,73 @@ void tipc_group_proto_rcv(struct tipc_group grp, bool usr_wakeup,
		u32 node = msg_orignode(hdr);
		u32 port = msg_origport(hdr);
		struct tipc_member m, pm;
		struct tipc_msg *ehdr;
		u16 remitted, in_flight;

		if (!grp)
		return;

		if (grp->scope == TIPC_NODE_SCOPE && node != tipc_own_addr(grp->net))
		return;

		m = tipc_group_find_member(grp, node, port);

		switch (msg_type(hdr)) {
		case GRP_JOIN_MSG:
		if (!m)
		m = tipc_group_create_member(grp, node, port,
		MBR_QUARANTINED);
		0, MBR_JOINING);
		if (!m)
		return;
		m->bc_syncpt = msg_grp_bc_syncpt(hdr);
		m->bc_rcv_nxt = m->bc_syncpt;
		m->window += msg_adv_win(hdr);

		/* Wait until PUBLISH event is received */
		if (m->state == MBR_DISCOVERED) {
		m->state = MBR_JOINING;
		} else if (m->state == MBR_PUBLISHED) {
		/* Wait until PUBLISH event is received if necessary */
		if (m->state != MBR_PUBLISHED)
		return;

		/* Member can be taken into service */
		m->state = MBR_JOINED;
		*usr_wakeup = true;
		m->usr_pending = false;
		tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
		ehdr = buf_msg(m->event_msg);
		msg_set_grp_bc_seqno(ehdr, m->bc_syncpt);
		__skb_queue_tail(inputq, m->event_msg);
		}
		list_del_init(&m->small_win);
		tipc_group_open(m, usr_wakeup);
		tipc_group_update_member(m, 0);
		tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
		tipc_group_create_event(grp, m, TIPC_PUBLISHED,
		m->bc_syncpt, inputq);
		return;
		case GRP_LEAVE_MSG:
		if (!m)
		return;
		m->bc_syncpt = msg_grp_bc_syncpt(hdr);
		list_del_init(&m->list);
		list_del_init(&m->small_win);
		*usr_wakeup = true;

		/* Wait until WITHDRAW event is received */
		if (m->state != MBR_LEAVING) {
		tipc_group_open(m, usr_wakeup);
		tipc_group_decr_active(grp, m);
		m->state = MBR_LEAVING;
		return;
		}
		/* Otherwise deliver already received WITHDRAW event */
		ehdr = buf_msg(m->event_msg);
		msg_set_grp_bc_seqno(ehdr, m->bc_syncpt);
		__skb_queue_tail(inputq, m->event_msg);
		tipc_group_create_event(grp, m, TIPC_WITHDRAWN,
		m->bc_syncpt, inputq);
		return;
		case GRP_ADV_MSG:
		if (!m)
		return;
		m->window += msg_adv_win(hdr);
		*usr_wakeup = m->usr_pending;
		m->usr_pending = false;
		list_del_init(&m->small_win);
		tipc_group_open(m, usr_wakeup);
		return;
		case GRP_ACK_MSG:
		if (!m)
		return;
		m->bc_acked = msg_grp_bc_acked(hdr);
		if (--grp->bc_ackers)
		break;
		return;
		list_del_init(&m->small_win);
		m->group->open = true;
		*usr_wakeup = true;
		m->usr_pending = false;
		tipc_group_update_member(m, 0);
		return;
		case GRP_RECLAIM_MSG:
		if (!m)
		return;
		*usr_wakeup = m->usr_pending;
		m->usr_pending = false;
		tipc_group_proto_xmit(grp, m, GRP_REMIT_MSG, xmitq);
		m->window = ADV_IDLE;
		tipc_group_open(m, usr_wakeup);
		return;
		case GRP_REMIT_MSG:
		if (!m \|\| m->state != MBR_RECLAIMING)
		@@ -761,18 +824,14 @@ void tipc_group_proto_rcv(struct tipc_group grp, bool usr_wakeup,
		m->advertised = ADV_IDLE + in_flight;
		return;
		}
		/* All messages preceding the REMIT have been read */
		if (m->advertised <= remitted) {
		m->state = MBR_JOINED;
		in_flight = 0;
		}
		/* ..and the REMIT overtaken by more messages => re-advertise */
		/* This should never happen */
		if (m->advertised < remitted)
		tipc_group_proto_xmit(grp, m, GRP_ADV_MSG, xmitq);
		pr_warn_ratelimited("Unexpected REMIT msg\n");

		m->advertised = ADV_IDLE + in_flight;
		/* All messages preceding the REMIT have been read */
		m->state = MBR_JOINED;
		grp->active_cnt--;
		list_del_init(&m->list);
		m->advertised = ADV_IDLE;

		/* Set oldest pending member to active and advertise */
		if (list_empty(&grp->pending))
		@@ -794,11 +853,10 @@ void tipc_group_proto_rcv(struct tipc_group grp, bool usr_wakeup,
		void tipc_group_member_evt(struct tipc_group *grp,
		bool *usr_wakeup,
		int *sk_rcvbuf,
		struct sk_buff *skb,
		struct tipc_msg *hdr,
		struct sk_buff_head *inputq,
		struct sk_buff_head *xmitq)
		{
		struct tipc_msg *hdr = buf_msg(skb);
		struct tipc_event evt = (void )msg_data(hdr);
		u32 instance = evt->found_lower;
		u32 node = evt->port.node;
		@@ -806,86 +864,59 @@ void tipc_group_member_evt(struct tipc_group *grp,
		int event = evt->event;
		struct tipc_member *m;
		struct net *net;
		bool node_up;
		u32 self;

		if (!grp)
		goto drop;
		return;

		net = grp->net;
		self = tipc_own_addr(net);
		if (!grp->loopback && node == self && port == grp->portid)
		goto drop;

		/* Convert message before delivery to user */
		msg_set_hdr_sz(hdr, GROUP_H_SIZE);
		msg_set_user(hdr, TIPC_CRITICAL_IMPORTANCE);
		msg_set_type(hdr, TIPC_GRP_MEMBER_EVT);
		msg_set_origport(hdr, port);
		msg_set_orignode(hdr, node);
		msg_set_nametype(hdr, grp->type);
		msg_set_grp_evt(hdr, event);
		return;

		m = tipc_group_find_member(grp, node, port);

		if (event == TIPC_PUBLISHED) {
		switch (event) {
		case TIPC_PUBLISHED:
		/* Send and wait for arrival of JOIN message if necessary */
		if (!m) {
		m = tipc_group_create_member(grp, node, port, instance,
		MBR_PUBLISHED);
		if (!m)
		m = tipc_group_create_member(grp, node, port,
		MBR_DISCOVERED);
		if (!m)
		goto drop;

		/* Hold back event if JOIN message not yet received */
		if (m->state == MBR_DISCOVERED) {
		m->event_msg = skb;
		m->state = MBR_PUBLISHED;
		} else {
		msg_set_grp_bc_seqno(hdr, m->bc_syncpt);
		__skb_queue_tail(inputq, skb);
		m->state = MBR_JOINED;
		*usr_wakeup = true;
		m->usr_pending = false;
		break;
		tipc_group_update_member(m, 0);
		tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
		break;
		}

		if (m->state != MBR_JOINING)
		break;

		/* Member can be taken into service */
		m->instance = instance;
		TIPC_SKB_CB(skb)->orig_member = m->instance;
		tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
		m->state = MBR_JOINED;
		tipc_group_open(m, usr_wakeup);
		tipc_group_update_member(m, 0);
		} else if (event == TIPC_WITHDRAWN) {
		tipc_group_proto_xmit(grp, m, GRP_JOIN_MSG, xmitq);
		tipc_group_create_event(grp, m, TIPC_PUBLISHED,
		m->bc_syncpt, inputq);
		break;
		case TIPC_WITHDRAWN:
		if (!m)
		goto drop;

		TIPC_SKB_CB(skb)->orig_member = m->instance;
		break;

		*usr_wakeup = true;
		m->usr_pending = false;
		node_up = tipc_node_is_up(net, node);
		m->event_msg = NULL;

		if (node_up) {
		/* Hold back event if a LEAVE msg should be expected */
		if (m->state != MBR_LEAVING) {
		m->event_msg = skb;
		tipc_group_decr_active(grp, m);
		m->state = MBR_LEAVING;
		} else {
		msg_set_grp_bc_seqno(hdr, m->bc_syncpt);
		__skb_queue_tail(inputq, skb);
		}
		} else {
		if (m->state != MBR_LEAVING) {
		tipc_group_decr_active(grp, m);
		m->state = MBR_LEAVING;
		msg_set_grp_bc_seqno(hdr, m->bc_rcv_nxt);
		} else {
		msg_set_grp_bc_seqno(hdr, m->bc_syncpt);
		}
		__skb_queue_tail(inputq, skb);
		}
		list_del_init(&m->list);
		list_del_init(&m->small_win);
		tipc_group_open(m, usr_wakeup);

		/* Only send event if no LEAVE message can be expected */
		if (!tipc_node_is_up(net, node))
		tipc_group_create_event(grp, m, TIPC_WITHDRAWN,
		m->bc_rcv_nxt, inputq);
		break;
		default:
		break;
		}
		*sk_rcvbuf = tipc_group_rcvbuf_limit(grp);
		return;
		drop:
		kfree_skb(skb);
		}

net/tipc/group.h

+5 −3

Original line number	Diff line number	Diff line
		@@ -44,8 +44,10 @@ struct tipc_msg;

		struct tipc_group tipc_group_create(struct net net, u32 portid,
		struct tipc_group_req *mreq);
		void tipc_group_join(struct net net, struct tipc_group grp, int *sk_rcv_buf);
		void tipc_group_delete(struct net net, struct tipc_group grp);
		void tipc_group_add_member(struct tipc_group *grp, u32 node, u32 port);
		void tipc_group_add_member(struct tipc_group *grp, u32 node,
		u32 port, u32 instance);
		struct tipc_nlist tipc_group_dests(struct tipc_group grp);
		void tipc_group_self(struct tipc_group grp, struct tipc_name_seq seq,
		int *scope);
		@@ -54,7 +56,7 @@ void tipc_group_filter_msg(struct tipc_group *grp,
		struct sk_buff_head *inputq,
		struct sk_buff_head *xmitq);
		void tipc_group_member_evt(struct tipc_group grp, bool wakeup,
		int sk_rcvbuf, struct sk_buff skb,
		int sk_rcvbuf, struct tipc_msg hdr,
		struct sk_buff_head *inputq,
		struct sk_buff_head *xmitq);
		void tipc_group_proto_rcv(struct tipc_group grp, bool wakeup,
		@@ -65,9 +67,9 @@ void tipc_group_update_bc_members(struct tipc_group *grp, int len, bool ack);
		bool tipc_group_cong(struct tipc_group *grp, u32 dnode, u32 dport,
		int len, struct tipc_member **m);
		bool tipc_group_bc_cong(struct tipc_group *grp, int len);
		bool tipc_group_is_open(struct tipc_group *grp);
		void tipc_group_update_rcv_win(struct tipc_group *grp, int blks, u32 node,
		u32 port, struct sk_buff_head *xmitq);
		u16 tipc_group_bc_snd_nxt(struct tipc_group *grp);
		void tipc_group_update_member(struct tipc_member *m, int len);
		int tipc_group_size(struct tipc_group *grp);
		#endif

net/tipc/name_table.c

+27 −28

Original line number	Diff line number	Diff line
		@@ -328,7 +328,8 @@ static struct publication tipc_nameseq_insert_publ(struct net net,
		list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
		tipc_subscrp_report_overlap(s, publ->lower, publ->upper,
		TIPC_PUBLISHED, publ->ref,
		publ->node, created_subseq);
		publ->node, publ->scope,
		created_subseq);
		}
		return publ;
		}
		@@ -398,19 +399,21 @@ found:
		list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
		tipc_subscrp_report_overlap(s, publ->lower, publ->upper,
		TIPC_WITHDRAWN, publ->ref,
		publ->node, removed_subseq);
		publ->node, publ->scope,
		removed_subseq);
		}

		return publ;
		}

		/**
		* tipc_nameseq_subscribe - attach a subscription, and issue
		* the prescribed number of events if there is any sub-
		* tipc_nameseq_subscribe - attach a subscription, and optionally
		* issue the prescribed number of events if there is any sub-
		* sequence overlapping with the requested sequence
		*/
		static void tipc_nameseq_subscribe(struct name_seq *nseq,
		struct tipc_subscription *s)
		struct tipc_subscription *s,
		bool status)
		{
		struct sub_seq *sseq = nseq->sseqs;
		struct tipc_name_seq ns;
		@@ -420,7 +423,7 @@ static void tipc_nameseq_subscribe(struct name_seq *nseq,
		tipc_subscrp_get(s);
		list_add(&s->nameseq_list, &nseq->subscriptions);

		if (!sseq)
		if (!status \|\| !sseq)
		return;

		while (sseq != &nseq->sseqs[nseq->first_free]) {
		@@ -434,6 +437,7 @@ static void tipc_nameseq_subscribe(struct name_seq *nseq,
		sseq->upper,
		TIPC_PUBLISHED,
		crs->ref, crs->node,
		crs->scope,
		must_report);
		must_report = 0;
		}
		@@ -597,7 +601,7 @@ not_found:
		return ref;
		}

		bool tipc_nametbl_lookup(struct net *net, u32 type, u32 instance, u32 domain,
		bool tipc_nametbl_lookup(struct net *net, u32 type, u32 instance, u32 scope,
		struct list_head dsts, int dstcnt, u32 exclude,
		bool all)
		{
		@@ -607,9 +611,6 @@ bool tipc_nametbl_lookup(struct net *net, u32 type, u32 instance, u32 domain,
		struct name_seq *seq;
		struct sub_seq *sseq;

		if (!tipc_in_scope(domain, self))
		return false;

		*dstcnt = 0;
		rcu_read_lock();
		seq = nametbl_find_seq(net, type);
		@@ -620,7 +621,7 @@ bool tipc_nametbl_lookup(struct net *net, u32 type, u32 instance, u32 domain,
		if (likely(sseq)) {
		info = sseq->info;
		list_for_each_entry(publ, &info->zone_list, zone_list) {
		if (!tipc_in_scope(domain, publ->node))
		if (publ->scope != scope)
		continue;
		if (publ->ref == exclude && publ->node == self)
		continue;
		@@ -638,13 +639,14 @@ exit:
		return !list_empty(dsts);
		}

		int tipc_nametbl_mc_translate(struct net *net, u32 type, u32 lower, u32 upper,
		u32 limit, struct list_head *dports)
		int tipc_nametbl_mc_lookup(struct net *net, u32 type, u32 lower, u32 upper,
		u32 scope, bool exact, struct list_head *dports)
		{
		struct name_seq *seq;
		struct sub_seq *sseq;
		struct sub_seq *sseq_stop;
		struct name_info *info;
		struct publication *p;
		struct name_seq *seq;
		struct sub_seq *sseq;
		int res = 0;

		rcu_read_lock();
		@@ -656,15 +658,12 @@ int tipc_nametbl_mc_translate(struct net *net, u32 type, u32 lower, u32 upper,
		sseq = seq->sseqs + nameseq_locate_subseq(seq, lower);
		sseq_stop = seq->sseqs + seq->first_free;
		for (; sseq != sseq_stop; sseq++) {
		struct publication *publ;

		if (sseq->lower > upper)
		break;

		info = sseq->info;
		list_for_each_entry(publ, &info->node_list, node_list) {
		if (publ->scope <= limit)
		tipc_dest_push(dports, 0, publ->ref);
		list_for_each_entry(p, &info->node_list, node_list) {
		if (p->scope == scope \|\| (!exact && p->scope < scope))
		tipc_dest_push(dports, 0, p->ref);
		}

		if (info->cluster_list_size != info->node_list_size)
		@@ -681,7 +680,7 @@ exit:
		* - Determines if any node local ports overlap
		*/
		void tipc_nametbl_lookup_dst_nodes(struct net *net, u32 type, u32 lower,
		u32 upper, u32 domain,
		u32 upper, u32 scope,
		struct tipc_nlist *nodes)
		{
		struct sub_seq sseq, stop;
		@@ -700,7 +699,7 @@ void tipc_nametbl_lookup_dst_nodes(struct net *net, u32 type, u32 lower,
		for (; sseq != stop && sseq->lower <= upper; sseq++) {
		info = sseq->info;
		list_for_each_entry(publ, &info->zone_list, zone_list) {
		if (tipc_in_scope(domain, publ->node))
		if (publ->scope == scope)
		tipc_nlist_add(nodes, publ->node);
		}
		}
		@@ -712,7 +711,7 @@ exit:
		/* tipc_nametbl_build_group - build list of communication group members
		*/
		void tipc_nametbl_build_group(struct net net, struct tipc_group grp,
		u32 type, u32 domain)
		u32 type, u32 scope)
		{
		struct sub_seq sseq, stop;
		struct name_info *info;
		@@ -730,9 +729,9 @@ void tipc_nametbl_build_group(struct net net, struct tipc_group grp,
		for (; sseq != stop; sseq++) {
		info = sseq->info;
		list_for_each_entry(p, &info->zone_list, zone_list) {
		if (!tipc_in_scope(domain, p->node))
		if (p->scope != scope)
		continue;
		tipc_group_add_member(grp, p->node, p->ref);
		tipc_group_add_member(grp, p->node, p->ref, p->lower);
		}
		}
		spin_unlock_bh(&seq->lock);
		@@ -811,7 +810,7 @@ int tipc_nametbl_withdraw(struct net *net, u32 type, u32 lower, u32 ref,
		/**
		* tipc_nametbl_subscribe - add a subscription object to the name table
		*/
		void tipc_nametbl_subscribe(struct tipc_subscription *s)
		void tipc_nametbl_subscribe(struct tipc_subscription *s, bool status)
		{
		struct tipc_net *tn = net_generic(s->net, tipc_net_id);
		u32 type = tipc_subscrp_convert_seq_type(s->evt.s.seq.type, s->swap);
		@@ -825,7 +824,7 @@ void tipc_nametbl_subscribe(struct tipc_subscription *s)
		seq = tipc_nameseq_create(type, &tn->nametbl->seq_hlist[index]);
		if (seq) {
		spin_lock_bh(&seq->lock);
		tipc_nameseq_subscribe(seq, s);
		tipc_nameseq_subscribe(seq, s, status);
		spin_unlock_bh(&seq->lock);
		} else {
		tipc_subscrp_convert_seq(&s->evt.s.seq, s->swap, &ns);

net/tipc/name_table.h

+3 −3

Original line number	Diff line number	Diff line
		@@ -100,8 +100,8 @@ struct name_table {
		int tipc_nl_name_table_dump(struct sk_buff skb, struct netlink_callback cb);

		u32 tipc_nametbl_translate(struct net net, u32 type, u32 instance, u32 node);
		int tipc_nametbl_mc_translate(struct net *net, u32 type, u32 lower, u32 upper,
		u32 limit, struct list_head *dports);
		int tipc_nametbl_mc_lookup(struct net *net, u32 type, u32 lower, u32 upper,
		u32 scope, bool exact, struct list_head *dports);
		void tipc_nametbl_build_group(struct net net, struct tipc_group grp,
		u32 type, u32 domain);
		void tipc_nametbl_lookup_dst_nodes(struct net *net, u32 type, u32 lower,
		@@ -121,7 +121,7 @@ struct publication tipc_nametbl_insert_publ(struct net net, u32 type,
		struct publication tipc_nametbl_remove_publ(struct net net, u32 type,
		u32 lower, u32 node, u32 ref,
		u32 key);
		void tipc_nametbl_subscribe(struct tipc_subscription *s);
		void tipc_nametbl_subscribe(struct tipc_subscription *s, bool status);
		void tipc_nametbl_unsubscribe(struct tipc_subscription *s);
		int tipc_nametbl_init(struct net *net);
		void tipc_nametbl_stop(struct net *net);

Admin message