net/rxrpc/local_object.c

   1 /* AF_RXRPC local endpoint management
   2  *
   3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/module.h>
  15 #include <linux/net.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/slab.h>
  18 #include <linux/udp.h>
  19 #include <linux/ip.h>
  20 #include <net/sock.h>
  21 #include <net/af_rxrpc.h>
  22 #include <generated/utsrelease.h>
  23 #include "ar-internal.h"
  24
  25 static const char rxrpc_version_string[65] = "linux-" UTS_RELEASE " AF_RXRPC";
  26
  27 static LIST_HEAD(rxrpc_locals);
  28 DEFINE_RWLOCK(rxrpc_local_lock);
  29 static DECLARE_RWSEM(rxrpc_local_sem);
  30 static DECLARE_WAIT_QUEUE_HEAD(rxrpc_local_wq);
  31
  32 static void rxrpc_destroy_local(struct work_struct *work);
  33 static void rxrpc_process_local_events(struct work_struct *work);
  34
  35 /*
  36  * allocate a new local
  37  */
  38 static
  39 struct rxrpc_local *rxrpc_alloc_local(struct sockaddr_rxrpc *srx)
  40 {
  41         struct rxrpc_local *local;
  42
  43         local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
  44         if (local) {
  45                 INIT_WORK(&local->destroyer, &rxrpc_destroy_local);
  46                 INIT_WORK(&local->acceptor, &rxrpc_accept_incoming_calls);
  47                 INIT_WORK(&local->rejecter, &rxrpc_reject_packets);
  48                 INIT_WORK(&local->event_processor, &rxrpc_process_local_events);
  49                 INIT_LIST_HEAD(&local->services);
  50                 INIT_LIST_HEAD(&local->link);
  51                 init_rwsem(&local->defrag_sem);
  52                 skb_queue_head_init(&local->accept_queue);
  53                 skb_queue_head_init(&local->reject_queue);
  54                 skb_queue_head_init(&local->event_queue);
  55                 spin_lock_init(&local->lock);
  56                 rwlock_init(&local->services_lock);
  57                 atomic_set(&local->usage, 1);
  58                 local->debug_id = atomic_inc_return(&rxrpc_debug_id);
  59                 memcpy(&local->srx, srx, sizeof(*srx));
  60         }
  61
  62         _leave(" = %p", local);
  63         return local;
  64 }
  65
  66 /*
  67  * create the local socket
  68  * - must be called with rxrpc_local_sem writelocked
  69  */
  70 static int rxrpc_create_local(struct rxrpc_local *local)
  71 {
  72         struct sock *sock;
  73         int ret, opt;
  74
  75         _enter("%p{%d}", local, local->srx.transport_type);
  76
  77         /* create a socket to represent the local endpoint */
  78         ret = sock_create_kern(&init_net, PF_INET, local->srx.transport_type,
  79                                IPPROTO_UDP, &local->socket);
  80         if (ret < 0) {
  81                 _leave(" = %d [socket]", ret);
  82                 return ret;
  83         }
  84
  85         /* if a local address was supplied then bind it */
  86         if (local->srx.transport_len > sizeof(sa_family_t)) {
  87                 _debug("bind");
  88                 ret = kernel_bind(local->socket,
  89                                   (struct sockaddr *) &local->srx.transport,
  90                                   local->srx.transport_len);
  91                 if (ret < 0) {
  92                         _debug("bind failed");
  93                         goto error;
  94                 }
  95         }
  96
  97         /* we want to receive ICMP errors */
  98         opt = 1;
  99         ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR,
 100                                 (char *) &opt, sizeof(opt));
 101         if (ret < 0) {
 102                 _debug("setsockopt failed");
 103                 goto error;
 104         }
 105
 106         /* we want to set the don't fragment bit */
 107         opt = IP_PMTUDISC_DO;
 108         ret = kernel_setsockopt(local->socket, SOL_IP, IP_MTU_DISCOVER,
 109                                 (char *) &opt, sizeof(opt));
 110         if (ret < 0) {
 111                 _debug("setsockopt failed");
 112                 goto error;
 113         }
 114
 115         write_lock_bh(&rxrpc_local_lock);
 116         list_add(&local->link, &rxrpc_locals);
 117         write_unlock_bh(&rxrpc_local_lock);
 118
 119         /* set the socket up */
 120         sock = local->socket->sk;
 121         sock->sk_user_data      = local;
 122         sock->sk_data_ready     = rxrpc_data_ready;
 123         sock->sk_error_report   = rxrpc_UDP_error_report;
 124         _leave(" = 0");
 125         return 0;
 126
 127 error:
 128         kernel_sock_shutdown(local->socket, SHUT_RDWR);
 129         local->socket->sk->sk_user_data = NULL;
 130         sock_release(local->socket);
 131         local->socket = NULL;
 132
 133         _leave(" = %d", ret);
 134         return ret;
 135 }
 136
 137 /*
 138  * create a new local endpoint using the specified UDP address
 139  */
 140 struct rxrpc_local *rxrpc_lookup_local(struct sockaddr_rxrpc *srx)
 141 {
 142         struct rxrpc_local *local;
 143         int ret;
 144
 145         _enter("{%d,%u,%pI4+%hu}",
 146                srx->transport_type,
 147                srx->transport.family,
 148                &srx->transport.sin.sin_addr,
 149                ntohs(srx->transport.sin.sin_port));
 150
 151         down_write(&rxrpc_local_sem);
 152
 153         /* see if we have a suitable local local endpoint already */
 154         read_lock_bh(&rxrpc_local_lock);
 155
 156         list_for_each_entry(local, &rxrpc_locals, link) {
 157                 _debug("CMP {%d,%u,%pI4+%hu}",
 158                        local->srx.transport_type,
 159                        local->srx.transport.family,
 160                        &local->srx.transport.sin.sin_addr,
 161                        ntohs(local->srx.transport.sin.sin_port));
 162
 163                 if (local->srx.transport_type != srx->transport_type ||
 164                     local->srx.transport.family != srx->transport.family)
 165                         continue;
 166
 167                 switch (srx->transport.family) {
 168                 case AF_INET:
 169                         if (local->srx.transport.sin.sin_port !=
 170                             srx->transport.sin.sin_port)
 171                                 continue;
 172                         if (memcmp(&local->srx.transport.sin.sin_addr,
 173                                    &srx->transport.sin.sin_addr,
 174                                    sizeof(struct in_addr)) != 0)
 175                                 continue;
 176                         goto found_local;
 177
 178                 default:
 179                         BUG();
 180                 }
 181         }
 182
 183         read_unlock_bh(&rxrpc_local_lock);
 184
 185         /* we didn't find one, so we need to create one */
 186         local = rxrpc_alloc_local(srx);
 187         if (!local) {
 188                 up_write(&rxrpc_local_sem);
 189                 return ERR_PTR(-ENOMEM);
 190         }
 191
 192         ret = rxrpc_create_local(local);
 193         if (ret < 0) {
 194                 up_write(&rxrpc_local_sem);
 195                 kfree(local);
 196                 _leave(" = %d", ret);
 197                 return ERR_PTR(ret);
 198         }
 199
 200         up_write(&rxrpc_local_sem);
 201
 202         _net("LOCAL new %d {%d,%u,%pI4+%hu}",
 203              local->debug_id,
 204              local->srx.transport_type,
 205              local->srx.transport.family,
 206              &local->srx.transport.sin.sin_addr,
 207              ntohs(local->srx.transport.sin.sin_port));
 208
 209         _leave(" = %p [new]", local);
 210         return local;
 211
 212 found_local:
 213         rxrpc_get_local(local);
 214         read_unlock_bh(&rxrpc_local_lock);
 215         up_write(&rxrpc_local_sem);
 216
 217         _net("LOCAL old %d {%d,%u,%pI4+%hu}",
 218              local->debug_id,
 219              local->srx.transport_type,
 220              local->srx.transport.family,
 221              &local->srx.transport.sin.sin_addr,
 222              ntohs(local->srx.transport.sin.sin_port));
 223
 224         _leave(" = %p [reuse]", local);
 225         return local;
 226 }
 227
 228 /*
 229  * release a local endpoint
 230  */
 231 void rxrpc_put_local(struct rxrpc_local *local)
 232 {
 233         _enter("%p{u=%d}", local, atomic_read(&local->usage));
 234
 235         ASSERTCMP(atomic_read(&local->usage), >, 0);
 236
 237         /* to prevent a race, the decrement and the dequeue must be effectively
 238          * atomic */
 239         write_lock_bh(&rxrpc_local_lock);
 240         if (unlikely(atomic_dec_and_test(&local->usage))) {
 241                 _debug("destroy local");
 242                 rxrpc_queue_work(&local->destroyer);
 243         }
 244         write_unlock_bh(&rxrpc_local_lock);
 245         _leave("");
 246 }
 247
 248 /*
 249  * destroy a local endpoint
 250  */
 251 static void rxrpc_destroy_local(struct work_struct *work)
 252 {
 253         struct rxrpc_local *local =
 254                 container_of(work, struct rxrpc_local, destroyer);
 255
 256         _enter("%p{%d}", local, atomic_read(&local->usage));
 257
 258         down_write(&rxrpc_local_sem);
 259
 260         write_lock_bh(&rxrpc_local_lock);
 261         if (atomic_read(&local->usage) > 0) {
 262                 write_unlock_bh(&rxrpc_local_lock);
 263                 up_read(&rxrpc_local_sem);
 264                 _leave(" [resurrected]");
 265                 return;
 266         }
 267
 268         list_del(&local->link);
 269         local->socket->sk->sk_user_data = NULL;
 270         write_unlock_bh(&rxrpc_local_lock);
 271
 272         downgrade_write(&rxrpc_local_sem);
 273
 274         ASSERT(list_empty(&local->services));
 275         ASSERT(!work_pending(&local->acceptor));
 276         ASSERT(!work_pending(&local->rejecter));
 277         ASSERT(!work_pending(&local->event_processor));
 278
 279         /* finish cleaning up the local descriptor */
 280         rxrpc_purge_queue(&local->accept_queue);
 281         rxrpc_purge_queue(&local->reject_queue);
 282         rxrpc_purge_queue(&local->event_queue);
 283         kernel_sock_shutdown(local->socket, SHUT_RDWR);
 284         sock_release(local->socket);
 285
 286         up_read(&rxrpc_local_sem);
 287
 288         _net("DESTROY LOCAL %d", local->debug_id);
 289         kfree(local);
 290
 291         if (list_empty(&rxrpc_locals))
 292                 wake_up_all(&rxrpc_local_wq);
 293
 294         _leave("");
 295 }
 296
 297 /*
 298  * preemptively destroy all local local endpoint rather than waiting for
 299  * them to be destroyed
 300  */
 301 void __exit rxrpc_destroy_all_locals(void)
 302 {
 303         DECLARE_WAITQUEUE(myself,current);
 304
 305         _enter("");
 306
 307         /* we simply have to wait for them to go away */
 308         if (!list_empty(&rxrpc_locals)) {
 309                 set_current_state(TASK_UNINTERRUPTIBLE);
 310                 add_wait_queue(&rxrpc_local_wq, &myself);
 311
 312                 while (!list_empty(&rxrpc_locals)) {
 313                         schedule();
 314                         set_current_state(TASK_UNINTERRUPTIBLE);
 315                 }
 316
 317                 remove_wait_queue(&rxrpc_local_wq, &myself);
 318                 set_current_state(TASK_RUNNING);
 319         }
 320
 321         _leave("");
 322 }
 323
 324 /*
 325  * Reply to a version request
 326  */
 327 static void rxrpc_send_version_request(struct rxrpc_local *local,
 328                                        struct rxrpc_host_header *hdr,
 329                                        struct sk_buff *skb)
 330 {
 331         struct rxrpc_wire_header whdr;
 332         struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 333         struct sockaddr_in sin;
 334         struct msghdr msg;
 335         struct kvec iov[2];
 336         size_t len;
 337         int ret;
 338
 339         _enter("");
 340
 341         sin.sin_family = AF_INET;
 342         sin.sin_port = udp_hdr(skb)->source;
 343         sin.sin_addr.s_addr = ip_hdr(skb)->saddr;
 344
 345         msg.msg_name    = &sin;
 346         msg.msg_namelen = sizeof(sin);
 347         msg.msg_control = NULL;
 348         msg.msg_controllen = 0;
 349         msg.msg_flags   = 0;
 350
 351         whdr.epoch      = htonl(sp->hdr.epoch);
 352         whdr.cid        = htonl(sp->hdr.cid);
 353         whdr.callNumber = htonl(sp->hdr.callNumber);
 354         whdr.seq        = 0;
 355         whdr.serial     = 0;
 356         whdr.type       = RXRPC_PACKET_TYPE_VERSION;
 357         whdr.flags      = RXRPC_LAST_PACKET | (~hdr->flags & RXRPC_CLIENT_INITIATED);
 358         whdr.userStatus = 0;
 359         whdr.securityIndex = 0;
 360         whdr._rsvd      = 0;
 361         whdr.serviceId  = htons(sp->hdr.serviceId);
 362
 363         iov[0].iov_base = &whdr;
 364         iov[0].iov_len  = sizeof(whdr);
 365         iov[1].iov_base = (char *)rxrpc_version_string;
 366         iov[1].iov_len  = sizeof(rxrpc_version_string);
 367
 368         len = iov[0].iov_len + iov[1].iov_len;
 369
 370         _proto("Tx VERSION (reply)");
 371
 372         ret = kernel_sendmsg(local->socket, &msg, iov, 2, len);
 373         if (ret < 0)
 374                 _debug("sendmsg failed: %d", ret);
 375
 376         _leave("");
 377 }
 378
 379 /*
 380  * Process event packets targetted at a local endpoint.
 381  */
 382 static void rxrpc_process_local_events(struct work_struct *work)
 383 {
 384         struct rxrpc_local *local = container_of(work, struct rxrpc_local, event_processor);
 385         struct sk_buff *skb;
 386         char v;
 387
 388         _enter("");
 389
 390         atomic_inc(&local->usage);
 391
 392         while ((skb = skb_dequeue(&local->event_queue))) {
 393                 struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 394
 395                 _debug("{%d},{%u}", local->debug_id, sp->hdr.type);
 396
 397                 switch (sp->hdr.type) {
 398                 case RXRPC_PACKET_TYPE_VERSION:
 399                         if (skb_copy_bits(skb, 0, &v, 1) < 0)
 400                                 return;
 401                         _proto("Rx VERSION { %02x }", v);
 402                         if (v == 0)
 403                                 rxrpc_send_version_request(local, &sp->hdr, skb);
 404                         break;
 405
 406                 default:
 407                         /* Just ignore anything we don't understand */
 408                         break;
 409                 }
 410
 411                 rxrpc_put_local(local);
 412                 rxrpc_free_skb(skb);
 413         }
 414
 415         rxrpc_put_local(local);
 416         _leave("");
 417 }