Lines Matching full:server
2 /* AFS server record management
14 static unsigned afs_server_gc_delay = 10; /* Server record timeout in seconds */
22 * Find a server by one of its addresses.
26 struct afs_server *server = (struct afs_server *)rxrpc_kernel_get_peer_data(peer);
28 if (!server)
30 return afs_use_server(server, false, afs_server_trace_use_cm_call);
34 * Look up a server by its UUID and mark it active. The caller must hold
39 struct afs_server *server;
47 server = rb_entry(p, struct afs_server, uuid_rb);
49 diff = memcmp(uuid, &server->uuid, sizeof(*uuid));
55 if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags))
57 afs_use_server(server, true, afs_server_trace_use_by_uuid);
58 return server;
66 * Install a server record in the cell tree. The caller must hold an exclusive
72 struct afs_server *server;
79 /* Firstly install the server in the UUID lookup tree */
85 server = rb_entry(p, struct afs_server, uuid_rb);
86 diff = memcmp(&(*candidate)->uuid, &server->uuid, sizeof(uuid_t));
95 server = *candidate;
97 rb_link_node(&server->uuid_rb, p, pp);
98 rb_insert_color(&server->uuid_rb, &cell->fs_servers);
100 hlist_add_head_rcu(&server->proc_link, &net->fs_proc);
106 afs_use_server(server, true, afs_server_trace_use_install);
107 return server;
111 * Allocate a new server record and mark it as active but uncreated.
115 struct afs_server *server;
120 server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
121 if (!server)
124 refcount_set(&server->ref, 1);
125 atomic_set(&server->active, 0);
126 __set_bit(AFS_SERVER_FL_UNCREATED, &server->flags);
127 server->debug_id = atomic_inc_return(&afs_server_debug_id);
128 server->uuid = *uuid;
129 rwlock_init(&server->fs_lock);
130 INIT_WORK(&server->destroyer, &afs_server_destroyer);
131 timer_setup(&server->timer, afs_server_timer, 0);
132 INIT_LIST_HEAD(&server->volumes);
133 init_waitqueue_head(&server->probe_wq);
134 mutex_init(&server->cm_token_lock);
135 INIT_LIST_HEAD(&server->probe_link);
136 INIT_HLIST_NODE(&server->proc_link);
137 spin_lock_init(&server->probe_lock);
138 server->cell = cell;
139 server->rtt = UINT_MAX;
140 server->service_id = FS_SERVICE;
141 server->probe_counter = 1;
142 server->probed_at = jiffies - LONG_MAX / 2;
145 _leave(" = %p", server);
146 return server;
150 * Look up an address record for a server
152 static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_server *server,
160 if (afs_begin_vlserver_operation(&vc, server->cell, key)) {
162 if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags))
163 alist = afs_yfsvl_get_endpoints(&vc, &server->uuid);
165 alist = afs_vl_get_addrs_u(&vc, &server->uuid);
182 struct afs_server *server, *candidate = NULL;
189 server = afs_find_server_by_uuid(cell, uuid);
193 if (server) {
194 timer_delete_sync(&server->timer);
195 if (test_bit(AFS_SERVER_FL_CREATING, &server->flags))
197 if (server->addr_version != addr_version)
198 set_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags);
199 return server;
209 server = afs_install_server(cell, &candidate);
210 if (test_bit(AFS_SERVER_FL_CREATING, &server->flags)) {
215 if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) {
216 set_bit(AFS_SERVER_FL_CREATING, &server->flags);
217 clear_bit(AFS_SERVER_FL_UNCREATED, &server->flags);
221 timer_delete_sync(&server->timer);
223 /* If we get to create the server, we look up the addresses and then
229 alist = afs_vl_lookup_addrs(server, key);
235 ret = afs_fs_probe_fileserver(cell->net, server, alist, key);
239 clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, &server->flags);
245 kfree(rcu_access_pointer(server->endpoint_state));
249 return server ?: ERR_PTR(ret);
252 afs_see_server(server, afs_server_trace_wait_create);
253 wait_on_bit(&server->flags, AFS_SERVER_FL_CREATING, TASK_UNINTERRUPTIBLE);
254 if (test_bit_acquire(AFS_SERVER_FL_UNCREATED, &server->flags)) {
256 ret = READ_ONCE(server->create_error);
257 afs_put_server(cell->net, server, afs_server_trace_unuse_create_fail);
258 server = NULL;
268 WRITE_ONCE(server->create_error, ret);
270 set_bit(AFS_SERVER_FL_UNCREATED, &server->flags);
272 clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, &server->flags);
274 if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) {
275 clear_bit(AFS_SERVER_FL_UNCREATED, &server->flags);
278 afs_unuse_server(cell->net, server, afs_server_trace_unuse_create_fail);
279 server = NULL;
286 * Set/reduce a server's timer.
288 static void afs_set_server_timer(struct afs_server *server, unsigned int delay_secs)
290 mod_timer(&server->timer, jiffies + delay_secs * HZ);
294 * Get a reference on a server object.
296 struct afs_server *afs_get_server(struct afs_server *server,
302 __refcount_inc(&server->ref, &r);
303 a = atomic_read(&server->active);
304 trace_afs_server(server->debug_id, r + 1, a, reason);
305 return server;
309 * Get an active count on a server object and maybe remove from the inactive
312 struct afs_server *afs_use_server(struct afs_server *server, bool activate,
318 __refcount_inc(&server->ref, &r);
319 a = atomic_inc_return(&server->active);
321 !test_bit(AFS_SERVER_FL_EXPIRED, &server->flags))
322 timer_delete(&server->timer);
324 trace_afs_server(server->debug_id, r + 1, a, reason);
325 return server;
329 * Release a reference on a server record.
331 void afs_put_server(struct afs_net *net, struct afs_server *server,
334 unsigned int a, debug_id = server->debug_id;
338 if (!server)
341 a = atomic_read(&server->active);
342 zero = __refcount_dec_and_test(&server->ref, &r);
345 __afs_put_server(net, server);
349 * Drop an active count on a server object without updating the last-unused
352 void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server,
355 if (!server)
358 if (atomic_dec_and_test(&server->active)) {
359 if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) ||
360 READ_ONCE(server->cell->state) >= AFS_CELL_REMOVING)
361 schedule_work(&server->destroyer);
364 afs_put_server(net, server, reason);
368 * Drop an active count on a server object.
370 void afs_unuse_server(struct afs_net *net, struct afs_server *server,
373 if (!server)
376 if (atomic_dec_and_test(&server->active)) {
377 if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) &&
378 READ_ONCE(server->cell->state) < AFS_CELL_REMOVING) {
381 server->unuse_time = unuse_time;
382 afs_set_server_timer(server, afs_server_gc_delay);
384 schedule_work(&server->destroyer);
388 afs_put_server(net, server, reason);
393 struct afs_server *server = container_of(rcu, struct afs_server, rcu);
395 trace_afs_server(server->debug_id, refcount_read(&server->ref),
396 atomic_read(&server->active), afs_server_trace_free);
397 afs_put_endpoint_state(rcu_access_pointer(server->endpoint_state),
399 afs_put_cell(server->cell, afs_cell_trace_put_server);
400 kfree(server->cm_rxgk_appdata.data);
401 kfree(server);
404 static void __afs_put_server(struct afs_net *net, struct afs_server *server)
406 call_rcu(&server->rcu, afs_server_rcu);
410 static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server)
412 struct afs_endpoint_state *estate = rcu_access_pointer(server->endpoint_state);
415 afs_fs_give_up_all_callbacks(net, server, &alist->addrs[alist->preferred], NULL);
419 * Check to see if the server record has expired.
421 static bool afs_has_server_expired(const struct afs_server *server)
425 if (atomic_read(&server->active))
428 if (server->cell->net->live ||
429 server->cell->state >= AFS_CELL_REMOVING) {
430 trace_afs_server(server->debug_id, refcount_read(&server->ref),
435 expires_at = server->unuse_time;
436 if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) &&
437 !test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags))
444 * Remove a server record from it's parent cell's database.
446 static bool afs_remove_server_from_cell(struct afs_server *server)
448 struct afs_cell *cell = server->cell;
452 if (!afs_has_server_expired(server)) {
457 set_bit(AFS_SERVER_FL_EXPIRED, &server->flags);
458 _debug("expire %pU %u", &server->uuid, atomic_read(&server->active));
459 afs_see_server(server, afs_server_trace_see_expired);
460 rb_erase(&server->uuid_rb, &cell->fs_servers);
468 struct afs_server *server = container_of(work, struct afs_server, destroyer);
469 struct afs_net *net = server->cell->net;
471 afs_see_server(server, afs_server_trace_see_destroyer);
473 if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags))
476 if (!afs_remove_server_from_cell(server))
479 timer_shutdown_sync(&server->timer);
480 cancel_work(&server->destroyer);
482 if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags))
483 afs_give_up_callbacks(net, server);
485 /* Unbind the rxrpc_peer records from the server. */
486 estate = rcu_access_pointer(server->endpoint_state);
488 afs_set_peer_appdata(server, estate->addresses, NULL);
491 list_del_init(&server->probe_link);
492 if (!hlist_unhashed(&server->proc_link))
493 hlist_del_rcu(&server->proc_link);
496 afs_put_server(net, server, afs_server_trace_destroy);
501 struct afs_server *server = container_of(timer, struct afs_server, timer);
503 afs_see_server(server, afs_server_trace_see_timer);
504 if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags))
505 schedule_work(&server->destroyer);
513 struct afs_server *server;
518 server = rb_entry(rb, struct afs_server, uuid_rb);
519 afs_see_server(server, afs_server_trace_see_purge);
520 schedule_work(&server->destroyer);
539 * Get an update for a server's address list.
542 struct afs_server *server,
551 trace_afs_server(server->debug_id, refcount_read(&server->ref),
552 atomic_read(&server->active),
555 alist = afs_vl_lookup_addrs(server, op->key);
558 estate = rcu_dereference(server->endpoint_state);
574 if (server->addr_version != alist->version)
575 afs_fs_probe_fileserver(op->net, server, alist, key);
583 * See if a server's address list needs updating.
585 bool afs_check_server_record(struct afs_operation *op, struct afs_server *server,
593 ASSERT(server);
596 if (test_bit(AFS_SERVER_FL_UPDATING, &server->flags))
598 if (test_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags))
604 if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, &server->flags)) {
605 clear_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags);
606 success = afs_update_server_record(op, server, key);
607 clear_bit_unlock(AFS_SERVER_FL_UPDATING, &server->flags);
608 wake_up_bit(&server->flags, AFS_SERVER_FL_UPDATING);
614 ret = wait_on_bit(&server->flags, AFS_SERVER_FL_UPDATING,