708 lines · 17.8 KB · C
RawDownload
// SPDX-License-Identifier: GPL-2.0-or-later/* AFS server record management * * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) */ #include <linux/sched.h>#include <linux/slab.h>#include "afs_fs.h"#include "internal.h"#include "protocol_yfs.h" static unsigned afs_server_gc_delay = 10;	/* Server record timeout in seconds */static atomic_t afs_server_debug_id; static struct afs_server *afs_maybe_use_server(struct afs_server *,					       enum afs_server_trace);static void __afs_put_server(struct afs_net *, struct afs_server *); /* * Find a server by one of its addresses. */struct afs_server *afs_find_server(struct afs_net *net,				   const struct sockaddr_rxrpc *srx){	const struct afs_addr_list *alist;	struct afs_server *server = NULL;	unsigned int i;	int seq = 0, diff; 	rcu_read_lock(); 	do {		if (server)			afs_unuse_server_notime(net, server, afs_server_trace_put_find_rsq);		server = NULL;		read_seqbegin_or_lock(&net->fs_addr_lock, &seq); 		if (srx->transport.family == AF_INET6) {			const struct sockaddr_in6 *a = &srx->transport.sin6, *b;			hlist_for_each_entry_rcu(server, &net->fs_addresses6, addr6_link) {				alist = rcu_dereference(server->addresses);				for (i = alist->nr_ipv4; i < alist->nr_addrs; i++) {					b = &alist->addrs[i].transport.sin6;					diff = ((u16 __force)a->sin6_port -						(u16 __force)b->sin6_port);					if (diff == 0)						diff = memcmp(&a->sin6_addr,							      &b->sin6_addr,							      sizeof(struct in6_addr));					if (diff == 0)						goto found;				}			}		} else {			const struct sockaddr_in *a = &srx->transport.sin, *b;			hlist_for_each_entry_rcu(server, &net->fs_addresses4, addr4_link) {				alist = rcu_dereference(server->addresses);				for (i = 0; i < alist->nr_ipv4; i++) {					b = &alist->addrs[i].transport.sin;					diff = ((u16 __force)a->sin_port -						(u16 __force)b->sin_port);					if (diff == 0)						diff = ((u32 __force)a->sin_addr.s_addr -							(u32 __force)b->sin_addr.s_addr);					if (diff == 0)						goto found;				}			}		} 		server = NULL;		continue;	found:		server = afs_maybe_use_server(server, afs_server_trace_get_by_addr); 	} while (need_seqretry(&net->fs_addr_lock, seq)); 	done_seqretry(&net->fs_addr_lock, seq); 	rcu_read_unlock();	return server;} /* * Look up a server by its UUID and mark it active. */struct afs_server *afs_find_server_by_uuid(struct afs_net *net, const uuid_t *uuid){	struct afs_server *server = NULL;	struct rb_node *p;	int diff, seq = 0; 	_enter("%pU", uuid); 	do {		/* Unfortunately, rbtree walking doesn't give reliable results		 * under just the RCU read lock, so we have to check for		 * changes.		 */		if (server)			afs_unuse_server(net, server, afs_server_trace_put_uuid_rsq);		server = NULL; 		read_seqbegin_or_lock(&net->fs_lock, &seq); 		p = net->fs_servers.rb_node;		while (p) {			server = rb_entry(p, struct afs_server, uuid_rb); 			diff = memcmp(uuid, &server->uuid, sizeof(*uuid));			if (diff < 0) {				p = p->rb_left;			} else if (diff > 0) {				p = p->rb_right;			} else {				afs_use_server(server, afs_server_trace_get_by_uuid);				break;			} 			server = NULL;		}	} while (need_seqretry(&net->fs_lock, seq)); 	done_seqretry(&net->fs_lock, seq); 	_leave(" = %p", server);	return server;} /* * Install a server record in the namespace tree.  If there's a clash, we stick * it into a list anchored on whichever afs_server struct is actually in the * tree. */static struct afs_server *afs_install_server(struct afs_cell *cell,					     struct afs_server *candidate){	const struct afs_addr_list *alist;	struct afs_server *server, *next;	struct afs_net *net = cell->net;	struct rb_node **pp, *p;	int diff; 	_enter("%p", candidate); 	write_seqlock(&net->fs_lock); 	/* Firstly install the server in the UUID lookup tree */	pp = &net->fs_servers.rb_node;	p = NULL;	while (*pp) {		p = *pp;		_debug("- consider %p", p);		server = rb_entry(p, struct afs_server, uuid_rb);		diff = memcmp(&candidate->uuid, &server->uuid, sizeof(uuid_t));		if (diff < 0) {			pp = &(*pp)->rb_left;		} else if (diff > 0) {			pp = &(*pp)->rb_right;		} else {			if (server->cell == cell)				goto exists; 			/* We have the same UUID representing servers in			 * different cells.  Append the new server to the list.			 */			for (;;) {				next = rcu_dereference_protected(					server->uuid_next,					lockdep_is_held(&net->fs_lock.lock));				if (!next)					break;				server = next;			}			rcu_assign_pointer(server->uuid_next, candidate);			candidate->uuid_prev = server;			server = candidate;			goto added_dup;		}	} 	server = candidate;	rb_link_node(&server->uuid_rb, p, pp);	rb_insert_color(&server->uuid_rb, &net->fs_servers);	hlist_add_head_rcu(&server->proc_link, &net->fs_proc); added_dup:	write_seqlock(&net->fs_addr_lock);	alist = rcu_dereference_protected(server->addresses,					  lockdep_is_held(&net->fs_addr_lock.lock)); 	/* Secondly, if the server has any IPv4 and/or IPv6 addresses, install	 * it in the IPv4 and/or IPv6 reverse-map lists.	 *	 * TODO: For speed we want to use something other than a flat list	 * here; even sorting the list in terms of lowest address would help a	 * bit, but anything we might want to do gets messy and memory	 * intensive.	 */	if (alist->nr_ipv4 > 0)		hlist_add_head_rcu(&server->addr4_link, &net->fs_addresses4);	if (alist->nr_addrs > alist->nr_ipv4)		hlist_add_head_rcu(&server->addr6_link, &net->fs_addresses6); 	write_sequnlock(&net->fs_addr_lock); exists:	afs_get_server(server, afs_server_trace_get_install);	write_sequnlock(&net->fs_lock);	return server;} /* * Allocate a new server record and mark it active. */static struct afs_server *afs_alloc_server(struct afs_cell *cell,					   const uuid_t *uuid,					   struct afs_addr_list *alist){	struct afs_server *server;	struct afs_net *net = cell->net; 	_enter(""); 	server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);	if (!server)		goto enomem; 	atomic_set(&server->ref, 1);	atomic_set(&server->active, 1);	server->debug_id = atomic_inc_return(&afs_server_debug_id);	RCU_INIT_POINTER(server->addresses, alist);	server->addr_version = alist->version;	server->uuid = *uuid;	rwlock_init(&server->fs_lock);	init_waitqueue_head(&server->probe_wq);	INIT_LIST_HEAD(&server->probe_link);	spin_lock_init(&server->probe_lock);	server->cell = cell;	server->rtt = UINT_MAX; 	afs_inc_servers_outstanding(net);	trace_afs_server(server, 1, 1, afs_server_trace_alloc);	_leave(" = %p", server);	return server; enomem:	_leave(" = NULL [nomem]");	return NULL;} /* * Look up an address record for a server */static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_cell *cell,						 struct key *key, const uuid_t *uuid){	struct afs_vl_cursor vc;	struct afs_addr_list *alist = NULL;	int ret; 	ret = -ERESTARTSYS;	if (afs_begin_vlserver_operation(&vc, cell, key)) {		while (afs_select_vlserver(&vc)) {			if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags))				alist = afs_yfsvl_get_endpoints(&vc, uuid);			else				alist = afs_vl_get_addrs_u(&vc, uuid);		} 		ret = afs_end_vlserver_operation(&vc);	} 	return ret < 0 ? ERR_PTR(ret) : alist;} /* * Get or create a fileserver record. */struct afs_server *afs_lookup_server(struct afs_cell *cell, struct key *key,				     const uuid_t *uuid, u32 addr_version){	struct afs_addr_list *alist;	struct afs_server *server, *candidate; 	_enter("%p,%pU", cell->net, uuid); 	server = afs_find_server_by_uuid(cell->net, uuid);	if (server) {		if (server->addr_version != addr_version)			set_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags);		return server;	} 	alist = afs_vl_lookup_addrs(cell, key, uuid);	if (IS_ERR(alist))		return ERR_CAST(alist); 	candidate = afs_alloc_server(cell, uuid, alist);	if (!candidate) {		afs_put_addrlist(alist);		return ERR_PTR(-ENOMEM);	} 	server = afs_install_server(cell, candidate);	if (server != candidate) {		afs_put_addrlist(alist);		kfree(candidate);	} else {		/* Immediately dispatch an asynchronous probe to each interface		 * on the fileserver.  This will make sure the repeat-probing		 * service is started.		 */		afs_fs_probe_fileserver(cell->net, server, key, true);	} 	return server;} /* * Set the server timer to fire after a given delay, assuming it's not already * set for an earlier time. */static void afs_set_server_timer(struct afs_net *net, time64_t delay){	if (net->live) {		afs_inc_servers_outstanding(net);		if (timer_reduce(&net->fs_timer, jiffies + delay * HZ))			afs_dec_servers_outstanding(net);	}} /* * Server management timer.  We have an increment on fs_outstanding that we * need to pass along to the work item. */void afs_servers_timer(struct timer_list *timer){	struct afs_net *net = container_of(timer, struct afs_net, fs_timer); 	_enter("");	if (!queue_work(afs_wq, &net->fs_manager))		afs_dec_servers_outstanding(net);} /* * Get a reference on a server object. */struct afs_server *afs_get_server(struct afs_server *server,				  enum afs_server_trace reason){	unsigned int u = atomic_inc_return(&server->ref); 	trace_afs_server(server, u, atomic_read(&server->active), reason);	return server;} /* * Try to get a reference on a server object. */static struct afs_server *afs_maybe_use_server(struct afs_server *server,					       enum afs_server_trace reason){	unsigned int r = atomic_fetch_add_unless(&server->ref, 1, 0);	unsigned int a; 	if (r == 0)		return NULL; 	a = atomic_inc_return(&server->active);	trace_afs_server(server, r, a, reason);	return server;} /* * Get an active count on a server object. */struct afs_server *afs_use_server(struct afs_server *server, enum afs_server_trace reason){	unsigned int r = atomic_inc_return(&server->ref);	unsigned int a = atomic_inc_return(&server->active); 	trace_afs_server(server, r, a, reason);	return server;} /* * Release a reference on a server record. */void afs_put_server(struct afs_net *net, struct afs_server *server,		    enum afs_server_trace reason){	unsigned int usage; 	if (!server)		return; 	usage = atomic_dec_return(&server->ref);	trace_afs_server(server, usage, atomic_read(&server->active), reason);	if (unlikely(usage == 0))		__afs_put_server(net, server);} /* * Drop an active count on a server object without updating the last-unused * time. */void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server,			     enum afs_server_trace reason){	if (server) {		unsigned int active = atomic_dec_return(&server->active); 		if (active == 0)			afs_set_server_timer(net, afs_server_gc_delay);		afs_put_server(net, server, reason);	}} /* * Drop an active count on a server object. */void afs_unuse_server(struct afs_net *net, struct afs_server *server,		      enum afs_server_trace reason){	if (server) {		server->unuse_time = ktime_get_real_seconds();		afs_unuse_server_notime(net, server, reason);	}} static void afs_server_rcu(struct rcu_head *rcu){	struct afs_server *server = container_of(rcu, struct afs_server, rcu); 	trace_afs_server(server, atomic_read(&server->ref),			 atomic_read(&server->active), afs_server_trace_free);	afs_put_addrlist(rcu_access_pointer(server->addresses));	kfree(server);} static void __afs_put_server(struct afs_net *net, struct afs_server *server){	call_rcu(&server->rcu, afs_server_rcu);	afs_dec_servers_outstanding(net);} static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server){	struct afs_addr_list *alist = rcu_access_pointer(server->addresses);	struct afs_addr_cursor ac = {		.alist	= alist,		.index	= alist->preferred,		.error	= 0,	}; 	afs_fs_give_up_all_callbacks(net, server, &ac, NULL);} /* * destroy a dead server */static void afs_destroy_server(struct afs_net *net, struct afs_server *server){	if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags))		afs_give_up_callbacks(net, server); 	afs_put_server(net, server, afs_server_trace_destroy);} /* * Garbage collect any expired servers. */static void afs_gc_servers(struct afs_net *net, struct afs_server *gc_list){	struct afs_server *server, *next, *prev;	int active; 	while ((server = gc_list)) {		gc_list = server->gc_next; 		write_seqlock(&net->fs_lock); 		active = atomic_read(&server->active);		if (active == 0) {			trace_afs_server(server, atomic_read(&server->ref),					 active, afs_server_trace_gc);			next = rcu_dereference_protected(				server->uuid_next, lockdep_is_held(&net->fs_lock.lock));			prev = server->uuid_prev;			if (!prev) {				/* The one at the front is in the tree */				if (!next) {					rb_erase(&server->uuid_rb, &net->fs_servers);				} else {					rb_replace_node_rcu(&server->uuid_rb,							    &next->uuid_rb,							    &net->fs_servers);

Lines 1–500 of 708.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t