diff options
Diffstat (limited to 'fs/lockd')
-rw-r--r-- | fs/lockd/clntlock.c | 54 | ||||
-rw-r--r-- | fs/lockd/clntproc.c | 17 | ||||
-rw-r--r-- | fs/lockd/host.c | 325 | ||||
-rw-r--r-- | fs/lockd/mon.c | 65 | ||||
-rw-r--r-- | fs/lockd/svc.c | 19 | ||||
-rw-r--r-- | fs/lockd/svc4proc.c | 29 | ||||
-rw-r--r-- | fs/lockd/svclock.c | 197 | ||||
-rw-r--r-- | fs/lockd/svcproc.c | 27 | ||||
-rw-r--r-- | fs/lockd/svcshare.c | 20 | ||||
-rw-r--r-- | fs/lockd/svcsubs.c | 164 |
10 files changed, 549 insertions, 368 deletions
diff --git a/fs/lockd/clntlock.c b/fs/lockd/clntlock.c index 87e1d03e8267..e8c7765419e8 100644 --- a/fs/lockd/clntlock.c +++ b/fs/lockd/clntlock.c | |||
@@ -144,42 +144,12 @@ u32 nlmclnt_grant(const struct sockaddr_in *addr, const struct nlm_lock *lock) | |||
144 | */ | 144 | */ |
145 | 145 | ||
146 | /* | 146 | /* |
147 | * Someone has sent us an SM_NOTIFY. Ensure we bind to the new port number, | ||
148 | * that we mark locks for reclaiming, and that we bump the pseudo NSM state. | ||
149 | */ | ||
150 | static void nlmclnt_prepare_reclaim(struct nlm_host *host) | ||
151 | { | ||
152 | down_write(&host->h_rwsem); | ||
153 | host->h_monitored = 0; | ||
154 | host->h_state++; | ||
155 | host->h_nextrebind = 0; | ||
156 | nlm_rebind_host(host); | ||
157 | |||
158 | /* | ||
159 | * Mark the locks for reclaiming. | ||
160 | */ | ||
161 | list_splice_init(&host->h_granted, &host->h_reclaim); | ||
162 | |||
163 | dprintk("NLM: reclaiming locks for host %s\n", host->h_name); | ||
164 | } | ||
165 | |||
166 | static void nlmclnt_finish_reclaim(struct nlm_host *host) | ||
167 | { | ||
168 | host->h_reclaiming = 0; | ||
169 | up_write(&host->h_rwsem); | ||
170 | dprintk("NLM: done reclaiming locks for host %s", host->h_name); | ||
171 | } | ||
172 | |||
173 | /* | ||
174 | * Reclaim all locks on server host. We do this by spawning a separate | 147 | * Reclaim all locks on server host. We do this by spawning a separate |
175 | * reclaimer thread. | 148 | * reclaimer thread. |
176 | */ | 149 | */ |
177 | void | 150 | void |
178 | nlmclnt_recovery(struct nlm_host *host, u32 newstate) | 151 | nlmclnt_recovery(struct nlm_host *host) |
179 | { | 152 | { |
180 | if (host->h_nsmstate == newstate) | ||
181 | return; | ||
182 | host->h_nsmstate = newstate; | ||
183 | if (!host->h_reclaiming++) { | 153 | if (!host->h_reclaiming++) { |
184 | nlm_get_host(host); | 154 | nlm_get_host(host); |
185 | __module_get(THIS_MODULE); | 155 | __module_get(THIS_MODULE); |
@@ -199,18 +169,30 @@ reclaimer(void *ptr) | |||
199 | daemonize("%s-reclaim", host->h_name); | 169 | daemonize("%s-reclaim", host->h_name); |
200 | allow_signal(SIGKILL); | 170 | allow_signal(SIGKILL); |
201 | 171 | ||
172 | down_write(&host->h_rwsem); | ||
173 | |||
202 | /* This one ensures that our parent doesn't terminate while the | 174 | /* This one ensures that our parent doesn't terminate while the |
203 | * reclaim is in progress */ | 175 | * reclaim is in progress */ |
204 | lock_kernel(); | 176 | lock_kernel(); |
205 | lockd_up(0); /* note: this cannot fail as lockd is already running */ | 177 | lockd_up(0); /* note: this cannot fail as lockd is already running */ |
206 | 178 | ||
207 | nlmclnt_prepare_reclaim(host); | 179 | dprintk("lockd: reclaiming locks for host %s", host->h_name); |
208 | /* First, reclaim all locks that have been marked. */ | 180 | |
209 | restart: | 181 | restart: |
210 | nsmstate = host->h_nsmstate; | 182 | nsmstate = host->h_nsmstate; |
183 | |||
184 | /* Force a portmap getport - the peer's lockd will | ||
185 | * most likely end up on a different port. | ||
186 | */ | ||
187 | host->h_nextrebind = jiffies; | ||
188 | nlm_rebind_host(host); | ||
189 | |||
190 | /* First, reclaim all locks that have been granted. */ | ||
191 | list_splice_init(&host->h_granted, &host->h_reclaim); | ||
211 | list_for_each_entry_safe(fl, next, &host->h_reclaim, fl_u.nfs_fl.list) { | 192 | list_for_each_entry_safe(fl, next, &host->h_reclaim, fl_u.nfs_fl.list) { |
212 | list_del_init(&fl->fl_u.nfs_fl.list); | 193 | list_del_init(&fl->fl_u.nfs_fl.list); |
213 | 194 | ||
195 | /* Why are we leaking memory here? --okir */ | ||
214 | if (signalled()) | 196 | if (signalled()) |
215 | continue; | 197 | continue; |
216 | if (nlmclnt_reclaim(host, fl) != 0) | 198 | if (nlmclnt_reclaim(host, fl) != 0) |
@@ -218,11 +200,13 @@ restart: | |||
218 | list_add_tail(&fl->fl_u.nfs_fl.list, &host->h_granted); | 200 | list_add_tail(&fl->fl_u.nfs_fl.list, &host->h_granted); |
219 | if (host->h_nsmstate != nsmstate) { | 201 | if (host->h_nsmstate != nsmstate) { |
220 | /* Argh! The server rebooted again! */ | 202 | /* Argh! The server rebooted again! */ |
221 | list_splice_init(&host->h_granted, &host->h_reclaim); | ||
222 | goto restart; | 203 | goto restart; |
223 | } | 204 | } |
224 | } | 205 | } |
225 | nlmclnt_finish_reclaim(host); | 206 | |
207 | host->h_reclaiming = 0; | ||
208 | up_write(&host->h_rwsem); | ||
209 | dprintk("NLM: done reclaiming locks for host %s", host->h_name); | ||
226 | 210 | ||
227 | /* Now, wake up all processes that sleep on a blocked lock */ | 211 | /* Now, wake up all processes that sleep on a blocked lock */ |
228 | list_for_each_entry(block, &nlm_blocked, b_list) { | 212 | list_for_each_entry(block, &nlm_blocked, b_list) { |
diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c index 0116729cec5f..3d84f600b633 100644 --- a/fs/lockd/clntproc.c +++ b/fs/lockd/clntproc.c | |||
@@ -36,14 +36,14 @@ static const struct rpc_call_ops nlmclnt_cancel_ops; | |||
36 | /* | 36 | /* |
37 | * Cookie counter for NLM requests | 37 | * Cookie counter for NLM requests |
38 | */ | 38 | */ |
39 | static u32 nlm_cookie = 0x1234; | 39 | static atomic_t nlm_cookie = ATOMIC_INIT(0x1234); |
40 | 40 | ||
41 | static inline void nlmclnt_next_cookie(struct nlm_cookie *c) | 41 | void nlmclnt_next_cookie(struct nlm_cookie *c) |
42 | { | 42 | { |
43 | memcpy(c->data, &nlm_cookie, 4); | 43 | u32 cookie = atomic_inc_return(&nlm_cookie); |
44 | memset(c->data+4, 0, 4); | 44 | |
45 | memcpy(c->data, &cookie, 4); | ||
45 | c->len=4; | 46 | c->len=4; |
46 | nlm_cookie++; | ||
47 | } | 47 | } |
48 | 48 | ||
49 | static struct nlm_lockowner *nlm_get_lockowner(struct nlm_lockowner *lockowner) | 49 | static struct nlm_lockowner *nlm_get_lockowner(struct nlm_lockowner *lockowner) |
@@ -153,6 +153,7 @@ nlmclnt_proc(struct inode *inode, int cmd, struct file_lock *fl) | |||
153 | { | 153 | { |
154 | struct rpc_clnt *client = NFS_CLIENT(inode); | 154 | struct rpc_clnt *client = NFS_CLIENT(inode); |
155 | struct sockaddr_in addr; | 155 | struct sockaddr_in addr; |
156 | struct nfs_server *nfssrv = NFS_SERVER(inode); | ||
156 | struct nlm_host *host; | 157 | struct nlm_host *host; |
157 | struct nlm_rqst *call; | 158 | struct nlm_rqst *call; |
158 | sigset_t oldset; | 159 | sigset_t oldset; |
@@ -166,7 +167,9 @@ nlmclnt_proc(struct inode *inode, int cmd, struct file_lock *fl) | |||
166 | } | 167 | } |
167 | 168 | ||
168 | rpc_peeraddr(client, (struct sockaddr *) &addr, sizeof(addr)); | 169 | rpc_peeraddr(client, (struct sockaddr *) &addr, sizeof(addr)); |
169 | host = nlmclnt_lookup_host(&addr, client->cl_xprt->prot, vers); | 170 | host = nlmclnt_lookup_host(&addr, client->cl_xprt->prot, vers, |
171 | nfssrv->nfs_client->cl_hostname, | ||
172 | strlen(nfssrv->nfs_client->cl_hostname)); | ||
170 | if (host == NULL) | 173 | if (host == NULL) |
171 | return -ENOLCK; | 174 | return -ENOLCK; |
172 | 175 | ||
@@ -499,7 +502,7 @@ nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl) | |||
499 | unsigned char fl_flags = fl->fl_flags; | 502 | unsigned char fl_flags = fl->fl_flags; |
500 | int status = -ENOLCK; | 503 | int status = -ENOLCK; |
501 | 504 | ||
502 | if (!host->h_monitored && nsm_monitor(host) < 0) { | 505 | if (nsm_monitor(host) < 0) { |
503 | printk(KERN_NOTICE "lockd: failed to monitor %s\n", | 506 | printk(KERN_NOTICE "lockd: failed to monitor %s\n", |
504 | host->h_name); | 507 | host->h_name); |
505 | goto out; | 508 | goto out; |
diff --git a/fs/lockd/host.c b/fs/lockd/host.c index a0d0b58ce7a4..fb24a9730345 100644 --- a/fs/lockd/host.c +++ b/fs/lockd/host.c | |||
@@ -27,46 +27,60 @@ | |||
27 | #define NLM_HOST_EXPIRE ((nrhosts > NLM_HOST_MAX)? 300 * HZ : 120 * HZ) | 27 | #define NLM_HOST_EXPIRE ((nrhosts > NLM_HOST_MAX)? 300 * HZ : 120 * HZ) |
28 | #define NLM_HOST_COLLECT ((nrhosts > NLM_HOST_MAX)? 120 * HZ : 60 * HZ) | 28 | #define NLM_HOST_COLLECT ((nrhosts > NLM_HOST_MAX)? 120 * HZ : 60 * HZ) |
29 | 29 | ||
30 | static struct nlm_host * nlm_hosts[NLM_HOST_NRHASH]; | 30 | static struct hlist_head nlm_hosts[NLM_HOST_NRHASH]; |
31 | static unsigned long next_gc; | 31 | static unsigned long next_gc; |
32 | static int nrhosts; | 32 | static int nrhosts; |
33 | static DEFINE_MUTEX(nlm_host_mutex); | 33 | static DEFINE_MUTEX(nlm_host_mutex); |
34 | 34 | ||
35 | 35 | ||
36 | static void nlm_gc_hosts(void); | 36 | static void nlm_gc_hosts(void); |
37 | static struct nsm_handle * __nsm_find(const struct sockaddr_in *, | ||
38 | const char *, int, int); | ||
37 | 39 | ||
38 | /* | 40 | /* |
39 | * Find an NLM server handle in the cache. If there is none, create it. | 41 | * Find an NLM server handle in the cache. If there is none, create it. |
40 | */ | 42 | */ |
41 | struct nlm_host * | 43 | struct nlm_host * |
42 | nlmclnt_lookup_host(struct sockaddr_in *sin, int proto, int version) | 44 | nlmclnt_lookup_host(const struct sockaddr_in *sin, int proto, int version, |
45 | const char *hostname, int hostname_len) | ||
43 | { | 46 | { |
44 | return nlm_lookup_host(0, sin, proto, version); | 47 | return nlm_lookup_host(0, sin, proto, version, |
48 | hostname, hostname_len); | ||
45 | } | 49 | } |
46 | 50 | ||
47 | /* | 51 | /* |
48 | * Find an NLM client handle in the cache. If there is none, create it. | 52 | * Find an NLM client handle in the cache. If there is none, create it. |
49 | */ | 53 | */ |
50 | struct nlm_host * | 54 | struct nlm_host * |
51 | nlmsvc_lookup_host(struct svc_rqst *rqstp) | 55 | nlmsvc_lookup_host(struct svc_rqst *rqstp, |
56 | const char *hostname, int hostname_len) | ||
52 | { | 57 | { |
53 | return nlm_lookup_host(1, &rqstp->rq_addr, | 58 | return nlm_lookup_host(1, &rqstp->rq_addr, |
54 | rqstp->rq_prot, rqstp->rq_vers); | 59 | rqstp->rq_prot, rqstp->rq_vers, |
60 | hostname, hostname_len); | ||
55 | } | 61 | } |
56 | 62 | ||
57 | /* | 63 | /* |
58 | * Common host lookup routine for server & client | 64 | * Common host lookup routine for server & client |
59 | */ | 65 | */ |
60 | struct nlm_host * | 66 | struct nlm_host * |
61 | nlm_lookup_host(int server, struct sockaddr_in *sin, | 67 | nlm_lookup_host(int server, const struct sockaddr_in *sin, |
62 | int proto, int version) | 68 | int proto, int version, |
69 | const char *hostname, | ||
70 | int hostname_len) | ||
63 | { | 71 | { |
64 | struct nlm_host *host, **hp; | 72 | struct hlist_head *chain; |
65 | u32 addr; | 73 | struct hlist_node *pos; |
74 | struct nlm_host *host; | ||
75 | struct nsm_handle *nsm = NULL; | ||
66 | int hash; | 76 | int hash; |
67 | 77 | ||
68 | dprintk("lockd: nlm_lookup_host(%08x, p=%d, v=%d)\n", | 78 | dprintk("lockd: nlm_lookup_host(%u.%u.%u.%u, p=%d, v=%d, my role=%s, name=%.*s)\n", |
69 | (unsigned)(sin? ntohl(sin->sin_addr.s_addr) : 0), proto, version); | 79 | NIPQUAD(sin->sin_addr.s_addr), proto, version, |
80 | server? "server" : "client", | ||
81 | hostname_len, | ||
82 | hostname? hostname : "<none>"); | ||
83 | |||
70 | 84 | ||
71 | hash = NLM_ADDRHASH(sin->sin_addr.s_addr); | 85 | hash = NLM_ADDRHASH(sin->sin_addr.s_addr); |
72 | 86 | ||
@@ -76,7 +90,22 @@ nlm_lookup_host(int server, struct sockaddr_in *sin, | |||
76 | if (time_after_eq(jiffies, next_gc)) | 90 | if (time_after_eq(jiffies, next_gc)) |
77 | nlm_gc_hosts(); | 91 | nlm_gc_hosts(); |
78 | 92 | ||
79 | for (hp = &nlm_hosts[hash]; (host = *hp) != 0; hp = &host->h_next) { | 93 | /* We may keep several nlm_host objects for a peer, because each |
94 | * nlm_host is identified by | ||
95 | * (address, protocol, version, server/client) | ||
96 | * We could probably simplify this a little by putting all those | ||
97 | * different NLM rpc_clients into one single nlm_host object. | ||
98 | * This would allow us to have one nlm_host per address. | ||
99 | */ | ||
100 | chain = &nlm_hosts[hash]; | ||
101 | hlist_for_each_entry(host, pos, chain, h_hash) { | ||
102 | if (!nlm_cmp_addr(&host->h_addr, sin)) | ||
103 | continue; | ||
104 | |||
105 | /* See if we have an NSM handle for this client */ | ||
106 | if (!nsm) | ||
107 | nsm = host->h_nsmhandle; | ||
108 | |||
80 | if (host->h_proto != proto) | 109 | if (host->h_proto != proto) |
81 | continue; | 110 | continue; |
82 | if (host->h_version != version) | 111 | if (host->h_version != version) |
@@ -84,28 +113,30 @@ nlm_lookup_host(int server, struct sockaddr_in *sin, | |||
84 | if (host->h_server != server) | 113 | if (host->h_server != server) |
85 | continue; | 114 | continue; |
86 | 115 | ||
87 | if (nlm_cmp_addr(&host->h_addr, sin)) { | 116 | /* Move to head of hash chain. */ |
88 | if (hp != nlm_hosts + hash) { | 117 | hlist_del(&host->h_hash); |
89 | *hp = host->h_next; | 118 | hlist_add_head(&host->h_hash, chain); |
90 | host->h_next = nlm_hosts[hash]; | ||
91 | nlm_hosts[hash] = host; | ||
92 | } | ||
93 | nlm_get_host(host); | ||
94 | mutex_unlock(&nlm_host_mutex); | ||
95 | return host; | ||
96 | } | ||
97 | } | ||
98 | 119 | ||
99 | /* Ooops, no host found, create it */ | 120 | nlm_get_host(host); |
100 | dprintk("lockd: creating host entry\n"); | 121 | goto out; |
122 | } | ||
123 | if (nsm) | ||
124 | atomic_inc(&nsm->sm_count); | ||
101 | 125 | ||
102 | host = kzalloc(sizeof(*host), GFP_KERNEL); | 126 | host = NULL; |
103 | if (!host) | ||
104 | goto nohost; | ||
105 | 127 | ||
106 | addr = sin->sin_addr.s_addr; | 128 | /* Sadly, the host isn't in our hash table yet. See if |
107 | sprintf(host->h_name, "%u.%u.%u.%u", NIPQUAD(addr)); | 129 | * we have an NSM handle for it. If not, create one. |
130 | */ | ||
131 | if (!nsm && !(nsm = nsm_find(sin, hostname, hostname_len))) | ||
132 | goto out; | ||
108 | 133 | ||
134 | host = kzalloc(sizeof(*host), GFP_KERNEL); | ||
135 | if (!host) { | ||
136 | nsm_release(nsm); | ||
137 | goto out; | ||
138 | } | ||
139 | host->h_name = nsm->sm_name; | ||
109 | host->h_addr = *sin; | 140 | host->h_addr = *sin; |
110 | host->h_addr.sin_port = 0; /* ouch! */ | 141 | host->h_addr.sin_port = 0; /* ouch! */ |
111 | host->h_version = version; | 142 | host->h_version = version; |
@@ -119,9 +150,9 @@ nlm_lookup_host(int server, struct sockaddr_in *sin, | |||
119 | init_rwsem(&host->h_rwsem); | 150 | init_rwsem(&host->h_rwsem); |
120 | host->h_state = 0; /* pseudo NSM state */ | 151 | host->h_state = 0; /* pseudo NSM state */ |
121 | host->h_nsmstate = 0; /* real NSM state */ | 152 | host->h_nsmstate = 0; /* real NSM state */ |
153 | host->h_nsmhandle = nsm; | ||
122 | host->h_server = server; | 154 | host->h_server = server; |
123 | host->h_next = nlm_hosts[hash]; | 155 | hlist_add_head(&host->h_hash, chain); |
124 | nlm_hosts[hash] = host; | ||
125 | INIT_LIST_HEAD(&host->h_lockowners); | 156 | INIT_LIST_HEAD(&host->h_lockowners); |
126 | spin_lock_init(&host->h_lock); | 157 | spin_lock_init(&host->h_lock); |
127 | INIT_LIST_HEAD(&host->h_granted); | 158 | INIT_LIST_HEAD(&host->h_granted); |
@@ -130,35 +161,39 @@ nlm_lookup_host(int server, struct sockaddr_in *sin, | |||
130 | if (++nrhosts > NLM_HOST_MAX) | 161 | if (++nrhosts > NLM_HOST_MAX) |
131 | next_gc = 0; | 162 | next_gc = 0; |
132 | 163 | ||
133 | nohost: | 164 | out: |
134 | mutex_unlock(&nlm_host_mutex); | 165 | mutex_unlock(&nlm_host_mutex); |
135 | return host; | 166 | return host; |
136 | } | 167 | } |
137 | 168 | ||
138 | struct nlm_host * | 169 | /* |
139 | nlm_find_client(void) | 170 | * Destroy a host |
171 | */ | ||
172 | static void | ||
173 | nlm_destroy_host(struct nlm_host *host) | ||
140 | { | 174 | { |
141 | /* find a nlm_host for a client for which h_killed == 0. | 175 | struct rpc_clnt *clnt; |
142 | * and return it | 176 | |
177 | BUG_ON(!list_empty(&host->h_lockowners)); | ||
178 | BUG_ON(atomic_read(&host->h_count)); | ||
179 | |||
180 | /* | ||
181 | * Release NSM handle and unmonitor host. | ||
143 | */ | 182 | */ |
144 | int hash; | 183 | nsm_unmonitor(host); |
145 | mutex_lock(&nlm_host_mutex); | 184 | |
146 | for (hash = 0 ; hash < NLM_HOST_NRHASH; hash++) { | 185 | if ((clnt = host->h_rpcclnt) != NULL) { |
147 | struct nlm_host *host, **hp; | 186 | if (atomic_read(&clnt->cl_users)) { |
148 | for (hp = &nlm_hosts[hash]; (host = *hp) != 0; hp = &host->h_next) { | 187 | printk(KERN_WARNING |
149 | if (host->h_server && | 188 | "lockd: active RPC handle\n"); |
150 | host->h_killed == 0) { | 189 | clnt->cl_dead = 1; |
151 | nlm_get_host(host); | 190 | } else { |
152 | mutex_unlock(&nlm_host_mutex); | 191 | rpc_destroy_client(host->h_rpcclnt); |
153 | return host; | ||
154 | } | ||
155 | } | 192 | } |
156 | } | 193 | } |
157 | mutex_unlock(&nlm_host_mutex); | 194 | kfree(host); |
158 | return NULL; | ||
159 | } | 195 | } |
160 | 196 | ||
161 | |||
162 | /* | 197 | /* |
163 | * Create the NLM RPC client for an NLM peer | 198 | * Create the NLM RPC client for an NLM peer |
164 | */ | 199 | */ |
@@ -260,22 +295,82 @@ void nlm_release_host(struct nlm_host *host) | |||
260 | } | 295 | } |
261 | 296 | ||
262 | /* | 297 | /* |
298 | * We were notified that the host indicated by address &sin | ||
299 | * has rebooted. | ||
300 | * Release all resources held by that peer. | ||
301 | */ | ||
302 | void nlm_host_rebooted(const struct sockaddr_in *sin, | ||
303 | const char *hostname, int hostname_len, | ||
304 | u32 new_state) | ||
305 | { | ||
306 | struct hlist_head *chain; | ||
307 | struct hlist_node *pos; | ||
308 | struct nsm_handle *nsm; | ||
309 | struct nlm_host *host; | ||
310 | |||
311 | dprintk("lockd: nlm_host_rebooted(%s, %u.%u.%u.%u)\n", | ||
312 | hostname, NIPQUAD(sin->sin_addr)); | ||
313 | |||
314 | /* Find the NSM handle for this peer */ | ||
315 | if (!(nsm = __nsm_find(sin, hostname, hostname_len, 0))) | ||
316 | return; | ||
317 | |||
318 | /* When reclaiming locks on this peer, make sure that | ||
319 | * we set up a new notification */ | ||
320 | nsm->sm_monitored = 0; | ||
321 | |||
322 | /* Mark all hosts tied to this NSM state as having rebooted. | ||
323 | * We run the loop repeatedly, because we drop the host table | ||
324 | * lock for this. | ||
325 | * To avoid processing a host several times, we match the nsmstate. | ||
326 | */ | ||
327 | again: mutex_lock(&nlm_host_mutex); | ||
328 | for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) { | ||
329 | hlist_for_each_entry(host, pos, chain, h_hash) { | ||
330 | if (host->h_nsmhandle == nsm | ||
331 | && host->h_nsmstate != new_state) { | ||
332 | host->h_nsmstate = new_state; | ||
333 | host->h_state++; | ||
334 | |||
335 | nlm_get_host(host); | ||
336 | mutex_unlock(&nlm_host_mutex); | ||
337 | |||
338 | if (host->h_server) { | ||
339 | /* We're server for this guy, just ditch | ||
340 | * all the locks he held. */ | ||
341 | nlmsvc_free_host_resources(host); | ||
342 | } else { | ||
343 | /* He's the server, initiate lock recovery. */ | ||
344 | nlmclnt_recovery(host); | ||
345 | } | ||
346 | |||
347 | nlm_release_host(host); | ||
348 | goto again; | ||
349 | } | ||
350 | } | ||
351 | } | ||
352 | |||
353 | mutex_unlock(&nlm_host_mutex); | ||
354 | } | ||
355 | |||
356 | /* | ||
263 | * Shut down the hosts module. | 357 | * Shut down the hosts module. |
264 | * Note that this routine is called only at server shutdown time. | 358 | * Note that this routine is called only at server shutdown time. |
265 | */ | 359 | */ |
266 | void | 360 | void |
267 | nlm_shutdown_hosts(void) | 361 | nlm_shutdown_hosts(void) |
268 | { | 362 | { |
363 | struct hlist_head *chain; | ||
364 | struct hlist_node *pos; | ||
269 | struct nlm_host *host; | 365 | struct nlm_host *host; |
270 | int i; | ||
271 | 366 | ||
272 | dprintk("lockd: shutting down host module\n"); | 367 | dprintk("lockd: shutting down host module\n"); |
273 | mutex_lock(&nlm_host_mutex); | 368 | mutex_lock(&nlm_host_mutex); |
274 | 369 | ||
275 | /* First, make all hosts eligible for gc */ | 370 | /* First, make all hosts eligible for gc */ |
276 | dprintk("lockd: nuking all hosts...\n"); | 371 | dprintk("lockd: nuking all hosts...\n"); |
277 | for (i = 0; i < NLM_HOST_NRHASH; i++) { | 372 | for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) { |
278 | for (host = nlm_hosts[i]; host; host = host->h_next) | 373 | hlist_for_each_entry(host, pos, chain, h_hash) |
279 | host->h_expires = jiffies - 1; | 374 | host->h_expires = jiffies - 1; |
280 | } | 375 | } |
281 | 376 | ||
@@ -287,8 +382,8 @@ nlm_shutdown_hosts(void) | |||
287 | if (nrhosts) { | 382 | if (nrhosts) { |
288 | printk(KERN_WARNING "lockd: couldn't shutdown host module!\n"); | 383 | printk(KERN_WARNING "lockd: couldn't shutdown host module!\n"); |
289 | dprintk("lockd: %d hosts left:\n", nrhosts); | 384 | dprintk("lockd: %d hosts left:\n", nrhosts); |
290 | for (i = 0; i < NLM_HOST_NRHASH; i++) { | 385 | for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) { |
291 | for (host = nlm_hosts[i]; host; host = host->h_next) { | 386 | hlist_for_each_entry(host, pos, chain, h_hash) { |
292 | dprintk(" %s (cnt %d use %d exp %ld)\n", | 387 | dprintk(" %s (cnt %d use %d exp %ld)\n", |
293 | host->h_name, atomic_read(&host->h_count), | 388 | host->h_name, atomic_read(&host->h_count), |
294 | host->h_inuse, host->h_expires); | 389 | host->h_inuse, host->h_expires); |
@@ -305,45 +400,32 @@ nlm_shutdown_hosts(void) | |||
305 | static void | 400 | static void |
306 | nlm_gc_hosts(void) | 401 | nlm_gc_hosts(void) |
307 | { | 402 | { |
308 | struct nlm_host **q, *host; | 403 | struct hlist_head *chain; |
309 | struct rpc_clnt *clnt; | 404 | struct hlist_node *pos, *next; |
310 | int i; | 405 | struct nlm_host *host; |
311 | 406 | ||
312 | dprintk("lockd: host garbage collection\n"); | 407 | dprintk("lockd: host garbage collection\n"); |
313 | for (i = 0; i < NLM_HOST_NRHASH; i++) { | 408 | for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) { |
314 | for (host = nlm_hosts[i]; host; host = host->h_next) | 409 | hlist_for_each_entry(host, pos, chain, h_hash) |
315 | host->h_inuse = 0; | 410 | host->h_inuse = 0; |
316 | } | 411 | } |
317 | 412 | ||
318 | /* Mark all hosts that hold locks, blocks or shares */ | 413 | /* Mark all hosts that hold locks, blocks or shares */ |
319 | nlmsvc_mark_resources(); | 414 | nlmsvc_mark_resources(); |
320 | 415 | ||
321 | for (i = 0; i < NLM_HOST_NRHASH; i++) { | 416 | for (chain = nlm_hosts; chain < nlm_hosts + NLM_HOST_NRHASH; ++chain) { |
322 | q = &nlm_hosts[i]; | 417 | hlist_for_each_entry_safe(host, pos, next, chain, h_hash) { |
323 | while ((host = *q) != NULL) { | ||
324 | if (atomic_read(&host->h_count) || host->h_inuse | 418 | if (atomic_read(&host->h_count) || host->h_inuse |
325 | || time_before(jiffies, host->h_expires)) { | 419 | || time_before(jiffies, host->h_expires)) { |
326 | dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n", | 420 | dprintk("nlm_gc_hosts skipping %s (cnt %d use %d exp %ld)\n", |
327 | host->h_name, atomic_read(&host->h_count), | 421 | host->h_name, atomic_read(&host->h_count), |
328 | host->h_inuse, host->h_expires); | 422 | host->h_inuse, host->h_expires); |
329 | q = &host->h_next; | ||
330 | continue; | 423 | continue; |
331 | } | 424 | } |
332 | dprintk("lockd: delete host %s\n", host->h_name); | 425 | dprintk("lockd: delete host %s\n", host->h_name); |
333 | *q = host->h_next; | 426 | hlist_del_init(&host->h_hash); |
334 | /* Don't unmonitor hosts that have been invalidated */ | 427 | |
335 | if (host->h_monitored && !host->h_killed) | 428 | nlm_destroy_host(host); |
336 | nsm_unmonitor(host); | ||
337 | if ((clnt = host->h_rpcclnt) != NULL) { | ||
338 | if (atomic_read(&clnt->cl_users)) { | ||
339 | printk(KERN_WARNING | ||
340 | "lockd: active RPC handle\n"); | ||
341 | clnt->cl_dead = 1; | ||
342 | } else { | ||
343 | rpc_destroy_client(host->h_rpcclnt); | ||
344 | } | ||
345 | } | ||
346 | kfree(host); | ||
347 | nrhosts--; | 429 | nrhosts--; |
348 | } | 430 | } |
349 | } | 431 | } |
@@ -351,3 +433,88 @@ nlm_gc_hosts(void) | |||
351 | next_gc = jiffies + NLM_HOST_COLLECT; | 433 | next_gc = jiffies + NLM_HOST_COLLECT; |
352 | } | 434 | } |
353 | 435 | ||
436 | |||
437 | /* | ||
438 | * Manage NSM handles | ||
439 | */ | ||
440 | static LIST_HEAD(nsm_handles); | ||
441 | static DEFINE_MUTEX(nsm_mutex); | ||
442 | |||
443 | static struct nsm_handle * | ||
444 | __nsm_find(const struct sockaddr_in *sin, | ||
445 | const char *hostname, int hostname_len, | ||
446 | int create) | ||
447 | { | ||
448 | struct nsm_handle *nsm = NULL; | ||
449 | struct list_head *pos; | ||
450 | |||
451 | if (!sin) | ||
452 | return NULL; | ||
453 | |||
454 | if (hostname && memchr(hostname, '/', hostname_len) != NULL) { | ||
455 | if (printk_ratelimit()) { | ||
456 | printk(KERN_WARNING "Invalid hostname \"%.*s\" " | ||
457 | "in NFS lock request\n", | ||
458 | hostname_len, hostname); | ||
459 | } | ||
460 | return NULL; | ||
461 | } | ||
462 | |||
463 | mutex_lock(&nsm_mutex); | ||
464 | list_for_each(pos, &nsm_handles) { | ||
465 | nsm = list_entry(pos, struct nsm_handle, sm_link); | ||
466 | |||
467 | if (hostname && nsm_use_hostnames) { | ||
468 | if (strlen(nsm->sm_name) != hostname_len | ||
469 | || memcmp(nsm->sm_name, hostname, hostname_len)) | ||
470 | continue; | ||
471 | } else if (!nlm_cmp_addr(&nsm->sm_addr, sin)) | ||
472 | continue; | ||
473 | atomic_inc(&nsm->sm_count); | ||
474 | goto out; | ||
475 | } | ||
476 | |||
477 | if (!create) { | ||
478 | nsm = NULL; | ||
479 | goto out; | ||
480 | } | ||
481 | |||
482 | nsm = kzalloc(sizeof(*nsm) + hostname_len + 1, GFP_KERNEL); | ||
483 | if (nsm != NULL) { | ||
484 | nsm->sm_addr = *sin; | ||
485 | nsm->sm_name = (char *) (nsm + 1); | ||
486 | memcpy(nsm->sm_name, hostname, hostname_len); | ||
487 | nsm->sm_name[hostname_len] = '\0'; | ||
488 | atomic_set(&nsm->sm_count, 1); | ||
489 | |||
490 | list_add(&nsm->sm_link, &nsm_handles); | ||
491 | } | ||
492 | |||
493 | out: | ||
494 | mutex_unlock(&nsm_mutex); | ||
495 | return nsm; | ||
496 | } | ||
497 | |||
498 | struct nsm_handle * | ||
499 | nsm_find(const struct sockaddr_in *sin, const char *hostname, int hostname_len) | ||
500 | { | ||
501 | return __nsm_find(sin, hostname, hostname_len, 1); | ||
502 | } | ||
503 | |||
504 | /* | ||
505 | * Release an NSM handle | ||
506 | */ | ||
507 | void | ||
508 | nsm_release(struct nsm_handle *nsm) | ||
509 | { | ||
510 | if (!nsm) | ||
511 | return; | ||
512 | if (atomic_dec_and_test(&nsm->sm_count)) { | ||
513 | mutex_lock(&nsm_mutex); | ||
514 | if (atomic_read(&nsm->sm_count) == 0) { | ||
515 | list_del(&nsm->sm_link); | ||
516 | kfree(nsm); | ||
517 | } | ||
518 | mutex_unlock(&nsm_mutex); | ||
519 | } | ||
520 | } | ||
diff --git a/fs/lockd/mon.c b/fs/lockd/mon.c index a816b920d431..e0179f8c327f 100644 --- a/fs/lockd/mon.c +++ b/fs/lockd/mon.c | |||
@@ -24,13 +24,13 @@ static struct rpc_program nsm_program; | |||
24 | /* | 24 | /* |
25 | * Local NSM state | 25 | * Local NSM state |
26 | */ | 26 | */ |
27 | u32 nsm_local_state; | 27 | int nsm_local_state; |
28 | 28 | ||
29 | /* | 29 | /* |
30 | * Common procedure for SM_MON/SM_UNMON calls | 30 | * Common procedure for SM_MON/SM_UNMON calls |
31 | */ | 31 | */ |
32 | static int | 32 | static int |
33 | nsm_mon_unmon(struct nlm_host *host, u32 proc, struct nsm_res *res) | 33 | nsm_mon_unmon(struct nsm_handle *nsm, u32 proc, struct nsm_res *res) |
34 | { | 34 | { |
35 | struct rpc_clnt *clnt; | 35 | struct rpc_clnt *clnt; |
36 | int status; | 36 | int status; |
@@ -46,10 +46,11 @@ nsm_mon_unmon(struct nlm_host *host, u32 proc, struct nsm_res *res) | |||
46 | goto out; | 46 | goto out; |
47 | } | 47 | } |
48 | 48 | ||
49 | args.addr = host->h_addr.sin_addr.s_addr; | 49 | memset(&args, 0, sizeof(args)); |
50 | args.proto= (host->h_proto<<1) | host->h_server; | 50 | args.mon_name = nsm->sm_name; |
51 | args.addr = nsm->sm_addr.sin_addr.s_addr; | ||
51 | args.prog = NLM_PROGRAM; | 52 | args.prog = NLM_PROGRAM; |
52 | args.vers = host->h_version; | 53 | args.vers = 3; |
53 | args.proc = NLMPROC_NSM_NOTIFY; | 54 | args.proc = NLMPROC_NSM_NOTIFY; |
54 | memset(res, 0, sizeof(*res)); | 55 | memset(res, 0, sizeof(*res)); |
55 | 56 | ||
@@ -70,17 +71,22 @@ nsm_mon_unmon(struct nlm_host *host, u32 proc, struct nsm_res *res) | |||
70 | int | 71 | int |
71 | nsm_monitor(struct nlm_host *host) | 72 | nsm_monitor(struct nlm_host *host) |
72 | { | 73 | { |
74 | struct nsm_handle *nsm = host->h_nsmhandle; | ||
73 | struct nsm_res res; | 75 | struct nsm_res res; |
74 | int status; | 76 | int status; |
75 | 77 | ||
76 | dprintk("lockd: nsm_monitor(%s)\n", host->h_name); | 78 | dprintk("lockd: nsm_monitor(%s)\n", host->h_name); |
79 | BUG_ON(nsm == NULL); | ||
77 | 80 | ||
78 | status = nsm_mon_unmon(host, SM_MON, &res); | 81 | if (nsm->sm_monitored) |
82 | return 0; | ||
83 | |||
84 | status = nsm_mon_unmon(nsm, SM_MON, &res); | ||
79 | 85 | ||
80 | if (status < 0 || res.status != 0) | 86 | if (status < 0 || res.status != 0) |
81 | printk(KERN_NOTICE "lockd: cannot monitor %s\n", host->h_name); | 87 | printk(KERN_NOTICE "lockd: cannot monitor %s\n", host->h_name); |
82 | else | 88 | else |
83 | host->h_monitored = 1; | 89 | nsm->sm_monitored = 1; |
84 | return status; | 90 | return status; |
85 | } | 91 | } |
86 | 92 | ||
@@ -90,16 +96,26 @@ nsm_monitor(struct nlm_host *host) | |||
90 | int | 96 | int |
91 | nsm_unmonitor(struct nlm_host *host) | 97 | nsm_unmonitor(struct nlm_host *host) |
92 | { | 98 | { |
99 | struct nsm_handle *nsm = host->h_nsmhandle; | ||
93 | struct nsm_res res; | 100 | struct nsm_res res; |
94 | int status; | 101 | int status = 0; |
95 | 102 | ||
96 | dprintk("lockd: nsm_unmonitor(%s)\n", host->h_name); | 103 | if (nsm == NULL) |
97 | 104 | return 0; | |
98 | status = nsm_mon_unmon(host, SM_UNMON, &res); | 105 | host->h_nsmhandle = NULL; |
99 | if (status < 0) | 106 | |
100 | printk(KERN_NOTICE "lockd: cannot unmonitor %s\n", host->h_name); | 107 | if (atomic_read(&nsm->sm_count) == 1 |
101 | else | 108 | && nsm->sm_monitored && !nsm->sm_sticky) { |
102 | host->h_monitored = 0; | 109 | dprintk("lockd: nsm_unmonitor(%s)\n", host->h_name); |
110 | |||
111 | status = nsm_mon_unmon(nsm, SM_UNMON, &res); | ||
112 | if (status < 0) | ||
113 | printk(KERN_NOTICE "lockd: cannot unmonitor %s\n", | ||
114 | host->h_name); | ||
115 | else | ||
116 | nsm->sm_monitored = 0; | ||
117 | } | ||
118 | nsm_release(nsm); | ||
103 | return status; | 119 | return status; |
104 | } | 120 | } |
105 | 121 | ||
@@ -135,7 +151,7 @@ nsm_create(void) | |||
135 | static u32 * | 151 | static u32 * |
136 | xdr_encode_common(struct rpc_rqst *rqstp, u32 *p, struct nsm_args *argp) | 152 | xdr_encode_common(struct rpc_rqst *rqstp, u32 *p, struct nsm_args *argp) |
137 | { | 153 | { |
138 | char buffer[20]; | 154 | char buffer[20], *name; |
139 | 155 | ||
140 | /* | 156 | /* |
141 | * Use the dotted-quad IP address of the remote host as | 157 | * Use the dotted-quad IP address of the remote host as |
@@ -143,8 +159,13 @@ xdr_encode_common(struct rpc_rqst *rqstp, u32 *p, struct nsm_args *argp) | |||
143 | * hostname first for whatever remote hostname it receives, | 159 | * hostname first for whatever remote hostname it receives, |
144 | * so this works alright. | 160 | * so this works alright. |
145 | */ | 161 | */ |
146 | sprintf(buffer, "%u.%u.%u.%u", NIPQUAD(argp->addr)); | 162 | if (nsm_use_hostnames) { |
147 | if (!(p = xdr_encode_string(p, buffer)) | 163 | name = argp->mon_name; |
164 | } else { | ||
165 | sprintf(buffer, "%u.%u.%u.%u", NIPQUAD(argp->addr)); | ||
166 | name = buffer; | ||
167 | } | ||
168 | if (!(p = xdr_encode_string(p, name)) | ||
148 | || !(p = xdr_encode_string(p, utsname()->nodename))) | 169 | || !(p = xdr_encode_string(p, utsname()->nodename))) |
149 | return ERR_PTR(-EIO); | 170 | return ERR_PTR(-EIO); |
150 | *p++ = htonl(argp->prog); | 171 | *p++ = htonl(argp->prog); |
@@ -160,9 +181,11 @@ xdr_encode_mon(struct rpc_rqst *rqstp, u32 *p, struct nsm_args *argp) | |||
160 | p = xdr_encode_common(rqstp, p, argp); | 181 | p = xdr_encode_common(rqstp, p, argp); |
161 | if (IS_ERR(p)) | 182 | if (IS_ERR(p)) |
162 | return PTR_ERR(p); | 183 | return PTR_ERR(p); |
184 | |||
185 | /* Surprise - there may even be room for an IPv6 address now */ | ||
163 | *p++ = argp->addr; | 186 | *p++ = argp->addr; |
164 | *p++ = argp->vers; | 187 | *p++ = 0; |
165 | *p++ = argp->proto; | 188 | *p++ = 0; |
166 | *p++ = 0; | 189 | *p++ = 0; |
167 | rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p); | 190 | rqstp->rq_slen = xdr_adjust_iovec(rqstp->rq_svec, p); |
168 | return 0; | 191 | return 0; |
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c index 3cc369e5693f..634139232aaf 100644 --- a/fs/lockd/svc.c +++ b/fs/lockd/svc.c | |||
@@ -33,6 +33,7 @@ | |||
33 | #include <linux/sunrpc/svcsock.h> | 33 | #include <linux/sunrpc/svcsock.h> |
34 | #include <net/ip.h> | 34 | #include <net/ip.h> |
35 | #include <linux/lockd/lockd.h> | 35 | #include <linux/lockd/lockd.h> |
36 | #include <linux/lockd/sm_inter.h> | ||
36 | #include <linux/nfs.h> | 37 | #include <linux/nfs.h> |
37 | 38 | ||
38 | #define NLMDBG_FACILITY NLMDBG_SVC | 39 | #define NLMDBG_FACILITY NLMDBG_SVC |
@@ -61,6 +62,7 @@ static DECLARE_WAIT_QUEUE_HEAD(lockd_exit); | |||
61 | static unsigned long nlm_grace_period; | 62 | static unsigned long nlm_grace_period; |
62 | static unsigned long nlm_timeout = LOCKD_DFLT_TIMEO; | 63 | static unsigned long nlm_timeout = LOCKD_DFLT_TIMEO; |
63 | static int nlm_udpport, nlm_tcpport; | 64 | static int nlm_udpport, nlm_tcpport; |
65 | int nsm_use_hostnames = 0; | ||
64 | 66 | ||
65 | /* | 67 | /* |
66 | * Constants needed for the sysctl interface. | 68 | * Constants needed for the sysctl interface. |
@@ -395,6 +397,22 @@ static ctl_table nlm_sysctls[] = { | |||
395 | .extra1 = (int *) &nlm_port_min, | 397 | .extra1 = (int *) &nlm_port_min, |
396 | .extra2 = (int *) &nlm_port_max, | 398 | .extra2 = (int *) &nlm_port_max, |
397 | }, | 399 | }, |
400 | { | ||
401 | .ctl_name = CTL_UNNUMBERED, | ||
402 | .procname = "nsm_use_hostnames", | ||
403 | .data = &nsm_use_hostnames, | ||
404 | .maxlen = sizeof(int), | ||
405 | .mode = 0644, | ||
406 | .proc_handler = &proc_dointvec, | ||
407 | }, | ||
408 | { | ||
409 | .ctl_name = CTL_UNNUMBERED, | ||
410 | .procname = "nsm_local_state", | ||
411 | .data = &nsm_local_state, | ||
412 | .maxlen = sizeof(int), | ||
413 | .mode = 0644, | ||
414 | .proc_handler = &proc_dointvec, | ||
415 | }, | ||
398 | { .ctl_name = 0 } | 416 | { .ctl_name = 0 } |
399 | }; | 417 | }; |
400 | 418 | ||
@@ -483,6 +501,7 @@ module_param_call(nlm_udpport, param_set_port, param_get_int, | |||
483 | &nlm_udpport, 0644); | 501 | &nlm_udpport, 0644); |
484 | module_param_call(nlm_tcpport, param_set_port, param_get_int, | 502 | module_param_call(nlm_tcpport, param_set_port, param_get_int, |
485 | &nlm_tcpport, 0644); | 503 | &nlm_tcpport, 0644); |
504 | module_param(nsm_use_hostnames, bool, 0644); | ||
486 | 505 | ||
487 | /* | 506 | /* |
488 | * Initialising and terminating the module. | 507 | * Initialising and terminating the module. |
diff --git a/fs/lockd/svc4proc.c b/fs/lockd/svc4proc.c index a2dd9ccb9b32..fa370f6eb07b 100644 --- a/fs/lockd/svc4proc.c +++ b/fs/lockd/svc4proc.c | |||
@@ -38,8 +38,8 @@ nlm4svc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp, | |||
38 | return nlm_lck_denied_nolocks; | 38 | return nlm_lck_denied_nolocks; |
39 | 39 | ||
40 | /* Obtain host handle */ | 40 | /* Obtain host handle */ |
41 | if (!(host = nlmsvc_lookup_host(rqstp)) | 41 | if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len)) |
42 | || (argp->monitor && !host->h_monitored && nsm_monitor(host) < 0)) | 42 | || (argp->monitor && nsm_monitor(host) < 0)) |
43 | goto no_locks; | 43 | goto no_locks; |
44 | *hostp = host; | 44 | *hostp = host; |
45 | 45 | ||
@@ -260,7 +260,9 @@ static int nlm4svc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *a | |||
260 | struct nlm_rqst *call; | 260 | struct nlm_rqst *call; |
261 | int stat; | 261 | int stat; |
262 | 262 | ||
263 | host = nlmsvc_lookup_host(rqstp); | 263 | host = nlmsvc_lookup_host(rqstp, |
264 | argp->lock.caller, | ||
265 | argp->lock.len); | ||
264 | if (host == NULL) | 266 | if (host == NULL) |
265 | return rpc_system_err; | 267 | return rpc_system_err; |
266 | 268 | ||
@@ -420,10 +422,6 @@ nlm4svc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp, | |||
420 | void *resp) | 422 | void *resp) |
421 | { | 423 | { |
422 | struct sockaddr_in saddr = rqstp->rq_addr; | 424 | struct sockaddr_in saddr = rqstp->rq_addr; |
423 | int vers = argp->vers; | ||
424 | int prot = argp->proto >> 1; | ||
425 | |||
426 | struct nlm_host *host; | ||
427 | 425 | ||
428 | dprintk("lockd: SM_NOTIFY called\n"); | 426 | dprintk("lockd: SM_NOTIFY called\n"); |
429 | if (saddr.sin_addr.s_addr != htonl(INADDR_LOOPBACK) | 427 | if (saddr.sin_addr.s_addr != htonl(INADDR_LOOPBACK) |
@@ -438,21 +436,10 @@ nlm4svc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp, | |||
438 | /* Obtain the host pointer for this NFS server and try to | 436 | /* Obtain the host pointer for this NFS server and try to |
439 | * reclaim all locks we hold on this server. | 437 | * reclaim all locks we hold on this server. |
440 | */ | 438 | */ |
439 | memset(&saddr, 0, sizeof(saddr)); | ||
441 | saddr.sin_addr.s_addr = argp->addr; | 440 | saddr.sin_addr.s_addr = argp->addr; |
441 | nlm_host_rebooted(&saddr, argp->mon, argp->len, argp->state); | ||
442 | 442 | ||
443 | if ((argp->proto & 1)==0) { | ||
444 | if ((host = nlmclnt_lookup_host(&saddr, prot, vers)) != NULL) { | ||
445 | nlmclnt_recovery(host, argp->state); | ||
446 | nlm_release_host(host); | ||
447 | } | ||
448 | } else { | ||
449 | /* If we run on an NFS server, delete all locks held by the client */ | ||
450 | |||
451 | if ((host = nlm_lookup_host(1, &saddr, prot, vers)) != NULL) { | ||
452 | nlmsvc_free_host_resources(host); | ||
453 | nlm_release_host(host); | ||
454 | } | ||
455 | } | ||
456 | return rpc_success; | 443 | return rpc_success; |
457 | } | 444 | } |
458 | 445 | ||
@@ -468,7 +455,7 @@ nlm4svc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res *argp, | |||
468 | 455 | ||
469 | dprintk("lockd: GRANTED_RES called\n"); | 456 | dprintk("lockd: GRANTED_RES called\n"); |
470 | 457 | ||
471 | nlmsvc_grant_reply(rqstp, &argp->cookie, argp->status); | 458 | nlmsvc_grant_reply(&argp->cookie, argp->status); |
472 | return rpc_success; | 459 | return rpc_success; |
473 | } | 460 | } |
474 | 461 | ||
diff --git a/fs/lockd/svclock.c b/fs/lockd/svclock.c index 93c00ee7189d..814c6064c9e0 100644 --- a/fs/lockd/svclock.c +++ b/fs/lockd/svclock.c | |||
@@ -40,7 +40,7 @@ | |||
40 | 40 | ||
41 | static void nlmsvc_release_block(struct nlm_block *block); | 41 | static void nlmsvc_release_block(struct nlm_block *block); |
42 | static void nlmsvc_insert_block(struct nlm_block *block, unsigned long); | 42 | static void nlmsvc_insert_block(struct nlm_block *block, unsigned long); |
43 | static int nlmsvc_remove_block(struct nlm_block *block); | 43 | static void nlmsvc_remove_block(struct nlm_block *block); |
44 | 44 | ||
45 | static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock); | 45 | static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock); |
46 | static void nlmsvc_freegrantargs(struct nlm_rqst *call); | 46 | static void nlmsvc_freegrantargs(struct nlm_rqst *call); |
@@ -49,7 +49,7 @@ static const struct rpc_call_ops nlmsvc_grant_ops; | |||
49 | /* | 49 | /* |
50 | * The list of blocked locks to retry | 50 | * The list of blocked locks to retry |
51 | */ | 51 | */ |
52 | static struct nlm_block * nlm_blocked; | 52 | static LIST_HEAD(nlm_blocked); |
53 | 53 | ||
54 | /* | 54 | /* |
55 | * Insert a blocked lock into the global list | 55 | * Insert a blocked lock into the global list |
@@ -57,48 +57,44 @@ static struct nlm_block * nlm_blocked; | |||
57 | static void | 57 | static void |
58 | nlmsvc_insert_block(struct nlm_block *block, unsigned long when) | 58 | nlmsvc_insert_block(struct nlm_block *block, unsigned long when) |
59 | { | 59 | { |
60 | struct nlm_block **bp, *b; | 60 | struct nlm_block *b; |
61 | struct list_head *pos; | ||
61 | 62 | ||
62 | dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block, when); | 63 | dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block, when); |
63 | kref_get(&block->b_count); | 64 | if (list_empty(&block->b_list)) { |
64 | if (block->b_queued) | 65 | kref_get(&block->b_count); |
65 | nlmsvc_remove_block(block); | 66 | } else { |
66 | bp = &nlm_blocked; | 67 | list_del_init(&block->b_list); |
68 | } | ||
69 | |||
70 | pos = &nlm_blocked; | ||
67 | if (when != NLM_NEVER) { | 71 | if (when != NLM_NEVER) { |
68 | if ((when += jiffies) == NLM_NEVER) | 72 | if ((when += jiffies) == NLM_NEVER) |
69 | when ++; | 73 | when ++; |
70 | while ((b = *bp) && time_before_eq(b->b_when,when) && b->b_when != NLM_NEVER) | 74 | list_for_each(pos, &nlm_blocked) { |
71 | bp = &b->b_next; | 75 | b = list_entry(pos, struct nlm_block, b_list); |
72 | } else | 76 | if (time_after(b->b_when,when) || b->b_when == NLM_NEVER) |
73 | while ((b = *bp) != 0) | 77 | break; |
74 | bp = &b->b_next; | 78 | } |
79 | /* On normal exit from the loop, pos == &nlm_blocked, | ||
80 | * so we will be adding to the end of the list - good | ||
81 | */ | ||
82 | } | ||
75 | 83 | ||
76 | block->b_queued = 1; | 84 | list_add_tail(&block->b_list, pos); |
77 | block->b_when = when; | 85 | block->b_when = when; |
78 | block->b_next = b; | ||
79 | *bp = block; | ||
80 | } | 86 | } |
81 | 87 | ||
82 | /* | 88 | /* |
83 | * Remove a block from the global list | 89 | * Remove a block from the global list |
84 | */ | 90 | */ |
85 | static int | 91 | static inline void |
86 | nlmsvc_remove_block(struct nlm_block *block) | 92 | nlmsvc_remove_block(struct nlm_block *block) |
87 | { | 93 | { |
88 | struct nlm_block **bp, *b; | 94 | if (!list_empty(&block->b_list)) { |
89 | 95 | list_del_init(&block->b_list); | |
90 | if (!block->b_queued) | 96 | nlmsvc_release_block(block); |
91 | return 1; | ||
92 | for (bp = &nlm_blocked; (b = *bp) != 0; bp = &b->b_next) { | ||
93 | if (b == block) { | ||
94 | *bp = block->b_next; | ||
95 | block->b_queued = 0; | ||
96 | nlmsvc_release_block(block); | ||
97 | return 1; | ||
98 | } | ||
99 | } | 97 | } |
100 | |||
101 | return 0; | ||
102 | } | 98 | } |
103 | 99 | ||
104 | /* | 100 | /* |
@@ -107,14 +103,14 @@ nlmsvc_remove_block(struct nlm_block *block) | |||
107 | static struct nlm_block * | 103 | static struct nlm_block * |
108 | nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) | 104 | nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock) |
109 | { | 105 | { |
110 | struct nlm_block **head, *block; | 106 | struct nlm_block *block; |
111 | struct file_lock *fl; | 107 | struct file_lock *fl; |
112 | 108 | ||
113 | dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n", | 109 | dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n", |
114 | file, lock->fl.fl_pid, | 110 | file, lock->fl.fl_pid, |
115 | (long long)lock->fl.fl_start, | 111 | (long long)lock->fl.fl_start, |
116 | (long long)lock->fl.fl_end, lock->fl.fl_type); | 112 | (long long)lock->fl.fl_end, lock->fl.fl_type); |
117 | for (head = &nlm_blocked; (block = *head) != 0; head = &block->b_next) { | 113 | list_for_each_entry(block, &nlm_blocked, b_list) { |
118 | fl = &block->b_call->a_args.lock.fl; | 114 | fl = &block->b_call->a_args.lock.fl; |
119 | dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n", | 115 | dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n", |
120 | block->b_file, fl->fl_pid, | 116 | block->b_file, fl->fl_pid, |
@@ -143,20 +139,20 @@ static inline int nlm_cookie_match(struct nlm_cookie *a, struct nlm_cookie *b) | |||
143 | * Find a block with a given NLM cookie. | 139 | * Find a block with a given NLM cookie. |
144 | */ | 140 | */ |
145 | static inline struct nlm_block * | 141 | static inline struct nlm_block * |
146 | nlmsvc_find_block(struct nlm_cookie *cookie, struct sockaddr_in *sin) | 142 | nlmsvc_find_block(struct nlm_cookie *cookie) |
147 | { | 143 | { |
148 | struct nlm_block *block; | 144 | struct nlm_block *block; |
149 | 145 | ||
150 | for (block = nlm_blocked; block; block = block->b_next) { | 146 | list_for_each_entry(block, &nlm_blocked, b_list) { |
151 | dprintk("cookie: head of blocked queue %p, block %p\n", | 147 | if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie)) |
152 | nlm_blocked, block); | 148 | goto found; |
153 | if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie) | ||
154 | && nlm_cmp_addr(sin, &block->b_host->h_addr)) | ||
155 | break; | ||
156 | } | 149 | } |
157 | 150 | ||
158 | if (block != NULL) | 151 | return NULL; |
159 | kref_get(&block->b_count); | 152 | |
153 | found: | ||
154 | dprintk("nlmsvc_find_block(%s): block=%p\n", nlmdbg_cookie2a(cookie), block); | ||
155 | kref_get(&block->b_count); | ||
160 | return block; | 156 | return block; |
161 | } | 157 | } |
162 | 158 | ||
@@ -169,6 +165,11 @@ nlmsvc_find_block(struct nlm_cookie *cookie, struct sockaddr_in *sin) | |||
169 | * request, but (as I found out later) that's because some implementations | 165 | * request, but (as I found out later) that's because some implementations |
170 | * do just this. Never mind the standards comittees, they support our | 166 | * do just this. Never mind the standards comittees, they support our |
171 | * logging industries. | 167 | * logging industries. |
168 | * | ||
169 | * 10 years later: I hope we can safely ignore these old and broken | ||
170 | * clients by now. Let's fix this so we can uniquely identify an incoming | ||
171 | * GRANTED_RES message by cookie, without having to rely on the client's IP | ||
172 | * address. --okir | ||
172 | */ | 173 | */ |
173 | static inline struct nlm_block * | 174 | static inline struct nlm_block * |
174 | nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file, | 175 | nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file, |
@@ -179,7 +180,7 @@ nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file, | |||
179 | struct nlm_rqst *call = NULL; | 180 | struct nlm_rqst *call = NULL; |
180 | 181 | ||
181 | /* Create host handle for callback */ | 182 | /* Create host handle for callback */ |
182 | host = nlmsvc_lookup_host(rqstp); | 183 | host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len); |
183 | if (host == NULL) | 184 | if (host == NULL) |
184 | return NULL; | 185 | return NULL; |
185 | 186 | ||
@@ -192,6 +193,8 @@ nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file, | |||
192 | if (block == NULL) | 193 | if (block == NULL) |
193 | goto failed; | 194 | goto failed; |
194 | kref_init(&block->b_count); | 195 | kref_init(&block->b_count); |
196 | INIT_LIST_HEAD(&block->b_list); | ||
197 | INIT_LIST_HEAD(&block->b_flist); | ||
195 | 198 | ||
196 | if (!nlmsvc_setgrantargs(call, lock)) | 199 | if (!nlmsvc_setgrantargs(call, lock)) |
197 | goto failed_free; | 200 | goto failed_free; |
@@ -199,7 +202,7 @@ nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file, | |||
199 | /* Set notifier function for VFS, and init args */ | 202 | /* Set notifier function for VFS, and init args */ |
200 | call->a_args.lock.fl.fl_flags |= FL_SLEEP; | 203 | call->a_args.lock.fl.fl_flags |= FL_SLEEP; |
201 | call->a_args.lock.fl.fl_lmops = &nlmsvc_lock_operations; | 204 | call->a_args.lock.fl.fl_lmops = &nlmsvc_lock_operations; |
202 | call->a_args.cookie = *cookie; /* see above */ | 205 | nlmclnt_next_cookie(&call->a_args.cookie); |
203 | 206 | ||
204 | dprintk("lockd: created block %p...\n", block); | 207 | dprintk("lockd: created block %p...\n", block); |
205 | 208 | ||
@@ -210,8 +213,7 @@ nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file, | |||
210 | file->f_count++; | 213 | file->f_count++; |
211 | 214 | ||
212 | /* Add to file's list of blocks */ | 215 | /* Add to file's list of blocks */ |
213 | block->b_fnext = file->f_blocks; | 216 | list_add(&block->b_flist, &file->f_blocks); |
214 | file->f_blocks = block; | ||
215 | 217 | ||
216 | /* Set up RPC arguments for callback */ | 218 | /* Set up RPC arguments for callback */ |
217 | block->b_call = call; | 219 | block->b_call = call; |
@@ -248,19 +250,13 @@ static void nlmsvc_free_block(struct kref *kref) | |||
248 | { | 250 | { |
249 | struct nlm_block *block = container_of(kref, struct nlm_block, b_count); | 251 | struct nlm_block *block = container_of(kref, struct nlm_block, b_count); |
250 | struct nlm_file *file = block->b_file; | 252 | struct nlm_file *file = block->b_file; |
251 | struct nlm_block **bp; | ||
252 | 253 | ||
253 | dprintk("lockd: freeing block %p...\n", block); | 254 | dprintk("lockd: freeing block %p...\n", block); |
254 | 255 | ||
255 | down(&file->f_sema); | ||
256 | /* Remove block from file's list of blocks */ | 256 | /* Remove block from file's list of blocks */ |
257 | for (bp = &file->f_blocks; *bp; bp = &(*bp)->b_fnext) { | 257 | mutex_lock(&file->f_mutex); |
258 | if (*bp == block) { | 258 | list_del_init(&block->b_flist); |
259 | *bp = block->b_fnext; | 259 | mutex_unlock(&file->f_mutex); |
260 | break; | ||
261 | } | ||
262 | } | ||
263 | up(&file->f_sema); | ||
264 | 260 | ||
265 | nlmsvc_freegrantargs(block->b_call); | 261 | nlmsvc_freegrantargs(block->b_call); |
266 | nlm_release_call(block->b_call); | 262 | nlm_release_call(block->b_call); |
@@ -274,47 +270,32 @@ static void nlmsvc_release_block(struct nlm_block *block) | |||
274 | kref_put(&block->b_count, nlmsvc_free_block); | 270 | kref_put(&block->b_count, nlmsvc_free_block); |
275 | } | 271 | } |
276 | 272 | ||
277 | static void nlmsvc_act_mark(struct nlm_host *host, struct nlm_file *file) | 273 | /* |
278 | { | 274 | * Loop over all blocks and delete blocks held by |
279 | struct nlm_block *block; | 275 | * a matching host. |
280 | 276 | */ | |
281 | down(&file->f_sema); | 277 | void nlmsvc_traverse_blocks(struct nlm_host *host, |
282 | for (block = file->f_blocks; block != NULL; block = block->b_fnext) | 278 | struct nlm_file *file, |
283 | block->b_host->h_inuse = 1; | 279 | nlm_host_match_fn_t match) |
284 | up(&file->f_sema); | ||
285 | } | ||
286 | |||
287 | static void nlmsvc_act_unlock(struct nlm_host *host, struct nlm_file *file) | ||
288 | { | 280 | { |
289 | struct nlm_block *block; | 281 | struct nlm_block *block, *next; |
290 | 282 | ||
291 | restart: | 283 | restart: |
292 | down(&file->f_sema); | 284 | mutex_lock(&file->f_mutex); |
293 | for (block = file->f_blocks; block != NULL; block = block->b_fnext) { | 285 | list_for_each_entry_safe(block, next, &file->f_blocks, b_flist) { |
294 | if (host != NULL && host != block->b_host) | 286 | if (!match(block->b_host, host)) |
295 | continue; | 287 | continue; |
296 | if (!block->b_queued) | 288 | /* Do not destroy blocks that are not on |
289 | * the global retry list - why? */ | ||
290 | if (list_empty(&block->b_list)) | ||
297 | continue; | 291 | continue; |
298 | kref_get(&block->b_count); | 292 | kref_get(&block->b_count); |
299 | up(&file->f_sema); | 293 | mutex_unlock(&file->f_mutex); |
300 | nlmsvc_unlink_block(block); | 294 | nlmsvc_unlink_block(block); |
301 | nlmsvc_release_block(block); | 295 | nlmsvc_release_block(block); |
302 | goto restart; | 296 | goto restart; |
303 | } | 297 | } |
304 | up(&file->f_sema); | 298 | mutex_unlock(&file->f_mutex); |
305 | } | ||
306 | |||
307 | /* | ||
308 | * Loop over all blocks and perform the action specified. | ||
309 | * (NLM_ACT_CHECK handled by nlmsvc_inspect_file). | ||
310 | */ | ||
311 | void | ||
312 | nlmsvc_traverse_blocks(struct nlm_host *host, struct nlm_file *file, int action) | ||
313 | { | ||
314 | if (action == NLM_ACT_MARK) | ||
315 | nlmsvc_act_mark(host, file); | ||
316 | else | ||
317 | nlmsvc_act_unlock(host, file); | ||
318 | } | 299 | } |
319 | 300 | ||
320 | /* | 301 | /* |
@@ -373,7 +354,7 @@ nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file, | |||
373 | lock->fl.fl_flags &= ~FL_SLEEP; | 354 | lock->fl.fl_flags &= ~FL_SLEEP; |
374 | again: | 355 | again: |
375 | /* Lock file against concurrent access */ | 356 | /* Lock file against concurrent access */ |
376 | down(&file->f_sema); | 357 | mutex_lock(&file->f_mutex); |
377 | /* Get existing block (in case client is busy-waiting) */ | 358 | /* Get existing block (in case client is busy-waiting) */ |
378 | block = nlmsvc_lookup_block(file, lock); | 359 | block = nlmsvc_lookup_block(file, lock); |
379 | if (block == NULL) { | 360 | if (block == NULL) { |
@@ -411,10 +392,10 @@ again: | |||
411 | 392 | ||
412 | /* If we don't have a block, create and initialize it. Then | 393 | /* If we don't have a block, create and initialize it. Then |
413 | * retry because we may have slept in kmalloc. */ | 394 | * retry because we may have slept in kmalloc. */ |
414 | /* We have to release f_sema as nlmsvc_create_block may try to | 395 | /* We have to release f_mutex as nlmsvc_create_block may try to |
415 | * to claim it while doing host garbage collection */ | 396 | * to claim it while doing host garbage collection */ |
416 | if (newblock == NULL) { | 397 | if (newblock == NULL) { |
417 | up(&file->f_sema); | 398 | mutex_unlock(&file->f_mutex); |
418 | dprintk("lockd: blocking on this lock (allocating).\n"); | 399 | dprintk("lockd: blocking on this lock (allocating).\n"); |
419 | if (!(newblock = nlmsvc_create_block(rqstp, file, lock, cookie))) | 400 | if (!(newblock = nlmsvc_create_block(rqstp, file, lock, cookie))) |
420 | return nlm_lck_denied_nolocks; | 401 | return nlm_lck_denied_nolocks; |
@@ -424,7 +405,7 @@ again: | |||
424 | /* Append to list of blocked */ | 405 | /* Append to list of blocked */ |
425 | nlmsvc_insert_block(newblock, NLM_NEVER); | 406 | nlmsvc_insert_block(newblock, NLM_NEVER); |
426 | out: | 407 | out: |
427 | up(&file->f_sema); | 408 | mutex_unlock(&file->f_mutex); |
428 | nlmsvc_release_block(newblock); | 409 | nlmsvc_release_block(newblock); |
429 | nlmsvc_release_block(block); | 410 | nlmsvc_release_block(block); |
430 | dprintk("lockd: nlmsvc_lock returned %u\n", ret); | 411 | dprintk("lockd: nlmsvc_lock returned %u\n", ret); |
@@ -451,6 +432,7 @@ nlmsvc_testlock(struct nlm_file *file, struct nlm_lock *lock, | |||
451 | (long long)conflock->fl.fl_start, | 432 | (long long)conflock->fl.fl_start, |
452 | (long long)conflock->fl.fl_end); | 433 | (long long)conflock->fl.fl_end); |
453 | conflock->caller = "somehost"; /* FIXME */ | 434 | conflock->caller = "somehost"; /* FIXME */ |
435 | conflock->len = strlen(conflock->caller); | ||
454 | conflock->oh.len = 0; /* don't return OH info */ | 436 | conflock->oh.len = 0; /* don't return OH info */ |
455 | conflock->svid = conflock->fl.fl_pid; | 437 | conflock->svid = conflock->fl.fl_pid; |
456 | return nlm_lck_denied; | 438 | return nlm_lck_denied; |
@@ -507,9 +489,9 @@ nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock) | |||
507 | (long long)lock->fl.fl_start, | 489 | (long long)lock->fl.fl_start, |
508 | (long long)lock->fl.fl_end); | 490 | (long long)lock->fl.fl_end); |
509 | 491 | ||
510 | down(&file->f_sema); | 492 | mutex_lock(&file->f_mutex); |
511 | block = nlmsvc_lookup_block(file, lock); | 493 | block = nlmsvc_lookup_block(file, lock); |
512 | up(&file->f_sema); | 494 | mutex_unlock(&file->f_mutex); |
513 | if (block != NULL) { | 495 | if (block != NULL) { |
514 | status = nlmsvc_unlink_block(block); | 496 | status = nlmsvc_unlink_block(block); |
515 | nlmsvc_release_block(block); | 497 | nlmsvc_release_block(block); |
@@ -527,10 +509,10 @@ nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock) | |||
527 | static void | 509 | static void |
528 | nlmsvc_notify_blocked(struct file_lock *fl) | 510 | nlmsvc_notify_blocked(struct file_lock *fl) |
529 | { | 511 | { |
530 | struct nlm_block **bp, *block; | 512 | struct nlm_block *block; |
531 | 513 | ||
532 | dprintk("lockd: VFS unblock notification for block %p\n", fl); | 514 | dprintk("lockd: VFS unblock notification for block %p\n", fl); |
533 | for (bp = &nlm_blocked; (block = *bp) != 0; bp = &block->b_next) { | 515 | list_for_each_entry(block, &nlm_blocked, b_list) { |
534 | if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) { | 516 | if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) { |
535 | nlmsvc_insert_block(block, 0); | 517 | nlmsvc_insert_block(block, 0); |
536 | svc_wake_up(block->b_daemon); | 518 | svc_wake_up(block->b_daemon); |
@@ -663,17 +645,14 @@ static const struct rpc_call_ops nlmsvc_grant_ops = { | |||
663 | * block. | 645 | * block. |
664 | */ | 646 | */ |
665 | void | 647 | void |
666 | nlmsvc_grant_reply(struct svc_rqst *rqstp, struct nlm_cookie *cookie, u32 status) | 648 | nlmsvc_grant_reply(struct nlm_cookie *cookie, u32 status) |
667 | { | 649 | { |
668 | struct nlm_block *block; | 650 | struct nlm_block *block; |
669 | struct nlm_file *file; | ||
670 | 651 | ||
671 | dprintk("grant_reply: looking for cookie %x, host (%08x), s=%d \n", | 652 | dprintk("grant_reply: looking for cookie %x, s=%d \n", |
672 | *(unsigned int *)(cookie->data), | 653 | *(unsigned int *)(cookie->data), status); |
673 | ntohl(rqstp->rq_addr.sin_addr.s_addr), status); | 654 | if (!(block = nlmsvc_find_block(cookie))) |
674 | if (!(block = nlmsvc_find_block(cookie, &rqstp->rq_addr))) | ||
675 | return; | 655 | return; |
676 | file = block->b_file; | ||
677 | 656 | ||
678 | if (block) { | 657 | if (block) { |
679 | if (status == NLM_LCK_DENIED_GRACE_PERIOD) { | 658 | if (status == NLM_LCK_DENIED_GRACE_PERIOD) { |
@@ -696,16 +675,19 @@ nlmsvc_grant_reply(struct svc_rqst *rqstp, struct nlm_cookie *cookie, u32 status | |||
696 | unsigned long | 675 | unsigned long |
697 | nlmsvc_retry_blocked(void) | 676 | nlmsvc_retry_blocked(void) |
698 | { | 677 | { |
699 | struct nlm_block *block; | 678 | unsigned long timeout = MAX_SCHEDULE_TIMEOUT; |
679 | struct nlm_block *block; | ||
680 | |||
681 | while (!list_empty(&nlm_blocked)) { | ||
682 | block = list_entry(nlm_blocked.next, struct nlm_block, b_list); | ||
700 | 683 | ||
701 | dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n", | ||
702 | nlm_blocked, | ||
703 | nlm_blocked? nlm_blocked->b_when : 0); | ||
704 | while ((block = nlm_blocked) != 0) { | ||
705 | if (block->b_when == NLM_NEVER) | 684 | if (block->b_when == NLM_NEVER) |
706 | break; | 685 | break; |
707 | if (time_after(block->b_when,jiffies)) | 686 | if (time_after(block->b_when,jiffies)) { |
687 | timeout = block->b_when - jiffies; | ||
708 | break; | 688 | break; |
689 | } | ||
690 | |||
709 | dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n", | 691 | dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n", |
710 | block, block->b_when); | 692 | block, block->b_when); |
711 | kref_get(&block->b_count); | 693 | kref_get(&block->b_count); |
@@ -713,8 +695,5 @@ nlmsvc_retry_blocked(void) | |||
713 | nlmsvc_release_block(block); | 695 | nlmsvc_release_block(block); |
714 | } | 696 | } |
715 | 697 | ||
716 | if ((block = nlm_blocked) && block->b_when != NLM_NEVER) | 698 | return timeout; |
717 | return (block->b_when - jiffies); | ||
718 | |||
719 | return MAX_SCHEDULE_TIMEOUT; | ||
720 | } | 699 | } |
diff --git a/fs/lockd/svcproc.c b/fs/lockd/svcproc.c index dbb66a3b5cd9..75b2c81bcb93 100644 --- a/fs/lockd/svcproc.c +++ b/fs/lockd/svcproc.c | |||
@@ -66,8 +66,8 @@ nlmsvc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp, | |||
66 | return nlm_lck_denied_nolocks; | 66 | return nlm_lck_denied_nolocks; |
67 | 67 | ||
68 | /* Obtain host handle */ | 68 | /* Obtain host handle */ |
69 | if (!(host = nlmsvc_lookup_host(rqstp)) | 69 | if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len)) |
70 | || (argp->monitor && !host->h_monitored && nsm_monitor(host) < 0)) | 70 | || (argp->monitor && nsm_monitor(host) < 0)) |
71 | goto no_locks; | 71 | goto no_locks; |
72 | *hostp = host; | 72 | *hostp = host; |
73 | 73 | ||
@@ -287,7 +287,9 @@ static int nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *ar | |||
287 | struct nlm_rqst *call; | 287 | struct nlm_rqst *call; |
288 | int stat; | 288 | int stat; |
289 | 289 | ||
290 | host = nlmsvc_lookup_host(rqstp); | 290 | host = nlmsvc_lookup_host(rqstp, |
291 | argp->lock.caller, | ||
292 | argp->lock.len); | ||
291 | if (host == NULL) | 293 | if (host == NULL) |
292 | return rpc_system_err; | 294 | return rpc_system_err; |
293 | 295 | ||
@@ -449,9 +451,6 @@ nlmsvc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp, | |||
449 | void *resp) | 451 | void *resp) |
450 | { | 452 | { |
451 | struct sockaddr_in saddr = rqstp->rq_addr; | 453 | struct sockaddr_in saddr = rqstp->rq_addr; |
452 | int vers = argp->vers; | ||
453 | int prot = argp->proto >> 1; | ||
454 | struct nlm_host *host; | ||
455 | 454 | ||
456 | dprintk("lockd: SM_NOTIFY called\n"); | 455 | dprintk("lockd: SM_NOTIFY called\n"); |
457 | if (saddr.sin_addr.s_addr != htonl(INADDR_LOOPBACK) | 456 | if (saddr.sin_addr.s_addr != htonl(INADDR_LOOPBACK) |
@@ -466,19 +465,9 @@ nlmsvc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp, | |||
466 | /* Obtain the host pointer for this NFS server and try to | 465 | /* Obtain the host pointer for this NFS server and try to |
467 | * reclaim all locks we hold on this server. | 466 | * reclaim all locks we hold on this server. |
468 | */ | 467 | */ |
468 | memset(&saddr, 0, sizeof(saddr)); | ||
469 | saddr.sin_addr.s_addr = argp->addr; | 469 | saddr.sin_addr.s_addr = argp->addr; |
470 | if ((argp->proto & 1)==0) { | 470 | nlm_host_rebooted(&saddr, argp->mon, argp->len, argp->state); |
471 | if ((host = nlmclnt_lookup_host(&saddr, prot, vers)) != NULL) { | ||
472 | nlmclnt_recovery(host, argp->state); | ||
473 | nlm_release_host(host); | ||
474 | } | ||
475 | } else { | ||
476 | /* If we run on an NFS server, delete all locks held by the client */ | ||
477 | if ((host = nlm_lookup_host(1, &saddr, prot, vers)) != NULL) { | ||
478 | nlmsvc_free_host_resources(host); | ||
479 | nlm_release_host(host); | ||
480 | } | ||
481 | } | ||
482 | 471 | ||
483 | return rpc_success; | 472 | return rpc_success; |
484 | } | 473 | } |
@@ -495,7 +484,7 @@ nlmsvc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res *argp, | |||
495 | 484 | ||
496 | dprintk("lockd: GRANTED_RES called\n"); | 485 | dprintk("lockd: GRANTED_RES called\n"); |
497 | 486 | ||
498 | nlmsvc_grant_reply(rqstp, &argp->cookie, argp->status); | 487 | nlmsvc_grant_reply(&argp->cookie, argp->status); |
499 | return rpc_success; | 488 | return rpc_success; |
500 | } | 489 | } |
501 | 490 | ||
diff --git a/fs/lockd/svcshare.c b/fs/lockd/svcshare.c index 27288c83da96..b9926ce8782e 100644 --- a/fs/lockd/svcshare.c +++ b/fs/lockd/svcshare.c | |||
@@ -85,24 +85,20 @@ nlmsvc_unshare_file(struct nlm_host *host, struct nlm_file *file, | |||
85 | } | 85 | } |
86 | 86 | ||
87 | /* | 87 | /* |
88 | * Traverse all shares for a given file (and host). | 88 | * Traverse all shares for a given file, and delete |
89 | * NLM_ACT_CHECK is handled by nlmsvc_inspect_file. | 89 | * those owned by the given (type of) host |
90 | */ | 90 | */ |
91 | void | 91 | void nlmsvc_traverse_shares(struct nlm_host *host, struct nlm_file *file, |
92 | nlmsvc_traverse_shares(struct nlm_host *host, struct nlm_file *file, int action) | 92 | nlm_host_match_fn_t match) |
93 | { | 93 | { |
94 | struct nlm_share *share, **shpp; | 94 | struct nlm_share *share, **shpp; |
95 | 95 | ||
96 | shpp = &file->f_shares; | 96 | shpp = &file->f_shares; |
97 | while ((share = *shpp) != NULL) { | 97 | while ((share = *shpp) != NULL) { |
98 | if (action == NLM_ACT_MARK) | 98 | if (match(share->s_host, host)) { |
99 | share->s_host->h_inuse = 1; | 99 | *shpp = share->s_next; |
100 | else if (action == NLM_ACT_UNLOCK) { | 100 | kfree(share); |
101 | if (host == NULL || host == share->s_host) { | 101 | continue; |
102 | *shpp = share->s_next; | ||
103 | kfree(share); | ||
104 | continue; | ||
105 | } | ||
106 | } | 102 | } |
107 | shpp = &share->s_next; | 103 | shpp = &share->s_next; |
108 | } | 104 | } |
diff --git a/fs/lockd/svcsubs.c b/fs/lockd/svcsubs.c index a92dd98f8401..514f5f20701e 100644 --- a/fs/lockd/svcsubs.c +++ b/fs/lockd/svcsubs.c | |||
@@ -25,9 +25,9 @@ | |||
25 | /* | 25 | /* |
26 | * Global file hash table | 26 | * Global file hash table |
27 | */ | 27 | */ |
28 | #define FILE_HASH_BITS 5 | 28 | #define FILE_HASH_BITS 7 |
29 | #define FILE_NRHASH (1<<FILE_HASH_BITS) | 29 | #define FILE_NRHASH (1<<FILE_HASH_BITS) |
30 | static struct nlm_file * nlm_files[FILE_NRHASH]; | 30 | static struct hlist_head nlm_files[FILE_NRHASH]; |
31 | static DEFINE_MUTEX(nlm_file_mutex); | 31 | static DEFINE_MUTEX(nlm_file_mutex); |
32 | 32 | ||
33 | #ifdef NFSD_DEBUG | 33 | #ifdef NFSD_DEBUG |
@@ -82,6 +82,7 @@ u32 | |||
82 | nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result, | 82 | nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result, |
83 | struct nfs_fh *f) | 83 | struct nfs_fh *f) |
84 | { | 84 | { |
85 | struct hlist_node *pos; | ||
85 | struct nlm_file *file; | 86 | struct nlm_file *file; |
86 | unsigned int hash; | 87 | unsigned int hash; |
87 | u32 nfserr; | 88 | u32 nfserr; |
@@ -93,7 +94,7 @@ nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result, | |||
93 | /* Lock file table */ | 94 | /* Lock file table */ |
94 | mutex_lock(&nlm_file_mutex); | 95 | mutex_lock(&nlm_file_mutex); |
95 | 96 | ||
96 | for (file = nlm_files[hash]; file; file = file->f_next) | 97 | hlist_for_each_entry(file, pos, &nlm_files[hash], f_list) |
97 | if (!nfs_compare_fh(&file->f_handle, f)) | 98 | if (!nfs_compare_fh(&file->f_handle, f)) |
98 | goto found; | 99 | goto found; |
99 | 100 | ||
@@ -105,8 +106,9 @@ nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result, | |||
105 | goto out_unlock; | 106 | goto out_unlock; |
106 | 107 | ||
107 | memcpy(&file->f_handle, f, sizeof(struct nfs_fh)); | 108 | memcpy(&file->f_handle, f, sizeof(struct nfs_fh)); |
108 | file->f_hash = hash; | 109 | mutex_init(&file->f_mutex); |
109 | init_MUTEX(&file->f_sema); | 110 | INIT_HLIST_NODE(&file->f_list); |
111 | INIT_LIST_HEAD(&file->f_blocks); | ||
110 | 112 | ||
111 | /* Open the file. Note that this must not sleep for too long, else | 113 | /* Open the file. Note that this must not sleep for too long, else |
112 | * we would lock up lockd:-) So no NFS re-exports, folks. | 114 | * we would lock up lockd:-) So no NFS re-exports, folks. |
@@ -115,12 +117,11 @@ nlm_lookup_file(struct svc_rqst *rqstp, struct nlm_file **result, | |||
115 | * the file. | 117 | * the file. |
116 | */ | 118 | */ |
117 | if ((nfserr = nlmsvc_ops->fopen(rqstp, f, &file->f_file)) != 0) { | 119 | if ((nfserr = nlmsvc_ops->fopen(rqstp, f, &file->f_file)) != 0) { |
118 | dprintk("lockd: open failed (nfserr %d)\n", ntohl(nfserr)); | 120 | dprintk("lockd: open failed (error %d)\n", nfserr); |
119 | goto out_free; | 121 | goto out_free; |
120 | } | 122 | } |
121 | 123 | ||
122 | file->f_next = nlm_files[hash]; | 124 | hlist_add_head(&file->f_list, &nlm_files[hash]); |
123 | nlm_files[hash] = file; | ||
124 | 125 | ||
125 | found: | 126 | found: |
126 | dprintk("lockd: found file %p (count %d)\n", file, file->f_count); | 127 | dprintk("lockd: found file %p (count %d)\n", file, file->f_count); |
@@ -149,22 +150,14 @@ out_free: | |||
149 | static inline void | 150 | static inline void |
150 | nlm_delete_file(struct nlm_file *file) | 151 | nlm_delete_file(struct nlm_file *file) |
151 | { | 152 | { |
152 | struct nlm_file **fp, *f; | ||
153 | |||
154 | nlm_debug_print_file("closing file", file); | 153 | nlm_debug_print_file("closing file", file); |
155 | 154 | if (!hlist_unhashed(&file->f_list)) { | |
156 | fp = nlm_files + file->f_hash; | 155 | hlist_del(&file->f_list); |
157 | while ((f = *fp) != NULL) { | 156 | nlmsvc_ops->fclose(file->f_file); |
158 | if (f == file) { | 157 | kfree(file); |
159 | *fp = file->f_next; | 158 | } else { |
160 | nlmsvc_ops->fclose(file->f_file); | 159 | printk(KERN_WARNING "lockd: attempt to release unknown file!\n"); |
161 | kfree(file); | ||
162 | return; | ||
163 | } | ||
164 | fp = &f->f_next; | ||
165 | } | 160 | } |
166 | |||
167 | printk(KERN_WARNING "lockd: attempt to release unknown file!\n"); | ||
168 | } | 161 | } |
169 | 162 | ||
170 | /* | 163 | /* |
@@ -172,7 +165,8 @@ nlm_delete_file(struct nlm_file *file) | |||
172 | * action. | 165 | * action. |
173 | */ | 166 | */ |
174 | static int | 167 | static int |
175 | nlm_traverse_locks(struct nlm_host *host, struct nlm_file *file, int action) | 168 | nlm_traverse_locks(struct nlm_host *host, struct nlm_file *file, |
169 | nlm_host_match_fn_t match) | ||
176 | { | 170 | { |
177 | struct inode *inode = nlmsvc_file_inode(file); | 171 | struct inode *inode = nlmsvc_file_inode(file); |
178 | struct file_lock *fl; | 172 | struct file_lock *fl; |
@@ -186,17 +180,11 @@ again: | |||
186 | 180 | ||
187 | /* update current lock count */ | 181 | /* update current lock count */ |
188 | file->f_locks++; | 182 | file->f_locks++; |
183 | |||
189 | lockhost = (struct nlm_host *) fl->fl_owner; | 184 | lockhost = (struct nlm_host *) fl->fl_owner; |
190 | if (action == NLM_ACT_MARK) | 185 | if (match(lockhost, host)) { |
191 | lockhost->h_inuse = 1; | ||
192 | else if (action == NLM_ACT_CHECK) | ||
193 | return 1; | ||
194 | else if (action == NLM_ACT_UNLOCK) { | ||
195 | struct file_lock lock = *fl; | 186 | struct file_lock lock = *fl; |
196 | 187 | ||
197 | if (host && lockhost != host) | ||
198 | continue; | ||
199 | |||
200 | lock.fl_type = F_UNLCK; | 188 | lock.fl_type = F_UNLCK; |
201 | lock.fl_start = 0; | 189 | lock.fl_start = 0; |
202 | lock.fl_end = OFFSET_MAX; | 190 | lock.fl_end = OFFSET_MAX; |
@@ -213,53 +201,66 @@ again: | |||
213 | } | 201 | } |
214 | 202 | ||
215 | /* | 203 | /* |
216 | * Operate on a single file | 204 | * Inspect a single file |
217 | */ | 205 | */ |
218 | static inline int | 206 | static inline int |
219 | nlm_inspect_file(struct nlm_host *host, struct nlm_file *file, int action) | 207 | nlm_inspect_file(struct nlm_host *host, struct nlm_file *file, nlm_host_match_fn_t match) |
220 | { | 208 | { |
221 | if (action == NLM_ACT_CHECK) { | 209 | nlmsvc_traverse_blocks(host, file, match); |
222 | /* Fast path for mark and sweep garbage collection */ | 210 | nlmsvc_traverse_shares(host, file, match); |
223 | if (file->f_count || file->f_blocks || file->f_shares) | 211 | return nlm_traverse_locks(host, file, match); |
212 | } | ||
213 | |||
214 | /* | ||
215 | * Quick check whether there are still any locks, blocks or | ||
216 | * shares on a given file. | ||
217 | */ | ||
218 | static inline int | ||
219 | nlm_file_inuse(struct nlm_file *file) | ||
220 | { | ||
221 | struct inode *inode = nlmsvc_file_inode(file); | ||
222 | struct file_lock *fl; | ||
223 | |||
224 | if (file->f_count || !list_empty(&file->f_blocks) || file->f_shares) | ||
225 | return 1; | ||
226 | |||
227 | for (fl = inode->i_flock; fl; fl = fl->fl_next) { | ||
228 | if (fl->fl_lmops == &nlmsvc_lock_operations) | ||
224 | return 1; | 229 | return 1; |
225 | } else { | ||
226 | nlmsvc_traverse_blocks(host, file, action); | ||
227 | nlmsvc_traverse_shares(host, file, action); | ||
228 | } | 230 | } |
229 | return nlm_traverse_locks(host, file, action); | 231 | file->f_locks = 0; |
232 | return 0; | ||
230 | } | 233 | } |
231 | 234 | ||
232 | /* | 235 | /* |
233 | * Loop over all files in the file table. | 236 | * Loop over all files in the file table. |
234 | */ | 237 | */ |
235 | static int | 238 | static int |
236 | nlm_traverse_files(struct nlm_host *host, int action) | 239 | nlm_traverse_files(struct nlm_host *host, nlm_host_match_fn_t match) |
237 | { | 240 | { |
238 | struct nlm_file *file, **fp; | 241 | struct hlist_node *pos, *next; |
242 | struct nlm_file *file; | ||
239 | int i, ret = 0; | 243 | int i, ret = 0; |
240 | 244 | ||
241 | mutex_lock(&nlm_file_mutex); | 245 | mutex_lock(&nlm_file_mutex); |
242 | for (i = 0; i < FILE_NRHASH; i++) { | 246 | for (i = 0; i < FILE_NRHASH; i++) { |
243 | fp = nlm_files + i; | 247 | hlist_for_each_entry_safe(file, pos, next, &nlm_files[i], f_list) { |
244 | while ((file = *fp) != NULL) { | ||
245 | file->f_count++; | 248 | file->f_count++; |
246 | mutex_unlock(&nlm_file_mutex); | 249 | mutex_unlock(&nlm_file_mutex); |
247 | 250 | ||
248 | /* Traverse locks, blocks and shares of this file | 251 | /* Traverse locks, blocks and shares of this file |
249 | * and update file->f_locks count */ | 252 | * and update file->f_locks count */ |
250 | if (nlm_inspect_file(host, file, action)) | 253 | if (nlm_inspect_file(host, file, match)) |
251 | ret = 1; | 254 | ret = 1; |
252 | 255 | ||
253 | mutex_lock(&nlm_file_mutex); | 256 | mutex_lock(&nlm_file_mutex); |
254 | file->f_count--; | 257 | file->f_count--; |
255 | /* No more references to this file. Let go of it. */ | 258 | /* No more references to this file. Let go of it. */ |
256 | if (!file->f_blocks && !file->f_locks | 259 | if (list_empty(&file->f_blocks) && !file->f_locks |
257 | && !file->f_shares && !file->f_count) { | 260 | && !file->f_shares && !file->f_count) { |
258 | *fp = file->f_next; | 261 | hlist_del(&file->f_list); |
259 | nlmsvc_ops->fclose(file->f_file); | 262 | nlmsvc_ops->fclose(file->f_file); |
260 | kfree(file); | 263 | kfree(file); |
261 | } else { | ||
262 | fp = &file->f_next; | ||
263 | } | 264 | } |
264 | } | 265 | } |
265 | } | 266 | } |
@@ -286,23 +287,54 @@ nlm_release_file(struct nlm_file *file) | |||
286 | mutex_lock(&nlm_file_mutex); | 287 | mutex_lock(&nlm_file_mutex); |
287 | 288 | ||
288 | /* If there are no more locks etc, delete the file */ | 289 | /* If there are no more locks etc, delete the file */ |
289 | if(--file->f_count == 0) { | 290 | if (--file->f_count == 0 && !nlm_file_inuse(file)) |
290 | if(!nlm_inspect_file(NULL, file, NLM_ACT_CHECK)) | 291 | nlm_delete_file(file); |
291 | nlm_delete_file(file); | ||
292 | } | ||
293 | 292 | ||
294 | mutex_unlock(&nlm_file_mutex); | 293 | mutex_unlock(&nlm_file_mutex); |
295 | } | 294 | } |
296 | 295 | ||
297 | /* | 296 | /* |
297 | * Helpers function for resource traversal | ||
298 | * | ||
299 | * nlmsvc_mark_host: | ||
300 | * used by the garbage collector; simply sets h_inuse. | ||
301 | * Always returns 0. | ||
302 | * | ||
303 | * nlmsvc_same_host: | ||
304 | * returns 1 iff the two hosts match. Used to release | ||
305 | * all resources bound to a specific host. | ||
306 | * | ||
307 | * nlmsvc_is_client: | ||
308 | * returns 1 iff the host is a client. | ||
309 | * Used by nlmsvc_invalidate_all | ||
310 | */ | ||
311 | static int | ||
312 | nlmsvc_mark_host(struct nlm_host *host, struct nlm_host *dummy) | ||
313 | { | ||
314 | host->h_inuse = 1; | ||
315 | return 0; | ||
316 | } | ||
317 | |||
318 | static int | ||
319 | nlmsvc_same_host(struct nlm_host *host, struct nlm_host *other) | ||
320 | { | ||
321 | return host == other; | ||
322 | } | ||
323 | |||
324 | static int | ||
325 | nlmsvc_is_client(struct nlm_host *host, struct nlm_host *dummy) | ||
326 | { | ||
327 | return host->h_server; | ||
328 | } | ||
329 | |||
330 | /* | ||
298 | * Mark all hosts that still hold resources | 331 | * Mark all hosts that still hold resources |
299 | */ | 332 | */ |
300 | void | 333 | void |
301 | nlmsvc_mark_resources(void) | 334 | nlmsvc_mark_resources(void) |
302 | { | 335 | { |
303 | dprintk("lockd: nlmsvc_mark_resources\n"); | 336 | dprintk("lockd: nlmsvc_mark_resources\n"); |
304 | 337 | nlm_traverse_files(NULL, nlmsvc_mark_host); | |
305 | nlm_traverse_files(NULL, NLM_ACT_MARK); | ||
306 | } | 338 | } |
307 | 339 | ||
308 | /* | 340 | /* |
@@ -313,23 +345,25 @@ nlmsvc_free_host_resources(struct nlm_host *host) | |||
313 | { | 345 | { |
314 | dprintk("lockd: nlmsvc_free_host_resources\n"); | 346 | dprintk("lockd: nlmsvc_free_host_resources\n"); |
315 | 347 | ||
316 | if (nlm_traverse_files(host, NLM_ACT_UNLOCK)) | 348 | if (nlm_traverse_files(host, nlmsvc_same_host)) { |
317 | printk(KERN_WARNING | 349 | printk(KERN_WARNING |
318 | "lockd: couldn't remove all locks held by %s", | 350 | "lockd: couldn't remove all locks held by %s\n", |
319 | host->h_name); | 351 | host->h_name); |
352 | BUG(); | ||
353 | } | ||
320 | } | 354 | } |
321 | 355 | ||
322 | /* | 356 | /* |
323 | * delete all hosts structs for clients | 357 | * Remove all locks held for clients |
324 | */ | 358 | */ |
325 | void | 359 | void |
326 | nlmsvc_invalidate_all(void) | 360 | nlmsvc_invalidate_all(void) |
327 | { | 361 | { |
328 | struct nlm_host *host; | 362 | /* Release all locks held by NFS clients. |
329 | while ((host = nlm_find_client()) != NULL) { | 363 | * Previously, the code would call |
330 | nlmsvc_free_host_resources(host); | 364 | * nlmsvc_free_host_resources for each client in |
331 | host->h_expires = 0; | 365 | * turn, which is about as inefficient as it gets. |
332 | host->h_killed = 1; | 366 | * Now we just do it once in nlm_traverse_files. |
333 | nlm_release_host(host); | 367 | */ |
334 | } | 368 | nlm_traverse_files(NULL, nlmsvc_is_client); |
335 | } | 369 | } |