Eric Lee / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit ae245557f87fffe2e1c39ba07524024e650e822b

Authored by Parthasarathy Bhuvaragan
Committed by David S. Miller
1 parent f3ad288c56

tipc: donot create timers if subscription timeout = TIPC_WAIT_FOREVER 

Until now, we create timers even for the subscription requests
with timeout = TIPC_WAIT_FOREVER.
This can be improved by avoiding timer creation when the timeout
is set to TIPC_WAIT_FOREVER.

In this commit, we introduce a check to creates timers only
when timeout != TIPC_WAIT_FOREVER.

Acked-by: Ying Xue <ying.xue@windriver.com>
Reviewed-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: Parthasarathy Bhuvaragan <parthasarathy.bhuvaragan@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 1 changed file with 11 additions and 3 deletions Inline Diff

1 /* 1 /*
2 * net/tipc/subscr.c: TIPC network topology service 2 * net/tipc/subscr.c: TIPC network topology service
3 * 3 *
4 * Copyright (c) 2000-2006, Ericsson AB 4 * Copyright (c) 2000-2006, Ericsson AB
5 * Copyright (c) 2005-2007, 2010-2013, Wind River Systems 5 * Copyright (c) 2005-2007, 2010-2013, Wind River Systems
6 * All rights reserved. 6 * All rights reserved.
7 * 7 *
8 * Redistribution and use in source and binary forms, with or without 8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met: 9 * modification, are permitted provided that the following conditions are met:
10 * 10 *
11 * 1. Redistributions of source code must retain the above copyright 11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer. 12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright 13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the 14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution. 15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its 16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from 17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission. 18 * this software without specific prior written permission.
19 * 19 *
20 * Alternatively, this software may be distributed under the terms of the 20 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free 21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation. 22 * Software Foundation.
23 * 23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE. 34 * POSSIBILITY OF SUCH DAMAGE.
35 */ 35 */
36 36
37 #include "core.h" 37 #include "core.h"
38 #include "name_table.h" 38 #include "name_table.h"
39 #include "subscr.h" 39 #include "subscr.h"
40 40
41 /** 41 /**
42 * struct tipc_subscriber - TIPC network topology subscriber 42 * struct tipc_subscriber - TIPC network topology subscriber
43 * @kref: reference counter to tipc_subscription object 43 * @kref: reference counter to tipc_subscription object
44 * @conid: connection identifier to server connecting to subscriber 44 * @conid: connection identifier to server connecting to subscriber
45 * @lock: control access to subscriber 45 * @lock: control access to subscriber
46 * @subscrp_list: list of subscription objects for this subscriber 46 * @subscrp_list: list of subscription objects for this subscriber
47 */ 47 */
48 struct tipc_subscriber { 48 struct tipc_subscriber {
49 struct kref kref; 49 struct kref kref;
50 int conid; 50 int conid;
51 spinlock_t lock; 51 spinlock_t lock;
52 struct list_head subscrp_list; 52 struct list_head subscrp_list;
53 }; 53 };
54 54
55 static void tipc_subscrp_delete(struct tipc_subscription *sub); 55 static void tipc_subscrp_delete(struct tipc_subscription *sub);
56 static void tipc_subscrb_put(struct tipc_subscriber *subscriber); 56 static void tipc_subscrb_put(struct tipc_subscriber *subscriber);
57 57
58 /** 58 /**
59 * htohl - convert value to endianness used by destination 59 * htohl - convert value to endianness used by destination
60 * @in: value to convert 60 * @in: value to convert
61 * @swap: non-zero if endianness must be reversed 61 * @swap: non-zero if endianness must be reversed
62 * 62 *
63 * Returns converted value 63 * Returns converted value
64 */ 64 */
65 static u32 htohl(u32 in, int swap) 65 static u32 htohl(u32 in, int swap)
66 { 66 {
67 return swap ? swab32(in) : in; 67 return swap ? swab32(in) : in;
68 } 68 }
69 69
70 static void tipc_subscrp_send_event(struct tipc_subscription *sub, 70 static void tipc_subscrp_send_event(struct tipc_subscription *sub,
71 u32 found_lower, u32 found_upper, 71 u32 found_lower, u32 found_upper,
72 u32 event, u32 port_ref, u32 node) 72 u32 event, u32 port_ref, u32 node)
73 { 73 {
74 struct tipc_net *tn = net_generic(sub->net, tipc_net_id); 74 struct tipc_net *tn = net_generic(sub->net, tipc_net_id);
75 struct tipc_subscriber *subscriber = sub->subscriber; 75 struct tipc_subscriber *subscriber = sub->subscriber;
76 struct kvec msg_sect; 76 struct kvec msg_sect;
77 77
78 msg_sect.iov_base = (void *)&sub->evt; 78 msg_sect.iov_base = (void *)&sub->evt;
79 msg_sect.iov_len = sizeof(struct tipc_event); 79 msg_sect.iov_len = sizeof(struct tipc_event);
80 sub->evt.event = htohl(event, sub->swap); 80 sub->evt.event = htohl(event, sub->swap);
81 sub->evt.found_lower = htohl(found_lower, sub->swap); 81 sub->evt.found_lower = htohl(found_lower, sub->swap);
82 sub->evt.found_upper = htohl(found_upper, sub->swap); 82 sub->evt.found_upper = htohl(found_upper, sub->swap);
83 sub->evt.port.ref = htohl(port_ref, sub->swap); 83 sub->evt.port.ref = htohl(port_ref, sub->swap);
84 sub->evt.port.node = htohl(node, sub->swap); 84 sub->evt.port.node = htohl(node, sub->swap);
85 tipc_conn_sendmsg(tn->topsrv, subscriber->conid, NULL, 85 tipc_conn_sendmsg(tn->topsrv, subscriber->conid, NULL,
86 msg_sect.iov_base, msg_sect.iov_len); 86 msg_sect.iov_base, msg_sect.iov_len);
87 } 87 }
88 88
89 /** 89 /**
90 * tipc_subscrp_check_overlap - test for subscription overlap with the 90 * tipc_subscrp_check_overlap - test for subscription overlap with the
91 * given values 91 * given values
92 * 92 *
93 * Returns 1 if there is overlap, otherwise 0. 93 * Returns 1 if there is overlap, otherwise 0.
94 */ 94 */
95 int tipc_subscrp_check_overlap(struct tipc_name_seq *seq, u32 found_lower, 95 int tipc_subscrp_check_overlap(struct tipc_name_seq *seq, u32 found_lower,
96 u32 found_upper) 96 u32 found_upper)
97 { 97 {
98 if (found_lower < seq->lower) 98 if (found_lower < seq->lower)
99 found_lower = seq->lower; 99 found_lower = seq->lower;
100 if (found_upper > seq->upper) 100 if (found_upper > seq->upper)
101 found_upper = seq->upper; 101 found_upper = seq->upper;
102 if (found_lower > found_upper) 102 if (found_lower > found_upper)
103 return 0; 103 return 0;
104 return 1; 104 return 1;
105 } 105 }
106 106
107 u32 tipc_subscrp_convert_seq_type(u32 type, int swap) 107 u32 tipc_subscrp_convert_seq_type(u32 type, int swap)
108 { 108 {
109 return htohl(type, swap); 109 return htohl(type, swap);
110 } 110 }
111 111
112 void tipc_subscrp_convert_seq(struct tipc_name_seq *in, int swap, 112 void tipc_subscrp_convert_seq(struct tipc_name_seq *in, int swap,
113 struct tipc_name_seq *out) 113 struct tipc_name_seq *out)
114 { 114 {
115 out->type = htohl(in->type, swap); 115 out->type = htohl(in->type, swap);
116 out->lower = htohl(in->lower, swap); 116 out->lower = htohl(in->lower, swap);
117 out->upper = htohl(in->upper, swap); 117 out->upper = htohl(in->upper, swap);
118 } 118 }
119 119
120 void tipc_subscrp_report_overlap(struct tipc_subscription *sub, u32 found_lower, 120 void tipc_subscrp_report_overlap(struct tipc_subscription *sub, u32 found_lower,
121 u32 found_upper, u32 event, u32 port_ref, 121 u32 found_upper, u32 event, u32 port_ref,
122 u32 node, int must) 122 u32 node, int must)
123 { 123 {
124 struct tipc_name_seq seq; 124 struct tipc_name_seq seq;
125 125
126 tipc_subscrp_convert_seq(&sub->evt.s.seq, sub->swap, &seq); 126 tipc_subscrp_convert_seq(&sub->evt.s.seq, sub->swap, &seq);
127 if (!tipc_subscrp_check_overlap(&seq, found_lower, found_upper)) 127 if (!tipc_subscrp_check_overlap(&seq, found_lower, found_upper))
128 return; 128 return;
129 if (!must && 129 if (!must &&
130 !(htohl(sub->evt.s.filter, sub->swap) & TIPC_SUB_PORTS)) 130 !(htohl(sub->evt.s.filter, sub->swap) & TIPC_SUB_PORTS))
131 return; 131 return;
132 132
133 tipc_subscrp_send_event(sub, found_lower, found_upper, event, port_ref, 133 tipc_subscrp_send_event(sub, found_lower, found_upper, event, port_ref,
134 node); 134 node);
135 } 135 }
136 136
137 static void tipc_subscrp_timeout(unsigned long data) 137 static void tipc_subscrp_timeout(unsigned long data)
138 { 138 {
139 struct tipc_subscription *sub = (struct tipc_subscription *)data; 139 struct tipc_subscription *sub = (struct tipc_subscription *)data;
140 struct tipc_subscriber *subscriber = sub->subscriber; 140 struct tipc_subscriber *subscriber = sub->subscriber;
141 141
142 /* Notify subscriber of timeout */ 142 /* Notify subscriber of timeout */
143 tipc_subscrp_send_event(sub, sub->evt.s.seq.lower, sub->evt.s.seq.upper, 143 tipc_subscrp_send_event(sub, sub->evt.s.seq.lower, sub->evt.s.seq.upper,
144 TIPC_SUBSCR_TIMEOUT, 0, 0); 144 TIPC_SUBSCR_TIMEOUT, 0, 0);
145 145
146 spin_lock_bh(&subscriber->lock); 146 spin_lock_bh(&subscriber->lock);
147 tipc_subscrp_delete(sub); 147 tipc_subscrp_delete(sub);
148 spin_unlock_bh(&subscriber->lock); 148 spin_unlock_bh(&subscriber->lock);
149 149
150 tipc_subscrb_put(subscriber); 150 tipc_subscrb_put(subscriber);
151 } 151 }
152 152
153 static void tipc_subscrb_kref_release(struct kref *kref) 153 static void tipc_subscrb_kref_release(struct kref *kref)
154 { 154 {
155 struct tipc_subscriber *subcriber = container_of(kref, 155 struct tipc_subscriber *subcriber = container_of(kref,
156 struct tipc_subscriber, kref); 156 struct tipc_subscriber, kref);
157 157
158 kfree(subcriber); 158 kfree(subcriber);
159 } 159 }
160 160
161 static void tipc_subscrb_put(struct tipc_subscriber *subscriber) 161 static void tipc_subscrb_put(struct tipc_subscriber *subscriber)
162 { 162 {
163 kref_put(&subscriber->kref, tipc_subscrb_kref_release); 163 kref_put(&subscriber->kref, tipc_subscrb_kref_release);
164 } 164 }
165 165
166 static void tipc_subscrb_get(struct tipc_subscriber *subscriber) 166 static void tipc_subscrb_get(struct tipc_subscriber *subscriber)
167 { 167 {
168 kref_get(&subscriber->kref); 168 kref_get(&subscriber->kref);
169 } 169 }
170 170
171 static struct tipc_subscriber *tipc_subscrb_create(int conid) 171 static struct tipc_subscriber *tipc_subscrb_create(int conid)
172 { 172 {
173 struct tipc_subscriber *subscriber; 173 struct tipc_subscriber *subscriber;
174 174
175 subscriber = kzalloc(sizeof(*subscriber), GFP_ATOMIC); 175 subscriber = kzalloc(sizeof(*subscriber), GFP_ATOMIC);
176 if (!subscriber) { 176 if (!subscriber) {
177 pr_warn("Subscriber rejected, no memory\n"); 177 pr_warn("Subscriber rejected, no memory\n");
178 return NULL; 178 return NULL;
179 } 179 }
180 kref_init(&subscriber->kref); 180 kref_init(&subscriber->kref);
181 INIT_LIST_HEAD(&subscriber->subscrp_list); 181 INIT_LIST_HEAD(&subscriber->subscrp_list);
182 subscriber->conid = conid; 182 subscriber->conid = conid;
183 spin_lock_init(&subscriber->lock); 183 spin_lock_init(&subscriber->lock);
184 184
185 return subscriber; 185 return subscriber;
186 } 186 }
187 187
188 static void tipc_subscrb_delete(struct tipc_subscriber *subscriber) 188 static void tipc_subscrb_delete(struct tipc_subscriber *subscriber)
189 { 189 {
190 struct tipc_subscription *sub, *temp; 190 struct tipc_subscription *sub, *temp;
191 u32 timeout;
191 192
192 spin_lock_bh(&subscriber->lock); 193 spin_lock_bh(&subscriber->lock);
193 /* Destroy any existing subscriptions for subscriber */ 194 /* Destroy any existing subscriptions for subscriber */
194 list_for_each_entry_safe(sub, temp, &subscriber->subscrp_list, 195 list_for_each_entry_safe(sub, temp, &subscriber->subscrp_list,
195 subscrp_list) { 196 subscrp_list) {
196 if (del_timer(&sub->timer)) { 197 timeout = htohl(sub->evt.s.timeout, sub->swap);
198 if ((timeout == TIPC_WAIT_FOREVER) || del_timer(&sub->timer)) {
197 tipc_subscrp_delete(sub); 199 tipc_subscrp_delete(sub);
198 tipc_subscrb_put(subscriber); 200 tipc_subscrb_put(subscriber);
199 } 201 }
200 } 202 }
201 spin_unlock_bh(&subscriber->lock); 203 spin_unlock_bh(&subscriber->lock);
202 204
203 tipc_subscrb_put(subscriber); 205 tipc_subscrb_put(subscriber);
204 } 206 }
205 207
206 static void tipc_subscrp_delete(struct tipc_subscription *sub) 208 static void tipc_subscrp_delete(struct tipc_subscription *sub)
207 { 209 {
208 struct tipc_net *tn = net_generic(sub->net, tipc_net_id); 210 struct tipc_net *tn = net_generic(sub->net, tipc_net_id);
209 211
210 tipc_nametbl_unsubscribe(sub); 212 tipc_nametbl_unsubscribe(sub);
211 list_del(&sub->subscrp_list); 213 list_del(&sub->subscrp_list);
212 kfree(sub); 214 kfree(sub);
213 atomic_dec(&tn->subscription_count); 215 atomic_dec(&tn->subscription_count);
214 } 216 }
215 217
216 static void tipc_subscrp_cancel(struct tipc_subscr *s, 218 static void tipc_subscrp_cancel(struct tipc_subscr *s,
217 struct tipc_subscriber *subscriber) 219 struct tipc_subscriber *subscriber)
218 { 220 {
219 struct tipc_subscription *sub, *temp; 221 struct tipc_subscription *sub, *temp;
222 u32 timeout;
220 223
221 spin_lock_bh(&subscriber->lock); 224 spin_lock_bh(&subscriber->lock);
222 /* Find first matching subscription, exit if not found */ 225 /* Find first matching subscription, exit if not found */
223 list_for_each_entry_safe(sub, temp, &subscriber->subscrp_list, 226 list_for_each_entry_safe(sub, temp, &subscriber->subscrp_list,
224 subscrp_list) { 227 subscrp_list) {
225 if (!memcmp(s, &sub->evt.s, sizeof(struct tipc_subscr))) { 228 if (!memcmp(s, &sub->evt.s, sizeof(struct tipc_subscr))) {
226 if (del_timer(&sub->timer)) { 229 timeout = htohl(sub->evt.s.timeout, sub->swap);
230 if ((timeout == TIPC_WAIT_FOREVER) ||
231 del_timer(&sub->timer)) {
227 tipc_subscrp_delete(sub); 232 tipc_subscrp_delete(sub);
228 tipc_subscrb_put(subscriber); 233 tipc_subscrb_put(subscriber);
229 } 234 }
230 break; 235 break;
231 } 236 }
232 } 237 }
233 spin_unlock_bh(&subscriber->lock); 238 spin_unlock_bh(&subscriber->lock);
234 } 239 }
235 240
236 static struct tipc_subscription *tipc_subscrp_create(struct net *net, 241 static struct tipc_subscription *tipc_subscrp_create(struct net *net,
237 struct tipc_subscr *s, 242 struct tipc_subscr *s,
238 int swap) 243 int swap)
239 { 244 {
240 struct tipc_net *tn = net_generic(net, tipc_net_id); 245 struct tipc_net *tn = net_generic(net, tipc_net_id);
241 struct tipc_subscription *sub; 246 struct tipc_subscription *sub;
242 u32 filter = htohl(s->filter, swap); 247 u32 filter = htohl(s->filter, swap);
243 248
244 /* Refuse subscription if global limit exceeded */ 249 /* Refuse subscription if global limit exceeded */
245 if (atomic_read(&tn->subscription_count) >= TIPC_MAX_SUBSCRIPTIONS) { 250 if (atomic_read(&tn->subscription_count) >= TIPC_MAX_SUBSCRIPTIONS) {
246 pr_warn("Subscription rejected, limit reached (%u)\n", 251 pr_warn("Subscription rejected, limit reached (%u)\n",
247 TIPC_MAX_SUBSCRIPTIONS); 252 TIPC_MAX_SUBSCRIPTIONS);
248 return NULL; 253 return NULL;
249 } 254 }
250 255
251 /* Allocate subscription object */ 256 /* Allocate subscription object */
252 sub = kmalloc(sizeof(*sub), GFP_ATOMIC); 257 sub = kmalloc(sizeof(*sub), GFP_ATOMIC);
253 if (!sub) { 258 if (!sub) {
254 pr_warn("Subscription rejected, no memory\n"); 259 pr_warn("Subscription rejected, no memory\n");
255 return NULL; 260 return NULL;
256 } 261 }
257 262
258 /* Initialize subscription object */ 263 /* Initialize subscription object */
259 sub->net = net; 264 sub->net = net;
260 if (((filter & TIPC_SUB_PORTS) && (filter & TIPC_SUB_SERVICE)) || 265 if (((filter & TIPC_SUB_PORTS) && (filter & TIPC_SUB_SERVICE)) ||
261 (htohl(s->seq.lower, swap) > htohl(s->seq.upper, swap))) { 266 (htohl(s->seq.lower, swap) > htohl(s->seq.upper, swap))) {
262 pr_warn("Subscription rejected, illegal request\n"); 267 pr_warn("Subscription rejected, illegal request\n");
263 kfree(sub); 268 kfree(sub);
264 return NULL; 269 return NULL;
265 } 270 }
266 271
267 sub->swap = swap; 272 sub->swap = swap;
268 memcpy(&sub->evt.s, s, sizeof(*s)); 273 memcpy(&sub->evt.s, s, sizeof(*s));
269 atomic_inc(&tn->subscription_count); 274 atomic_inc(&tn->subscription_count);
270 setup_timer(&sub->timer, tipc_subscrp_timeout, (unsigned long)sub);
271 return sub; 275 return sub;
272 } 276 }
273 277
274 static void tipc_subscrp_subscribe(struct net *net, struct tipc_subscr *s, 278 static void tipc_subscrp_subscribe(struct net *net, struct tipc_subscr *s,
275 struct tipc_subscriber *subscriber, int swap) 279 struct tipc_subscriber *subscriber, int swap)
276 { 280 {
277 struct tipc_net *tn = net_generic(net, tipc_net_id); 281 struct tipc_net *tn = net_generic(net, tipc_net_id);
278 struct tipc_subscription *sub = NULL; 282 struct tipc_subscription *sub = NULL;
279 u32 timeout; 283 u32 timeout;
280 284
281 sub = tipc_subscrp_create(net, s, swap); 285 sub = tipc_subscrp_create(net, s, swap);
282 if (!sub) 286 if (!sub)
283 return tipc_conn_terminate(tn->topsrv, subscriber->conid); 287 return tipc_conn_terminate(tn->topsrv, subscriber->conid);
284 288
285 spin_lock_bh(&subscriber->lock); 289 spin_lock_bh(&subscriber->lock);
286 list_add(&sub->subscrp_list, &subscriber->subscrp_list); 290 list_add(&sub->subscrp_list, &subscriber->subscrp_list);
287 tipc_subscrb_get(subscriber); 291 tipc_subscrb_get(subscriber);
288 sub->subscriber = subscriber; 292 sub->subscriber = subscriber;
289 tipc_nametbl_subscribe(sub); 293 tipc_nametbl_subscribe(sub);
290 spin_unlock_bh(&subscriber->lock); 294 spin_unlock_bh(&subscriber->lock);
291 295
292 timeout = htohl(sub->evt.s.timeout, swap); 296 timeout = htohl(sub->evt.s.timeout, swap);
297 if (timeout == TIPC_WAIT_FOREVER)
298 return;
299
300 setup_timer(&sub->timer, tipc_subscrp_timeout, (unsigned long)sub);
293 mod_timer(&sub->timer, jiffies + msecs_to_jiffies(timeout)); 301 mod_timer(&sub->timer, jiffies + msecs_to_jiffies(timeout));
294 } 302 }
295 303
296 /* Handle one termination request for the subscriber */ 304 /* Handle one termination request for the subscriber */
297 static void tipc_subscrb_shutdown_cb(int conid, void *usr_data) 305 static void tipc_subscrb_shutdown_cb(int conid, void *usr_data)
298 { 306 {
299 tipc_subscrb_delete((struct tipc_subscriber *)usr_data); 307 tipc_subscrb_delete((struct tipc_subscriber *)usr_data);
300 } 308 }
301 309
302 /* Handle one request to create a new subscription for the subscriber */ 310 /* Handle one request to create a new subscription for the subscriber */
303 static void tipc_subscrb_rcv_cb(struct net *net, int conid, 311 static void tipc_subscrb_rcv_cb(struct net *net, int conid,
304 struct sockaddr_tipc *addr, void *usr_data, 312 struct sockaddr_tipc *addr, void *usr_data,
305 void *buf, size_t len) 313 void *buf, size_t len)
306 { 314 {
307 struct tipc_subscriber *subscriber = usr_data; 315 struct tipc_subscriber *subscriber = usr_data;
308 struct tipc_subscr *s = (struct tipc_subscr *)buf; 316 struct tipc_subscr *s = (struct tipc_subscr *)buf;
309 int swap; 317 int swap;
310 318
311 /* Determine subscriber's endianness */ 319 /* Determine subscriber's endianness */
312 swap = !(s->filter & (TIPC_SUB_PORTS | TIPC_SUB_SERVICE | 320 swap = !(s->filter & (TIPC_SUB_PORTS | TIPC_SUB_SERVICE |
313 TIPC_SUB_CANCEL)); 321 TIPC_SUB_CANCEL));
314 322
315 /* Detect & process a subscription cancellation request */ 323 /* Detect & process a subscription cancellation request */
316 if (s->filter & htohl(TIPC_SUB_CANCEL, swap)) { 324 if (s->filter & htohl(TIPC_SUB_CANCEL, swap)) {
317 s->filter &= ~htohl(TIPC_SUB_CANCEL, swap); 325 s->filter &= ~htohl(TIPC_SUB_CANCEL, swap);
318 return tipc_subscrp_cancel(s, subscriber); 326 return tipc_subscrp_cancel(s, subscriber);
319 } 327 }
320 328
321 tipc_subscrp_subscribe(net, s, subscriber, swap); 329 tipc_subscrp_subscribe(net, s, subscriber, swap);
322 } 330 }
323 331
324 /* Handle one request to establish a new subscriber */ 332 /* Handle one request to establish a new subscriber */
325 static void *tipc_subscrb_connect_cb(int conid) 333 static void *tipc_subscrb_connect_cb(int conid)
326 { 334 {
327 return (void *)tipc_subscrb_create(conid); 335 return (void *)tipc_subscrb_create(conid);
328 } 336 }
329 337
330 int tipc_topsrv_start(struct net *net) 338 int tipc_topsrv_start(struct net *net)
331 { 339 {
332 struct tipc_net *tn = net_generic(net, tipc_net_id); 340 struct tipc_net *tn = net_generic(net, tipc_net_id);
333 const char name[] = "topology_server"; 341 const char name[] = "topology_server";
334 struct tipc_server *topsrv; 342 struct tipc_server *topsrv;
335 struct sockaddr_tipc *saddr; 343 struct sockaddr_tipc *saddr;
336 344
337 saddr = kzalloc(sizeof(*saddr), GFP_ATOMIC); 345 saddr = kzalloc(sizeof(*saddr), GFP_ATOMIC);
338 if (!saddr) 346 if (!saddr)
339 return -ENOMEM; 347 return -ENOMEM;
340 saddr->family = AF_TIPC; 348 saddr->family = AF_TIPC;
341 saddr->addrtype = TIPC_ADDR_NAMESEQ; 349 saddr->addrtype = TIPC_ADDR_NAMESEQ;
342 saddr->addr.nameseq.type = TIPC_TOP_SRV; 350 saddr->addr.nameseq.type = TIPC_TOP_SRV;
343 saddr->addr.nameseq.lower = TIPC_TOP_SRV; 351 saddr->addr.nameseq.lower = TIPC_TOP_SRV;
344 saddr->addr.nameseq.upper = TIPC_TOP_SRV; 352 saddr->addr.nameseq.upper = TIPC_TOP_SRV;
345 saddr->scope = TIPC_NODE_SCOPE; 353 saddr->scope = TIPC_NODE_SCOPE;
346 354
347 topsrv = kzalloc(sizeof(*topsrv), GFP_ATOMIC); 355 topsrv = kzalloc(sizeof(*topsrv), GFP_ATOMIC);
348 if (!topsrv) { 356 if (!topsrv) {
349 kfree(saddr); 357 kfree(saddr);
350 return -ENOMEM; 358 return -ENOMEM;
351 } 359 }
352 topsrv->net = net; 360 topsrv->net = net;
353 topsrv->saddr = saddr; 361 topsrv->saddr = saddr;
354 topsrv->imp = TIPC_CRITICAL_IMPORTANCE; 362 topsrv->imp = TIPC_CRITICAL_IMPORTANCE;
355 topsrv->type = SOCK_SEQPACKET; 363 topsrv->type = SOCK_SEQPACKET;
356 topsrv->max_rcvbuf_size = sizeof(struct tipc_subscr); 364 topsrv->max_rcvbuf_size = sizeof(struct tipc_subscr);
357 topsrv->tipc_conn_recvmsg = tipc_subscrb_rcv_cb; 365 topsrv->tipc_conn_recvmsg = tipc_subscrb_rcv_cb;
358 topsrv->tipc_conn_new = tipc_subscrb_connect_cb; 366 topsrv->tipc_conn_new = tipc_subscrb_connect_cb;
359 topsrv->tipc_conn_shutdown = tipc_subscrb_shutdown_cb; 367 topsrv->tipc_conn_shutdown = tipc_subscrb_shutdown_cb;
360 368
361 strncpy(topsrv->name, name, strlen(name) + 1); 369 strncpy(topsrv->name, name, strlen(name) + 1);
362 tn->topsrv = topsrv; 370 tn->topsrv = topsrv;
363 atomic_set(&tn->subscription_count, 0); 371 atomic_set(&tn->subscription_count, 0);
364 372
365 return tipc_server_start(topsrv); 373 return tipc_server_start(topsrv);
366 } 374 }
367 375
368 void tipc_topsrv_stop(struct net *net) 376 void tipc_topsrv_stop(struct net *net)
369 { 377 {
370 struct tipc_net *tn = net_generic(net, tipc_net_id); 378 struct tipc_net *tn = net_generic(net, tipc_net_id);
371 struct tipc_server *topsrv = tn->topsrv; 379 struct tipc_server *topsrv = tn->topsrv;
372 380
373 tipc_server_stop(topsrv); 381 tipc_server_stop(topsrv);
374 kfree(topsrv->saddr); 382 kfree(topsrv->saddr);
375 kfree(topsrv); 383 kfree(topsrv);
376 } 384 }