net/qrtr/ns.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /*
   3  * Copyright (c) 2015, Sony Mobile Communications Inc.
   4  * Copyright (c) 2013, The Linux Foundation. All rights reserved.
   5  * Copyright (c) 2020, Linaro Ltd.
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/qrtr.h>
  10 #include <linux/workqueue.h>
  11 #include <net/sock.h>
  12
  13 #include "qrtr.h"
  14
  15 static RADIX_TREE(nodes, GFP_KERNEL);
  16
  17 static struct {
  18         struct socket *sock;
  19         struct sockaddr_qrtr bcast_sq;
  20         struct list_head lookups;
  21         struct workqueue_struct *workqueue;
  22         struct work_struct work;
  23         int local_node;
  24 } qrtr_ns;
  25
  26 static const char * const qrtr_ctrl_pkt_strings[] = {
  27         [QRTR_TYPE_HELLO]       = "hello",
  28         [QRTR_TYPE_BYE]         = "bye",
  29         [QRTR_TYPE_NEW_SERVER]  = "new-server",
  30         [QRTR_TYPE_DEL_SERVER]  = "del-server",
  31         [QRTR_TYPE_DEL_CLIENT]  = "del-client",
  32         [QRTR_TYPE_RESUME_TX]   = "resume-tx",
  33         [QRTR_TYPE_EXIT]        = "exit",
  34         [QRTR_TYPE_PING]        = "ping",
  35         [QRTR_TYPE_NEW_LOOKUP]  = "new-lookup",
  36         [QRTR_TYPE_DEL_LOOKUP]  = "del-lookup",
  37 };
  38
  39 struct qrtr_server_filter {
  40         unsigned int service;
  41         unsigned int instance;
  42         unsigned int ifilter;
  43 };
  44
  45 struct qrtr_lookup {
  46         unsigned int service;
  47         unsigned int instance;
  48
  49         struct sockaddr_qrtr sq;
  50         struct list_head li;
  51 };
  52
  53 struct qrtr_server {
  54         unsigned int service;
  55         unsigned int instance;
  56
  57         unsigned int node;
  58         unsigned int port;
  59
  60         struct list_head qli;
  61 };
  62
  63 struct qrtr_node {
  64         unsigned int id;
  65         struct radix_tree_root servers;
  66 };
  67
  68 static struct qrtr_node *node_get(unsigned int node_id)
  69 {
  70         struct qrtr_node *node;
  71
  72         node = radix_tree_lookup(&nodes, node_id);
  73         if (node)
  74                 return node;
  75
  76         /* If node didn't exist, allocate and insert it to the tree */
  77         node = kzalloc(sizeof(*node), GFP_KERNEL);
  78         if (!node)
  79                 return NULL;
  80
  81         node->id = node_id;
  82
  83         radix_tree_insert(&nodes, node_id, node);
  84
  85         return node;
  86 }
  87
  88 static int server_match(const struct qrtr_server *srv,
  89                         const struct qrtr_server_filter *f)
  90 {
  91         unsigned int ifilter = f->ifilter;
  92
  93         if (f->service != 0 && srv->service != f->service)
  94                 return 0;
  95         if (!ifilter && f->instance)
  96                 ifilter = ~0;
  97
  98         return (srv->instance & ifilter) == f->instance;
  99 }
 100
 101 static int service_announce_new(struct sockaddr_qrtr *dest,
 102                                 struct qrtr_server *srv)
 103 {
 104         struct qrtr_ctrl_pkt pkt;
 105         struct msghdr msg = { };
 106         struct kvec iv;
 107
 108         trace_printk("advertising new server [%d:%x]@[%d:%d]\n",
 109                      srv->service, srv->instance, srv->node, srv->port);
 110
 111         iv.iov_base = &pkt;
 112         iv.iov_len = sizeof(pkt);
 113
 114         memset(&pkt, 0, sizeof(pkt));
 115         pkt.cmd = cpu_to_le32(QRTR_TYPE_NEW_SERVER);
 116         pkt.server.service = cpu_to_le32(srv->service);
 117         pkt.server.instance = cpu_to_le32(srv->instance);
 118         pkt.server.node = cpu_to_le32(srv->node);
 119         pkt.server.port = cpu_to_le32(srv->port);
 120
 121         msg.msg_name = (struct sockaddr *)dest;
 122         msg.msg_namelen = sizeof(*dest);
 123
 124         return kernel_sendmsg(qrtr_ns.sock, &msg, &iv, 1, sizeof(pkt));
 125 }
 126
 127 static int service_announce_del(struct sockaddr_qrtr *dest,
 128                                 struct qrtr_server *srv)
 129 {
 130         struct qrtr_ctrl_pkt pkt;
 131         struct msghdr msg = { };
 132         struct kvec iv;
 133         int ret;
 134
 135         trace_printk("advertising removal of server [%d:%x]@[%d:%d]\n",
 136                      srv->service, srv->instance, srv->node, srv->port);
 137
 138         iv.iov_base = &pkt;
 139         iv.iov_len = sizeof(pkt);
 140
 141         memset(&pkt, 0, sizeof(pkt));
 142         pkt.cmd = cpu_to_le32(QRTR_TYPE_DEL_SERVER);
 143         pkt.server.service = cpu_to_le32(srv->service);
 144         pkt.server.instance = cpu_to_le32(srv->instance);
 145         pkt.server.node = cpu_to_le32(srv->node);
 146         pkt.server.port = cpu_to_le32(srv->port);
 147
 148         msg.msg_name = (struct sockaddr *)dest;
 149         msg.msg_namelen = sizeof(*dest);
 150
 151         ret = kernel_sendmsg(qrtr_ns.sock, &msg, &iv, 1, sizeof(pkt));
 152         if (ret < 0)
 153                 pr_err("failed to announce del service\n");
 154
 155         return ret;
 156 }
 157
 158 static void lookup_notify(struct sockaddr_qrtr *to, struct qrtr_server *srv,
 159                           bool new)
 160 {
 161         struct qrtr_ctrl_pkt pkt;
 162         struct msghdr msg = { };
 163         struct kvec iv;
 164         int ret;
 165
 166         iv.iov_base = &pkt;
 167         iv.iov_len = sizeof(pkt);
 168
 169         memset(&pkt, 0, sizeof(pkt));
 170         pkt.cmd = new ? cpu_to_le32(QRTR_TYPE_NEW_SERVER) :
 171                         cpu_to_le32(QRTR_TYPE_DEL_SERVER);
 172         if (srv) {
 173                 pkt.server.service = cpu_to_le32(srv->service);
 174                 pkt.server.instance = cpu_to_le32(srv->instance);
 175                 pkt.server.node = cpu_to_le32(srv->node);
 176                 pkt.server.port = cpu_to_le32(srv->port);
 177         }
 178
 179         msg.msg_name = (struct sockaddr *)to;
 180         msg.msg_namelen = sizeof(*to);
 181
 182         ret = kernel_sendmsg(qrtr_ns.sock, &msg, &iv, 1, sizeof(pkt));
 183         if (ret < 0)
 184                 pr_err("failed to send lookup notification\n");
 185 }
 186
 187 static int announce_servers(struct sockaddr_qrtr *sq)
 188 {
 189         struct radix_tree_iter iter;
 190         struct qrtr_server *srv;
 191         struct qrtr_node *node;
 192         void __rcu **slot;
 193         int ret;
 194
 195         node = node_get(qrtr_ns.local_node);
 196         if (!node)
 197                 return 0;
 198
 199         /* Announce the list of servers registered in this node */
 200         radix_tree_for_each_slot(slot, &node->servers, &iter, 0) {
 201                 srv = radix_tree_deref_slot(slot);
 202
 203                 ret = service_announce_new(sq, srv);
 204                 if (ret < 0) {
 205                         pr_err("failed to announce new service\n");
 206                         return ret;
 207                 }
 208         }
 209
 210         return 0;
 211 }
 212
 213 static struct qrtr_server *server_add(unsigned int service,
 214                                       unsigned int instance,
 215                                       unsigned int node_id,
 216                                       unsigned int port)
 217 {
 218         struct qrtr_server *srv;
 219         struct qrtr_server *old;
 220         struct qrtr_node *node;
 221
 222         if (!service || !port)
 223                 return NULL;
 224
 225         srv = kzalloc(sizeof(*srv), GFP_KERNEL);
 226         if (!srv)
 227                 return NULL;
 228
 229         srv->service = service;
 230         srv->instance = instance;
 231         srv->node = node_id;
 232         srv->port = port;
 233
 234         node = node_get(node_id);
 235         if (!node)
 236                 goto err;
 237
 238         /* Delete the old server on the same port */
 239         old = radix_tree_lookup(&node->servers, port);
 240         if (old) {
 241                 radix_tree_delete(&node->servers, port);
 242                 kfree(old);
 243         }
 244
 245         radix_tree_insert(&node->servers, port, srv);
 246
 247         trace_printk("add server [%d:%x]@[%d:%d]\n", srv->service,
 248                      srv->instance, srv->node, srv->port);
 249
 250         return srv;
 251
 252 err:
 253         kfree(srv);
 254         return NULL;
 255 }
 256
 257 static int server_del(struct qrtr_node *node, unsigned int port)
 258 {
 259         struct qrtr_lookup *lookup;
 260         struct qrtr_server *srv;
 261         struct list_head *li;
 262
 263         srv = radix_tree_lookup(&node->servers, port);
 264         if (!srv)
 265                 return -ENOENT;
 266
 267         radix_tree_delete(&node->servers, port);
 268
 269         /* Broadcast the removal of local servers */
 270         if (srv->node == qrtr_ns.local_node)
 271                 service_announce_del(&qrtr_ns.bcast_sq, srv);
 272
 273         /* Announce the service's disappearance to observers */
 274         list_for_each(li, &qrtr_ns.lookups) {
 275                 lookup = container_of(li, struct qrtr_lookup, li);
 276                 if (lookup->service && lookup->service != srv->service)
 277                         continue;
 278                 if (lookup->instance && lookup->instance != srv->instance)
 279                         continue;
 280
 281                 lookup_notify(&lookup->sq, srv, false);
 282         }
 283
 284         kfree(srv);
 285
 286         return 0;
 287 }
 288
 289 static int say_hello(struct sockaddr_qrtr *dest)
 290 {
 291         struct qrtr_ctrl_pkt pkt;
 292         struct msghdr msg = { };
 293         struct kvec iv;
 294         int ret;
 295
 296         iv.iov_base = &pkt;
 297         iv.iov_len = sizeof(pkt);
 298
 299         memset(&pkt, 0, sizeof(pkt));
 300         pkt.cmd = cpu_to_le32(QRTR_TYPE_HELLO);
 301
 302         msg.msg_name = (struct sockaddr *)dest;
 303         msg.msg_namelen = sizeof(*dest);
 304
 305         ret = kernel_sendmsg(qrtr_ns.sock, &msg, &iv, 1, sizeof(pkt));
 306         if (ret < 0)
 307                 pr_err("failed to send hello msg\n");
 308
 309         return ret;
 310 }
 311
 312 /* Announce the list of servers registered on the local node */
 313 static int ctrl_cmd_hello(struct sockaddr_qrtr *sq)
 314 {
 315         int ret;
 316
 317         ret = say_hello(sq);
 318         if (ret < 0)
 319                 return ret;
 320
 321         return announce_servers(sq);
 322 }
 323
 324 static int ctrl_cmd_bye(struct sockaddr_qrtr *from)
 325 {
 326         struct qrtr_node *local_node;
 327         struct radix_tree_iter iter;
 328         struct qrtr_ctrl_pkt pkt;
 329         struct qrtr_server *srv;
 330         struct sockaddr_qrtr sq;
 331         struct msghdr msg = { };
 332         struct qrtr_node *node;
 333         void __rcu **slot;
 334         struct kvec iv;
 335         int ret;
 336
 337         iv.iov_base = &pkt;
 338         iv.iov_len = sizeof(pkt);
 339
 340         node = node_get(from->sq_node);
 341         if (!node)
 342                 return 0;
 343
 344         /* Advertise removal of this client to all servers of remote node */
 345         radix_tree_for_each_slot(slot, &node->servers, &iter, 0) {
 346                 srv = radix_tree_deref_slot(slot);
 347                 server_del(node, srv->port);
 348         }
 349
 350         /* Advertise the removal of this client to all local servers */
 351         local_node = node_get(qrtr_ns.local_node);
 352         if (!local_node)
 353                 return 0;
 354
 355         memset(&pkt, 0, sizeof(pkt));
 356         pkt.cmd = cpu_to_le32(QRTR_TYPE_BYE);
 357         pkt.client.node = cpu_to_le32(from->sq_node);
 358
 359         radix_tree_for_each_slot(slot, &local_node->servers, &iter, 0) {
 360                 srv = radix_tree_deref_slot(slot);
 361
 362                 sq.sq_family = AF_QIPCRTR;
 363                 sq.sq_node = srv->node;
 364                 sq.sq_port = srv->port;
 365
 366                 msg.msg_name = (struct sockaddr *)&sq;
 367                 msg.msg_namelen = sizeof(sq);
 368
 369                 ret = kernel_sendmsg(qrtr_ns.sock, &msg, &iv, 1, sizeof(pkt));
 370                 if (ret < 0) {
 371                         pr_err("failed to send bye cmd\n");
 372                         return ret;
 373                 }
 374         }
 375
 376         return 0;
 377 }
 378
 379 static int ctrl_cmd_del_client(struct sockaddr_qrtr *from,
 380                                unsigned int node_id, unsigned int port)
 381 {
 382         struct qrtr_node *local_node;
 383         struct radix_tree_iter iter;
 384         struct qrtr_lookup *lookup;
 385         struct qrtr_ctrl_pkt pkt;
 386         struct msghdr msg = { };
 387         struct qrtr_server *srv;
 388         struct sockaddr_qrtr sq;
 389         struct qrtr_node *node;
 390         struct list_head *tmp;
 391         struct list_head *li;
 392         void __rcu **slot;
 393         struct kvec iv;
 394         int ret;
 395
 396         iv.iov_base = &pkt;
 397         iv.iov_len = sizeof(pkt);
 398
 399         /* Don't accept spoofed messages */
 400         if (from->sq_node != node_id)
 401                 return -EINVAL;
 402
 403         /* Local DEL_CLIENT messages comes from the port being closed */
 404         if (from->sq_node == qrtr_ns.local_node && from->sq_port != port)
 405                 return -EINVAL;
 406
 407         /* Remove any lookups by this client */
 408         list_for_each_safe(li, tmp, &qrtr_ns.lookups) {
 409                 lookup = container_of(li, struct qrtr_lookup, li);
 410                 if (lookup->sq.sq_node != node_id)
 411                         continue;
 412                 if (lookup->sq.sq_port != port)
 413                         continue;
 414
 415                 list_del(&lookup->li);
 416                 kfree(lookup);
 417         }
 418
 419         /* Remove the server belonging to this port */
 420         node = node_get(node_id);
 421         if (node)
 422                 server_del(node, port);
 423
 424         /* Advertise the removal of this client to all local servers */
 425         local_node = node_get(qrtr_ns.local_node);
 426         if (!local_node)
 427                 return 0;
 428
 429         memset(&pkt, 0, sizeof(pkt));
 430         pkt.cmd = cpu_to_le32(QRTR_TYPE_DEL_CLIENT);
 431         pkt.client.node = cpu_to_le32(node_id);
 432         pkt.client.port = cpu_to_le32(port);
 433
 434         radix_tree_for_each_slot(slot, &local_node->servers, &iter, 0) {
 435                 srv = radix_tree_deref_slot(slot);
 436
 437                 sq.sq_family = AF_QIPCRTR;
 438                 sq.sq_node = srv->node;
 439                 sq.sq_port = srv->port;
 440
 441                 msg.msg_name = (struct sockaddr *)&sq;
 442                 msg.msg_namelen = sizeof(sq);
 443
 444                 ret = kernel_sendmsg(qrtr_ns.sock, &msg, &iv, 1, sizeof(pkt));
 445                 if (ret < 0) {
 446                         pr_err("failed to send del client cmd\n");
 447                         return ret;
 448                 }
 449         }
 450
 451         return 0;
 452 }
 453
 454 static int ctrl_cmd_new_server(struct sockaddr_qrtr *from,
 455                                unsigned int service, unsigned int instance,
 456                                unsigned int node_id, unsigned int port)
 457 {
 458         struct qrtr_lookup *lookup;
 459         struct qrtr_server *srv;
 460         struct list_head *li;
 461         int ret = 0;
 462
 463         /* Ignore specified node and port for local servers */
 464         if (from->sq_node == qrtr_ns.local_node) {
 465                 node_id = from->sq_node;
 466                 port = from->sq_port;
 467         }
 468
 469         /* Don't accept spoofed messages */
 470         if (from->sq_node != node_id)
 471                 return -EINVAL;
 472
 473         srv = server_add(service, instance, node_id, port);
 474         if (!srv)
 475                 return -EINVAL;
 476
 477         if (srv->node == qrtr_ns.local_node) {
 478                 ret = service_announce_new(&qrtr_ns.bcast_sq, srv);
 479                 if (ret < 0) {
 480                         pr_err("failed to announce new service\n");
 481                         return ret;
 482                 }
 483         }
 484
 485         /* Notify any potential lookups about the new server */
 486         list_for_each(li, &qrtr_ns.lookups) {
 487                 lookup = container_of(li, struct qrtr_lookup, li);
 488                 if (lookup->service && lookup->service != service)
 489                         continue;
 490                 if (lookup->instance && lookup->instance != instance)
 491                         continue;
 492
 493                 lookup_notify(&lookup->sq, srv, true);
 494         }
 495
 496         return ret;
 497 }
 498
 499 static int ctrl_cmd_del_server(struct sockaddr_qrtr *from,
 500                                unsigned int service, unsigned int instance,
 501                                unsigned int node_id, unsigned int port)
 502 {
 503         struct qrtr_node *node;
 504
 505         /* Ignore specified node and port for local servers*/
 506         if (from->sq_node == qrtr_ns.local_node) {
 507                 node_id = from->sq_node;
 508                 port = from->sq_port;
 509         }
 510
 511         /* Don't accept spoofed messages */
 512         if (from->sq_node != node_id)
 513                 return -EINVAL;
 514
 515         /* Local servers may only unregister themselves */
 516         if (from->sq_node == qrtr_ns.local_node && from->sq_port != port)
 517                 return -EINVAL;
 518
 519         node = node_get(node_id);
 520         if (!node)
 521                 return -ENOENT;
 522
 523         return server_del(node, port);
 524 }
 525
 526 static int ctrl_cmd_new_lookup(struct sockaddr_qrtr *from,
 527                                unsigned int service, unsigned int instance)
 528 {
 529         struct radix_tree_iter node_iter;
 530         struct qrtr_server_filter filter;
 531         struct radix_tree_iter srv_iter;
 532         struct qrtr_lookup *lookup;
 533         struct qrtr_node *node;
 534         void __rcu **node_slot;
 535         void __rcu **srv_slot;
 536
 537         /* Accept only local observers */
 538         if (from->sq_node != qrtr_ns.local_node)
 539                 return -EINVAL;
 540
 541         lookup = kzalloc(sizeof(*lookup), GFP_KERNEL);
 542         if (!lookup)
 543                 return -ENOMEM;
 544
 545         lookup->sq = *from;
 546         lookup->service = service;
 547         lookup->instance = instance;
 548         list_add_tail(&lookup->li, &qrtr_ns.lookups);
 549
 550         memset(&filter, 0, sizeof(filter));
 551         filter.service = service;
 552         filter.instance = instance;
 553
 554         radix_tree_for_each_slot(node_slot, &nodes, &node_iter, 0) {
 555                 node = radix_tree_deref_slot(node_slot);
 556
 557                 radix_tree_for_each_slot(srv_slot, &node->servers,
 558                                          &srv_iter, 0) {
 559                         struct qrtr_server *srv;
 560
 561                         srv = radix_tree_deref_slot(srv_slot);
 562                         if (!server_match(srv, &filter))
 563                                 continue;
 564
 565                         lookup_notify(from, srv, true);
 566                 }
 567         }
 568
 569         /* Empty notification, to indicate end of listing */
 570         lookup_notify(from, NULL, true);
 571
 572         return 0;
 573 }
 574
 575 static void ctrl_cmd_del_lookup(struct sockaddr_qrtr *from,
 576                                 unsigned int service, unsigned int instance)
 577 {
 578         struct qrtr_lookup *lookup;
 579         struct list_head *tmp;
 580         struct list_head *li;
 581
 582         list_for_each_safe(li, tmp, &qrtr_ns.lookups) {
 583                 lookup = container_of(li, struct qrtr_lookup, li);
 584                 if (lookup->sq.sq_node != from->sq_node)
 585                         continue;
 586                 if (lookup->sq.sq_port != from->sq_port)
 587                         continue;
 588                 if (lookup->service != service)
 589                         continue;
 590                 if (lookup->instance && lookup->instance != instance)
 591                         continue;
 592
 593                 list_del(&lookup->li);
 594                 kfree(lookup);
 595         }
 596 }
 597
 598 static void qrtr_ns_worker(struct work_struct *work)
 599 {
 600         const struct qrtr_ctrl_pkt *pkt;
 601         size_t recv_buf_size = 4096;
 602         struct sockaddr_qrtr sq;
 603         struct msghdr msg = { };
 604         unsigned int cmd;
 605         ssize_t msglen;
 606         void *recv_buf;
 607         struct kvec iv;
 608         int ret;
 609
 610         msg.msg_name = (struct sockaddr *)&sq;
 611         msg.msg_namelen = sizeof(sq);
 612
 613         recv_buf = kzalloc(recv_buf_size, GFP_KERNEL);
 614         if (!recv_buf)
 615                 return;
 616
 617         for (;;) {
 618                 iv.iov_base = recv_buf;
 619                 iv.iov_len = recv_buf_size;
 620
 621                 msglen = kernel_recvmsg(qrtr_ns.sock, &msg, &iv, 1,
 622                                         iv.iov_len, MSG_DONTWAIT);
 623
 624                 if (msglen == -EAGAIN)
 625                         break;
 626
 627                 if (msglen < 0) {
 628                         pr_err("error receiving packet: %zd\n", msglen);
 629                         break;
 630                 }
 631
 632                 pkt = recv_buf;
 633                 cmd = le32_to_cpu(pkt->cmd);
 634                 if (cmd < ARRAY_SIZE(qrtr_ctrl_pkt_strings) &&
 635                     qrtr_ctrl_pkt_strings[cmd])
 636                         trace_printk("%s from %d:%d\n",
 637                                      qrtr_ctrl_pkt_strings[cmd], sq.sq_node,
 638                                      sq.sq_port);
 639
 640                 ret = 0;
 641                 switch (cmd) {
 642                 case QRTR_TYPE_HELLO:
 643                         ret = ctrl_cmd_hello(&sq);
 644                         break;
 645                 case QRTR_TYPE_BYE:
 646                         ret = ctrl_cmd_bye(&sq);
 647                         break;
 648                 case QRTR_TYPE_DEL_CLIENT:
 649                         ret = ctrl_cmd_del_client(&sq,
 650                                         le32_to_cpu(pkt->client.node),
 651                                         le32_to_cpu(pkt->client.port));
 652                         break;
 653                 case QRTR_TYPE_NEW_SERVER:
 654                         ret = ctrl_cmd_new_server(&sq,
 655                                         le32_to_cpu(pkt->server.service),
 656                                         le32_to_cpu(pkt->server.instance),
 657                                         le32_to_cpu(pkt->server.node),
 658                                         le32_to_cpu(pkt->server.port));
 659                         break;
 660                 case QRTR_TYPE_DEL_SERVER:
 661                         ret = ctrl_cmd_del_server(&sq,
 662                                          le32_to_cpu(pkt->server.service),
 663                                          le32_to_cpu(pkt->server.instance),
 664                                          le32_to_cpu(pkt->server.node),
 665                                          le32_to_cpu(pkt->server.port));
 666                         break;
 667                 case QRTR_TYPE_EXIT:
 668                 case QRTR_TYPE_PING:
 669                 case QRTR_TYPE_RESUME_TX:
 670                         break;
 671                 case QRTR_TYPE_NEW_LOOKUP:
 672                         ret = ctrl_cmd_new_lookup(&sq,
 673                                          le32_to_cpu(pkt->server.service),
 674                                          le32_to_cpu(pkt->server.instance));
 675                         break;
 676                 case QRTR_TYPE_DEL_LOOKUP:
 677                         ctrl_cmd_del_lookup(&sq,
 678                                     le32_to_cpu(pkt->server.service),
 679                                     le32_to_cpu(pkt->server.instance));
 680                         break;
 681                 }
 682
 683                 if (ret < 0)
 684                         pr_err("failed while handling packet from %d:%d",
 685                                sq.sq_node, sq.sq_port);
 686         }
 687
 688         kfree(recv_buf);
 689 }
 690
 691 static void qrtr_ns_data_ready(struct sock *sk)
 692 {
 693         queue_work(qrtr_ns.workqueue, &qrtr_ns.work);
 694 }
 695
 696 void qrtr_ns_init(void)
 697 {
 698         struct sockaddr_qrtr sq;
 699         int ret;
 700
 701         INIT_LIST_HEAD(&qrtr_ns.lookups);
 702         INIT_WORK(&qrtr_ns.work, qrtr_ns_worker);
 703
 704         ret = sock_create_kern(&init_net, AF_QIPCRTR, SOCK_DGRAM,
 705                                PF_QIPCRTR, &qrtr_ns.sock);
 706         if (ret < 0)
 707                 return;
 708
 709         ret = kernel_getsockname(qrtr_ns.sock, (struct sockaddr *)&sq);
 710         if (ret < 0) {
 711                 pr_err("failed to get socket name\n");
 712                 goto err_sock;
 713         }
 714
 715         qrtr_ns.workqueue = alloc_workqueue("qrtr_ns_handler", WQ_UNBOUND, 1);
 716         if (!qrtr_ns.workqueue)
 717                 goto err_sock;
 718
 719         qrtr_ns.sock->sk->sk_data_ready = qrtr_ns_data_ready;
 720
 721         sq.sq_port = QRTR_PORT_CTRL;
 722         qrtr_ns.local_node = sq.sq_node;
 723
 724         ret = kernel_bind(qrtr_ns.sock, (struct sockaddr *)&sq, sizeof(sq));
 725         if (ret < 0) {
 726                 pr_err("failed to bind to socket\n");
 727                 goto err_wq;
 728         }
 729
 730         qrtr_ns.bcast_sq.sq_family = AF_QIPCRTR;
 731         qrtr_ns.bcast_sq.sq_node = QRTR_NODE_BCAST;
 732         qrtr_ns.bcast_sq.sq_port = QRTR_PORT_CTRL;
 733
 734         ret = say_hello(&qrtr_ns.bcast_sq);
 735         if (ret < 0)
 736                 goto err_wq;
 737
 738         return;
 739
 740 err_wq:
 741         destroy_workqueue(qrtr_ns.workqueue);
 742 err_sock:
 743         sock_release(qrtr_ns.sock);
 744 }
 745 EXPORT_SYMBOL_GPL(qrtr_ns_init);
 746
 747 void qrtr_ns_remove(void)
 748 {
 749         cancel_work_sync(&qrtr_ns.work);
 750         destroy_workqueue(qrtr_ns.workqueue);
 751         sock_release(qrtr_ns.sock);
 752 }
 753 EXPORT_SYMBOL_GPL(qrtr_ns_remove);
 754
 755 MODULE_AUTHOR("Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>");
 756 MODULE_DESCRIPTION("Qualcomm IPC Router Nameservice");
 757 MODULE_LICENSE("Dual BSD/GPL");