net/mctp/route.c

76 /* A note on the key allocations.
85  * a key with (local = local-eid, peer = ANY). This allows a match on the
100  * So, the key set allows both a local EID of ANY, as well as a peer EID of
110 static bool mctp_key_match(struct mctp_sk_key *key, unsigned int net,
113 	if (key->net != net)
116 	if (!mctp_address_matches(key->local_addr, local))
119 	if (!mctp_address_matches(key->peer_addr, peer))
122 	if (key->tag != tag)
128 /* returns a key (with key->lock held, and refcounted), or NULL if no such
129  * key exists.
134 	__acquires(&key->lock)
136 	struct mctp_sk_key *key, *ret;
147 	hlist_for_each_entry(key, &net->mctp.keys, hlist) {
148 		if (!mctp_key_match(key, netid, mh->dest, peer, tag))
151 		spin_lock(&key->lock);
152 		if (key->valid) {
153 			refcount_inc(&key->refs);
154 			ret = key;
157 		spin_unlock(&key->lock);
175 	struct mctp_sk_key *key;
177 	key = kzalloc(sizeof(*key), gfp);
178 	if (!key)
181 	key->net = net;
182 	key->peer_addr = peer;
183 	key->local_addr = local;
184 	key->tag = tag;
185 	key->sk = &msk->sk;
186 	key->valid = true;
187 	spin_lock_init(&key->lock);
188 	refcount_set(&key->refs, 1);
189 	sock_hold(key->sk);
191 	return key;
194 void mctp_key_unref(struct mctp_sk_key *key)
198 	if (!refcount_dec_and_test(&key->refs))
204 	spin_lock_irqsave(&key->lock, flags);
205 	mctp_dev_release_key(key->dev, key);
206 	spin_unlock_irqrestore(&key->lock, flags);
208 	sock_put(key->sk);
209 	kfree(key);
212 static int mctp_key_add(struct mctp_sk_key *key, struct mctp_sock *msk)
227 		if (mctp_key_match(tmp, key->net, key->local_addr,
228 				   key->peer_addr, key->tag)) {
239 		refcount_inc(&key->refs);
240 		key->expiry = jiffies + mctp_key_lifetime;
241 		timer_reduce(&msk->key_expiry, key->expiry);
243 		hlist_add_head(&key->hlist, &net->mctp.keys);
244 		hlist_add_head(&key->sklist, &msk->keys);
254  * We're done with the key; unlock and unref the key.
255  * For the usual case of automatic expiry we remove the key from lists.
256  * In the case that manual allocation is set on a key we release the lock
259 static void __mctp_key_done_in(struct mctp_sk_key *key, struct net *net,
261 __releases(&key->lock)
265 	trace_mctp_key_release(key, reason);
266 	skb = key->reasm_head;
267 	key->reasm_head = NULL;
269 	if (!key->manual_alloc) {
270 		key->reasm_dead = true;
271 		key->valid = false;
272 		mctp_dev_release_key(key->dev, key);
274 	spin_unlock_irqrestore(&key->lock, flags);
276 	if (!key->manual_alloc) {
278 		if (!hlist_unhashed(&key->hlist)) {
279 			hlist_del_init(&key->hlist);
280 			hlist_del_init(&key->sklist);
281 			mctp_key_unref(key);
287 	mctp_key_unref(key);
293 static void mctp_skb_set_flow(struct sk_buff *skb, struct mctp_sk_key *key)
301 	refcount_inc(&key->refs);
302 	flow->key = key;
307 	struct mctp_sk_key *key;
314 	key = flow->key;
316 	if (WARN_ON(key->dev && key->dev != dev))
319 	mctp_dev_set_key(dev, key);
322 static void mctp_skb_set_flow(struct sk_buff *skb, struct mctp_sk_key *key) {}
326 static int mctp_frag_queue(struct mctp_sk_key *key, struct sk_buff *skb)
334 	if (!key->reasm_head) {
335 		key->reasm_head = skb;
336 		key->reasm_tailp = &(skb_shinfo(skb)->frag_list);
337 		key->last_seq = this_seq;
341 	exp_seq = (key->last_seq + 1) & MCTP_HDR_SEQ_MASK;
346 	if (key->reasm_head->len + skb->len > mctp_message_maxlen)
351 	*key->reasm_tailp = skb;
352 	key->reasm_tailp = &skb->next;
354 	key->last_seq = this_seq;
356 	key->reasm_head->data_len += skb->len;
357 	key->reasm_head->len += skb->len;
358 	key->reasm_head->truesize += skb->truesize;
365 	struct mctp_sk_key *key, *any_key = NULL;
400 	 * we hold a ref on the key, and key->lock held.
402 	key = mctp_lookup_key(net, skb, netid, mh->src, &f);
405 		if (key) {
406 			msk = container_of(key->sk, struct mctp_sock, sk);
409 			 * key lookup to find the socket, but don't use this
410 			 * key for reassembly - we'll create a more specific
413 			 * this lookup requires key->peer to be MCTP_ADDR_ANY,
414 			 * it doesn't match just any key->peer.
425 		if (!key && !msk && (tag & MCTP_HDR_FLAG_TO))
434 		 * pending key.
438 			if (key) {
442 				__mctp_key_done_in(key, net, f,
444 				key = NULL;
450 		/* broadcast response or a bind() - create a key for further
453 		if (!key) {
454 			key = mctp_key_alloc(msk, netid, mh->dest, mh->src,
456 			if (!key) {
461 			/* we can queue without the key lock here, as the
462 			 * key isn't observable yet
464 			mctp_frag_queue(key, skb);
472 			rc = mctp_key_add(key, msk);
474 				trace_mctp_key_acquire(key);
476 			/* we don't need to release key->lock on exit, so
480 			mctp_key_unref(key);
481 			key = NULL;
484 			if (key->reasm_head || key->reasm_dead) {
486 				__mctp_key_done_in(key, net, f,
489 				key = NULL;
491 				rc = mctp_frag_queue(key, skb);
495 	} else if (key) {
497 		 * using the message-specific key
501 		if (!key->reasm_head)
504 			rc = mctp_frag_queue(key, skb);
507 		 * the reassembly/response key
510 			sock_queue_rcv_skb(key->sk, key->reasm_head);
511 			key->reasm_head = NULL;
512 			__mctp_key_done_in(key, net, f, MCTP_TRACE_KEY_REPLIED);
513 			key = NULL;
517 		/* not a start, no matching key */
523 	if (key) {
524 		spin_unlock_irqrestore(&key->lock, f);
525 		mctp_key_unref(key);
626 static void mctp_reserve_tag(struct net *net, struct mctp_sk_key *key,
633 	key->expiry = jiffies + mctp_key_lifetime;
634 	timer_reduce(&msk->key_expiry, key->expiry);
639 	hlist_add_head_rcu(&key->hlist, &mns->keys);
640 	hlist_add_head_rcu(&key->sklist, &msk->keys);
641 	refcount_inc(&key->refs);
654 	struct mctp_sk_key *key, *tmp;
663 	key = mctp_key_alloc(msk, netid, local, peer, 0, GFP_KERNEL);
664 	if (!key)
677 		 * lock held, they don't change over the lifetime of the key.
690 		 * 'A note on key allocations' for background.
701 		/* key must still be valid. If we find a match, clear the
713 		key->tag = __ffs(tagbits);
714 		mctp_reserve_tag(net, key, msk);
715 		trace_mctp_key_acquire(key);
717 		key->manual_alloc = manual;
718 		*tagp = key->tag;
724 		mctp_key_unref(key);
728 	return key;
738 	struct mctp_sk_key *key, *tmp;
742 	key = NULL;
761 			key = tmp;
762 			refcount_inc(&key->refs);
770 	if (!key)
774 		*tagp = key->tag;
776 	return key;
930 	struct mctp_sk_key *key;
992 			key = mctp_lookup_prealloc_tag(msk, netid, daddr,
995 			key = mctp_alloc_local_tag(msk, netid, saddr, daddr,
998 		if (IS_ERR(key)) {
999 			rc = PTR_ERR(key);
1002 		mctp_skb_set_flow(skb, key);
1003 		/* done with the key in this scope */
1004 		mctp_key_unref(key);
1007 		key = NULL;