blob: c001b1f2455fbf6dee4c9635c95590ada3890483 [file] [log] [blame]
David Howellsec268152007-04-26 15:49:28 -07001/* AFS server record management
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
David Howells08e0e7c2007-04-26 15:55:03 -07003 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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#include <linux/sched.h>
13#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include "internal.h"
15
Adrian Bunkc1206a22007-10-16 23:26:41 -070016static unsigned afs_server_timeout = 10; /* server timeout in seconds */
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
David Howells08e0e7c2007-04-26 15:55:03 -070018static void afs_reap_server(struct work_struct *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
David Howells08e0e7c2007-04-26 15:55:03 -070020/* tree of all the servers, indexed by IP address */
21static struct rb_root afs_servers = RB_ROOT;
22static DEFINE_RWLOCK(afs_servers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
David Howells08e0e7c2007-04-26 15:55:03 -070024/* LRU list of all the servers not currently in use */
25static LIST_HEAD(afs_server_graveyard);
26static DEFINE_SPINLOCK(afs_server_graveyard_lock);
27static DECLARE_DELAYED_WORK(afs_server_reaper, afs_reap_server);
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
Linus Torvalds1da177e2005-04-16 15:20:36 -070029/*
David Howells08e0e7c2007-04-26 15:55:03 -070030 * install a server record in the master tree
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 */
David Howells08e0e7c2007-04-26 15:55:03 -070032static int afs_install_server(struct afs_server *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -070033{
David Howells08e0e7c2007-04-26 15:55:03 -070034 struct afs_server *xserver;
35 struct rb_node **pp, *p;
36 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
David Howells08e0e7c2007-04-26 15:55:03 -070038 _enter("%p", server);
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
David Howells08e0e7c2007-04-26 15:55:03 -070040 write_lock(&afs_servers_lock);
41
42 ret = -EEXIST;
43 pp = &afs_servers.rb_node;
44 p = NULL;
45 while (*pp) {
46 p = *pp;
47 _debug("- consider %p", p);
48 xserver = rb_entry(p, struct afs_server, master_rb);
49 if (server->addr.s_addr < xserver->addr.s_addr)
50 pp = &(*pp)->rb_left;
51 else if (server->addr.s_addr > xserver->addr.s_addr)
52 pp = &(*pp)->rb_right;
53 else
54 goto error;
55 }
56
57 rb_link_node(&server->master_rb, p, pp);
58 rb_insert_color(&server->master_rb, &afs_servers);
59 ret = 0;
60
61error:
62 write_unlock(&afs_servers_lock);
63 return ret;
64}
65
66/*
67 * allocate a new server record
68 */
69static struct afs_server *afs_alloc_server(struct afs_cell *cell,
70 const struct in_addr *addr)
71{
72 struct afs_server *server;
73
74 _enter("");
75
Yan Burmanb593e482006-12-06 20:40:32 -080076 server = kzalloc(sizeof(struct afs_server), GFP_KERNEL);
David Howells08e0e7c2007-04-26 15:55:03 -070077 if (server) {
78 atomic_set(&server->usage, 1);
79 server->cell = cell;
80
81 INIT_LIST_HEAD(&server->link);
82 INIT_LIST_HEAD(&server->grave);
83 init_rwsem(&server->sem);
84 spin_lock_init(&server->fs_lock);
85 server->fs_vnodes = RB_ROOT;
86 server->cb_promises = RB_ROOT;
87 spin_lock_init(&server->cb_lock);
88 init_waitqueue_head(&server->cb_break_waitq);
89 INIT_DELAYED_WORK(&server->cb_break_work,
90 afs_dispatch_give_up_callbacks);
91
92 memcpy(&server->addr, addr, sizeof(struct in_addr));
93 server->addr.s_addr = addr->s_addr;
Denis Kirjanov037776f2010-06-01 17:15:39 +010094 _leave(" = %p{%d}", server, atomic_read(&server->usage));
95 } else {
96 _leave(" = NULL [nomem]");
David Howells08e0e7c2007-04-26 15:55:03 -070097 }
David Howells08e0e7c2007-04-26 15:55:03 -070098 return server;
99}
100
101/*
102 * get an FS-server record for a cell
103 */
104struct afs_server *afs_lookup_server(struct afs_cell *cell,
105 const struct in_addr *addr)
106{
107 struct afs_server *server, *candidate;
108
Harvey Harrisonbe859402008-10-31 00:56:28 -0700109 _enter("%p,%pI4", cell, &addr->s_addr);
David Howells08e0e7c2007-04-26 15:55:03 -0700110
111 /* quick scan of the list to see if we already have the server */
112 read_lock(&cell->servers_lock);
113
114 list_for_each_entry(server, &cell->servers, link) {
115 if (server->addr.s_addr == addr->s_addr)
116 goto found_server_quickly;
117 }
118 read_unlock(&cell->servers_lock);
119
120 candidate = afs_alloc_server(cell, addr);
121 if (!candidate) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 _leave(" = -ENOMEM");
David Howells08e0e7c2007-04-26 15:55:03 -0700123 return ERR_PTR(-ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 }
125
David Howells08e0e7c2007-04-26 15:55:03 -0700126 write_lock(&cell->servers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
David Howells08e0e7c2007-04-26 15:55:03 -0700128 /* check the cell's server list again */
129 list_for_each_entry(server, &cell->servers, link) {
130 if (server->addr.s_addr == addr->s_addr)
131 goto found_server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 }
133
David Howells08e0e7c2007-04-26 15:55:03 -0700134 _debug("new");
135 server = candidate;
136 if (afs_install_server(server) < 0)
137 goto server_in_two_cells;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139 afs_get_cell(cell);
David Howells08e0e7c2007-04-26 15:55:03 -0700140 list_add_tail(&server->link, &cell->servers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
David Howells08e0e7c2007-04-26 15:55:03 -0700142 write_unlock(&cell->servers_lock);
143 _leave(" = %p{%d}", server, atomic_read(&server->usage));
144 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
David Howells08e0e7c2007-04-26 15:55:03 -0700146 /* found a matching server quickly */
147found_server_quickly:
148 _debug("found quickly");
149 afs_get_server(server);
150 read_unlock(&cell->servers_lock);
151no_longer_unused:
152 if (!list_empty(&server->grave)) {
153 spin_lock(&afs_server_graveyard_lock);
154 list_del_init(&server->grave);
155 spin_unlock(&afs_server_graveyard_lock);
156 }
157 _leave(" = %p{%d}", server, atomic_read(&server->usage));
158 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
David Howells08e0e7c2007-04-26 15:55:03 -0700160 /* found a matching server on the second pass */
161found_server:
162 _debug("found");
163 afs_get_server(server);
164 write_unlock(&cell->servers_lock);
165 kfree(candidate);
166 goto no_longer_unused;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
David Howells08e0e7c2007-04-26 15:55:03 -0700168 /* found a server that seems to be in two cells */
169server_in_two_cells:
170 write_unlock(&cell->servers_lock);
171 kfree(candidate);
Harvey Harrisonbe859402008-10-31 00:56:28 -0700172 printk(KERN_NOTICE "kAFS: Server %pI4 appears to be in two cells\n",
173 addr);
David Howells08e0e7c2007-04-26 15:55:03 -0700174 _leave(" = -EEXIST");
175 return ERR_PTR(-EEXIST);
176}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
David Howells08e0e7c2007-04-26 15:55:03 -0700178/*
179 * look up a server by its IP address
180 */
David Howells8324f0b2016-08-30 09:49:29 +0100181struct afs_server *afs_find_server(const struct sockaddr_rxrpc *srx)
David Howells08e0e7c2007-04-26 15:55:03 -0700182{
183 struct afs_server *server = NULL;
184 struct rb_node *p;
David Howells8324f0b2016-08-30 09:49:29 +0100185 struct in_addr addr = srx->transport.sin.sin_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
David Howells8324f0b2016-08-30 09:49:29 +0100187 _enter("{%d,%pI4}", srx->transport.family, &addr.s_addr);
188
189 if (srx->transport.family != AF_INET) {
190 WARN(true, "AFS does not yes support non-IPv4 addresses\n");
191 return NULL;
192 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
David Howells08e0e7c2007-04-26 15:55:03 -0700194 read_lock(&afs_servers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
David Howells08e0e7c2007-04-26 15:55:03 -0700196 p = afs_servers.rb_node;
197 while (p) {
198 server = rb_entry(p, struct afs_server, master_rb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
David Howells08e0e7c2007-04-26 15:55:03 -0700200 _debug("- consider %p", p);
201
202 if (addr.s_addr < server->addr.s_addr) {
203 p = p->rb_left;
204 } else if (addr.s_addr > server->addr.s_addr) {
205 p = p->rb_right;
206 } else {
207 afs_get_server(server);
208 goto found;
209 }
210 }
211
212 server = NULL;
213found:
214 read_unlock(&afs_servers_lock);
215 ASSERTIFCMP(server, server->addr.s_addr, ==, addr.s_addr);
216 _leave(" = %p", server);
217 return server;
David Howellsec268152007-04-26 15:49:28 -0700218}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220/*
221 * destroy a server record
222 * - removes from the cell list
223 */
224void afs_put_server(struct afs_server *server)
225{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 if (!server)
227 return;
228
David Howells08e0e7c2007-04-26 15:55:03 -0700229 _enter("%p{%d}", server, atomic_read(&server->usage));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
David Howells260a9802007-04-26 15:59:35 -0700231 _debug("PUT SERVER %d", atomic_read(&server->usage));
232
David Howells08e0e7c2007-04-26 15:55:03 -0700233 ASSERTCMP(atomic_read(&server->usage), >, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
235 if (likely(!atomic_dec_and_test(&server->usage))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 _leave("");
237 return;
238 }
239
David Howells08e0e7c2007-04-26 15:55:03 -0700240 afs_flush_callback_breaks(server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
David Howells08e0e7c2007-04-26 15:55:03 -0700242 spin_lock(&afs_server_graveyard_lock);
243 if (atomic_read(&server->usage) == 0) {
244 list_move_tail(&server->grave, &afs_server_graveyard);
Tina Ruchandani7da1b852017-03-16 16:27:46 +0000245 server->time_of_death = ktime_get_real_seconds();
Tejun Heo0ad53ee2011-01-14 15:56:37 +0000246 queue_delayed_work(afs_wq, &afs_server_reaper,
247 afs_server_timeout * HZ);
David Howells08e0e7c2007-04-26 15:55:03 -0700248 }
249 spin_unlock(&afs_server_graveyard_lock);
250 _leave(" [dead]");
David Howellsec268152007-04-26 15:49:28 -0700251}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253/*
David Howells08e0e7c2007-04-26 15:55:03 -0700254 * destroy a dead server
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 */
David Howells08e0e7c2007-04-26 15:55:03 -0700256static void afs_destroy_server(struct afs_server *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 _enter("%p", server);
259
David Howells416351f2007-05-09 02:33:45 -0700260 ASSERTIF(server->cb_break_head != server->cb_break_tail,
261 delayed_work_pending(&server->cb_break_work));
262
David Howells08e0e7c2007-04-26 15:55:03 -0700263 ASSERTCMP(server->fs_vnodes.rb_node, ==, NULL);
264 ASSERTCMP(server->cb_promises.rb_node, ==, NULL);
265 ASSERTCMP(server->cb_break_head, ==, server->cb_break_tail);
266 ASSERTCMP(atomic_read(&server->cb_break_n), ==, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
David Howells08e0e7c2007-04-26 15:55:03 -0700268 afs_put_cell(server->cell);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 kfree(server);
David Howellsec268152007-04-26 15:49:28 -0700270}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272/*
David Howells08e0e7c2007-04-26 15:55:03 -0700273 * reap dead server records
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 */
David Howells08e0e7c2007-04-26 15:55:03 -0700275static void afs_reap_server(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
David Howells08e0e7c2007-04-26 15:55:03 -0700277 LIST_HEAD(corpses);
278 struct afs_server *server;
279 unsigned long delay, expiry;
Tina Ruchandani7da1b852017-03-16 16:27:46 +0000280 time64_t now;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Tina Ruchandani7da1b852017-03-16 16:27:46 +0000282 now = ktime_get_real_seconds();
David Howells08e0e7c2007-04-26 15:55:03 -0700283 spin_lock(&afs_server_graveyard_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
David Howells08e0e7c2007-04-26 15:55:03 -0700285 while (!list_empty(&afs_server_graveyard)) {
286 server = list_entry(afs_server_graveyard.next,
287 struct afs_server, grave);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
David Howells08e0e7c2007-04-26 15:55:03 -0700289 /* the queue is ordered most dead first */
290 expiry = server->time_of_death + afs_server_timeout;
291 if (expiry > now) {
292 delay = (expiry - now) * HZ;
Tejun Heo41f63c52012-08-03 10:30:47 -0700293 mod_delayed_work(afs_wq, &afs_server_reaper, delay);
David Howells08e0e7c2007-04-26 15:55:03 -0700294 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 }
296
David Howells08e0e7c2007-04-26 15:55:03 -0700297 write_lock(&server->cell->servers_lock);
298 write_lock(&afs_servers_lock);
299 if (atomic_read(&server->usage) > 0) {
300 list_del_init(&server->grave);
301 } else {
302 list_move_tail(&server->grave, &corpses);
303 list_del_init(&server->link);
304 rb_erase(&server->master_rb, &afs_servers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 }
David Howells08e0e7c2007-04-26 15:55:03 -0700306 write_unlock(&afs_servers_lock);
307 write_unlock(&server->cell->servers_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 }
309
David Howells08e0e7c2007-04-26 15:55:03 -0700310 spin_unlock(&afs_server_graveyard_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
David Howells08e0e7c2007-04-26 15:55:03 -0700312 /* now reap the corpses we've extracted */
313 while (!list_empty(&corpses)) {
314 server = list_entry(corpses.next, struct afs_server, grave);
315 list_del(&server->grave);
316 afs_destroy_server(server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 }
David Howellsec268152007-04-26 15:49:28 -0700318}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320/*
David Howells08e0e7c2007-04-26 15:55:03 -0700321 * discard all the server records for rmmod
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 */
David Howells08e0e7c2007-04-26 15:55:03 -0700323void __exit afs_purge_servers(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
David Howells08e0e7c2007-04-26 15:55:03 -0700325 afs_server_timeout = 0;
Tejun Heo41f63c52012-08-03 10:30:47 -0700326 mod_delayed_work(afs_wq, &afs_server_reaper, 0);
David Howellsec268152007-04-26 15:49:28 -0700327}