]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/nfsd/nfs4recover.c
sched, cleanup, treewide: Remove set_current_state(TASK_RUNNING) after schedule()
[mirror_ubuntu-bionic-kernel.git] / fs / nfsd / nfs4recover.c
CommitLineData
a55370a3 1/*
a55370a3 2* Copyright (c) 2004 The Regents of the University of Michigan.
f3f80148 3* Copyright (c) 2012 Jeff Layton <jlayton@redhat.com>
a55370a3
N
4* All rights reserved.
5*
6* Andy Adamson <andros@citi.umich.edu>
7*
8* Redistribution and use in source and binary forms, with or without
9* modification, are permitted provided that the following conditions
10* are met:
11*
12* 1. Redistributions of source code must retain the above copyright
13* notice, this list of conditions and the following disclaimer.
14* 2. Redistributions in binary form must reproduce the above copyright
15* notice, this list of conditions and the following disclaimer in the
16* documentation and/or other materials provided with the distribution.
17* 3. Neither the name of the University nor the names of its
18* contributors may be used to endorse or promote products derived
19* from this software without specific prior written permission.
20*
21* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
22* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32*
33*/
34
190e4fbf 35#include <linux/file.h>
5a0e3ad6 36#include <linux/slab.h>
190e4fbf 37#include <linux/namei.h>
a55370a3 38#include <linux/crypto.h>
e8edc6e0 39#include <linux/sched.h>
f3f80148 40#include <linux/fs.h>
813fd320 41#include <linux/module.h>
f3f80148
JL
42#include <net/net_namespace.h>
43#include <linux/sunrpc/rpc_pipe_fs.h>
44#include <linux/sunrpc/clnt.h>
45#include <linux/nfsd/cld.h>
9a74af21
BH
46
47#include "nfsd.h"
48#include "state.h"
0a3adade 49#include "vfs.h"
f3f80148 50#include "netns.h"
a55370a3
N
51
52#define NFSDDBG_FACILITY NFSDDBG_PROC
53
2a4317c5
JL
54/* Declarations */
55struct nfsd4_client_tracking_ops {
56 int (*init)(struct net *);
57 void (*exit)(struct net *);
58 void (*create)(struct nfs4_client *);
59 void (*remove)(struct nfs4_client *);
60 int (*check)(struct nfs4_client *);
12760c66 61 void (*grace_done)(struct nfsd_net *, time_t);
2a4317c5
JL
62};
63
190e4fbf 64/* Globals */
48483bf2 65static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
190e4fbf 66
d84f4f99
DH
67static int
68nfs4_save_creds(const struct cred **original_creds)
190e4fbf 69{
d84f4f99
DH
70 struct cred *new;
71
72 new = prepare_creds();
73 if (!new)
74 return -ENOMEM;
75
6fab8779
EB
76 new->fsuid = GLOBAL_ROOT_UID;
77 new->fsgid = GLOBAL_ROOT_GID;
d84f4f99
DH
78 *original_creds = override_creds(new);
79 put_cred(new);
80 return 0;
190e4fbf
N
81}
82
83static void
d84f4f99 84nfs4_reset_creds(const struct cred *original)
190e4fbf 85{
d84f4f99 86 revert_creds(original);
190e4fbf
N
87}
88
a55370a3
N
89static void
90md5_to_hex(char *out, char *md5)
91{
92 int i;
93
94 for (i=0; i<16; i++) {
95 unsigned char c = md5[i];
96
97 *out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);
98 *out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);
99 }
100 *out = '\0';
101}
102
2216d449
JL
103static int
104nfs4_make_rec_clidname(char *dname, const struct xdr_netobj *clname)
a55370a3
N
105{
106 struct xdr_netobj cksum;
35058687 107 struct hash_desc desc;
60c74f81 108 struct scatterlist sg;
2216d449 109 int status;
a55370a3
N
110
111 dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n",
112 clname->len, clname->data);
35058687
HX
113 desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
114 desc.tfm = crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC);
2216d449
JL
115 if (IS_ERR(desc.tfm)) {
116 status = PTR_ERR(desc.tfm);
35058687 117 goto out_no_tfm;
2216d449
JL
118 }
119
35058687 120 cksum.len = crypto_hash_digestsize(desc.tfm);
a55370a3 121 cksum.data = kmalloc(cksum.len, GFP_KERNEL);
2216d449
JL
122 if (cksum.data == NULL) {
123 status = -ENOMEM;
a55370a3 124 goto out;
2216d449 125 }
a55370a3 126
60c74f81 127 sg_init_one(&sg, clname->data, clname->len);
a55370a3 128
2216d449
JL
129 status = crypto_hash_digest(&desc, &sg, sg.length, cksum.data);
130 if (status)
35058687 131 goto out;
a55370a3
N
132
133 md5_to_hex(dname, cksum.data);
134
2216d449 135 status = 0;
a55370a3 136out:
2bd9e7b6 137 kfree(cksum.data);
35058687
HX
138 crypto_free_hash(desc.tfm);
139out_no_tfm:
a55370a3
N
140 return status;
141}
190e4fbf 142
2216d449
JL
143/*
144 * If we had an error generating the recdir name for the legacy tracker
145 * then warn the admin. If the error doesn't appear to be transient,
146 * then disable recovery tracking.
147 */
148static void
7255e716 149legacy_recdir_name_error(struct nfs4_client *clp, int error)
2216d449
JL
150{
151 printk(KERN_ERR "NFSD: unable to generate recoverydir "
152 "name (%d).\n", error);
153
154 /*
155 * if the algorithm just doesn't exist, then disable the recovery
156 * tracker altogether. The crypto libs will generally return this if
157 * FIPS is enabled as well.
158 */
159 if (error == -ENOENT) {
160 printk(KERN_ERR "NFSD: disabling legacy clientid tracking. "
161 "Reboot recovery will not function correctly!\n");
7255e716 162 nfsd4_client_tracking_exit(clp->net);
2216d449
JL
163 }
164}
165
2a4317c5
JL
166static void
167nfsd4_create_clid_dir(struct nfs4_client *clp)
c7b9a459 168{
d84f4f99 169 const struct cred *original_cred;
2216d449 170 char dname[HEXDIR_LEN];
e970a573 171 struct dentry *dir, *dentry;
0ce0c2b5 172 struct nfs4_client_reclaim *crp;
c7b9a459 173 int status;
52e19c09 174 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
c7b9a459 175
a52d726b 176 if (test_and_set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
7a6ef8c7 177 return;
3a073369 178 if (!nn->rec_file)
7a6ef8c7 179 return;
2216d449
JL
180
181 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
182 if (status)
7255e716 183 return legacy_recdir_name_error(clp, status);
2216d449 184
d84f4f99
DH
185 status = nfs4_save_creds(&original_cred);
186 if (status < 0)
7a6ef8c7 187 return;
c7b9a459 188
3a073369 189 status = mnt_want_write_file(nn->rec_file);
4a55c101
JK
190 if (status)
191 return;
192
3a073369 193 dir = nn->rec_file->f_path.dentry;
c7b9a459 194 /* lock the parent */
e970a573 195 mutex_lock(&dir->d_inode->i_mutex);
c7b9a459 196
e970a573 197 dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
c7b9a459
N
198 if (IS_ERR(dentry)) {
199 status = PTR_ERR(dentry);
200 goto out_unlock;
201 }
6577aac0 202 if (dentry->d_inode)
aec39680
BF
203 /*
204 * In the 4.1 case, where we're called from
205 * reclaim_complete(), records from the previous reboot
206 * may still be left, so this is OK.
207 *
208 * In the 4.0 case, we should never get here; but we may
209 * as well be forgiving and just succeed silently.
210 */
c7b9a459 211 goto out_put;
e970a573 212 status = vfs_mkdir(dir->d_inode, dentry, S_IRWXU);
c7b9a459
N
213out_put:
214 dput(dentry);
215out_unlock:
e970a573 216 mutex_unlock(&dir->d_inode->i_mutex);
0ce0c2b5 217 if (status == 0) {
f141f79d 218 if (nn->in_grace) {
52e19c09 219 crp = nfs4_client_to_reclaim(dname, nn);
0ce0c2b5
JL
220 if (crp)
221 crp->cr_clp = clp;
222 }
3a073369 223 vfs_fsync(nn->rec_file, 0);
0ce0c2b5 224 } else {
6577aac0
BH
225 printk(KERN_ERR "NFSD: failed to write recovery record"
226 " (err %d); please check that %s exists"
227 " and is writeable", status,
228 user_recovery_dirname);
0ce0c2b5 229 }
3a073369 230 mnt_drop_write_file(nn->rec_file);
d84f4f99 231 nfs4_reset_creds(original_cred);
c7b9a459
N
232}
233
52e19c09 234typedef int (recdir_func)(struct dentry *, struct dentry *, struct nfsd_net *);
190e4fbf 235
05f4f678
BF
236struct name_list {
237 char name[HEXDIR_LEN];
190e4fbf
N
238 struct list_head list;
239};
240
bb6f619b
AV
241struct nfs4_dir_ctx {
242 struct dir_context ctx;
243 struct list_head names;
244};
245
190e4fbf 246static int
05f4f678 247nfsd4_build_namelist(void *arg, const char *name, int namlen,
afefdbb2 248 loff_t offset, u64 ino, unsigned int d_type)
190e4fbf 249{
bb6f619b 250 struct nfs4_dir_ctx *ctx = arg;
05f4f678 251 struct name_list *entry;
190e4fbf 252
05f4f678 253 if (namlen != HEXDIR_LEN - 1)
b37ad28b 254 return 0;
05f4f678
BF
255 entry = kmalloc(sizeof(struct name_list), GFP_KERNEL);
256 if (entry == NULL)
190e4fbf 257 return -ENOMEM;
05f4f678
BF
258 memcpy(entry->name, name, HEXDIR_LEN - 1);
259 entry->name[HEXDIR_LEN - 1] = '\0';
bb6f619b 260 list_add(&entry->list, &ctx->names);
190e4fbf
N
261 return 0;
262}
263
264static int
52e19c09 265nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
190e4fbf 266{
d84f4f99 267 const struct cred *original_cred;
3a073369 268 struct dentry *dir = nn->rec_file->f_path.dentry;
ac6614b7
AV
269 struct nfs4_dir_ctx ctx = {
270 .ctx.actor = nfsd4_build_namelist,
271 .names = LIST_HEAD_INIT(ctx.names)
272 };
190e4fbf
N
273 int status;
274
d84f4f99
DH
275 status = nfs4_save_creds(&original_cred);
276 if (status < 0)
277 return status;
190e4fbf 278
3a073369 279 status = vfs_llseek(nn->rec_file, 0, SEEK_SET);
5b4b299c
AV
280 if (status < 0) {
281 nfs4_reset_creds(original_cred);
282 return status;
283 }
284
5c0ba4e0 285 status = iterate_dir(nn->rec_file, &ctx.ctx);
8daed1e5 286 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
5c0ba4e0 287 while (!list_empty(&ctx.names)) {
5b4b299c 288 struct name_list *entry;
5c0ba4e0 289 entry = list_entry(ctx.names.next, struct name_list, list);
5b4b299c
AV
290 if (!status) {
291 struct dentry *dentry;
292 dentry = lookup_one_len(entry->name, dir, HEXDIR_LEN-1);
293 if (IS_ERR(dentry)) {
294 status = PTR_ERR(dentry);
295 break;
296 }
52e19c09 297 status = f(dir, dentry, nn);
5b4b299c 298 dput(dentry);
05f4f678 299 }
05f4f678
BF
300 list_del(&entry->list);
301 kfree(entry);
190e4fbf 302 }
2f9092e1 303 mutex_unlock(&dir->d_inode->i_mutex);
d84f4f99 304 nfs4_reset_creds(original_cred);
190e4fbf
N
305 return status;
306}
307
c7b9a459 308static int
3a073369 309nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn)
c7b9a459 310{
e970a573 311 struct dentry *dir, *dentry;
c7b9a459
N
312 int status;
313
314 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
315
3a073369 316 dir = nn->rec_file->f_path.dentry;
e970a573
CH
317 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
318 dentry = lookup_one_len(name, dir, namlen);
c7b9a459
N
319 if (IS_ERR(dentry)) {
320 status = PTR_ERR(dentry);
2f9092e1 321 goto out_unlock;
c7b9a459
N
322 }
323 status = -ENOENT;
324 if (!dentry->d_inode)
325 goto out;
e970a573 326 status = vfs_rmdir(dir->d_inode, dentry);
c7b9a459
N
327out:
328 dput(dentry);
2f9092e1 329out_unlock:
e970a573 330 mutex_unlock(&dir->d_inode->i_mutex);
c7b9a459
N
331 return status;
332}
333
2a4317c5 334static void
c7b9a459
N
335nfsd4_remove_clid_dir(struct nfs4_client *clp)
336{
d84f4f99 337 const struct cred *original_cred;
0ce0c2b5 338 struct nfs4_client_reclaim *crp;
2216d449 339 char dname[HEXDIR_LEN];
c7b9a459 340 int status;
52e19c09 341 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
c7b9a459 342
3a073369 343 if (!nn->rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
c7b9a459
N
344 return;
345
2216d449
JL
346 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
347 if (status)
7255e716 348 return legacy_recdir_name_error(clp, status);
2216d449 349
3a073369 350 status = mnt_want_write_file(nn->rec_file);
0622753b
DH
351 if (status)
352 goto out;
a52d726b 353 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
d84f4f99
DH
354
355 status = nfs4_save_creds(&original_cred);
356 if (status < 0)
698d8d87 357 goto out_drop_write;
d84f4f99 358
3a073369 359 status = nfsd4_unlink_clid_dir(dname, HEXDIR_LEN-1, nn);
d84f4f99 360 nfs4_reset_creds(original_cred);
0ce0c2b5 361 if (status == 0) {
3a073369 362 vfs_fsync(nn->rec_file, 0);
f141f79d 363 if (nn->in_grace) {
0ce0c2b5 364 /* remove reclaim record */
52e19c09 365 crp = nfsd4_find_reclaim_client(dname, nn);
0ce0c2b5 366 if (crp)
52e19c09 367 nfs4_remove_reclaim_record(crp, nn);
0ce0c2b5
JL
368 }
369 }
698d8d87 370out_drop_write:
3a073369 371 mnt_drop_write_file(nn->rec_file);
0622753b 372out:
c7b9a459
N
373 if (status)
374 printk("NFSD: Failed to remove expired client state directory"
2216d449 375 " %.*s\n", HEXDIR_LEN, dname);
c7b9a459
N
376}
377
378static int
52e19c09 379purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
c7b9a459
N
380{
381 int status;
382
52e19c09 383 if (nfs4_has_reclaimed_state(child->d_name.name, nn))
b37ad28b 384 return 0;
c7b9a459 385
2f9092e1 386 status = vfs_rmdir(parent->d_inode, child);
c7b9a459 387 if (status)
a6a9f18f
AV
388 printk("failed to remove client recovery directory %pd\n",
389 child);
c7b9a459 390 /* Keep trying, success or failure: */
b37ad28b 391 return 0;
c7b9a459
N
392}
393
2a4317c5 394static void
12760c66 395nfsd4_recdir_purge_old(struct nfsd_net *nn, time_t boot_time)
2a4317c5 396{
c7b9a459
N
397 int status;
398
f141f79d 399 nn->in_grace = false;
3a073369 400 if (!nn->rec_file)
c7b9a459 401 return;
3a073369 402 status = mnt_want_write_file(nn->rec_file);
0622753b
DH
403 if (status)
404 goto out;
52e19c09 405 status = nfsd4_list_rec_dir(purge_old, nn);
c7b9a459 406 if (status == 0)
3a073369
SK
407 vfs_fsync(nn->rec_file, 0);
408 mnt_drop_write_file(nn->rec_file);
0622753b 409out:
52e19c09 410 nfs4_release_reclaim(nn);
c7b9a459
N
411 if (status)
412 printk("nfsd4: failed to purge old clients from recovery"
a6a9f18f 413 " directory %pD\n", nn->rec_file);
c7b9a459
N
414}
415
190e4fbf 416static int
52e19c09 417load_recdir(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
190e4fbf
N
418{
419 if (child->d_name.len != HEXDIR_LEN - 1) {
a6a9f18f
AV
420 printk("nfsd4: illegal name %pd in recovery directory\n",
421 child);
190e4fbf 422 /* Keep trying; maybe the others are OK: */
b37ad28b 423 return 0;
190e4fbf 424 }
52e19c09 425 nfs4_client_to_reclaim(child->d_name.name, nn);
b37ad28b 426 return 0;
190e4fbf
N
427}
428
2a4317c5 429static int
52e19c09 430nfsd4_recdir_load(struct net *net) {
190e4fbf 431 int status;
52e19c09 432 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
190e4fbf 433
3a073369 434 if (!nn->rec_file)
e970a573
CH
435 return 0;
436
52e19c09 437 status = nfsd4_list_rec_dir(load_recdir, nn);
190e4fbf
N
438 if (status)
439 printk("nfsd4: failed loading clients from recovery"
a6a9f18f 440 " directory %pD\n", nn->rec_file);
190e4fbf
N
441 return status;
442}
443
444/*
445 * Hold reference to the recovery directory.
446 */
447
2a4317c5 448static int
3a073369 449nfsd4_init_recdir(struct net *net)
190e4fbf 450{
3a073369 451 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
d84f4f99
DH
452 const struct cred *original_cred;
453 int status;
190e4fbf
N
454
455 printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
48483bf2 456 user_recovery_dirname);
190e4fbf 457
3a073369 458 BUG_ON(nn->rec_file);
190e4fbf 459
d84f4f99
DH
460 status = nfs4_save_creds(&original_cred);
461 if (status < 0) {
462 printk("NFSD: Unable to change credentials to find recovery"
463 " directory: error %d\n",
464 status);
2a4317c5 465 return status;
d84f4f99 466 }
190e4fbf 467
3a073369
SK
468 nn->rec_file = filp_open(user_recovery_dirname, O_RDONLY | O_DIRECTORY, 0);
469 if (IS_ERR(nn->rec_file)) {
c2642ab0 470 printk("NFSD: unable to find recovery directory %s\n",
48483bf2 471 user_recovery_dirname);
3a073369
SK
472 status = PTR_ERR(nn->rec_file);
473 nn->rec_file = NULL;
e970a573 474 }
190e4fbf 475
d84f4f99 476 nfs4_reset_creds(original_cred);
0ce0c2b5 477 if (!status)
f141f79d 478 nn->in_grace = true;
2a4317c5 479 return status;
190e4fbf
N
480}
481
52e19c09
SK
482
483static int
484nfs4_legacy_state_init(struct net *net)
485{
486 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
487 int i;
488
489 nn->reclaim_str_hashtbl = kmalloc(sizeof(struct list_head) *
490 CLIENT_HASH_SIZE, GFP_KERNEL);
491 if (!nn->reclaim_str_hashtbl)
492 return -ENOMEM;
493
494 for (i = 0; i < CLIENT_HASH_SIZE; i++)
495 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]);
496 nn->reclaim_str_hashtbl_size = 0;
497
498 return 0;
499}
500
501static void
502nfs4_legacy_state_shutdown(struct net *net)
503{
504 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
505
506 kfree(nn->reclaim_str_hashtbl);
507}
508
2a4317c5
JL
509static int
510nfsd4_load_reboot_recovery_data(struct net *net)
511{
512 int status;
513
3a073369 514 status = nfsd4_init_recdir(net);
52e19c09
SK
515 if (!status)
516 status = nfsd4_recdir_load(net);
52e19c09
SK
517 if (status)
518 printk(KERN_ERR "NFSD: Failure reading reboot recovery data\n");
519 return status;
520}
521
522static int
523nfsd4_legacy_tracking_init(struct net *net)
524{
525 int status;
526
cc27e0d4
JL
527 /* XXX: The legacy code won't work in a container */
528 if (net != &init_net) {
529 WARN(1, KERN_ERR "NFSD: attempt to initialize legacy client "
530 "tracking in a container!\n");
531 return -EINVAL;
532 }
533
52e19c09 534 status = nfs4_legacy_state_init(net);
2a4317c5 535 if (status)
52e19c09
SK
536 return status;
537
538 status = nfsd4_load_reboot_recovery_data(net);
539 if (status)
540 goto err;
541 return 0;
542
543err:
544 nfs4_legacy_state_shutdown(net);
2a4317c5
JL
545 return status;
546}
547
548static void
3a073369 549nfsd4_shutdown_recdir(struct nfsd_net *nn)
190e4fbf 550{
3a073369 551 if (!nn->rec_file)
190e4fbf 552 return;
3a073369
SK
553 fput(nn->rec_file);
554 nn->rec_file = NULL;
190e4fbf 555}
48483bf2 556
2a4317c5
JL
557static void
558nfsd4_legacy_tracking_exit(struct net *net)
559{
52e19c09
SK
560 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
561
562 nfs4_release_reclaim(nn);
3a073369 563 nfsd4_shutdown_recdir(nn);
52e19c09 564 nfs4_legacy_state_shutdown(net);
2a4317c5
JL
565}
566
48483bf2
BF
567/*
568 * Change the NFSv4 recovery directory to recdir.
569 */
570int
571nfs4_reset_recoverydir(char *recdir)
572{
573 int status;
574 struct path path;
575
576 status = kern_path(recdir, LOOKUP_FOLLOW, &path);
577 if (status)
578 return status;
579 status = -ENOTDIR;
580 if (S_ISDIR(path.dentry->d_inode->i_mode)) {
581 strcpy(user_recovery_dirname, recdir);
582 status = 0;
583 }
584 path_put(&path);
585 return status;
586}
587
588char *
589nfs4_recoverydir(void)
590{
591 return user_recovery_dirname;
592}
2a4317c5
JL
593
594static int
595nfsd4_check_legacy_client(struct nfs4_client *clp)
596{
2216d449
JL
597 int status;
598 char dname[HEXDIR_LEN];
0ce0c2b5 599 struct nfs4_client_reclaim *crp;
52e19c09 600 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
0ce0c2b5 601
2a4317c5
JL
602 /* did we already find that this client is stable? */
603 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
604 return 0;
605
2216d449
JL
606 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
607 if (status) {
7255e716 608 legacy_recdir_name_error(clp, status);
2216d449
JL
609 return status;
610 }
611
2a4317c5 612 /* look for it in the reclaim hashtable otherwise */
52e19c09 613 crp = nfsd4_find_reclaim_client(dname, nn);
0ce0c2b5 614 if (crp) {
2a4317c5 615 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
0ce0c2b5 616 crp->cr_clp = clp;
2a4317c5
JL
617 return 0;
618 }
619
620 return -ENOENT;
621}
622
623static struct nfsd4_client_tracking_ops nfsd4_legacy_tracking_ops = {
52e19c09 624 .init = nfsd4_legacy_tracking_init,
2a4317c5
JL
625 .exit = nfsd4_legacy_tracking_exit,
626 .create = nfsd4_create_clid_dir,
627 .remove = nfsd4_remove_clid_dir,
628 .check = nfsd4_check_legacy_client,
629 .grace_done = nfsd4_recdir_purge_old,
630};
631
f3f80148
JL
632/* Globals */
633#define NFSD_PIPE_DIR "nfsd"
634#define NFSD_CLD_PIPE "cld"
635
636/* per-net-ns structure for holding cld upcall info */
637struct cld_net {
638 struct rpc_pipe *cn_pipe;
639 spinlock_t cn_lock;
640 struct list_head cn_list;
641 unsigned int cn_xid;
642};
643
644struct cld_upcall {
645 struct list_head cu_list;
646 struct cld_net *cu_net;
647 struct task_struct *cu_task;
648 struct cld_msg cu_msg;
649};
650
651static int
652__cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg)
653{
654 int ret;
655 struct rpc_pipe_msg msg;
656
657 memset(&msg, 0, sizeof(msg));
658 msg.data = cmsg;
659 msg.len = sizeof(*cmsg);
660
661 /*
662 * Set task state before we queue the upcall. That prevents
663 * wake_up_process in the downcall from racing with schedule.
664 */
665 set_current_state(TASK_UNINTERRUPTIBLE);
666 ret = rpc_queue_upcall(pipe, &msg);
667 if (ret < 0) {
668 set_current_state(TASK_RUNNING);
669 goto out;
670 }
671
672 schedule();
f3f80148
JL
673
674 if (msg.errno < 0)
675 ret = msg.errno;
676out:
677 return ret;
678}
679
680static int
681cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg)
682{
683 int ret;
684
685 /*
686 * -EAGAIN occurs when pipe is closed and reopened while there are
687 * upcalls queued.
688 */
689 do {
690 ret = __cld_pipe_upcall(pipe, cmsg);
691 } while (ret == -EAGAIN);
692
693 return ret;
694}
695
696static ssize_t
697cld_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
698{
699 struct cld_upcall *tmp, *cup;
bc1b542b 700 struct cld_msg __user *cmsg = (struct cld_msg __user *)src;
f3f80148
JL
701 uint32_t xid;
702 struct nfsd_net *nn = net_generic(filp->f_dentry->d_sb->s_fs_info,
703 nfsd_net_id);
704 struct cld_net *cn = nn->cld_net;
705
706 if (mlen != sizeof(*cmsg)) {
8a7dc4b0 707 dprintk("%s: got %zu bytes, expected %zu\n", __func__, mlen,
f3f80148
JL
708 sizeof(*cmsg));
709 return -EINVAL;
710 }
711
712 /* copy just the xid so we can try to find that */
713 if (copy_from_user(&xid, &cmsg->cm_xid, sizeof(xid)) != 0) {
714 dprintk("%s: error when copying xid from userspace", __func__);
715 return -EFAULT;
716 }
717
718 /* walk the list and find corresponding xid */
719 cup = NULL;
720 spin_lock(&cn->cn_lock);
721 list_for_each_entry(tmp, &cn->cn_list, cu_list) {
722 if (get_unaligned(&tmp->cu_msg.cm_xid) == xid) {
723 cup = tmp;
724 list_del_init(&cup->cu_list);
725 break;
726 }
727 }
728 spin_unlock(&cn->cn_lock);
729
730 /* couldn't find upcall? */
731 if (!cup) {
21f72c9f 732 dprintk("%s: couldn't find upcall -- xid=%u\n", __func__, xid);
f3f80148
JL
733 return -EINVAL;
734 }
735
736 if (copy_from_user(&cup->cu_msg, src, mlen) != 0)
737 return -EFAULT;
738
739 wake_up_process(cup->cu_task);
740 return mlen;
741}
742
743static void
744cld_pipe_destroy_msg(struct rpc_pipe_msg *msg)
745{
746 struct cld_msg *cmsg = msg->data;
747 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall,
748 cu_msg);
749
750 /* errno >= 0 means we got a downcall */
751 if (msg->errno >= 0)
752 return;
753
754 wake_up_process(cup->cu_task);
755}
756
757static const struct rpc_pipe_ops cld_upcall_ops = {
758 .upcall = rpc_pipe_generic_upcall,
759 .downcall = cld_pipe_downcall,
760 .destroy_msg = cld_pipe_destroy_msg,
761};
762
763static struct dentry *
764nfsd4_cld_register_sb(struct super_block *sb, struct rpc_pipe *pipe)
765{
766 struct dentry *dir, *dentry;
767
768 dir = rpc_d_lookup_sb(sb, NFSD_PIPE_DIR);
769 if (dir == NULL)
770 return ERR_PTR(-ENOENT);
771 dentry = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe);
772 dput(dir);
773 return dentry;
774}
775
776static void
777nfsd4_cld_unregister_sb(struct rpc_pipe *pipe)
778{
779 if (pipe->dentry)
780 rpc_unlink(pipe->dentry);
781}
782
783static struct dentry *
784nfsd4_cld_register_net(struct net *net, struct rpc_pipe *pipe)
785{
786 struct super_block *sb;
787 struct dentry *dentry;
788
789 sb = rpc_get_sb_net(net);
790 if (!sb)
791 return NULL;
792 dentry = nfsd4_cld_register_sb(sb, pipe);
793 rpc_put_sb_net(net);
794 return dentry;
795}
796
797static void
798nfsd4_cld_unregister_net(struct net *net, struct rpc_pipe *pipe)
799{
800 struct super_block *sb;
801
802 sb = rpc_get_sb_net(net);
803 if (sb) {
804 nfsd4_cld_unregister_sb(pipe);
805 rpc_put_sb_net(net);
806 }
807}
808
809/* Initialize rpc_pipefs pipe for communication with client tracking daemon */
810static int
811nfsd4_init_cld_pipe(struct net *net)
812{
813 int ret;
814 struct dentry *dentry;
815 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
816 struct cld_net *cn;
817
818 if (nn->cld_net)
819 return 0;
820
821 cn = kzalloc(sizeof(*cn), GFP_KERNEL);
822 if (!cn) {
823 ret = -ENOMEM;
824 goto err;
825 }
826
827 cn->cn_pipe = rpc_mkpipe_data(&cld_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
828 if (IS_ERR(cn->cn_pipe)) {
829 ret = PTR_ERR(cn->cn_pipe);
830 goto err;
831 }
832 spin_lock_init(&cn->cn_lock);
833 INIT_LIST_HEAD(&cn->cn_list);
834
835 dentry = nfsd4_cld_register_net(net, cn->cn_pipe);
836 if (IS_ERR(dentry)) {
837 ret = PTR_ERR(dentry);
838 goto err_destroy_data;
839 }
840
841 cn->cn_pipe->dentry = dentry;
842 nn->cld_net = cn;
843 return 0;
844
845err_destroy_data:
846 rpc_destroy_pipe_data(cn->cn_pipe);
847err:
848 kfree(cn);
849 printk(KERN_ERR "NFSD: unable to create nfsdcld upcall pipe (%d)\n",
850 ret);
851 return ret;
852}
853
854static void
855nfsd4_remove_cld_pipe(struct net *net)
856{
857 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
858 struct cld_net *cn = nn->cld_net;
859
860 nfsd4_cld_unregister_net(net, cn->cn_pipe);
861 rpc_destroy_pipe_data(cn->cn_pipe);
862 kfree(nn->cld_net);
863 nn->cld_net = NULL;
864}
865
866static struct cld_upcall *
867alloc_cld_upcall(struct cld_net *cn)
868{
869 struct cld_upcall *new, *tmp;
870
871 new = kzalloc(sizeof(*new), GFP_KERNEL);
872 if (!new)
873 return new;
874
875 /* FIXME: hard cap on number in flight? */
876restart_search:
877 spin_lock(&cn->cn_lock);
878 list_for_each_entry(tmp, &cn->cn_list, cu_list) {
879 if (tmp->cu_msg.cm_xid == cn->cn_xid) {
880 cn->cn_xid++;
881 spin_unlock(&cn->cn_lock);
882 goto restart_search;
883 }
884 }
885 new->cu_task = current;
886 new->cu_msg.cm_vers = CLD_UPCALL_VERSION;
887 put_unaligned(cn->cn_xid++, &new->cu_msg.cm_xid);
888 new->cu_net = cn;
889 list_add(&new->cu_list, &cn->cn_list);
890 spin_unlock(&cn->cn_lock);
891
892 dprintk("%s: allocated xid %u\n", __func__, new->cu_msg.cm_xid);
893
894 return new;
895}
896
897static void
898free_cld_upcall(struct cld_upcall *victim)
899{
900 struct cld_net *cn = victim->cu_net;
901
902 spin_lock(&cn->cn_lock);
903 list_del(&victim->cu_list);
904 spin_unlock(&cn->cn_lock);
905 kfree(victim);
906}
907
908/* Ask daemon to create a new record */
909static void
910nfsd4_cld_create(struct nfs4_client *clp)
911{
912 int ret;
913 struct cld_upcall *cup;
c212cecf 914 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
f3f80148
JL
915 struct cld_net *cn = nn->cld_net;
916
917 /* Don't upcall if it's already stored */
918 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
919 return;
920
921 cup = alloc_cld_upcall(cn);
922 if (!cup) {
923 ret = -ENOMEM;
924 goto out_err;
925 }
926
927 cup->cu_msg.cm_cmd = Cld_Create;
928 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
929 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
930 clp->cl_name.len);
931
932 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
933 if (!ret) {
934 ret = cup->cu_msg.cm_status;
935 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
936 }
937
938 free_cld_upcall(cup);
939out_err:
940 if (ret)
941 printk(KERN_ERR "NFSD: Unable to create client "
942 "record on stable storage: %d\n", ret);
943}
944
945/* Ask daemon to create a new record */
946static void
947nfsd4_cld_remove(struct nfs4_client *clp)
948{
949 int ret;
950 struct cld_upcall *cup;
c212cecf 951 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
f3f80148
JL
952 struct cld_net *cn = nn->cld_net;
953
954 /* Don't upcall if it's already removed */
955 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
956 return;
957
958 cup = alloc_cld_upcall(cn);
959 if (!cup) {
960 ret = -ENOMEM;
961 goto out_err;
962 }
963
964 cup->cu_msg.cm_cmd = Cld_Remove;
965 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
966 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
967 clp->cl_name.len);
968
969 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
970 if (!ret) {
971 ret = cup->cu_msg.cm_status;
972 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
973 }
974
975 free_cld_upcall(cup);
976out_err:
977 if (ret)
978 printk(KERN_ERR "NFSD: Unable to remove client "
979 "record from stable storage: %d\n", ret);
980}
981
982/* Check for presence of a record, and update its timestamp */
983static int
984nfsd4_cld_check(struct nfs4_client *clp)
985{
986 int ret;
987 struct cld_upcall *cup;
c212cecf 988 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
f3f80148
JL
989 struct cld_net *cn = nn->cld_net;
990
991 /* Don't upcall if one was already stored during this grace pd */
992 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
993 return 0;
994
995 cup = alloc_cld_upcall(cn);
996 if (!cup) {
997 printk(KERN_ERR "NFSD: Unable to check client record on "
998 "stable storage: %d\n", -ENOMEM);
999 return -ENOMEM;
1000 }
1001
1002 cup->cu_msg.cm_cmd = Cld_Check;
1003 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
1004 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
1005 clp->cl_name.len);
1006
1007 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
1008 if (!ret) {
1009 ret = cup->cu_msg.cm_status;
1010 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1011 }
1012
1013 free_cld_upcall(cup);
1014 return ret;
1015}
1016
1017static void
12760c66 1018nfsd4_cld_grace_done(struct nfsd_net *nn, time_t boot_time)
f3f80148
JL
1019{
1020 int ret;
1021 struct cld_upcall *cup;
f3f80148
JL
1022 struct cld_net *cn = nn->cld_net;
1023
1024 cup = alloc_cld_upcall(cn);
1025 if (!cup) {
1026 ret = -ENOMEM;
1027 goto out_err;
1028 }
1029
1030 cup->cu_msg.cm_cmd = Cld_GraceDone;
1031 cup->cu_msg.cm_u.cm_gracetime = (int64_t)boot_time;
1032 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
1033 if (!ret)
1034 ret = cup->cu_msg.cm_status;
1035
1036 free_cld_upcall(cup);
1037out_err:
1038 if (ret)
1039 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret);
1040}
1041
1042static struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops = {
1043 .init = nfsd4_init_cld_pipe,
1044 .exit = nfsd4_remove_cld_pipe,
1045 .create = nfsd4_cld_create,
1046 .remove = nfsd4_cld_remove,
1047 .check = nfsd4_cld_check,
1048 .grace_done = nfsd4_cld_grace_done,
1049};
1050
2873d214
JL
1051/* upcall via usermodehelper */
1052static char cltrack_prog[PATH_MAX] = "/sbin/nfsdcltrack";
1053module_param_string(cltrack_prog, cltrack_prog, sizeof(cltrack_prog),
1054 S_IRUGO|S_IWUSR);
1055MODULE_PARM_DESC(cltrack_prog, "Path to the nfsdcltrack upcall program");
1056
f3aa7e24
JL
1057static bool cltrack_legacy_disable;
1058module_param(cltrack_legacy_disable, bool, S_IRUGO|S_IWUSR);
1059MODULE_PARM_DESC(cltrack_legacy_disable,
1060 "Disable legacy recoverydir conversion. Default: false");
1061
1062#define LEGACY_TOPDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_TOPDIR="
1063#define LEGACY_RECDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_RECDIR="
1064
1065static char *
1066nfsd4_cltrack_legacy_topdir(void)
1067{
1068 int copied;
1069 size_t len;
1070 char *result;
1071
1072 if (cltrack_legacy_disable)
1073 return NULL;
1074
1075 len = strlen(LEGACY_TOPDIR_ENV_PREFIX) +
1076 strlen(nfs4_recoverydir()) + 1;
1077
1078 result = kmalloc(len, GFP_KERNEL);
1079 if (!result)
1080 return result;
1081
1082 copied = snprintf(result, len, LEGACY_TOPDIR_ENV_PREFIX "%s",
1083 nfs4_recoverydir());
1084 if (copied >= len) {
1085 /* just return nothing if output was truncated */
1086 kfree(result);
1087 return NULL;
1088 }
1089
1090 return result;
1091}
1092
1093static char *
2216d449 1094nfsd4_cltrack_legacy_recdir(const struct xdr_netobj *name)
f3aa7e24
JL
1095{
1096 int copied;
1097 size_t len;
1098 char *result;
1099
1100 if (cltrack_legacy_disable)
1101 return NULL;
1102
1103 /* +1 is for '/' between "topdir" and "recdir" */
1104 len = strlen(LEGACY_RECDIR_ENV_PREFIX) +
1105 strlen(nfs4_recoverydir()) + 1 + HEXDIR_LEN;
1106
1107 result = kmalloc(len, GFP_KERNEL);
1108 if (!result)
1109 return result;
1110
2216d449
JL
1111 copied = snprintf(result, len, LEGACY_RECDIR_ENV_PREFIX "%s/",
1112 nfs4_recoverydir());
1113 if (copied > (len - HEXDIR_LEN)) {
1114 /* just return nothing if output will be truncated */
1115 kfree(result);
1116 return NULL;
1117 }
1118
1119 copied = nfs4_make_rec_clidname(result + copied, name);
1120 if (copied) {
f3aa7e24
JL
1121 kfree(result);
1122 return NULL;
1123 }
1124
1125 return result;
1126}
1127
2873d214 1128static int
f3aa7e24 1129nfsd4_umh_cltrack_upcall(char *cmd, char *arg, char *legacy)
2873d214 1130{
f3aa7e24 1131 char *envp[2];
2873d214
JL
1132 char *argv[4];
1133 int ret;
1134
1135 if (unlikely(!cltrack_prog[0])) {
1136 dprintk("%s: cltrack_prog is disabled\n", __func__);
1137 return -EACCES;
1138 }
1139
1140 dprintk("%s: cmd: %s\n", __func__, cmd);
1141 dprintk("%s: arg: %s\n", __func__, arg ? arg : "(null)");
f3aa7e24
JL
1142 dprintk("%s: legacy: %s\n", __func__, legacy ? legacy : "(null)");
1143
1144 envp[0] = legacy;
1145 envp[1] = NULL;
2873d214
JL
1146
1147 argv[0] = (char *)cltrack_prog;
1148 argv[1] = cmd;
1149 argv[2] = arg;
1150 argv[3] = NULL;
1151
1152 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
1153 /*
1154 * Disable the upcall mechanism if we're getting an ENOENT or EACCES
1155 * error. The admin can re-enable it on the fly by using sysfs
1156 * once the problem has been fixed.
1157 */
1158 if (ret == -ENOENT || ret == -EACCES) {
1159 dprintk("NFSD: %s was not found or isn't executable (%d). "
1160 "Setting cltrack_prog to blank string!",
1161 cltrack_prog, ret);
1162 cltrack_prog[0] = '\0';
1163 }
1164 dprintk("%s: %s return value: %d\n", __func__, cltrack_prog, ret);
1165
1166 return ret;
1167}
1168
1169static char *
1170bin_to_hex_dup(const unsigned char *src, int srclen)
1171{
1172 int i;
1173 char *buf, *hex;
1174
1175 /* +1 for terminating NULL */
1176 buf = kmalloc((srclen * 2) + 1, GFP_KERNEL);
1177 if (!buf)
1178 return buf;
1179
1180 hex = buf;
1181 for (i = 0; i < srclen; i++) {
1182 sprintf(hex, "%2.2x", *src++);
1183 hex += 2;
1184 }
1185 return buf;
1186}
1187
1188static int
1189nfsd4_umh_cltrack_init(struct net __attribute__((unused)) *net)
1190{
71a50306
SK
1191 /* XXX: The usermode helper s not working in container yet. */
1192 if (net != &init_net) {
1193 WARN(1, KERN_ERR "NFSD: attempt to initialize umh client "
1194 "tracking in a container!\n");
1195 return -EINVAL;
1196 }
f3aa7e24 1197 return nfsd4_umh_cltrack_upcall("init", NULL, NULL);
2873d214
JL
1198}
1199
1200static void
1201nfsd4_umh_cltrack_create(struct nfs4_client *clp)
1202{
1203 char *hexid;
1204
1205 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1206 if (!hexid) {
1207 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1208 return;
1209 }
f3aa7e24 1210 nfsd4_umh_cltrack_upcall("create", hexid, NULL);
2873d214
JL
1211 kfree(hexid);
1212}
1213
1214static void
1215nfsd4_umh_cltrack_remove(struct nfs4_client *clp)
1216{
1217 char *hexid;
1218
1219 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1220 if (!hexid) {
1221 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1222 return;
1223 }
f3aa7e24 1224 nfsd4_umh_cltrack_upcall("remove", hexid, NULL);
2873d214
JL
1225 kfree(hexid);
1226}
1227
1228static int
1229nfsd4_umh_cltrack_check(struct nfs4_client *clp)
1230{
1231 int ret;
f3aa7e24 1232 char *hexid, *legacy;
2873d214
JL
1233
1234 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1235 if (!hexid) {
1236 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1237 return -ENOMEM;
1238 }
2216d449 1239 legacy = nfsd4_cltrack_legacy_recdir(&clp->cl_name);
f3aa7e24
JL
1240 ret = nfsd4_umh_cltrack_upcall("check", hexid, legacy);
1241 kfree(legacy);
2873d214
JL
1242 kfree(hexid);
1243 return ret;
1244}
1245
1246static void
12760c66 1247nfsd4_umh_cltrack_grace_done(struct nfsd_net __attribute__((unused)) *nn,
2873d214
JL
1248 time_t boot_time)
1249{
f3aa7e24 1250 char *legacy;
2873d214
JL
1251 char timestr[22]; /* FIXME: better way to determine max size? */
1252
1253 sprintf(timestr, "%ld", boot_time);
f3aa7e24
JL
1254 legacy = nfsd4_cltrack_legacy_topdir();
1255 nfsd4_umh_cltrack_upcall("gracedone", timestr, legacy);
1256 kfree(legacy);
2873d214
JL
1257}
1258
1259static struct nfsd4_client_tracking_ops nfsd4_umh_tracking_ops = {
1260 .init = nfsd4_umh_cltrack_init,
1261 .exit = NULL,
1262 .create = nfsd4_umh_cltrack_create,
1263 .remove = nfsd4_umh_cltrack_remove,
1264 .check = nfsd4_umh_cltrack_check,
1265 .grace_done = nfsd4_umh_cltrack_grace_done,
1266};
1267
2a4317c5
JL
1268int
1269nfsd4_client_tracking_init(struct net *net)
1270{
1271 int status;
f3f80148 1272 struct path path;
9a9c6478 1273 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2a4317c5 1274
2d77bf0a 1275 /* just run the init if it the method is already decided */
9a9c6478 1276 if (nn->client_tracking_ops)
2d77bf0a
JL
1277 goto do_init;
1278
1279 /*
1280 * First, try a UMH upcall. It should succeed or fail quickly, so
1281 * there's little harm in trying that first.
1282 */
9a9c6478
SK
1283 nn->client_tracking_ops = &nfsd4_umh_tracking_ops;
1284 status = nn->client_tracking_ops->init(net);
2d77bf0a
JL
1285 if (!status)
1286 return status;
1287
1288 /*
1289 * See if the recoverydir exists and is a directory. If it is,
1290 * then use the legacy ops.
1291 */
9a9c6478 1292 nn->client_tracking_ops = &nfsd4_legacy_tracking_ops;
2d77bf0a
JL
1293 status = kern_path(nfs4_recoverydir(), LOOKUP_FOLLOW, &path);
1294 if (!status) {
1295 status = S_ISDIR(path.dentry->d_inode->i_mode);
1296 path_put(&path);
1297 if (status)
1298 goto do_init;
f3f80148 1299 }
2a4317c5 1300
2d77bf0a 1301 /* Finally, try to use nfsdcld */
9a9c6478 1302 nn->client_tracking_ops = &nfsd4_cld_tracking_ops;
8b0554e9
JL
1303 printk(KERN_WARNING "NFSD: the nfsdcld client tracking upcall will be "
1304 "removed in 3.10. Please transition to using "
1305 "nfsdcltrack.\n");
2d77bf0a 1306do_init:
9a9c6478 1307 status = nn->client_tracking_ops->init(net);
2a4317c5
JL
1308 if (status) {
1309 printk(KERN_WARNING "NFSD: Unable to initialize client "
1310 "recovery tracking! (%d)\n", status);
9a9c6478 1311 nn->client_tracking_ops = NULL;
2a4317c5
JL
1312 }
1313 return status;
1314}
1315
1316void
1317nfsd4_client_tracking_exit(struct net *net)
1318{
9a9c6478
SK
1319 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1320
1321 if (nn->client_tracking_ops) {
1322 if (nn->client_tracking_ops->exit)
1323 nn->client_tracking_ops->exit(net);
1324 nn->client_tracking_ops = NULL;
2a4317c5
JL
1325 }
1326}
1327
1328void
1329nfsd4_client_record_create(struct nfs4_client *clp)
1330{
9a9c6478
SK
1331 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1332
1333 if (nn->client_tracking_ops)
1334 nn->client_tracking_ops->create(clp);
2a4317c5
JL
1335}
1336
1337void
1338nfsd4_client_record_remove(struct nfs4_client *clp)
1339{
9a9c6478
SK
1340 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1341
1342 if (nn->client_tracking_ops)
1343 nn->client_tracking_ops->remove(clp);
2a4317c5
JL
1344}
1345
1346int
1347nfsd4_client_record_check(struct nfs4_client *clp)
1348{
9a9c6478
SK
1349 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1350
1351 if (nn->client_tracking_ops)
1352 return nn->client_tracking_ops->check(clp);
2a4317c5
JL
1353
1354 return -EOPNOTSUPP;
1355}
1356
1357void
12760c66 1358nfsd4_record_grace_done(struct nfsd_net *nn, time_t boot_time)
2a4317c5 1359{
9a9c6478
SK
1360 if (nn->client_tracking_ops)
1361 nn->client_tracking_ops->grace_done(nn, boot_time);
2a4317c5 1362}
813fd320
JL
1363
1364static int
1365rpc_pipefs_event(struct notifier_block *nb, unsigned long event, void *ptr)
1366{
1367 struct super_block *sb = ptr;
1368 struct net *net = sb->s_fs_info;
1369 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1370 struct cld_net *cn = nn->cld_net;
1371 struct dentry *dentry;
1372 int ret = 0;
1373
1374 if (!try_module_get(THIS_MODULE))
1375 return 0;
1376
1377 if (!cn) {
1378 module_put(THIS_MODULE);
1379 return 0;
1380 }
1381
1382 switch (event) {
1383 case RPC_PIPEFS_MOUNT:
1384 dentry = nfsd4_cld_register_sb(sb, cn->cn_pipe);
1385 if (IS_ERR(dentry)) {
1386 ret = PTR_ERR(dentry);
1387 break;
1388 }
1389 cn->cn_pipe->dentry = dentry;
1390 break;
1391 case RPC_PIPEFS_UMOUNT:
1392 if (cn->cn_pipe->dentry)
1393 nfsd4_cld_unregister_sb(cn->cn_pipe);
1394 break;
1395 default:
1396 ret = -ENOTSUPP;
1397 break;
1398 }
1399 module_put(THIS_MODULE);
1400 return ret;
1401}
1402
2355c596 1403static struct notifier_block nfsd4_cld_block = {
813fd320
JL
1404 .notifier_call = rpc_pipefs_event,
1405};
797a9d79
JL
1406
1407int
1408register_cld_notifier(void)
1409{
1410 return rpc_pipefs_notifier_register(&nfsd4_cld_block);
1411}
1412
1413void
1414unregister_cld_notifier(void)
1415{
1416 rpc_pipefs_notifier_unregister(&nfsd4_cld_block);
1417}