1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37#include <net/sock.h>
38#include "core.h"
39#include "netlink.h"
40#include "name_table.h"
41#include "name_distr.h"
42#include "subscr.h"
43#include "bcast.h"
44#include "addr.h"
45#include <net/genetlink.h>
46
47#define TIPC_NAMETBL_SIZE 1024
48
49static const struct nla_policy
50tipc_nl_name_table_policy[TIPC_NLA_NAME_TABLE_MAX + 1] = {
51 [TIPC_NLA_NAME_TABLE_UNSPEC] = { .type = NLA_UNSPEC },
52 [TIPC_NLA_NAME_TABLE_PUBL] = { .type = NLA_NESTED }
53};
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68struct name_info {
69 struct list_head node_list;
70 struct list_head cluster_list;
71 struct list_head zone_list;
72 u32 node_list_size;
73 u32 cluster_list_size;
74 u32 zone_list_size;
75};
76
77
78
79
80
81
82
83struct sub_seq {
84 u32 lower;
85 u32 upper;
86 struct name_info *info;
87};
88
89
90
91
92
93
94
95
96
97
98
99
100
101struct name_seq {
102 u32 type;
103 struct sub_seq *sseqs;
104 u32 alloc;
105 u32 first_free;
106 struct hlist_node ns_list;
107 struct list_head subscriptions;
108 spinlock_t lock;
109 struct rcu_head rcu;
110};
111
112static int hash(int x)
113{
114 return x & (TIPC_NAMETBL_SIZE - 1);
115}
116
117
118
119
120static struct publication *publ_create(u32 type, u32 lower, u32 upper,
121 u32 scope, u32 node, u32 port_ref,
122 u32 key)
123{
124 struct publication *publ = kzalloc(sizeof(*publ), GFP_ATOMIC);
125 if (publ == NULL) {
126 pr_warn("Publication creation failure, no memory\n");
127 return NULL;
128 }
129
130 publ->type = type;
131 publ->lower = lower;
132 publ->upper = upper;
133 publ->scope = scope;
134 publ->node = node;
135 publ->ref = port_ref;
136 publ->key = key;
137 INIT_LIST_HEAD(&publ->pport_list);
138 return publ;
139}
140
141
142
143
144static struct sub_seq *tipc_subseq_alloc(u32 cnt)
145{
146 return kcalloc(cnt, sizeof(struct sub_seq), GFP_ATOMIC);
147}
148
149
150
151
152
153
154static struct name_seq *tipc_nameseq_create(u32 type, struct hlist_head *seq_head)
155{
156 struct name_seq *nseq = kzalloc(sizeof(*nseq), GFP_ATOMIC);
157 struct sub_seq *sseq = tipc_subseq_alloc(1);
158
159 if (!nseq || !sseq) {
160 pr_warn("Name sequence creation failed, no memory\n");
161 kfree(nseq);
162 kfree(sseq);
163 return NULL;
164 }
165
166 spin_lock_init(&nseq->lock);
167 nseq->type = type;
168 nseq->sseqs = sseq;
169 nseq->alloc = 1;
170 INIT_HLIST_NODE(&nseq->ns_list);
171 INIT_LIST_HEAD(&nseq->subscriptions);
172 hlist_add_head_rcu(&nseq->ns_list, seq_head);
173 return nseq;
174}
175
176
177
178
179
180
181static struct sub_seq *nameseq_find_subseq(struct name_seq *nseq,
182 u32 instance)
183{
184 struct sub_seq *sseqs = nseq->sseqs;
185 int low = 0;
186 int high = nseq->first_free - 1;
187 int mid;
188
189 while (low <= high) {
190 mid = (low + high) / 2;
191 if (instance < sseqs[mid].lower)
192 high = mid - 1;
193 else if (instance > sseqs[mid].upper)
194 low = mid + 1;
195 else
196 return &sseqs[mid];
197 }
198 return NULL;
199}
200
201
202
203
204
205
206
207
208
209
210static u32 nameseq_locate_subseq(struct name_seq *nseq, u32 instance)
211{
212 struct sub_seq *sseqs = nseq->sseqs;
213 int low = 0;
214 int high = nseq->first_free - 1;
215 int mid;
216
217 while (low <= high) {
218 mid = (low + high) / 2;
219 if (instance < sseqs[mid].lower)
220 high = mid - 1;
221 else if (instance > sseqs[mid].upper)
222 low = mid + 1;
223 else
224 return mid;
225 }
226 return low;
227}
228
229
230
231
232static struct publication *tipc_nameseq_insert_publ(struct net *net,
233 struct name_seq *nseq,
234 u32 type, u32 lower,
235 u32 upper, u32 scope,
236 u32 node, u32 port, u32 key)
237{
238 struct tipc_subscription *s;
239 struct tipc_subscription *st;
240 struct publication *publ;
241 struct sub_seq *sseq;
242 struct name_info *info;
243 int created_subseq = 0;
244
245 sseq = nameseq_find_subseq(nseq, lower);
246 if (sseq) {
247
248
249 if ((sseq->lower != lower) || (sseq->upper != upper)) {
250 return NULL;
251 }
252
253 info = sseq->info;
254
255
256 list_for_each_entry(publ, &info->zone_list, zone_list) {
257 if ((publ->ref == port) && (publ->key == key) &&
258 (!publ->node || (publ->node == node)))
259 return NULL;
260 }
261 } else {
262 u32 inspos;
263 struct sub_seq *freesseq;
264
265
266 inspos = nameseq_locate_subseq(nseq, lower);
267
268
269 if ((inspos < nseq->first_free) &&
270 (upper >= nseq->sseqs[inspos].lower)) {
271 return NULL;
272 }
273
274
275 if (nseq->first_free == nseq->alloc) {
276 struct sub_seq *sseqs = tipc_subseq_alloc(nseq->alloc * 2);
277
278 if (!sseqs) {
279 pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
280 type, lower, upper);
281 return NULL;
282 }
283 memcpy(sseqs, nseq->sseqs,
284 nseq->alloc * sizeof(struct sub_seq));
285 kfree(nseq->sseqs);
286 nseq->sseqs = sseqs;
287 nseq->alloc *= 2;
288 }
289
290 info = kzalloc(sizeof(*info), GFP_ATOMIC);
291 if (!info) {
292 pr_warn("Cannot publish {%u,%u,%u}, no memory\n",
293 type, lower, upper);
294 return NULL;
295 }
296
297 INIT_LIST_HEAD(&info->node_list);
298 INIT_LIST_HEAD(&info->cluster_list);
299 INIT_LIST_HEAD(&info->zone_list);
300
301
302 sseq = &nseq->sseqs[inspos];
303 freesseq = &nseq->sseqs[nseq->first_free];
304 memmove(sseq + 1, sseq, (freesseq - sseq) * sizeof(*sseq));
305 memset(sseq, 0, sizeof(*sseq));
306 nseq->first_free++;
307 sseq->lower = lower;
308 sseq->upper = upper;
309 sseq->info = info;
310 created_subseq = 1;
311 }
312
313
314 publ = publ_create(type, lower, upper, scope, node, port, key);
315 if (!publ)
316 return NULL;
317
318 list_add(&publ->zone_list, &info->zone_list);
319 info->zone_list_size++;
320
321 if (in_own_cluster(net, node)) {
322 list_add(&publ->cluster_list, &info->cluster_list);
323 info->cluster_list_size++;
324 }
325
326 if (in_own_node(net, node)) {
327 list_add(&publ->node_list, &info->node_list);
328 info->node_list_size++;
329 }
330
331
332 list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
333 tipc_subscr_report_overlap(s,
334 publ->lower,
335 publ->upper,
336 TIPC_PUBLISHED,
337 publ->ref,
338 publ->node,
339 created_subseq);
340 }
341 return publ;
342}
343
344
345
346
347
348
349
350
351
352
353
354
355static struct publication *tipc_nameseq_remove_publ(struct net *net,
356 struct name_seq *nseq,
357 u32 inst, u32 node,
358 u32 ref, u32 key)
359{
360 struct publication *publ;
361 struct sub_seq *sseq = nameseq_find_subseq(nseq, inst);
362 struct name_info *info;
363 struct sub_seq *free;
364 struct tipc_subscription *s, *st;
365 int removed_subseq = 0;
366
367 if (!sseq)
368 return NULL;
369
370 info = sseq->info;
371
372
373 list_for_each_entry(publ, &info->zone_list, zone_list) {
374 if ((publ->key == key) && (publ->ref == ref) &&
375 (!publ->node || (publ->node == node)))
376 goto found;
377 }
378 return NULL;
379
380found:
381
382 list_del(&publ->zone_list);
383 info->zone_list_size--;
384
385
386 if (in_own_cluster(net, node)) {
387 list_del(&publ->cluster_list);
388 info->cluster_list_size--;
389 }
390
391
392 if (in_own_node(net, node)) {
393 list_del(&publ->node_list);
394 info->node_list_size--;
395 }
396
397
398 if (list_empty(&info->zone_list)) {
399 kfree(info);
400 free = &nseq->sseqs[nseq->first_free--];
401 memmove(sseq, sseq + 1, (free - (sseq + 1)) * sizeof(*sseq));
402 removed_subseq = 1;
403 }
404
405
406 list_for_each_entry_safe(s, st, &nseq->subscriptions, nameseq_list) {
407 tipc_subscr_report_overlap(s,
408 publ->lower,
409 publ->upper,
410 TIPC_WITHDRAWN,
411 publ->ref,
412 publ->node,
413 removed_subseq);
414 }
415
416 return publ;
417}
418
419
420
421
422
423
424static void tipc_nameseq_subscribe(struct name_seq *nseq,
425 struct tipc_subscription *s)
426{
427 struct sub_seq *sseq = nseq->sseqs;
428
429 list_add(&s->nameseq_list, &nseq->subscriptions);
430
431 if (!sseq)
432 return;
433
434 while (sseq != &nseq->sseqs[nseq->first_free]) {
435 if (tipc_subscr_overlap(s, sseq->lower, sseq->upper)) {
436 struct publication *crs;
437 struct name_info *info = sseq->info;
438 int must_report = 1;
439
440 list_for_each_entry(crs, &info->zone_list, zone_list) {
441 tipc_subscr_report_overlap(s,
442 sseq->lower,
443 sseq->upper,
444 TIPC_PUBLISHED,
445 crs->ref,
446 crs->node,
447 must_report);
448 must_report = 0;
449 }
450 }
451 sseq++;
452 }
453}
454
455static struct name_seq *nametbl_find_seq(struct net *net, u32 type)
456{
457 struct tipc_net *tn = net_generic(net, tipc_net_id);
458 struct hlist_head *seq_head;
459 struct name_seq *ns;
460
461 seq_head = &tn->nametbl->seq_hlist[hash(type)];
462 hlist_for_each_entry_rcu(ns, seq_head, ns_list) {
463 if (ns->type == type)
464 return ns;
465 }
466
467 return NULL;
468};
469
470struct publication *tipc_nametbl_insert_publ(struct net *net, u32 type,
471 u32 lower, u32 upper, u32 scope,
472 u32 node, u32 port, u32 key)
473{
474 struct tipc_net *tn = net_generic(net, tipc_net_id);
475 struct publication *publ;
476 struct name_seq *seq = nametbl_find_seq(net, type);
477 int index = hash(type);
478
479 if ((scope < TIPC_ZONE_SCOPE) || (scope > TIPC_NODE_SCOPE) ||
480 (lower > upper)) {
481 pr_debug("Failed to publish illegal {%u,%u,%u} with scope %u\n",
482 type, lower, upper, scope);
483 return NULL;
484 }
485
486 if (!seq)
487 seq = tipc_nameseq_create(type, &tn->nametbl->seq_hlist[index]);
488 if (!seq)
489 return NULL;
490
491 spin_lock_bh(&seq->lock);
492 publ = tipc_nameseq_insert_publ(net, seq, type, lower, upper,
493 scope, node, port, key);
494 spin_unlock_bh(&seq->lock);
495 return publ;
496}
497
498struct publication *tipc_nametbl_remove_publ(struct net *net, u32 type,
499 u32 lower, u32 node, u32 ref,
500 u32 key)
501{
502 struct publication *publ;
503 struct name_seq *seq = nametbl_find_seq(net, type);
504
505 if (!seq)
506 return NULL;
507
508 spin_lock_bh(&seq->lock);
509 publ = tipc_nameseq_remove_publ(net, seq, lower, node, ref, key);
510 if (!seq->first_free && list_empty(&seq->subscriptions)) {
511 hlist_del_init_rcu(&seq->ns_list);
512 kfree(seq->sseqs);
513 spin_unlock_bh(&seq->lock);
514 kfree_rcu(seq, rcu);
515 return publ;
516 }
517 spin_unlock_bh(&seq->lock);
518 return publ;
519}
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534u32 tipc_nametbl_translate(struct net *net, u32 type, u32 instance,
535 u32 *destnode)
536{
537 struct tipc_net *tn = net_generic(net, tipc_net_id);
538 struct sub_seq *sseq;
539 struct name_info *info;
540 struct publication *publ;
541 struct name_seq *seq;
542 u32 ref = 0;
543 u32 node = 0;
544
545 if (!tipc_in_scope(*destnode, tn->own_addr))
546 return 0;
547
548 rcu_read_lock();
549 seq = nametbl_find_seq(net, type);
550 if (unlikely(!seq))
551 goto not_found;
552 spin_lock_bh(&seq->lock);
553 sseq = nameseq_find_subseq(seq, instance);
554 if (unlikely(!sseq))
555 goto no_match;
556 info = sseq->info;
557
558
559 if (likely(!*destnode)) {
560 if (!list_empty(&info->node_list)) {
561 publ = list_first_entry(&info->node_list,
562 struct publication,
563 node_list);
564 list_move_tail(&publ->node_list,
565 &info->node_list);
566 } else if (!list_empty(&info->cluster_list)) {
567 publ = list_first_entry(&info->cluster_list,
568 struct publication,
569 cluster_list);
570 list_move_tail(&publ->cluster_list,
571 &info->cluster_list);
572 } else {
573 publ = list_first_entry(&info->zone_list,
574 struct publication,
575 zone_list);
576 list_move_tail(&publ->zone_list,
577 &info->zone_list);
578 }
579 }
580
581
582 else if (*destnode == tn->own_addr) {
583 if (list_empty(&info->node_list))
584 goto no_match;
585 publ = list_first_entry(&info->node_list, struct publication,
586 node_list);
587 list_move_tail(&publ->node_list, &info->node_list);
588 } else if (in_own_cluster_exact(net, *destnode)) {
589 if (list_empty(&info->cluster_list))
590 goto no_match;
591 publ = list_first_entry(&info->cluster_list, struct publication,
592 cluster_list);
593 list_move_tail(&publ->cluster_list, &info->cluster_list);
594 } else {
595 publ = list_first_entry(&info->zone_list, struct publication,
596 zone_list);
597 list_move_tail(&publ->zone_list, &info->zone_list);
598 }
599
600 ref = publ->ref;
601 node = publ->node;
602no_match:
603 spin_unlock_bh(&seq->lock);
604not_found:
605 rcu_read_unlock();
606 *destnode = node;
607 return ref;
608}
609
610
611
612
613
614
615
616
617
618
619
620
621
622int tipc_nametbl_mc_translate(struct net *net, u32 type, u32 lower, u32 upper,
623 u32 limit, struct tipc_plist *dports)
624{
625 struct name_seq *seq;
626 struct sub_seq *sseq;
627 struct sub_seq *sseq_stop;
628 struct name_info *info;
629 int res = 0;
630
631 rcu_read_lock();
632 seq = nametbl_find_seq(net, type);
633 if (!seq)
634 goto exit;
635
636 spin_lock_bh(&seq->lock);
637 sseq = seq->sseqs + nameseq_locate_subseq(seq, lower);
638 sseq_stop = seq->sseqs + seq->first_free;
639 for (; sseq != sseq_stop; sseq++) {
640 struct publication *publ;
641
642 if (sseq->lower > upper)
643 break;
644
645 info = sseq->info;
646 list_for_each_entry(publ, &info->node_list, node_list) {
647 if (publ->scope <= limit)
648 tipc_plist_push(dports, publ->ref);
649 }
650
651 if (info->cluster_list_size != info->node_list_size)
652 res = 1;
653 }
654 spin_unlock_bh(&seq->lock);
655exit:
656 rcu_read_unlock();
657 return res;
658}
659
660
661
662
663struct publication *tipc_nametbl_publish(struct net *net, u32 type, u32 lower,
664 u32 upper, u32 scope, u32 port_ref,
665 u32 key)
666{
667 struct publication *publ;
668 struct sk_buff *buf = NULL;
669 struct tipc_net *tn = net_generic(net, tipc_net_id);
670
671 spin_lock_bh(&tn->nametbl_lock);
672 if (tn->nametbl->local_publ_count >= TIPC_MAX_PUBLICATIONS) {
673 pr_warn("Publication failed, local publication limit reached (%u)\n",
674 TIPC_MAX_PUBLICATIONS);
675 spin_unlock_bh(&tn->nametbl_lock);
676 return NULL;
677 }
678
679 publ = tipc_nametbl_insert_publ(net, type, lower, upper, scope,
680 tn->own_addr, port_ref, key);
681 if (likely(publ)) {
682 tn->nametbl->local_publ_count++;
683 buf = tipc_named_publish(net, publ);
684
685 tipc_named_process_backlog(net);
686 }
687 spin_unlock_bh(&tn->nametbl_lock);
688
689 if (buf)
690 named_cluster_distribute(net, buf);
691 return publ;
692}
693
694
695
696
697int tipc_nametbl_withdraw(struct net *net, u32 type, u32 lower, u32 ref,
698 u32 key)
699{
700 struct publication *publ;
701 struct sk_buff *skb = NULL;
702 struct tipc_net *tn = net_generic(net, tipc_net_id);
703
704 spin_lock_bh(&tn->nametbl_lock);
705 publ = tipc_nametbl_remove_publ(net, type, lower, tn->own_addr,
706 ref, key);
707 if (likely(publ)) {
708 tn->nametbl->local_publ_count--;
709 skb = tipc_named_withdraw(net, publ);
710
711 tipc_named_process_backlog(net);
712 list_del_init(&publ->pport_list);
713 kfree_rcu(publ, rcu);
714 } else {
715 pr_err("Unable to remove local publication\n"
716 "(type=%u, lower=%u, ref=%u, key=%u)\n",
717 type, lower, ref, key);
718 }
719 spin_unlock_bh(&tn->nametbl_lock);
720
721 if (skb) {
722 named_cluster_distribute(net, skb);
723 return 1;
724 }
725 return 0;
726}
727
728
729
730
731void tipc_nametbl_subscribe(struct tipc_subscription *s)
732{
733 struct tipc_net *tn = net_generic(s->net, tipc_net_id);
734 u32 type = s->seq.type;
735 int index = hash(type);
736 struct name_seq *seq;
737
738 spin_lock_bh(&tn->nametbl_lock);
739 seq = nametbl_find_seq(s->net, type);
740 if (!seq)
741 seq = tipc_nameseq_create(type, &tn->nametbl->seq_hlist[index]);
742 if (seq) {
743 spin_lock_bh(&seq->lock);
744 tipc_nameseq_subscribe(seq, s);
745 spin_unlock_bh(&seq->lock);
746 } else {
747 pr_warn("Failed to create subscription for {%u,%u,%u}\n",
748 s->seq.type, s->seq.lower, s->seq.upper);
749 }
750 spin_unlock_bh(&tn->nametbl_lock);
751}
752
753
754
755
756void tipc_nametbl_unsubscribe(struct tipc_subscription *s)
757{
758 struct tipc_net *tn = net_generic(s->net, tipc_net_id);
759 struct name_seq *seq;
760
761 spin_lock_bh(&tn->nametbl_lock);
762 seq = nametbl_find_seq(s->net, s->seq.type);
763 if (seq != NULL) {
764 spin_lock_bh(&seq->lock);
765 list_del_init(&s->nameseq_list);
766 if (!seq->first_free && list_empty(&seq->subscriptions)) {
767 hlist_del_init_rcu(&seq->ns_list);
768 kfree(seq->sseqs);
769 spin_unlock_bh(&seq->lock);
770 kfree_rcu(seq, rcu);
771 } else {
772 spin_unlock_bh(&seq->lock);
773 }
774 }
775 spin_unlock_bh(&tn->nametbl_lock);
776}
777
778int tipc_nametbl_init(struct net *net)
779{
780 struct tipc_net *tn = net_generic(net, tipc_net_id);
781 struct name_table *tipc_nametbl;
782 int i;
783
784 tipc_nametbl = kzalloc(sizeof(*tipc_nametbl), GFP_ATOMIC);
785 if (!tipc_nametbl)
786 return -ENOMEM;
787
788 for (i = 0; i < TIPC_NAMETBL_SIZE; i++)
789 INIT_HLIST_HEAD(&tipc_nametbl->seq_hlist[i]);
790
791 INIT_LIST_HEAD(&tipc_nametbl->publ_list[TIPC_ZONE_SCOPE]);
792 INIT_LIST_HEAD(&tipc_nametbl->publ_list[TIPC_CLUSTER_SCOPE]);
793 INIT_LIST_HEAD(&tipc_nametbl->publ_list[TIPC_NODE_SCOPE]);
794 tn->nametbl = tipc_nametbl;
795 spin_lock_init(&tn->nametbl_lock);
796 return 0;
797}
798
799
800
801
802
803
804static void tipc_purge_publications(struct net *net, struct name_seq *seq)
805{
806 struct publication *publ, *safe;
807 struct sub_seq *sseq;
808 struct name_info *info;
809
810 spin_lock_bh(&seq->lock);
811 sseq = seq->sseqs;
812 info = sseq->info;
813 list_for_each_entry_safe(publ, safe, &info->zone_list, zone_list) {
814 tipc_nameseq_remove_publ(net, seq, publ->lower, publ->node,
815 publ->ref, publ->key);
816 kfree_rcu(publ, rcu);
817 }
818 hlist_del_init_rcu(&seq->ns_list);
819 kfree(seq->sseqs);
820 spin_unlock_bh(&seq->lock);
821
822 kfree_rcu(seq, rcu);
823}
824
825void tipc_nametbl_stop(struct net *net)
826{
827 u32 i;
828 struct name_seq *seq;
829 struct hlist_head *seq_head;
830 struct tipc_net *tn = net_generic(net, tipc_net_id);
831 struct name_table *tipc_nametbl = tn->nametbl;
832
833
834
835
836 spin_lock_bh(&tn->nametbl_lock);
837 for (i = 0; i < TIPC_NAMETBL_SIZE; i++) {
838 if (hlist_empty(&tipc_nametbl->seq_hlist[i]))
839 continue;
840 seq_head = &tipc_nametbl->seq_hlist[i];
841 hlist_for_each_entry_rcu(seq, seq_head, ns_list) {
842 tipc_purge_publications(net, seq);
843 }
844 }
845 spin_unlock_bh(&tn->nametbl_lock);
846
847 synchronize_net();
848 kfree(tipc_nametbl);
849
850}
851
852static int __tipc_nl_add_nametable_publ(struct tipc_nl_msg *msg,
853 struct name_seq *seq,
854 struct sub_seq *sseq, u32 *last_publ)
855{
856 void *hdr;
857 struct nlattr *attrs;
858 struct nlattr *publ;
859 struct publication *p;
860
861 if (*last_publ) {
862 list_for_each_entry(p, &sseq->info->zone_list, zone_list)
863 if (p->key == *last_publ)
864 break;
865 if (p->key != *last_publ)
866 return -EPIPE;
867 } else {
868 p = list_first_entry(&sseq->info->zone_list, struct publication,
869 zone_list);
870 }
871
872 list_for_each_entry_from(p, &sseq->info->zone_list, zone_list) {
873 *last_publ = p->key;
874
875 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq,
876 &tipc_genl_family, NLM_F_MULTI,
877 TIPC_NL_NAME_TABLE_GET);
878 if (!hdr)
879 return -EMSGSIZE;
880
881 attrs = nla_nest_start(msg->skb, TIPC_NLA_NAME_TABLE);
882 if (!attrs)
883 goto msg_full;
884
885 publ = nla_nest_start(msg->skb, TIPC_NLA_NAME_TABLE_PUBL);
886 if (!publ)
887 goto attr_msg_full;
888
889 if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_TYPE, seq->type))
890 goto publ_msg_full;
891 if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_LOWER, sseq->lower))
892 goto publ_msg_full;
893 if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_UPPER, sseq->upper))
894 goto publ_msg_full;
895 if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_SCOPE, p->scope))
896 goto publ_msg_full;
897 if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_NODE, p->node))
898 goto publ_msg_full;
899 if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_REF, p->ref))
900 goto publ_msg_full;
901 if (nla_put_u32(msg->skb, TIPC_NLA_PUBL_KEY, p->key))
902 goto publ_msg_full;
903
904 nla_nest_end(msg->skb, publ);
905 nla_nest_end(msg->skb, attrs);
906 genlmsg_end(msg->skb, hdr);
907 }
908 *last_publ = 0;
909
910 return 0;
911
912publ_msg_full:
913 nla_nest_cancel(msg->skb, publ);
914attr_msg_full:
915 nla_nest_cancel(msg->skb, attrs);
916msg_full:
917 genlmsg_cancel(msg->skb, hdr);
918
919 return -EMSGSIZE;
920}
921
922static int __tipc_nl_subseq_list(struct tipc_nl_msg *msg, struct name_seq *seq,
923 u32 *last_lower, u32 *last_publ)
924{
925 struct sub_seq *sseq;
926 struct sub_seq *sseq_start;
927 int err;
928
929 if (*last_lower) {
930 sseq_start = nameseq_find_subseq(seq, *last_lower);
931 if (!sseq_start)
932 return -EPIPE;
933 } else {
934 sseq_start = seq->sseqs;
935 }
936
937 for (sseq = sseq_start; sseq != &seq->sseqs[seq->first_free]; sseq++) {
938 err = __tipc_nl_add_nametable_publ(msg, seq, sseq, last_publ);
939 if (err) {
940 *last_lower = sseq->lower;
941 return err;
942 }
943 }
944 *last_lower = 0;
945
946 return 0;
947}
948
949static int tipc_nl_seq_list(struct net *net, struct tipc_nl_msg *msg,
950 u32 *last_type, u32 *last_lower, u32 *last_publ)
951{
952 struct tipc_net *tn = net_generic(net, tipc_net_id);
953 struct hlist_head *seq_head;
954 struct name_seq *seq = NULL;
955 int err;
956 int i;
957
958 if (*last_type)
959 i = hash(*last_type);
960 else
961 i = 0;
962
963 for (; i < TIPC_NAMETBL_SIZE; i++) {
964 seq_head = &tn->nametbl->seq_hlist[i];
965
966 if (*last_type) {
967 seq = nametbl_find_seq(net, *last_type);
968 if (!seq)
969 return -EPIPE;
970 } else {
971 hlist_for_each_entry_rcu(seq, seq_head, ns_list)
972 break;
973 if (!seq)
974 continue;
975 }
976
977 hlist_for_each_entry_from_rcu(seq, ns_list) {
978 spin_lock_bh(&seq->lock);
979 err = __tipc_nl_subseq_list(msg, seq, last_lower,
980 last_publ);
981
982 if (err) {
983 *last_type = seq->type;
984 spin_unlock_bh(&seq->lock);
985 return err;
986 }
987 spin_unlock_bh(&seq->lock);
988 }
989 *last_type = 0;
990 }
991 return 0;
992}
993
994int tipc_nl_name_table_dump(struct sk_buff *skb, struct netlink_callback *cb)
995{
996 int err;
997 int done = cb->args[3];
998 u32 last_type = cb->args[0];
999 u32 last_lower = cb->args[1];
1000 u32 last_publ = cb->args[2];
1001 struct net *net = sock_net(skb->sk);
1002 struct tipc_nl_msg msg;
1003
1004 if (done)
1005 return 0;
1006
1007 msg.skb = skb;
1008 msg.portid = NETLINK_CB(cb->skb).portid;
1009 msg.seq = cb->nlh->nlmsg_seq;
1010
1011 rcu_read_lock();
1012 err = tipc_nl_seq_list(net, &msg, &last_type, &last_lower, &last_publ);
1013 if (!err) {
1014 done = 1;
1015 } else if (err != -EMSGSIZE) {
1016
1017
1018
1019
1020
1021
1022 cb->prev_seq = 1;
1023 }
1024 rcu_read_unlock();
1025
1026 cb->args[0] = last_type;
1027 cb->args[1] = last_lower;
1028 cb->args[2] = last_publ;
1029 cb->args[3] = done;
1030
1031 return skb->len;
1032}
1033
1034void tipc_plist_push(struct tipc_plist *pl, u32 port)
1035{
1036 struct tipc_plist *nl;
1037
1038 if (likely(!pl->port)) {
1039 pl->port = port;
1040 return;
1041 }
1042 if (pl->port == port)
1043 return;
1044 list_for_each_entry(nl, &pl->list, list) {
1045 if (nl->port == port)
1046 return;
1047 }
1048 nl = kmalloc(sizeof(*nl), GFP_ATOMIC);
1049 if (nl) {
1050 nl->port = port;
1051 list_add(&nl->list, &pl->list);
1052 }
1053}
1054
1055u32 tipc_plist_pop(struct tipc_plist *pl)
1056{
1057 struct tipc_plist *nl;
1058 u32 port = 0;
1059
1060 if (likely(list_empty(&pl->list))) {
1061 port = pl->port;
1062 pl->port = 0;
1063 return port;
1064 }
1065 nl = list_first_entry(&pl->list, typeof(*nl), list);
1066 port = nl->port;
1067 list_del(&nl->list);
1068 kfree(nl);
1069 return port;
1070}
1071