discover.c 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346
  1. /*
  2. * net/tipc/discover.c
  3. *
  4. * Copyright (c) 2003-2006, Ericsson AB
  5. * Copyright (c) 2005-2006, Wind River Systems
  6. * All rights reserved.
  7. *
  8. * Redistribution and use in source and binary forms, with or without
  9. * modification, are permitted provided that the following conditions are met:
  10. *
  11. * 1. Redistributions of source code must retain the above copyright
  12. * notice, this list of conditions and the following disclaimer.
  13. * 2. Redistributions in binary form must reproduce the above copyright
  14. * notice, this list of conditions and the following disclaimer in the
  15. * documentation and/or other materials provided with the distribution.
  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
  18. * this software without specific prior written permission.
  19. *
  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
  22. * Software Foundation.
  23. *
  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
  26. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27. * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  28. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  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
  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
  34. * POSSIBILITY OF SUCH DAMAGE.
  35. */
  36. #include "core.h"
  37. #include "dbg.h"
  38. #include "link.h"
  39. #include "zone.h"
  40. #include "discover.h"
  41. #include "port.h"
  42. #include "name_table.h"
  43. #define TIPC_LINK_REQ_INIT 125 /* min delay during bearer start up */
  44. #define TIPC_LINK_REQ_FAST 2000 /* normal delay if bearer has no links */
  45. #define TIPC_LINK_REQ_SLOW 600000 /* normal delay if bearer has links */
  46. #if 0
  47. #define GET_NODE_INFO 300
  48. #define GET_NODE_INFO_RESULT 301
  49. #define FORWARD_LINK_PROBE 302
  50. #define LINK_REQUEST_REJECTED 303
  51. #define LINK_REQUEST_ACCEPTED 304
  52. #define DROP_LINK_REQUEST 305
  53. #define CHECK_LINK_COUNT 306
  54. #endif
  55. /*
  56. * TODO: Most of the inter-cluster setup stuff should be
  57. * rewritten, and be made conformant with specification.
  58. */
  59. /**
  60. * struct link_req - information about an ongoing link setup request
  61. * @bearer: bearer issuing requests
  62. * @dest: destination address for request messages
  63. * @buf: request message to be (repeatedly) sent
  64. * @timer: timer governing period between requests
  65. * @timer_intv: current interval between requests (in ms)
  66. */
  67. struct link_req {
  68. struct bearer *bearer;
  69. struct tipc_media_addr dest;
  70. struct sk_buff *buf;
  71. struct timer_list timer;
  72. unsigned int timer_intv;
  73. };
  74. #if 0
  75. int disc_create_link(const struct tipc_link_create *argv)
  76. {
  77. /*
  78. * Code for inter cluster link setup here
  79. */
  80. return TIPC_OK;
  81. }
  82. #endif
  83. /*
  84. * disc_lost_link(): A link has lost contact
  85. */
  86. void tipc_disc_link_event(u32 addr, char *name, int up)
  87. {
  88. if (in_own_cluster(addr))
  89. return;
  90. /*
  91. * Code for inter cluster link setup here
  92. */
  93. }
  94. /**
  95. * tipc_disc_init_msg - initialize a link setup message
  96. * @type: message type (request or response)
  97. * @req_links: number of links associated with message
  98. * @dest_domain: network domain of node(s) which should respond to message
  99. * @b_ptr: ptr to bearer issuing message
  100. */
  101. static struct sk_buff *tipc_disc_init_msg(u32 type,
  102. u32 req_links,
  103. u32 dest_domain,
  104. struct bearer *b_ptr)
  105. {
  106. struct sk_buff *buf = buf_acquire(DSC_H_SIZE);
  107. struct tipc_msg *msg;
  108. if (buf) {
  109. msg = buf_msg(buf);
  110. msg_init(msg, LINK_CONFIG, type, TIPC_OK, DSC_H_SIZE,
  111. dest_domain);
  112. msg_set_non_seq(msg);
  113. msg_set_req_links(msg, req_links);
  114. msg_set_dest_domain(msg, dest_domain);
  115. msg_set_bc_netid(msg, tipc_net_id);
  116. msg_set_media_addr(msg, &b_ptr->publ.addr);
  117. }
  118. return buf;
  119. }
  120. /**
  121. * disc_dupl_alert - issue node address duplication alert
  122. * @b_ptr: pointer to bearer detecting duplication
  123. * @node_addr: duplicated node address
  124. * @media_addr: media address advertised by duplicated node
  125. */
  126. static void disc_dupl_alert(struct bearer *b_ptr, u32 node_addr,
  127. struct tipc_media_addr *media_addr)
  128. {
  129. char node_addr_str[16];
  130. char media_addr_str[64];
  131. struct print_buf pb;
  132. addr_string_fill(node_addr_str, node_addr);
  133. tipc_printbuf_init(&pb, media_addr_str, sizeof(media_addr_str));
  134. tipc_media_addr_printf(&pb, media_addr);
  135. tipc_printbuf_validate(&pb);
  136. warn("Duplicate %s using %s seen on <%s>\n",
  137. node_addr_str, media_addr_str, b_ptr->publ.name);
  138. }
  139. /**
  140. * tipc_disc_recv_msg - handle incoming link setup message (request or response)
  141. * @buf: buffer containing message
  142. */
  143. void tipc_disc_recv_msg(struct sk_buff *buf)
  144. {
  145. struct bearer *b_ptr = (struct bearer *)TIPC_SKB_CB(buf)->handle;
  146. struct link *link;
  147. struct tipc_media_addr media_addr;
  148. struct tipc_msg *msg = buf_msg(buf);
  149. u32 dest = msg_dest_domain(msg);
  150. u32 orig = msg_prevnode(msg);
  151. u32 net_id = msg_bc_netid(msg);
  152. u32 type = msg_type(msg);
  153. msg_get_media_addr(msg,&media_addr);
  154. msg_dbg(msg, "RECV:");
  155. buf_discard(buf);
  156. if (net_id != tipc_net_id)
  157. return;
  158. if (!tipc_addr_domain_valid(dest))
  159. return;
  160. if (!tipc_addr_node_valid(orig))
  161. return;
  162. if (orig == tipc_own_addr) {
  163. if (memcmp(&media_addr, &b_ptr->publ.addr, sizeof(media_addr)))
  164. disc_dupl_alert(b_ptr, tipc_own_addr, &media_addr);
  165. return;
  166. }
  167. if (!in_scope(dest, tipc_own_addr))
  168. return;
  169. if (is_slave(tipc_own_addr) && is_slave(orig))
  170. return;
  171. if (is_slave(orig) && !in_own_cluster(orig))
  172. return;
  173. if (in_own_cluster(orig)) {
  174. /* Always accept link here */
  175. struct sk_buff *rbuf;
  176. struct tipc_media_addr *addr;
  177. struct node *n_ptr = tipc_node_find(orig);
  178. int link_fully_up;
  179. dbg(" in own cluster\n");
  180. if (n_ptr == NULL) {
  181. n_ptr = tipc_node_create(orig);
  182. }
  183. if (n_ptr == NULL) {
  184. return;
  185. }
  186. spin_lock_bh(&n_ptr->lock);
  187. link = n_ptr->links[b_ptr->identity];
  188. if (!link) {
  189. dbg("creating link\n");
  190. link = tipc_link_create(b_ptr, orig, &media_addr);
  191. if (!link) {
  192. spin_unlock_bh(&n_ptr->lock);
  193. return;
  194. }
  195. }
  196. addr = &link->media_addr;
  197. if (memcmp(addr, &media_addr, sizeof(*addr))) {
  198. if (tipc_link_is_up(link) || (!link->started)) {
  199. disc_dupl_alert(b_ptr, orig, &media_addr);
  200. spin_unlock_bh(&n_ptr->lock);
  201. return;
  202. }
  203. warn("Resetting link <%s>, peer interface address changed\n",
  204. link->name);
  205. memcpy(addr, &media_addr, sizeof(*addr));
  206. tipc_link_reset(link);
  207. }
  208. link_fully_up = (link->state == WORKING_WORKING);
  209. spin_unlock_bh(&n_ptr->lock);
  210. if ((type == DSC_RESP_MSG) || link_fully_up)
  211. return;
  212. rbuf = tipc_disc_init_msg(DSC_RESP_MSG, 1, orig, b_ptr);
  213. if (rbuf != NULL) {
  214. msg_dbg(buf_msg(rbuf),"SEND:");
  215. b_ptr->media->send_msg(rbuf, &b_ptr->publ, &media_addr);
  216. buf_discard(rbuf);
  217. }
  218. }
  219. }
  220. /**
  221. * tipc_disc_stop_link_req - stop sending periodic link setup requests
  222. * @req: ptr to link request structure
  223. */
  224. void tipc_disc_stop_link_req(struct link_req *req)
  225. {
  226. if (!req)
  227. return;
  228. k_cancel_timer(&req->timer);
  229. k_term_timer(&req->timer);
  230. buf_discard(req->buf);
  231. kfree(req);
  232. }
  233. /**
  234. * tipc_disc_update_link_req - update frequency of periodic link setup requests
  235. * @req: ptr to link request structure
  236. */
  237. void tipc_disc_update_link_req(struct link_req *req)
  238. {
  239. if (!req)
  240. return;
  241. if (req->timer_intv == TIPC_LINK_REQ_SLOW) {
  242. if (!req->bearer->nodes.count) {
  243. req->timer_intv = TIPC_LINK_REQ_FAST;
  244. k_start_timer(&req->timer, req->timer_intv);
  245. }
  246. } else if (req->timer_intv == TIPC_LINK_REQ_FAST) {
  247. if (req->bearer->nodes.count) {
  248. req->timer_intv = TIPC_LINK_REQ_SLOW;
  249. k_start_timer(&req->timer, req->timer_intv);
  250. }
  251. } else {
  252. /* leave timer "as is" if haven't yet reached a "normal" rate */
  253. }
  254. }
  255. /**
  256. * disc_timeout - send a periodic link setup request
  257. * @req: ptr to link request structure
  258. *
  259. * Called whenever a link setup request timer associated with a bearer expires.
  260. */
  261. static void disc_timeout(struct link_req *req)
  262. {
  263. spin_lock_bh(&req->bearer->publ.lock);
  264. req->bearer->media->send_msg(req->buf, &req->bearer->publ, &req->dest);
  265. if ((req->timer_intv == TIPC_LINK_REQ_SLOW) ||
  266. (req->timer_intv == TIPC_LINK_REQ_FAST)) {
  267. /* leave timer interval "as is" if already at a "normal" rate */
  268. } else {
  269. req->timer_intv *= 2;
  270. if (req->timer_intv > TIPC_LINK_REQ_FAST)
  271. req->timer_intv = TIPC_LINK_REQ_FAST;
  272. if ((req->timer_intv == TIPC_LINK_REQ_FAST) &&
  273. (req->bearer->nodes.count))
  274. req->timer_intv = TIPC_LINK_REQ_SLOW;
  275. }
  276. k_start_timer(&req->timer, req->timer_intv);
  277. spin_unlock_bh(&req->bearer->publ.lock);
  278. }
  279. /**
  280. * tipc_disc_init_link_req - start sending periodic link setup requests
  281. * @b_ptr: ptr to bearer issuing requests
  282. * @dest: destination address for request messages
  283. * @dest_domain: network domain of node(s) which should respond to message
  284. * @req_links: max number of desired links
  285. *
  286. * Returns pointer to link request structure, or NULL if unable to create.
  287. */
  288. struct link_req *tipc_disc_init_link_req(struct bearer *b_ptr,
  289. const struct tipc_media_addr *dest,
  290. u32 dest_domain,
  291. u32 req_links)
  292. {
  293. struct link_req *req;
  294. req = kmalloc(sizeof(*req), GFP_ATOMIC);
  295. if (!req)
  296. return NULL;
  297. req->buf = tipc_disc_init_msg(DSC_REQ_MSG, req_links, dest_domain, b_ptr);
  298. if (!req->buf) {
  299. kfree(req);
  300. return NULL;
  301. }
  302. memcpy(&req->dest, dest, sizeof(*dest));
  303. req->bearer = b_ptr;
  304. req->timer_intv = TIPC_LINK_REQ_INIT;
  305. k_init_timer(&req->timer, (Handler)disc_timeout, (unsigned long)req);
  306. k_start_timer(&req->timer, req->timer_intv);
  307. return req;
  308. }