/* AF_RXRPC local endpoint management * * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */ #include <linux/module.h> #include <linux/net.h> #include <linux/skbuff.h> #include <linux/slab.h> #include <net/sock.h> #include <net/af_rxrpc.h> #include "ar-internal.h" static LIST_HEAD(rxrpc_locals); DEFINE_RWLOCK(rxrpc_local_lock); static DECLARE_RWSEM(rxrpc_local_sem); static DECLARE_WAIT_QUEUE_HEAD(rxrpc_local_wq); static void rxrpc_destroy_local(struct work_struct *work); /* * allocate a new local */ static struct rxrpc_local *rxrpc_alloc_local(struct sockaddr_rxrpc *srx) { struct rxrpc_local *local; local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL); if (local) { INIT_WORK(&local->destroyer, &rxrpc_destroy_local); INIT_WORK(&local->acceptor, &rxrpc_accept_incoming_calls); INIT_WORK(&local->rejecter, &rxrpc_reject_packets); INIT_LIST_HEAD(&local->services); INIT_LIST_HEAD(&local->link); init_rwsem(&local->defrag_sem); skb_queue_head_init(&local->accept_queue); skb_queue_head_init(&local->reject_queue); spin_lock_init(&local->lock); rwlock_init(&local->services_lock); atomic_set(&local->usage, 1); local->debug_id = atomic_inc_return(&rxrpc_debug_id); memcpy(&local->srx, srx, sizeof(*srx)); } _leave(" = %p", local); return local; } /* * create the local socket * - must be called with rxrpc_local_sem writelocked */ static int rxrpc_create_local(struct rxrpc_local *local) { struct sock *sock; int ret, opt; _enter("%p{%d}", local, local->srx.transport_type); /* create a socket to represent the local endpoint */ ret = sock_create_kern(PF_INET, local->srx.transport_type, IPPROTO_UDP, &local->socket); if (ret < 0) { _leave(" = %d [socket]", ret); return ret; } /* if a local address was supplied then bind it */ if (local->srx.transport_len > sizeof(sa_family_t)) { _debug("bind"); ret = kernel_bind(local->socket, (struct sockaddr *) &local->srx.transport, local->srx.transport_len); if (ret < 0) { _debug("bind failed"); goto error; } } /* we want to receive ICMP errors */ opt = 1; ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR, (char *) &opt, sizeof(opt)); if (ret < 0) { _debug("setsockopt failed"); goto error; } /* we want to set the don't fragment bit */ opt = IP_PMTUDISC_DO; ret = kernel_setsockopt(local->socket, SOL_IP, IP_MTU_DISCOVER, (char *) &opt, sizeof(opt)); if (ret < 0) { _debug("setsockopt failed"); goto error; } write_lock_bh(&rxrpc_local_lock); list_add(&local->link, &rxrpc_locals); write_unlock_bh(&rxrpc_local_lock); /* set the socket up */ sock = local->socket->sk; sock->sk_user_data = local; sock->sk_data_ready = rxrpc_data_ready; sock->sk_error_report = rxrpc_UDP_error_report; _leave(" = 0"); return 0; error: kernel_sock_shutdown(local->socket, SHUT_RDWR); local->socket->sk->sk_user_data = NULL; sock_release(local->socket); local->socket = NULL; _leave(" = %d", ret); return ret; } /* * create a new local endpoint using the specified UDP address */ struct rxrpc_local *rxrpc_lookup_local(struct sockaddr_rxrpc *srx) { struct rxrpc_local *local; int ret; _enter("{%d,%u,%pI4+%hu}", srx->transport_type, srx->transport.family, &srx->transport.sin.sin_addr, ntohs(srx->transport.sin.sin_port)); down_write(&rxrpc_local_sem); /* see if we have a suitable local local endpoint already */ read_lock_bh(&rxrpc_local_lock); list_for_each_entry(local, &rxrpc_locals, link) { _debug("CMP {%d,%u,%pI4+%hu}", local->srx.transport_type, local->srx.transport.family, &local->srx.transport.sin.sin_addr, ntohs(local->srx.transport.sin.sin_port)); if (local->srx.transport_type != srx->transport_type || local->srx.transport.family != srx->transport.family) continue; switch (srx->transport.family) { case AF_INET: if (local->srx.transport.sin.sin_port != srx->transport.sin.sin_port) continue; if (memcmp(&local->srx.transport.sin.sin_addr, &srx->transport.sin.sin_addr, sizeof(struct in_addr)) != 0) continue; goto found_local; default: BUG(); } } read_unlock_bh(&rxrpc_local_lock); /* we didn't find one, so we need to create one */ local = rxrpc_alloc_local(srx); if (!local) { up_write(&rxrpc_local_sem); return ERR_PTR(-ENOMEM); } ret = rxrpc_create_local(local); if (ret < 0) { up_write(&rxrpc_local_sem); kfree(local); _leave(" = %d", ret); return ERR_PTR(ret); } up_write(&rxrpc_local_sem); _net("LOCAL new %d {%d,%u,%pI4+%hu}", local->debug_id, local->srx.transport_type, local->srx.transport.family, &local->srx.transport.sin.sin_addr, ntohs(local->srx.transport.sin.sin_port)); _leave(" = %p [new]", local); return local; found_local: rxrpc_get_local(local); read_unlock_bh(&rxrpc_local_lock); up_write(&rxrpc_local_sem); _net("LOCAL old %d {%d,%u,%pI4+%hu}", local->debug_id, local->srx.transport_type, local->srx.transport.family, &local->srx.transport.sin.sin_addr, ntohs(local->srx.transport.sin.sin_port)); _leave(" = %p [reuse]", local); return local; } /* * release a local endpoint */ void rxrpc_put_local(struct rxrpc_local *local) { _enter("%p{u=%d}", local, atomic_read(&local->usage)); ASSERTCMP(atomic_read(&local->usage), >, 0); /* to prevent a race, the decrement and the dequeue must be effectively * atomic */ write_lock_bh(&rxrpc_local_lock); if (unlikely(atomic_dec_and_test(&local->usage))) { _debug("destroy local"); rxrpc_queue_work(&local->destroyer); } write_unlock_bh(&rxrpc_local_lock); _leave(""); } /* * destroy a local endpoint */ static void rxrpc_destroy_local(struct work_struct *work) { struct rxrpc_local *local = container_of(work, struct rxrpc_local, destroyer); _enter("%p{%d}", local, atomic_read(&local->usage)); down_write(&rxrpc_local_sem); write_lock_bh(&rxrpc_local_lock); if (atomic_read(&local->usage) > 0) { write_unlock_bh(&rxrpc_local_lock); up_read(&rxrpc_local_sem); _leave(" [resurrected]"); return; } list_del(&local->link); local->socket->sk->sk_user_data = NULL; write_unlock_bh(&rxrpc_local_lock); downgrade_write(&rxrpc_local_sem); ASSERT(list_empty(&local->services)); ASSERT(!work_pending(&local->acceptor)); ASSERT(!work_pending(&local->rejecter)); /* finish cleaning up the local descriptor */ rxrpc_purge_queue(&local->accept_queue); rxrpc_purge_queue(&local->reject_queue); kernel_sock_shutdown(local->socket, SHUT_RDWR); sock_release(local->socket); up_read(&rxrpc_local_sem); _net("DESTROY LOCAL %d", local->debug_id); kfree(local); if (list_empty(&rxrpc_locals)) wake_up_all(&rxrpc_local_wq); _leave(""); } /* * preemptively destroy all local local endpoint rather than waiting for * them to be destroyed */ void __exit rxrpc_destroy_all_locals(void) { DECLARE_WAITQUEUE(myself,current); _enter(""); /* we simply have to wait for them to go away */ if (!list_empty(&rxrpc_locals)) { set_current_state(TASK_UNINTERRUPTIBLE); add_wait_queue(&rxrpc_local_wq, &myself); while (!list_empty(&rxrpc_locals)) { schedule(); set_current_state(TASK_UNINTERRUPTIBLE); } remove_wait_queue(&rxrpc_local_wq, &myself); set_current_state(TASK_RUNNING); } _leave(""); }