fs/afs/server.c

2 /* AFS server record management
22  * Find a server by one of its addresses.
28 	struct afs_server *server = NULL;
35 		if (server)
36 			afs_unuse_server_notime(net, server, afs_server_trace_put_find_rsq);
37 		server = NULL;
41 		hlist_for_each_entry_rcu(server, &net->fs_addresses, addr_link) {
42 			estate = rcu_dereference(server->endpoint_state);
49 		server = NULL;
52 		server = afs_maybe_use_server(server, afs_server_trace_get_by_addr);
59 	return server;
63  * Look up a server by its UUID and mark it active.
67 	struct afs_server *server = NULL;
78 		if (server)
79 			afs_unuse_server(net, server, afs_server_trace_put_uuid_rsq);
80 		server = NULL;
86 			server = rb_entry(p, struct afs_server, uuid_rb);
88 			diff = memcmp(uuid, &server->uuid, sizeof(*uuid));
94 				afs_use_server(server, afs_server_trace_get_by_uuid);
98 			server = NULL;
104 	_leave(" = %p", server);
105 	return server;
109  * Install a server record in the namespace tree.  If there's a clash, we stick
118 	struct afs_server *server, *next;
127 	/* Firstly install the server in the UUID lookup tree */
133 		server = rb_entry(p, struct afs_server, uuid_rb);
134 		diff = memcmp(&candidate->uuid, &server->uuid, sizeof(uuid_t));
140 			if (server->cell == cell)
144 			 * different cells.  Append the new server to the list.
148 					server->uuid_next,
152 				server = next;
154 			rcu_assign_pointer(server->uuid_next, candidate);
155 			candidate->uuid_prev = server;
156 			server = candidate;
161 	server = candidate;
162 	rb_link_node(&server->uuid_rb, p, pp);
163 	rb_insert_color(&server->uuid_rb, &net->fs_servers);
164 	hlist_add_head_rcu(&server->proc_link, &net->fs_proc);
168 	estate = rcu_dereference_protected(server->endpoint_state,
172 	/* Secondly, if the server has any IPv4 and/or IPv6 addresses, install
181 		hlist_add_head_rcu(&server->addr_link, &net->fs_addresses);
186 	afs_get_server(server, afs_server_trace_get_install);
188 	return server;
192  * Allocate a new server record and mark it active.
199 	struct afs_server *server;
204 	server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
205 	if (!server)
212 	refcount_set(&server->ref, 1);
213 	atomic_set(&server->active, 1);
214 	server->debug_id = atomic_inc_return(&afs_server_debug_id);
215 	server->addr_version = alist->version;
216 	server->uuid = *uuid;
217 	rwlock_init(&server->fs_lock);
218 	INIT_LIST_HEAD(&server->volumes);
219 	init_waitqueue_head(&server->probe_wq);
220 	INIT_LIST_HEAD(&server->probe_link);
221 	spin_lock_init(&server->probe_lock);
222 	server->cell = cell;
223 	server->rtt = UINT_MAX;
224 	server->service_id = FS_SERVICE;
226 	server->probe_counter = 1;
227 	server->probed_at = jiffies - LONG_MAX / 2;
230 	estate->server_id = server->debug_id;
232 	rcu_assign_pointer(server->endpoint_state, estate);
235 	trace_afs_server(server->debug_id, 1, 1, afs_server_trace_alloc);
238 	_leave(" = %p", server);
239 	return server;
242 	kfree(server);
249  * Look up an address record for a server
261 			if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags))
280 	struct afs_server *server, *candidate;
284 	server = afs_find_server_by_uuid(cell->net, uuid);
285 	if (server) {
286 		if (server->addr_version != addr_version)
287 			set_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags);
288 		return server;
301 	server = afs_install_server(cell, candidate);
302 	if (server != candidate) {
310 		afs_fs_probe_fileserver(cell->net, server, alist, key);
313 	return server;
317  * Set the server timer to fire after a given delay, assuming it's not already
343  * Get a reference on a server object.
345 struct afs_server *afs_get_server(struct afs_server *server,
351 	__refcount_inc(&server->ref, &r);
352 	a = atomic_read(&server->active);
353 	trace_afs_server(server->debug_id, r + 1, a, reason);
354 	return server;
358  * Try to get a reference on a server object.
360 static struct afs_server *afs_maybe_use_server(struct afs_server *server,
366 	if (!__refcount_inc_not_zero(&server->ref, &r))
369 	a = atomic_inc_return(&server->active);
370 	trace_afs_server(server->debug_id, r + 1, a, reason);
371 	return server;
375  * Get an active count on a server object.
377 struct afs_server *afs_use_server(struct afs_server *server, enum afs_server_trace reason)
382 	__refcount_inc(&server->ref, &r);
383 	a = atomic_inc_return(&server->active);
385 	trace_afs_server(server->debug_id, r + 1, a, reason);
386 	return server;
390  * Release a reference on a server record.
392 void afs_put_server(struct afs_net *net, struct afs_server *server,
395 	unsigned int a, debug_id = server->debug_id;
399 	if (!server)
402 	a = atomic_read(&server->active);
403 	zero = __refcount_dec_and_test(&server->ref, &r);
406 		__afs_put_server(net, server);
410  * Drop an active count on a server object without updating the last-unused
413 void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server,
416 	if (server) {
417 		unsigned int active = atomic_dec_return(&server->active);
421 		afs_put_server(net, server, reason);
426  * Drop an active count on a server object.
428 void afs_unuse_server(struct afs_net *net, struct afs_server *server,
431 	if (server) {
432 		server->unuse_time = ktime_get_real_seconds();
433 		afs_unuse_server_notime(net, server, reason);
439 	struct afs_server *server = container_of(rcu, struct afs_server, rcu);
441 	trace_afs_server(server->debug_id, refcount_read(&server->ref),
442 			 atomic_read(&server->active), afs_server_trace_free);
443 	afs_put_endpoint_state(rcu_access_pointer(server->endpoint_state),
445 	kfree(server);
448 static void __afs_put_server(struct afs_net *net, struct afs_server *server)
450 	call_rcu(&server->rcu, afs_server_rcu);
454 static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server)
456 	struct afs_endpoint_state *estate = rcu_access_pointer(server->endpoint_state);
459 	afs_fs_give_up_all_callbacks(net, server, &alist->addrs[alist->preferred], NULL);
463  * destroy a dead server
465 static void afs_destroy_server(struct afs_net *net, struct afs_server *server)
467 	if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags))
468 		afs_give_up_callbacks(net, server);
470 	afs_put_server(net, server, afs_server_trace_destroy);
478 	struct afs_server *server, *next, *prev;
481 	while ((server = gc_list)) {
482 		gc_list = server->gc_next;
486 		active = atomic_read(&server->active);
488 			trace_afs_server(server->debug_id, refcount_read(&server->ref),
491 				server->uuid_next, lockdep_is_held(&net->fs_lock.lock));
492 			prev = server->uuid_prev;
496 					rb_erase(&server->uuid_rb, &net->fs_servers);
498 					rb_replace_node_rcu(&server->uuid_rb,
504 				/* This server is not at the front */
510 			list_del(&server->probe_link);
511 			hlist_del_rcu(&server->proc_link);
512 			if (!hlist_unhashed(&server->addr_link))
513 				hlist_del_rcu(&server->addr_link);
518 			afs_destroy_server(net, server);
539 	/* Trawl the server list looking for servers that have expired from
545 		struct afs_server *server =
547 		int active = atomic_read(&server->active);
549 		_debug("manage %pU %u", &server->uuid, active);
552 			trace_afs_server(server->debug_id, refcount_read(&server->ref),
555 				pr_notice("Can't purge s=%08x\n", server->debug_id);
559 			time64_t expire_at = server->unuse_time;
561 			if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) &&
562 			    !test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags))
565 				server->gc_next = gc_list;
566 				gc_list = server;
623  * Get an update for a server's address list.
626 					      struct afs_server *server,
635 	trace_afs_server(server->debug_id, refcount_read(&server->ref),
636 			 atomic_read(&server->active),
639 	alist = afs_vl_lookup_addrs(op->volume->cell, op->key, &server->uuid);
642 		estate = rcu_dereference(server->endpoint_state);
658 	if (server->addr_version != alist->version)
659 		afs_fs_probe_fileserver(op->net, server, alist, key);
667  * See if a server's address list needs updating.
669 bool afs_check_server_record(struct afs_operation *op, struct afs_server *server,
677 	ASSERT(server);
680 	if (test_bit(AFS_SERVER_FL_UPDATING, &server->flags))
682 	if (test_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags))
688 	if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, &server->flags)) {
689 		clear_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags);
690 		success = afs_update_server_record(op, server, key);
691 		clear_bit_unlock(AFS_SERVER_FL_UPDATING, &server->flags);
692 		wake_up_bit(&server->flags, AFS_SERVER_FL_UPDATING);
698 	ret = wait_on_bit(&server->flags, AFS_SERVER_FL_UPDATING,