Loading...
1/*
2* Copyright (c) 2004 The Regents of the University of Michigan.
3* All rights reserved.
4*
5* Andy Adamson <andros@citi.umich.edu>
6*
7* Redistribution and use in source and binary forms, with or without
8* modification, are permitted provided that the following conditions
9* are met:
10*
11* 1. Redistributions of source code must retain the above copyright
12* notice, this list of conditions and the following disclaimer.
13* 2. Redistributions in binary form must reproduce the above copyright
14* notice, this list of conditions and the following disclaimer in the
15* documentation and/or other materials provided with the distribution.
16* 3. Neither the name of the University nor the names of its
17* contributors may be used to endorse or promote products derived
18* from this software without specific prior written permission.
19*
20* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
21* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31*
32*/
33
34#include <linux/file.h>
35#include <linux/slab.h>
36#include <linux/namei.h>
37#include <linux/crypto.h>
38#include <linux/sched.h>
39
40#include "nfsd.h"
41#include "state.h"
42#include "vfs.h"
43
44#define NFSDDBG_FACILITY NFSDDBG_PROC
45
46/* Globals */
47static struct file *rec_file;
48
49static int
50nfs4_save_creds(const struct cred **original_creds)
51{
52 struct cred *new;
53
54 new = prepare_creds();
55 if (!new)
56 return -ENOMEM;
57
58 new->fsuid = 0;
59 new->fsgid = 0;
60 *original_creds = override_creds(new);
61 put_cred(new);
62 return 0;
63}
64
65static void
66nfs4_reset_creds(const struct cred *original)
67{
68 revert_creds(original);
69}
70
71static void
72md5_to_hex(char *out, char *md5)
73{
74 int i;
75
76 for (i=0; i<16; i++) {
77 unsigned char c = md5[i];
78
79 *out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);
80 *out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);
81 }
82 *out = '\0';
83}
84
85__be32
86nfs4_make_rec_clidname(char *dname, struct xdr_netobj *clname)
87{
88 struct xdr_netobj cksum;
89 struct hash_desc desc;
90 struct scatterlist sg;
91 __be32 status = nfserr_resource;
92
93 dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n",
94 clname->len, clname->data);
95 desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP;
96 desc.tfm = crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC);
97 if (IS_ERR(desc.tfm))
98 goto out_no_tfm;
99 cksum.len = crypto_hash_digestsize(desc.tfm);
100 cksum.data = kmalloc(cksum.len, GFP_KERNEL);
101 if (cksum.data == NULL)
102 goto out;
103
104 sg_init_one(&sg, clname->data, clname->len);
105
106 if (crypto_hash_digest(&desc, &sg, sg.length, cksum.data))
107 goto out;
108
109 md5_to_hex(dname, cksum.data);
110
111 status = nfs_ok;
112out:
113 kfree(cksum.data);
114 crypto_free_hash(desc.tfm);
115out_no_tfm:
116 return status;
117}
118
119int
120nfsd4_create_clid_dir(struct nfs4_client *clp)
121{
122 const struct cred *original_cred;
123 char *dname = clp->cl_recdir;
124 struct dentry *dir, *dentry;
125 int status;
126
127 dprintk("NFSD: nfsd4_create_clid_dir for \"%s\"\n", dname);
128
129 if (!rec_file || clp->cl_firststate)
130 return 0;
131
132 status = nfs4_save_creds(&original_cred);
133 if (status < 0)
134 return status;
135
136 dir = rec_file->f_path.dentry;
137 /* lock the parent */
138 mutex_lock(&dir->d_inode->i_mutex);
139
140 dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
141 if (IS_ERR(dentry)) {
142 status = PTR_ERR(dentry);
143 goto out_unlock;
144 }
145 status = -EEXIST;
146 if (dentry->d_inode) {
147 dprintk("NFSD: nfsd4_create_clid_dir: DIRECTORY EXISTS\n");
148 goto out_put;
149 }
150 status = mnt_want_write(rec_file->f_path.mnt);
151 if (status)
152 goto out_put;
153 status = vfs_mkdir(dir->d_inode, dentry, S_IRWXU);
154 mnt_drop_write(rec_file->f_path.mnt);
155out_put:
156 dput(dentry);
157out_unlock:
158 mutex_unlock(&dir->d_inode->i_mutex);
159 if (status == 0) {
160 clp->cl_firststate = 1;
161 vfs_fsync(rec_file, 0);
162 }
163 nfs4_reset_creds(original_cred);
164 dprintk("NFSD: nfsd4_create_clid_dir returns %d\n", status);
165 return status;
166}
167
168typedef int (recdir_func)(struct dentry *, struct dentry *);
169
170struct name_list {
171 char name[HEXDIR_LEN];
172 struct list_head list;
173};
174
175static int
176nfsd4_build_namelist(void *arg, const char *name, int namlen,
177 loff_t offset, u64 ino, unsigned int d_type)
178{
179 struct list_head *names = arg;
180 struct name_list *entry;
181
182 if (namlen != HEXDIR_LEN - 1)
183 return 0;
184 entry = kmalloc(sizeof(struct name_list), GFP_KERNEL);
185 if (entry == NULL)
186 return -ENOMEM;
187 memcpy(entry->name, name, HEXDIR_LEN - 1);
188 entry->name[HEXDIR_LEN - 1] = '\0';
189 list_add(&entry->list, names);
190 return 0;
191}
192
193static int
194nfsd4_list_rec_dir(recdir_func *f)
195{
196 const struct cred *original_cred;
197 struct dentry *dir = rec_file->f_path.dentry;
198 LIST_HEAD(names);
199 int status;
200
201 status = nfs4_save_creds(&original_cred);
202 if (status < 0)
203 return status;
204
205 status = vfs_llseek(rec_file, 0, SEEK_SET);
206 if (status < 0) {
207 nfs4_reset_creds(original_cred);
208 return status;
209 }
210
211 status = vfs_readdir(rec_file, nfsd4_build_namelist, &names);
212 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
213 while (!list_empty(&names)) {
214 struct name_list *entry;
215 entry = list_entry(names.next, struct name_list, list);
216 if (!status) {
217 struct dentry *dentry;
218 dentry = lookup_one_len(entry->name, dir, HEXDIR_LEN-1);
219 if (IS_ERR(dentry)) {
220 status = PTR_ERR(dentry);
221 break;
222 }
223 status = f(dir, dentry);
224 dput(dentry);
225 }
226 list_del(&entry->list);
227 kfree(entry);
228 }
229 mutex_unlock(&dir->d_inode->i_mutex);
230 nfs4_reset_creds(original_cred);
231 return status;
232}
233
234static int
235nfsd4_unlink_clid_dir(char *name, int namlen)
236{
237 struct dentry *dir, *dentry;
238 int status;
239
240 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
241
242 dir = rec_file->f_path.dentry;
243 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
244 dentry = lookup_one_len(name, dir, namlen);
245 if (IS_ERR(dentry)) {
246 status = PTR_ERR(dentry);
247 goto out_unlock;
248 }
249 status = -ENOENT;
250 if (!dentry->d_inode)
251 goto out;
252 status = vfs_rmdir(dir->d_inode, dentry);
253out:
254 dput(dentry);
255out_unlock:
256 mutex_unlock(&dir->d_inode->i_mutex);
257 return status;
258}
259
260void
261nfsd4_remove_clid_dir(struct nfs4_client *clp)
262{
263 const struct cred *original_cred;
264 int status;
265
266 if (!rec_file || !clp->cl_firststate)
267 return;
268
269 status = mnt_want_write(rec_file->f_path.mnt);
270 if (status)
271 goto out;
272 clp->cl_firststate = 0;
273
274 status = nfs4_save_creds(&original_cred);
275 if (status < 0)
276 goto out;
277
278 status = nfsd4_unlink_clid_dir(clp->cl_recdir, HEXDIR_LEN-1);
279 nfs4_reset_creds(original_cred);
280 if (status == 0)
281 vfs_fsync(rec_file, 0);
282 mnt_drop_write(rec_file->f_path.mnt);
283out:
284 if (status)
285 printk("NFSD: Failed to remove expired client state directory"
286 " %.*s\n", HEXDIR_LEN, clp->cl_recdir);
287 return;
288}
289
290static int
291purge_old(struct dentry *parent, struct dentry *child)
292{
293 int status;
294
295 if (nfs4_has_reclaimed_state(child->d_name.name, false))
296 return 0;
297
298 status = vfs_rmdir(parent->d_inode, child);
299 if (status)
300 printk("failed to remove client recovery directory %s\n",
301 child->d_name.name);
302 /* Keep trying, success or failure: */
303 return 0;
304}
305
306void
307nfsd4_recdir_purge_old(void) {
308 int status;
309
310 if (!rec_file)
311 return;
312 status = mnt_want_write(rec_file->f_path.mnt);
313 if (status)
314 goto out;
315 status = nfsd4_list_rec_dir(purge_old);
316 if (status == 0)
317 vfs_fsync(rec_file, 0);
318 mnt_drop_write(rec_file->f_path.mnt);
319out:
320 if (status)
321 printk("nfsd4: failed to purge old clients from recovery"
322 " directory %s\n", rec_file->f_path.dentry->d_name.name);
323}
324
325static int
326load_recdir(struct dentry *parent, struct dentry *child)
327{
328 if (child->d_name.len != HEXDIR_LEN - 1) {
329 printk("nfsd4: illegal name %s in recovery directory\n",
330 child->d_name.name);
331 /* Keep trying; maybe the others are OK: */
332 return 0;
333 }
334 nfs4_client_to_reclaim(child->d_name.name);
335 return 0;
336}
337
338int
339nfsd4_recdir_load(void) {
340 int status;
341
342 if (!rec_file)
343 return 0;
344
345 status = nfsd4_list_rec_dir(load_recdir);
346 if (status)
347 printk("nfsd4: failed loading clients from recovery"
348 " directory %s\n", rec_file->f_path.dentry->d_name.name);
349 return status;
350}
351
352/*
353 * Hold reference to the recovery directory.
354 */
355
356void
357nfsd4_init_recdir(char *rec_dirname)
358{
359 const struct cred *original_cred;
360 int status;
361
362 printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
363 rec_dirname);
364
365 BUG_ON(rec_file);
366
367 status = nfs4_save_creds(&original_cred);
368 if (status < 0) {
369 printk("NFSD: Unable to change credentials to find recovery"
370 " directory: error %d\n",
371 status);
372 return;
373 }
374
375 rec_file = filp_open(rec_dirname, O_RDONLY | O_DIRECTORY, 0);
376 if (IS_ERR(rec_file)) {
377 printk("NFSD: unable to find recovery directory %s\n",
378 rec_dirname);
379 rec_file = NULL;
380 }
381
382 nfs4_reset_creds(original_cred);
383}
384
385void
386nfsd4_shutdown_recdir(void)
387{
388 if (!rec_file)
389 return;
390 fput(rec_file);
391 rec_file = NULL;
392}
1/*
2* Copyright (c) 2004 The Regents of the University of Michigan.
3* Copyright (c) 2012 Jeff Layton <jlayton@redhat.com>
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
35#include <crypto/hash.h>
36#include <linux/file.h>
37#include <linux/slab.h>
38#include <linux/namei.h>
39#include <linux/sched.h>
40#include <linux/fs.h>
41#include <linux/module.h>
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>
46
47#include "nfsd.h"
48#include "state.h"
49#include "vfs.h"
50#include "netns.h"
51
52#define NFSDDBG_FACILITY NFSDDBG_PROC
53
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 *);
61 void (*grace_done)(struct nfsd_net *);
62 uint8_t version;
63 size_t msglen;
64};
65
66static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops;
67static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops_v2;
68
69#ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
70/* Globals */
71static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
72
73static int
74nfs4_save_creds(const struct cred **original_creds)
75{
76 struct cred *new;
77
78 new = prepare_creds();
79 if (!new)
80 return -ENOMEM;
81
82 new->fsuid = GLOBAL_ROOT_UID;
83 new->fsgid = GLOBAL_ROOT_GID;
84 *original_creds = override_creds(new);
85 put_cred(new);
86 return 0;
87}
88
89static void
90nfs4_reset_creds(const struct cred *original)
91{
92 revert_creds(original);
93}
94
95static void
96md5_to_hex(char *out, char *md5)
97{
98 int i;
99
100 for (i=0; i<16; i++) {
101 unsigned char c = md5[i];
102
103 *out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);
104 *out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);
105 }
106 *out = '\0';
107}
108
109static int
110nfs4_make_rec_clidname(char *dname, const struct xdr_netobj *clname)
111{
112 struct xdr_netobj cksum;
113 struct crypto_shash *tfm;
114 int status;
115
116 dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n",
117 clname->len, clname->data);
118 tfm = crypto_alloc_shash("md5", 0, 0);
119 if (IS_ERR(tfm)) {
120 status = PTR_ERR(tfm);
121 goto out_no_tfm;
122 }
123
124 cksum.len = crypto_shash_digestsize(tfm);
125 cksum.data = kmalloc(cksum.len, GFP_KERNEL);
126 if (cksum.data == NULL) {
127 status = -ENOMEM;
128 goto out;
129 }
130
131 status = crypto_shash_tfm_digest(tfm, clname->data, clname->len,
132 cksum.data);
133 if (status)
134 goto out;
135
136 md5_to_hex(dname, cksum.data);
137
138 status = 0;
139out:
140 kfree(cksum.data);
141 crypto_free_shash(tfm);
142out_no_tfm:
143 return status;
144}
145
146/*
147 * If we had an error generating the recdir name for the legacy tracker
148 * then warn the admin. If the error doesn't appear to be transient,
149 * then disable recovery tracking.
150 */
151static void
152legacy_recdir_name_error(struct nfs4_client *clp, int error)
153{
154 printk(KERN_ERR "NFSD: unable to generate recoverydir "
155 "name (%d).\n", error);
156
157 /*
158 * if the algorithm just doesn't exist, then disable the recovery
159 * tracker altogether. The crypto libs will generally return this if
160 * FIPS is enabled as well.
161 */
162 if (error == -ENOENT) {
163 printk(KERN_ERR "NFSD: disabling legacy clientid tracking. "
164 "Reboot recovery will not function correctly!\n");
165 nfsd4_client_tracking_exit(clp->net);
166 }
167}
168
169static void
170__nfsd4_create_reclaim_record_grace(struct nfs4_client *clp,
171 const char *dname, int len, struct nfsd_net *nn)
172{
173 struct xdr_netobj name;
174 struct xdr_netobj princhash = { .len = 0, .data = NULL };
175 struct nfs4_client_reclaim *crp;
176
177 name.data = kmemdup(dname, len, GFP_KERNEL);
178 if (!name.data) {
179 dprintk("%s: failed to allocate memory for name.data!\n",
180 __func__);
181 return;
182 }
183 name.len = len;
184 crp = nfs4_client_to_reclaim(name, princhash, nn);
185 if (!crp) {
186 kfree(name.data);
187 return;
188 }
189 crp->cr_clp = clp;
190}
191
192static void
193nfsd4_create_clid_dir(struct nfs4_client *clp)
194{
195 const struct cred *original_cred;
196 char dname[HEXDIR_LEN];
197 struct dentry *dir, *dentry;
198 int status;
199 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
200
201 if (test_and_set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
202 return;
203 if (!nn->rec_file)
204 return;
205
206 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
207 if (status)
208 return legacy_recdir_name_error(clp, status);
209
210 status = nfs4_save_creds(&original_cred);
211 if (status < 0)
212 return;
213
214 status = mnt_want_write_file(nn->rec_file);
215 if (status)
216 goto out_creds;
217
218 dir = nn->rec_file->f_path.dentry;
219 /* lock the parent */
220 inode_lock(d_inode(dir));
221
222 dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
223 if (IS_ERR(dentry)) {
224 status = PTR_ERR(dentry);
225 goto out_unlock;
226 }
227 if (d_really_is_positive(dentry))
228 /*
229 * In the 4.1 case, where we're called from
230 * reclaim_complete(), records from the previous reboot
231 * may still be left, so this is OK.
232 *
233 * In the 4.0 case, we should never get here; but we may
234 * as well be forgiving and just succeed silently.
235 */
236 goto out_put;
237 status = vfs_mkdir(&nop_mnt_idmap, d_inode(dir), dentry, S_IRWXU);
238out_put:
239 dput(dentry);
240out_unlock:
241 inode_unlock(d_inode(dir));
242 if (status == 0) {
243 if (nn->in_grace)
244 __nfsd4_create_reclaim_record_grace(clp, dname,
245 HEXDIR_LEN, nn);
246 vfs_fsync(nn->rec_file, 0);
247 } else {
248 printk(KERN_ERR "NFSD: failed to write recovery record"
249 " (err %d); please check that %s exists"
250 " and is writeable", status,
251 user_recovery_dirname);
252 }
253 mnt_drop_write_file(nn->rec_file);
254out_creds:
255 nfs4_reset_creds(original_cred);
256}
257
258typedef int (recdir_func)(struct dentry *, struct dentry *, struct nfsd_net *);
259
260struct name_list {
261 char name[HEXDIR_LEN];
262 struct list_head list;
263};
264
265struct nfs4_dir_ctx {
266 struct dir_context ctx;
267 struct list_head names;
268};
269
270static bool
271nfsd4_build_namelist(struct dir_context *__ctx, const char *name, int namlen,
272 loff_t offset, u64 ino, unsigned int d_type)
273{
274 struct nfs4_dir_ctx *ctx =
275 container_of(__ctx, struct nfs4_dir_ctx, ctx);
276 struct name_list *entry;
277
278 if (namlen != HEXDIR_LEN - 1)
279 return true;
280 entry = kmalloc(sizeof(struct name_list), GFP_KERNEL);
281 if (entry == NULL)
282 return false;
283 memcpy(entry->name, name, HEXDIR_LEN - 1);
284 entry->name[HEXDIR_LEN - 1] = '\0';
285 list_add(&entry->list, &ctx->names);
286 return true;
287}
288
289static int
290nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
291{
292 const struct cred *original_cred;
293 struct dentry *dir = nn->rec_file->f_path.dentry;
294 struct nfs4_dir_ctx ctx = {
295 .ctx.actor = nfsd4_build_namelist,
296 .names = LIST_HEAD_INIT(ctx.names)
297 };
298 struct name_list *entry, *tmp;
299 int status;
300
301 status = nfs4_save_creds(&original_cred);
302 if (status < 0)
303 return status;
304
305 status = vfs_llseek(nn->rec_file, 0, SEEK_SET);
306 if (status < 0) {
307 nfs4_reset_creds(original_cred);
308 return status;
309 }
310
311 status = iterate_dir(nn->rec_file, &ctx.ctx);
312 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
313
314 list_for_each_entry_safe(entry, tmp, &ctx.names, list) {
315 if (!status) {
316 struct dentry *dentry;
317 dentry = lookup_one_len(entry->name, dir, HEXDIR_LEN-1);
318 if (IS_ERR(dentry)) {
319 status = PTR_ERR(dentry);
320 break;
321 }
322 status = f(dir, dentry, nn);
323 dput(dentry);
324 }
325 list_del(&entry->list);
326 kfree(entry);
327 }
328 inode_unlock(d_inode(dir));
329 nfs4_reset_creds(original_cred);
330
331 list_for_each_entry_safe(entry, tmp, &ctx.names, list) {
332 dprintk("NFSD: %s. Left entry %s\n", __func__, entry->name);
333 list_del(&entry->list);
334 kfree(entry);
335 }
336 return status;
337}
338
339static int
340nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn)
341{
342 struct dentry *dir, *dentry;
343 int status;
344
345 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
346
347 dir = nn->rec_file->f_path.dentry;
348 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);
349 dentry = lookup_one_len(name, dir, namlen);
350 if (IS_ERR(dentry)) {
351 status = PTR_ERR(dentry);
352 goto out_unlock;
353 }
354 status = -ENOENT;
355 if (d_really_is_negative(dentry))
356 goto out;
357 status = vfs_rmdir(&nop_mnt_idmap, d_inode(dir), dentry);
358out:
359 dput(dentry);
360out_unlock:
361 inode_unlock(d_inode(dir));
362 return status;
363}
364
365static void
366__nfsd4_remove_reclaim_record_grace(const char *dname, int len,
367 struct nfsd_net *nn)
368{
369 struct xdr_netobj name;
370 struct nfs4_client_reclaim *crp;
371
372 name.data = kmemdup(dname, len, GFP_KERNEL);
373 if (!name.data) {
374 dprintk("%s: failed to allocate memory for name.data!\n",
375 __func__);
376 return;
377 }
378 name.len = len;
379 crp = nfsd4_find_reclaim_client(name, nn);
380 kfree(name.data);
381 if (crp)
382 nfs4_remove_reclaim_record(crp, nn);
383}
384
385static void
386nfsd4_remove_clid_dir(struct nfs4_client *clp)
387{
388 const struct cred *original_cred;
389 char dname[HEXDIR_LEN];
390 int status;
391 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
392
393 if (!nn->rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
394 return;
395
396 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
397 if (status)
398 return legacy_recdir_name_error(clp, status);
399
400 status = mnt_want_write_file(nn->rec_file);
401 if (status)
402 goto out;
403 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
404
405 status = nfs4_save_creds(&original_cred);
406 if (status < 0)
407 goto out_drop_write;
408
409 status = nfsd4_unlink_clid_dir(dname, HEXDIR_LEN-1, nn);
410 nfs4_reset_creds(original_cred);
411 if (status == 0) {
412 vfs_fsync(nn->rec_file, 0);
413 if (nn->in_grace)
414 __nfsd4_remove_reclaim_record_grace(dname,
415 HEXDIR_LEN, nn);
416 }
417out_drop_write:
418 mnt_drop_write_file(nn->rec_file);
419out:
420 if (status)
421 printk("NFSD: Failed to remove expired client state directory"
422 " %.*s\n", HEXDIR_LEN, dname);
423}
424
425static int
426purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
427{
428 int status;
429 struct xdr_netobj name;
430
431 if (child->d_name.len != HEXDIR_LEN - 1) {
432 printk("%s: illegal name %pd in recovery directory\n",
433 __func__, child);
434 /* Keep trying; maybe the others are OK: */
435 return 0;
436 }
437 name.data = kmemdup_nul(child->d_name.name, child->d_name.len, GFP_KERNEL);
438 if (!name.data) {
439 dprintk("%s: failed to allocate memory for name.data!\n",
440 __func__);
441 goto out;
442 }
443 name.len = HEXDIR_LEN;
444 if (nfs4_has_reclaimed_state(name, nn))
445 goto out_free;
446
447 status = vfs_rmdir(&nop_mnt_idmap, d_inode(parent), child);
448 if (status)
449 printk("failed to remove client recovery directory %pd\n",
450 child);
451out_free:
452 kfree(name.data);
453out:
454 /* Keep trying, success or failure: */
455 return 0;
456}
457
458static void
459nfsd4_recdir_purge_old(struct nfsd_net *nn)
460{
461 int status;
462
463 nn->in_grace = false;
464 if (!nn->rec_file)
465 return;
466 status = mnt_want_write_file(nn->rec_file);
467 if (status)
468 goto out;
469 status = nfsd4_list_rec_dir(purge_old, nn);
470 if (status == 0)
471 vfs_fsync(nn->rec_file, 0);
472 mnt_drop_write_file(nn->rec_file);
473out:
474 nfs4_release_reclaim(nn);
475 if (status)
476 printk("nfsd4: failed to purge old clients from recovery"
477 " directory %pD\n", nn->rec_file);
478}
479
480static int
481load_recdir(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
482{
483 struct xdr_netobj name;
484 struct xdr_netobj princhash = { .len = 0, .data = NULL };
485
486 if (child->d_name.len != HEXDIR_LEN - 1) {
487 printk("%s: illegal name %pd in recovery directory\n",
488 __func__, child);
489 /* Keep trying; maybe the others are OK: */
490 return 0;
491 }
492 name.data = kmemdup_nul(child->d_name.name, child->d_name.len, GFP_KERNEL);
493 if (!name.data) {
494 dprintk("%s: failed to allocate memory for name.data!\n",
495 __func__);
496 goto out;
497 }
498 name.len = HEXDIR_LEN;
499 if (!nfs4_client_to_reclaim(name, princhash, nn))
500 kfree(name.data);
501out:
502 return 0;
503}
504
505static int
506nfsd4_recdir_load(struct net *net) {
507 int status;
508 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
509
510 if (!nn->rec_file)
511 return 0;
512
513 status = nfsd4_list_rec_dir(load_recdir, nn);
514 if (status)
515 printk("nfsd4: failed loading clients from recovery"
516 " directory %pD\n", nn->rec_file);
517 return status;
518}
519
520/*
521 * Hold reference to the recovery directory.
522 */
523
524static int
525nfsd4_init_recdir(struct net *net)
526{
527 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
528 const struct cred *original_cred;
529 int status;
530
531 printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
532 user_recovery_dirname);
533
534 BUG_ON(nn->rec_file);
535
536 status = nfs4_save_creds(&original_cred);
537 if (status < 0) {
538 printk("NFSD: Unable to change credentials to find recovery"
539 " directory: error %d\n",
540 status);
541 return status;
542 }
543
544 nn->rec_file = filp_open(user_recovery_dirname, O_RDONLY | O_DIRECTORY, 0);
545 if (IS_ERR(nn->rec_file)) {
546 printk("NFSD: unable to find recovery directory %s\n",
547 user_recovery_dirname);
548 status = PTR_ERR(nn->rec_file);
549 nn->rec_file = NULL;
550 }
551
552 nfs4_reset_creds(original_cred);
553 if (!status)
554 nn->in_grace = true;
555 return status;
556}
557
558static void
559nfsd4_shutdown_recdir(struct net *net)
560{
561 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
562
563 if (!nn->rec_file)
564 return;
565 fput(nn->rec_file);
566 nn->rec_file = NULL;
567}
568
569static int
570nfs4_legacy_state_init(struct net *net)
571{
572 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
573 int i;
574
575 nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
576 sizeof(struct list_head),
577 GFP_KERNEL);
578 if (!nn->reclaim_str_hashtbl)
579 return -ENOMEM;
580
581 for (i = 0; i < CLIENT_HASH_SIZE; i++)
582 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]);
583 nn->reclaim_str_hashtbl_size = 0;
584
585 return 0;
586}
587
588static void
589nfs4_legacy_state_shutdown(struct net *net)
590{
591 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
592
593 kfree(nn->reclaim_str_hashtbl);
594}
595
596static int
597nfsd4_load_reboot_recovery_data(struct net *net)
598{
599 int status;
600
601 status = nfsd4_init_recdir(net);
602 if (status)
603 return status;
604
605 status = nfsd4_recdir_load(net);
606 if (status)
607 nfsd4_shutdown_recdir(net);
608
609 return status;
610}
611
612static int
613nfsd4_legacy_tracking_init(struct net *net)
614{
615 int status;
616
617 /* XXX: The legacy code won't work in a container */
618 if (net != &init_net) {
619 pr_warn("NFSD: attempt to initialize legacy client tracking in a container ignored.\n");
620 return -EINVAL;
621 }
622
623 status = nfs4_legacy_state_init(net);
624 if (status)
625 return status;
626
627 status = nfsd4_load_reboot_recovery_data(net);
628 if (status)
629 goto err;
630 pr_info("NFSD: Using legacy client tracking operations.\n");
631 return 0;
632
633err:
634 nfs4_legacy_state_shutdown(net);
635 return status;
636}
637
638static void
639nfsd4_legacy_tracking_exit(struct net *net)
640{
641 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
642
643 nfs4_release_reclaim(nn);
644 nfsd4_shutdown_recdir(net);
645 nfs4_legacy_state_shutdown(net);
646}
647
648/*
649 * Change the NFSv4 recovery directory to recdir.
650 */
651int
652nfs4_reset_recoverydir(char *recdir)
653{
654 int status;
655 struct path path;
656
657 status = kern_path(recdir, LOOKUP_FOLLOW, &path);
658 if (status)
659 return status;
660 status = -ENOTDIR;
661 if (d_is_dir(path.dentry)) {
662 strcpy(user_recovery_dirname, recdir);
663 status = 0;
664 }
665 path_put(&path);
666 return status;
667}
668
669char *
670nfs4_recoverydir(void)
671{
672 return user_recovery_dirname;
673}
674
675static int
676nfsd4_check_legacy_client(struct nfs4_client *clp)
677{
678 int status;
679 char dname[HEXDIR_LEN];
680 struct nfs4_client_reclaim *crp;
681 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
682 struct xdr_netobj name;
683
684 /* did we already find that this client is stable? */
685 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
686 return 0;
687
688 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
689 if (status) {
690 legacy_recdir_name_error(clp, status);
691 return status;
692 }
693
694 /* look for it in the reclaim hashtable otherwise */
695 name.data = kmemdup(dname, HEXDIR_LEN, GFP_KERNEL);
696 if (!name.data) {
697 dprintk("%s: failed to allocate memory for name.data!\n",
698 __func__);
699 goto out_enoent;
700 }
701 name.len = HEXDIR_LEN;
702 crp = nfsd4_find_reclaim_client(name, nn);
703 kfree(name.data);
704 if (crp) {
705 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
706 crp->cr_clp = clp;
707 return 0;
708 }
709
710out_enoent:
711 return -ENOENT;
712}
713
714static const struct nfsd4_client_tracking_ops nfsd4_legacy_tracking_ops = {
715 .init = nfsd4_legacy_tracking_init,
716 .exit = nfsd4_legacy_tracking_exit,
717 .create = nfsd4_create_clid_dir,
718 .remove = nfsd4_remove_clid_dir,
719 .check = nfsd4_check_legacy_client,
720 .grace_done = nfsd4_recdir_purge_old,
721 .version = 1,
722 .msglen = 0,
723};
724#endif /* CONFIG_NFSD_LEGACY_CLIENT_TRACKING */
725
726/* Globals */
727#define NFSD_PIPE_DIR "nfsd"
728#define NFSD_CLD_PIPE "cld"
729
730/* per-net-ns structure for holding cld upcall info */
731struct cld_net {
732 struct rpc_pipe *cn_pipe;
733 spinlock_t cn_lock;
734 struct list_head cn_list;
735 unsigned int cn_xid;
736 struct crypto_shash *cn_tfm;
737#ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
738 bool cn_has_legacy;
739#endif
740};
741
742struct cld_upcall {
743 struct list_head cu_list;
744 struct cld_net *cu_net;
745 struct completion cu_done;
746 union {
747 struct cld_msg_hdr cu_hdr;
748 struct cld_msg cu_msg;
749 struct cld_msg_v2 cu_msg_v2;
750 } cu_u;
751};
752
753static int
754__cld_pipe_upcall(struct rpc_pipe *pipe, void *cmsg, struct nfsd_net *nn)
755{
756 int ret;
757 struct rpc_pipe_msg msg;
758 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall, cu_u);
759
760 memset(&msg, 0, sizeof(msg));
761 msg.data = cmsg;
762 msg.len = nn->client_tracking_ops->msglen;
763
764 ret = rpc_queue_upcall(pipe, &msg);
765 if (ret < 0) {
766 goto out;
767 }
768
769 wait_for_completion(&cup->cu_done);
770
771 if (msg.errno < 0)
772 ret = msg.errno;
773out:
774 return ret;
775}
776
777static int
778cld_pipe_upcall(struct rpc_pipe *pipe, void *cmsg, struct nfsd_net *nn)
779{
780 int ret;
781
782 /*
783 * -EAGAIN occurs when pipe is closed and reopened while there are
784 * upcalls queued.
785 */
786 do {
787 ret = __cld_pipe_upcall(pipe, cmsg, nn);
788 } while (ret == -EAGAIN);
789
790 return ret;
791}
792
793static ssize_t
794__cld_pipe_inprogress_downcall(const struct cld_msg_v2 __user *cmsg,
795 struct nfsd_net *nn)
796{
797 uint8_t cmd, princhashlen;
798 struct xdr_netobj name, princhash = { .len = 0, .data = NULL };
799 uint16_t namelen;
800
801 if (get_user(cmd, &cmsg->cm_cmd)) {
802 dprintk("%s: error when copying cmd from userspace", __func__);
803 return -EFAULT;
804 }
805 if (cmd == Cld_GraceStart) {
806 if (nn->client_tracking_ops->version >= 2) {
807 const struct cld_clntinfo __user *ci;
808
809 ci = &cmsg->cm_u.cm_clntinfo;
810 if (get_user(namelen, &ci->cc_name.cn_len))
811 return -EFAULT;
812 name.data = memdup_user(&ci->cc_name.cn_id, namelen);
813 if (IS_ERR(name.data))
814 return PTR_ERR(name.data);
815 name.len = namelen;
816 get_user(princhashlen, &ci->cc_princhash.cp_len);
817 if (princhashlen > 0) {
818 princhash.data = memdup_user(
819 &ci->cc_princhash.cp_data,
820 princhashlen);
821 if (IS_ERR(princhash.data)) {
822 kfree(name.data);
823 return PTR_ERR(princhash.data);
824 }
825 princhash.len = princhashlen;
826 } else
827 princhash.len = 0;
828 } else {
829 const struct cld_name __user *cnm;
830
831 cnm = &cmsg->cm_u.cm_name;
832 if (get_user(namelen, &cnm->cn_len))
833 return -EFAULT;
834 name.data = memdup_user(&cnm->cn_id, namelen);
835 if (IS_ERR(name.data))
836 return PTR_ERR(name.data);
837 name.len = namelen;
838 }
839#ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
840 if (name.len > 5 && memcmp(name.data, "hash:", 5) == 0) {
841 struct cld_net *cn = nn->cld_net;
842
843 name.len = name.len - 5;
844 memmove(name.data, name.data + 5, name.len);
845 cn->cn_has_legacy = true;
846 }
847#endif
848 if (!nfs4_client_to_reclaim(name, princhash, nn)) {
849 kfree(name.data);
850 kfree(princhash.data);
851 return -EFAULT;
852 }
853 return nn->client_tracking_ops->msglen;
854 }
855 return -EFAULT;
856}
857
858static ssize_t
859cld_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
860{
861 struct cld_upcall *tmp, *cup;
862 struct cld_msg_hdr __user *hdr = (struct cld_msg_hdr __user *)src;
863 struct cld_msg_v2 __user *cmsg = (struct cld_msg_v2 __user *)src;
864 uint32_t xid;
865 struct nfsd_net *nn = net_generic(file_inode(filp)->i_sb->s_fs_info,
866 nfsd_net_id);
867 struct cld_net *cn = nn->cld_net;
868 int16_t status;
869
870 if (mlen != nn->client_tracking_ops->msglen) {
871 dprintk("%s: got %zu bytes, expected %zu\n", __func__, mlen,
872 nn->client_tracking_ops->msglen);
873 return -EINVAL;
874 }
875
876 /* copy just the xid so we can try to find that */
877 if (copy_from_user(&xid, &hdr->cm_xid, sizeof(xid)) != 0) {
878 dprintk("%s: error when copying xid from userspace", __func__);
879 return -EFAULT;
880 }
881
882 /*
883 * copy the status so we know whether to remove the upcall from the
884 * list (for -EINPROGRESS, we just want to make sure the xid is
885 * valid, not remove the upcall from the list)
886 */
887 if (get_user(status, &hdr->cm_status)) {
888 dprintk("%s: error when copying status from userspace", __func__);
889 return -EFAULT;
890 }
891
892 /* walk the list and find corresponding xid */
893 cup = NULL;
894 spin_lock(&cn->cn_lock);
895 list_for_each_entry(tmp, &cn->cn_list, cu_list) {
896 if (get_unaligned(&tmp->cu_u.cu_hdr.cm_xid) == xid) {
897 cup = tmp;
898 if (status != -EINPROGRESS)
899 list_del_init(&cup->cu_list);
900 break;
901 }
902 }
903 spin_unlock(&cn->cn_lock);
904
905 /* couldn't find upcall? */
906 if (!cup) {
907 dprintk("%s: couldn't find upcall -- xid=%u\n", __func__, xid);
908 return -EINVAL;
909 }
910
911 if (status == -EINPROGRESS)
912 return __cld_pipe_inprogress_downcall(cmsg, nn);
913
914 if (copy_from_user(&cup->cu_u.cu_msg_v2, src, mlen) != 0)
915 return -EFAULT;
916
917 complete(&cup->cu_done);
918 return mlen;
919}
920
921static void
922cld_pipe_destroy_msg(struct rpc_pipe_msg *msg)
923{
924 struct cld_msg *cmsg = msg->data;
925 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall,
926 cu_u.cu_msg);
927
928 /* errno >= 0 means we got a downcall */
929 if (msg->errno >= 0)
930 return;
931
932 complete(&cup->cu_done);
933}
934
935static const struct rpc_pipe_ops cld_upcall_ops = {
936 .upcall = rpc_pipe_generic_upcall,
937 .downcall = cld_pipe_downcall,
938 .destroy_msg = cld_pipe_destroy_msg,
939};
940
941static struct dentry *
942nfsd4_cld_register_sb(struct super_block *sb, struct rpc_pipe *pipe)
943{
944 struct dentry *dir, *dentry;
945
946 dir = rpc_d_lookup_sb(sb, NFSD_PIPE_DIR);
947 if (dir == NULL)
948 return ERR_PTR(-ENOENT);
949 dentry = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe);
950 dput(dir);
951 return dentry;
952}
953
954static void
955nfsd4_cld_unregister_sb(struct rpc_pipe *pipe)
956{
957 if (pipe->dentry)
958 rpc_unlink(pipe->dentry);
959}
960
961static struct dentry *
962nfsd4_cld_register_net(struct net *net, struct rpc_pipe *pipe)
963{
964 struct super_block *sb;
965 struct dentry *dentry;
966
967 sb = rpc_get_sb_net(net);
968 if (!sb)
969 return NULL;
970 dentry = nfsd4_cld_register_sb(sb, pipe);
971 rpc_put_sb_net(net);
972 return dentry;
973}
974
975static void
976nfsd4_cld_unregister_net(struct net *net, struct rpc_pipe *pipe)
977{
978 struct super_block *sb;
979
980 sb = rpc_get_sb_net(net);
981 if (sb) {
982 nfsd4_cld_unregister_sb(pipe);
983 rpc_put_sb_net(net);
984 }
985}
986
987/* Initialize rpc_pipefs pipe for communication with client tracking daemon */
988static int
989__nfsd4_init_cld_pipe(struct net *net)
990{
991 int ret;
992 struct dentry *dentry;
993 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
994 struct cld_net *cn;
995
996 if (nn->cld_net)
997 return 0;
998
999 cn = kzalloc(sizeof(*cn), GFP_KERNEL);
1000 if (!cn) {
1001 ret = -ENOMEM;
1002 goto err;
1003 }
1004
1005 cn->cn_pipe = rpc_mkpipe_data(&cld_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
1006 if (IS_ERR(cn->cn_pipe)) {
1007 ret = PTR_ERR(cn->cn_pipe);
1008 goto err;
1009 }
1010 spin_lock_init(&cn->cn_lock);
1011 INIT_LIST_HEAD(&cn->cn_list);
1012
1013 dentry = nfsd4_cld_register_net(net, cn->cn_pipe);
1014 if (IS_ERR(dentry)) {
1015 ret = PTR_ERR(dentry);
1016 goto err_destroy_data;
1017 }
1018
1019 cn->cn_pipe->dentry = dentry;
1020#ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
1021 cn->cn_has_legacy = false;
1022#endif
1023 nn->cld_net = cn;
1024 return 0;
1025
1026err_destroy_data:
1027 rpc_destroy_pipe_data(cn->cn_pipe);
1028err:
1029 kfree(cn);
1030 printk(KERN_ERR "NFSD: unable to create nfsdcld upcall pipe (%d)\n",
1031 ret);
1032 return ret;
1033}
1034
1035static int
1036nfsd4_init_cld_pipe(struct net *net)
1037{
1038 int status;
1039
1040 status = __nfsd4_init_cld_pipe(net);
1041 if (!status)
1042 pr_info("NFSD: Using old nfsdcld client tracking operations.\n");
1043 return status;
1044}
1045
1046static void
1047nfsd4_remove_cld_pipe(struct net *net)
1048{
1049 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1050 struct cld_net *cn = nn->cld_net;
1051
1052 nfsd4_cld_unregister_net(net, cn->cn_pipe);
1053 rpc_destroy_pipe_data(cn->cn_pipe);
1054 if (cn->cn_tfm)
1055 crypto_free_shash(cn->cn_tfm);
1056 kfree(nn->cld_net);
1057 nn->cld_net = NULL;
1058}
1059
1060static struct cld_upcall *
1061alloc_cld_upcall(struct nfsd_net *nn)
1062{
1063 struct cld_upcall *new, *tmp;
1064 struct cld_net *cn = nn->cld_net;
1065
1066 new = kzalloc(sizeof(*new), GFP_KERNEL);
1067 if (!new)
1068 return new;
1069
1070 /* FIXME: hard cap on number in flight? */
1071restart_search:
1072 spin_lock(&cn->cn_lock);
1073 list_for_each_entry(tmp, &cn->cn_list, cu_list) {
1074 if (tmp->cu_u.cu_msg.cm_xid == cn->cn_xid) {
1075 cn->cn_xid++;
1076 spin_unlock(&cn->cn_lock);
1077 goto restart_search;
1078 }
1079 }
1080 init_completion(&new->cu_done);
1081 new->cu_u.cu_msg.cm_vers = nn->client_tracking_ops->version;
1082 put_unaligned(cn->cn_xid++, &new->cu_u.cu_msg.cm_xid);
1083 new->cu_net = cn;
1084 list_add(&new->cu_list, &cn->cn_list);
1085 spin_unlock(&cn->cn_lock);
1086
1087 dprintk("%s: allocated xid %u\n", __func__, new->cu_u.cu_msg.cm_xid);
1088
1089 return new;
1090}
1091
1092static void
1093free_cld_upcall(struct cld_upcall *victim)
1094{
1095 struct cld_net *cn = victim->cu_net;
1096
1097 spin_lock(&cn->cn_lock);
1098 list_del(&victim->cu_list);
1099 spin_unlock(&cn->cn_lock);
1100 kfree(victim);
1101}
1102
1103/* Ask daemon to create a new record */
1104static void
1105nfsd4_cld_create(struct nfs4_client *clp)
1106{
1107 int ret;
1108 struct cld_upcall *cup;
1109 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1110 struct cld_net *cn = nn->cld_net;
1111
1112 /* Don't upcall if it's already stored */
1113 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1114 return;
1115
1116 cup = alloc_cld_upcall(nn);
1117 if (!cup) {
1118 ret = -ENOMEM;
1119 goto out_err;
1120 }
1121
1122 cup->cu_u.cu_msg.cm_cmd = Cld_Create;
1123 cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
1124 memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
1125 clp->cl_name.len);
1126
1127 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);
1128 if (!ret) {
1129 ret = cup->cu_u.cu_msg.cm_status;
1130 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1131 }
1132
1133 free_cld_upcall(cup);
1134out_err:
1135 if (ret)
1136 printk(KERN_ERR "NFSD: Unable to create client "
1137 "record on stable storage: %d\n", ret);
1138}
1139
1140/* Ask daemon to create a new record */
1141static void
1142nfsd4_cld_create_v2(struct nfs4_client *clp)
1143{
1144 int ret;
1145 struct cld_upcall *cup;
1146 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1147 struct cld_net *cn = nn->cld_net;
1148 struct cld_msg_v2 *cmsg;
1149 struct crypto_shash *tfm = cn->cn_tfm;
1150 struct xdr_netobj cksum;
1151 char *principal = NULL;
1152
1153 /* Don't upcall if it's already stored */
1154 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1155 return;
1156
1157 cup = alloc_cld_upcall(nn);
1158 if (!cup) {
1159 ret = -ENOMEM;
1160 goto out_err;
1161 }
1162
1163 cmsg = &cup->cu_u.cu_msg_v2;
1164 cmsg->cm_cmd = Cld_Create;
1165 cmsg->cm_u.cm_clntinfo.cc_name.cn_len = clp->cl_name.len;
1166 memcpy(cmsg->cm_u.cm_clntinfo.cc_name.cn_id, clp->cl_name.data,
1167 clp->cl_name.len);
1168 if (clp->cl_cred.cr_raw_principal)
1169 principal = clp->cl_cred.cr_raw_principal;
1170 else if (clp->cl_cred.cr_principal)
1171 principal = clp->cl_cred.cr_principal;
1172 if (principal) {
1173 cksum.len = crypto_shash_digestsize(tfm);
1174 cksum.data = kmalloc(cksum.len, GFP_KERNEL);
1175 if (cksum.data == NULL) {
1176 ret = -ENOMEM;
1177 goto out;
1178 }
1179 ret = crypto_shash_tfm_digest(tfm, principal, strlen(principal),
1180 cksum.data);
1181 if (ret) {
1182 kfree(cksum.data);
1183 goto out;
1184 }
1185 cmsg->cm_u.cm_clntinfo.cc_princhash.cp_len = cksum.len;
1186 memcpy(cmsg->cm_u.cm_clntinfo.cc_princhash.cp_data,
1187 cksum.data, cksum.len);
1188 kfree(cksum.data);
1189 } else
1190 cmsg->cm_u.cm_clntinfo.cc_princhash.cp_len = 0;
1191
1192 ret = cld_pipe_upcall(cn->cn_pipe, cmsg, nn);
1193 if (!ret) {
1194 ret = cmsg->cm_status;
1195 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1196 }
1197
1198out:
1199 free_cld_upcall(cup);
1200out_err:
1201 if (ret)
1202 pr_err("NFSD: Unable to create client record on stable storage: %d\n",
1203 ret);
1204}
1205
1206/* Ask daemon to create a new record */
1207static void
1208nfsd4_cld_remove(struct nfs4_client *clp)
1209{
1210 int ret;
1211 struct cld_upcall *cup;
1212 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1213 struct cld_net *cn = nn->cld_net;
1214
1215 /* Don't upcall if it's already removed */
1216 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1217 return;
1218
1219 cup = alloc_cld_upcall(nn);
1220 if (!cup) {
1221 ret = -ENOMEM;
1222 goto out_err;
1223 }
1224
1225 cup->cu_u.cu_msg.cm_cmd = Cld_Remove;
1226 cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
1227 memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
1228 clp->cl_name.len);
1229
1230 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);
1231 if (!ret) {
1232 ret = cup->cu_u.cu_msg.cm_status;
1233 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1234 }
1235
1236 free_cld_upcall(cup);
1237out_err:
1238 if (ret)
1239 printk(KERN_ERR "NFSD: Unable to remove client "
1240 "record from stable storage: %d\n", ret);
1241}
1242
1243/*
1244 * For older nfsdcld's that do not allow us to "slurp" the clients
1245 * from the tracking database during startup.
1246 *
1247 * Check for presence of a record, and update its timestamp
1248 */
1249static int
1250nfsd4_cld_check_v0(struct nfs4_client *clp)
1251{
1252 int ret;
1253 struct cld_upcall *cup;
1254 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1255 struct cld_net *cn = nn->cld_net;
1256
1257 /* Don't upcall if one was already stored during this grace pd */
1258 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1259 return 0;
1260
1261 cup = alloc_cld_upcall(nn);
1262 if (!cup) {
1263 printk(KERN_ERR "NFSD: Unable to check client record on "
1264 "stable storage: %d\n", -ENOMEM);
1265 return -ENOMEM;
1266 }
1267
1268 cup->cu_u.cu_msg.cm_cmd = Cld_Check;
1269 cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
1270 memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
1271 clp->cl_name.len);
1272
1273 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);
1274 if (!ret) {
1275 ret = cup->cu_u.cu_msg.cm_status;
1276 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1277 }
1278
1279 free_cld_upcall(cup);
1280 return ret;
1281}
1282
1283/*
1284 * For newer nfsdcld's that allow us to "slurp" the clients
1285 * from the tracking database during startup.
1286 *
1287 * Check for presence of a record in the reclaim_str_hashtbl
1288 */
1289static int
1290nfsd4_cld_check(struct nfs4_client *clp)
1291{
1292 struct nfs4_client_reclaim *crp;
1293 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1294
1295 /* did we already find that this client is stable? */
1296 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1297 return 0;
1298
1299 /* look for it in the reclaim hashtable otherwise */
1300 crp = nfsd4_find_reclaim_client(clp->cl_name, nn);
1301 if (crp)
1302 goto found;
1303
1304#ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
1305 if (nn->cld_net->cn_has_legacy) {
1306 int status;
1307 char dname[HEXDIR_LEN];
1308 struct xdr_netobj name;
1309
1310 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
1311 if (status)
1312 return -ENOENT;
1313
1314 name.data = kmemdup(dname, HEXDIR_LEN, GFP_KERNEL);
1315 if (!name.data) {
1316 dprintk("%s: failed to allocate memory for name.data!\n",
1317 __func__);
1318 return -ENOENT;
1319 }
1320 name.len = HEXDIR_LEN;
1321 crp = nfsd4_find_reclaim_client(name, nn);
1322 kfree(name.data);
1323 if (crp)
1324 goto found;
1325
1326 }
1327#endif
1328 return -ENOENT;
1329found:
1330 crp->cr_clp = clp;
1331 return 0;
1332}
1333
1334static int
1335nfsd4_cld_check_v2(struct nfs4_client *clp)
1336{
1337 struct nfs4_client_reclaim *crp;
1338 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1339 struct cld_net *cn = nn->cld_net;
1340 int status;
1341 struct crypto_shash *tfm = cn->cn_tfm;
1342 struct xdr_netobj cksum;
1343 char *principal = NULL;
1344
1345 /* did we already find that this client is stable? */
1346 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1347 return 0;
1348
1349 /* look for it in the reclaim hashtable otherwise */
1350 crp = nfsd4_find_reclaim_client(clp->cl_name, nn);
1351 if (crp)
1352 goto found;
1353
1354#ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
1355 if (cn->cn_has_legacy) {
1356 struct xdr_netobj name;
1357 char dname[HEXDIR_LEN];
1358
1359 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
1360 if (status)
1361 return -ENOENT;
1362
1363 name.data = kmemdup(dname, HEXDIR_LEN, GFP_KERNEL);
1364 if (!name.data) {
1365 dprintk("%s: failed to allocate memory for name.data\n",
1366 __func__);
1367 return -ENOENT;
1368 }
1369 name.len = HEXDIR_LEN;
1370 crp = nfsd4_find_reclaim_client(name, nn);
1371 kfree(name.data);
1372 if (crp)
1373 goto found;
1374
1375 }
1376#endif
1377 return -ENOENT;
1378found:
1379 if (crp->cr_princhash.len) {
1380 if (clp->cl_cred.cr_raw_principal)
1381 principal = clp->cl_cred.cr_raw_principal;
1382 else if (clp->cl_cred.cr_principal)
1383 principal = clp->cl_cred.cr_principal;
1384 if (principal == NULL)
1385 return -ENOENT;
1386 cksum.len = crypto_shash_digestsize(tfm);
1387 cksum.data = kmalloc(cksum.len, GFP_KERNEL);
1388 if (cksum.data == NULL)
1389 return -ENOENT;
1390 status = crypto_shash_tfm_digest(tfm, principal,
1391 strlen(principal), cksum.data);
1392 if (status) {
1393 kfree(cksum.data);
1394 return -ENOENT;
1395 }
1396 if (memcmp(crp->cr_princhash.data, cksum.data,
1397 crp->cr_princhash.len)) {
1398 kfree(cksum.data);
1399 return -ENOENT;
1400 }
1401 kfree(cksum.data);
1402 }
1403 crp->cr_clp = clp;
1404 return 0;
1405}
1406
1407static int
1408nfsd4_cld_grace_start(struct nfsd_net *nn)
1409{
1410 int ret;
1411 struct cld_upcall *cup;
1412 struct cld_net *cn = nn->cld_net;
1413
1414 cup = alloc_cld_upcall(nn);
1415 if (!cup) {
1416 ret = -ENOMEM;
1417 goto out_err;
1418 }
1419
1420 cup->cu_u.cu_msg.cm_cmd = Cld_GraceStart;
1421 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);
1422 if (!ret)
1423 ret = cup->cu_u.cu_msg.cm_status;
1424
1425 free_cld_upcall(cup);
1426out_err:
1427 if (ret)
1428 dprintk("%s: Unable to get clients from userspace: %d\n",
1429 __func__, ret);
1430 return ret;
1431}
1432
1433/* For older nfsdcld's that need cm_gracetime */
1434static void
1435nfsd4_cld_grace_done_v0(struct nfsd_net *nn)
1436{
1437 int ret;
1438 struct cld_upcall *cup;
1439 struct cld_net *cn = nn->cld_net;
1440
1441 cup = alloc_cld_upcall(nn);
1442 if (!cup) {
1443 ret = -ENOMEM;
1444 goto out_err;
1445 }
1446
1447 cup->cu_u.cu_msg.cm_cmd = Cld_GraceDone;
1448 cup->cu_u.cu_msg.cm_u.cm_gracetime = nn->boot_time;
1449 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);
1450 if (!ret)
1451 ret = cup->cu_u.cu_msg.cm_status;
1452
1453 free_cld_upcall(cup);
1454out_err:
1455 if (ret)
1456 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret);
1457}
1458
1459/*
1460 * For newer nfsdcld's that do not need cm_gracetime. We also need to call
1461 * nfs4_release_reclaim() to clear out the reclaim_str_hashtbl.
1462 */
1463static void
1464nfsd4_cld_grace_done(struct nfsd_net *nn)
1465{
1466 int ret;
1467 struct cld_upcall *cup;
1468 struct cld_net *cn = nn->cld_net;
1469
1470 cup = alloc_cld_upcall(nn);
1471 if (!cup) {
1472 ret = -ENOMEM;
1473 goto out_err;
1474 }
1475
1476 cup->cu_u.cu_msg.cm_cmd = Cld_GraceDone;
1477 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);
1478 if (!ret)
1479 ret = cup->cu_u.cu_msg.cm_status;
1480
1481 free_cld_upcall(cup);
1482out_err:
1483 nfs4_release_reclaim(nn);
1484 if (ret)
1485 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret);
1486}
1487
1488static int
1489nfs4_cld_state_init(struct net *net)
1490{
1491 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1492 int i;
1493
1494 nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
1495 sizeof(struct list_head),
1496 GFP_KERNEL);
1497 if (!nn->reclaim_str_hashtbl)
1498 return -ENOMEM;
1499
1500 for (i = 0; i < CLIENT_HASH_SIZE; i++)
1501 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]);
1502 nn->reclaim_str_hashtbl_size = 0;
1503 nn->track_reclaim_completes = true;
1504 atomic_set(&nn->nr_reclaim_complete, 0);
1505
1506 return 0;
1507}
1508
1509static void
1510nfs4_cld_state_shutdown(struct net *net)
1511{
1512 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1513
1514 nn->track_reclaim_completes = false;
1515 kfree(nn->reclaim_str_hashtbl);
1516}
1517
1518static bool
1519cld_running(struct nfsd_net *nn)
1520{
1521 struct cld_net *cn = nn->cld_net;
1522 struct rpc_pipe *pipe = cn->cn_pipe;
1523
1524 return pipe->nreaders || pipe->nwriters;
1525}
1526
1527static int
1528nfsd4_cld_get_version(struct nfsd_net *nn)
1529{
1530 int ret = 0;
1531 struct cld_upcall *cup;
1532 struct cld_net *cn = nn->cld_net;
1533 uint8_t version;
1534
1535 cup = alloc_cld_upcall(nn);
1536 if (!cup) {
1537 ret = -ENOMEM;
1538 goto out_err;
1539 }
1540 cup->cu_u.cu_msg.cm_cmd = Cld_GetVersion;
1541 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);
1542 if (!ret) {
1543 ret = cup->cu_u.cu_msg.cm_status;
1544 if (ret)
1545 goto out_free;
1546 version = cup->cu_u.cu_msg.cm_u.cm_version;
1547 dprintk("%s: userspace returned version %u\n",
1548 __func__, version);
1549 if (version < 1)
1550 version = 1;
1551 else if (version > CLD_UPCALL_VERSION)
1552 version = CLD_UPCALL_VERSION;
1553
1554 switch (version) {
1555 case 1:
1556 nn->client_tracking_ops = &nfsd4_cld_tracking_ops;
1557 break;
1558 case 2:
1559 nn->client_tracking_ops = &nfsd4_cld_tracking_ops_v2;
1560 break;
1561 default:
1562 break;
1563 }
1564 }
1565out_free:
1566 free_cld_upcall(cup);
1567out_err:
1568 if (ret)
1569 dprintk("%s: Unable to get version from userspace: %d\n",
1570 __func__, ret);
1571 return ret;
1572}
1573
1574static int
1575nfsd4_cld_tracking_init(struct net *net)
1576{
1577 int status;
1578 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1579 bool running;
1580 int retries = 10;
1581 struct crypto_shash *tfm;
1582
1583 status = nfs4_cld_state_init(net);
1584 if (status)
1585 return status;
1586
1587 status = __nfsd4_init_cld_pipe(net);
1588 if (status)
1589 goto err_shutdown;
1590
1591 /*
1592 * rpc pipe upcalls take 30 seconds to time out, so we don't want to
1593 * queue an upcall unless we know that nfsdcld is running (because we
1594 * want this to fail fast so that nfsd4_client_tracking_init() can try
1595 * the next client tracking method). nfsdcld should already be running
1596 * before nfsd is started, so the wait here is for nfsdcld to open the
1597 * pipefs file we just created.
1598 */
1599 while (!(running = cld_running(nn)) && retries--)
1600 msleep(100);
1601
1602 if (!running) {
1603 status = -ETIMEDOUT;
1604 goto err_remove;
1605 }
1606 tfm = crypto_alloc_shash("sha256", 0, 0);
1607 if (IS_ERR(tfm)) {
1608 status = PTR_ERR(tfm);
1609 goto err_remove;
1610 }
1611 nn->cld_net->cn_tfm = tfm;
1612
1613 status = nfsd4_cld_get_version(nn);
1614 if (status == -EOPNOTSUPP)
1615 pr_warn("NFSD: nfsdcld GetVersion upcall failed. Please upgrade nfsdcld.\n");
1616
1617 status = nfsd4_cld_grace_start(nn);
1618 if (status) {
1619 if (status == -EOPNOTSUPP)
1620 pr_warn("NFSD: nfsdcld GraceStart upcall failed. Please upgrade nfsdcld.\n");
1621 nfs4_release_reclaim(nn);
1622 goto err_remove;
1623 } else
1624 pr_info("NFSD: Using nfsdcld client tracking operations.\n");
1625 return 0;
1626
1627err_remove:
1628 nfsd4_remove_cld_pipe(net);
1629err_shutdown:
1630 nfs4_cld_state_shutdown(net);
1631 return status;
1632}
1633
1634static void
1635nfsd4_cld_tracking_exit(struct net *net)
1636{
1637 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1638
1639 nfs4_release_reclaim(nn);
1640 nfsd4_remove_cld_pipe(net);
1641 nfs4_cld_state_shutdown(net);
1642}
1643
1644/* For older nfsdcld's */
1645static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops_v0 = {
1646 .init = nfsd4_init_cld_pipe,
1647 .exit = nfsd4_remove_cld_pipe,
1648 .create = nfsd4_cld_create,
1649 .remove = nfsd4_cld_remove,
1650 .check = nfsd4_cld_check_v0,
1651 .grace_done = nfsd4_cld_grace_done_v0,
1652 .version = 1,
1653 .msglen = sizeof(struct cld_msg),
1654};
1655
1656/* For newer nfsdcld's */
1657static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops = {
1658 .init = nfsd4_cld_tracking_init,
1659 .exit = nfsd4_cld_tracking_exit,
1660 .create = nfsd4_cld_create,
1661 .remove = nfsd4_cld_remove,
1662 .check = nfsd4_cld_check,
1663 .grace_done = nfsd4_cld_grace_done,
1664 .version = 1,
1665 .msglen = sizeof(struct cld_msg),
1666};
1667
1668/* v2 create/check ops include the principal, if available */
1669static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops_v2 = {
1670 .init = nfsd4_cld_tracking_init,
1671 .exit = nfsd4_cld_tracking_exit,
1672 .create = nfsd4_cld_create_v2,
1673 .remove = nfsd4_cld_remove,
1674 .check = nfsd4_cld_check_v2,
1675 .grace_done = nfsd4_cld_grace_done,
1676 .version = 2,
1677 .msglen = sizeof(struct cld_msg_v2),
1678};
1679
1680#ifdef CONFIG_NFSD_LEGACY_CLIENT_TRACKING
1681/* upcall via usermodehelper */
1682static char cltrack_prog[PATH_MAX] = "/sbin/nfsdcltrack";
1683module_param_string(cltrack_prog, cltrack_prog, sizeof(cltrack_prog),
1684 S_IRUGO|S_IWUSR);
1685MODULE_PARM_DESC(cltrack_prog, "Path to the nfsdcltrack upcall program");
1686
1687static bool cltrack_legacy_disable;
1688module_param(cltrack_legacy_disable, bool, S_IRUGO|S_IWUSR);
1689MODULE_PARM_DESC(cltrack_legacy_disable,
1690 "Disable legacy recoverydir conversion. Default: false");
1691
1692#define LEGACY_TOPDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_TOPDIR="
1693#define LEGACY_RECDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_RECDIR="
1694#define HAS_SESSION_ENV_PREFIX "NFSDCLTRACK_CLIENT_HAS_SESSION="
1695#define GRACE_START_ENV_PREFIX "NFSDCLTRACK_GRACE_START="
1696
1697static char *
1698nfsd4_cltrack_legacy_topdir(void)
1699{
1700 int copied;
1701 size_t len;
1702 char *result;
1703
1704 if (cltrack_legacy_disable)
1705 return NULL;
1706
1707 len = strlen(LEGACY_TOPDIR_ENV_PREFIX) +
1708 strlen(nfs4_recoverydir()) + 1;
1709
1710 result = kmalloc(len, GFP_KERNEL);
1711 if (!result)
1712 return result;
1713
1714 copied = snprintf(result, len, LEGACY_TOPDIR_ENV_PREFIX "%s",
1715 nfs4_recoverydir());
1716 if (copied >= len) {
1717 /* just return nothing if output was truncated */
1718 kfree(result);
1719 return NULL;
1720 }
1721
1722 return result;
1723}
1724
1725static char *
1726nfsd4_cltrack_legacy_recdir(const struct xdr_netobj *name)
1727{
1728 int copied;
1729 size_t len;
1730 char *result;
1731
1732 if (cltrack_legacy_disable)
1733 return NULL;
1734
1735 /* +1 is for '/' between "topdir" and "recdir" */
1736 len = strlen(LEGACY_RECDIR_ENV_PREFIX) +
1737 strlen(nfs4_recoverydir()) + 1 + HEXDIR_LEN;
1738
1739 result = kmalloc(len, GFP_KERNEL);
1740 if (!result)
1741 return result;
1742
1743 copied = snprintf(result, len, LEGACY_RECDIR_ENV_PREFIX "%s/",
1744 nfs4_recoverydir());
1745 if (copied > (len - HEXDIR_LEN)) {
1746 /* just return nothing if output will be truncated */
1747 kfree(result);
1748 return NULL;
1749 }
1750
1751 copied = nfs4_make_rec_clidname(result + copied, name);
1752 if (copied) {
1753 kfree(result);
1754 return NULL;
1755 }
1756
1757 return result;
1758}
1759
1760static char *
1761nfsd4_cltrack_client_has_session(struct nfs4_client *clp)
1762{
1763 int copied;
1764 size_t len;
1765 char *result;
1766
1767 /* prefix + Y/N character + terminating NULL */
1768 len = strlen(HAS_SESSION_ENV_PREFIX) + 1 + 1;
1769
1770 result = kmalloc(len, GFP_KERNEL);
1771 if (!result)
1772 return result;
1773
1774 copied = snprintf(result, len, HAS_SESSION_ENV_PREFIX "%c",
1775 clp->cl_minorversion ? 'Y' : 'N');
1776 if (copied >= len) {
1777 /* just return nothing if output was truncated */
1778 kfree(result);
1779 return NULL;
1780 }
1781
1782 return result;
1783}
1784
1785static char *
1786nfsd4_cltrack_grace_start(time64_t grace_start)
1787{
1788 int copied;
1789 size_t len;
1790 char *result;
1791
1792 /* prefix + max width of int64_t string + terminating NULL */
1793 len = strlen(GRACE_START_ENV_PREFIX) + 22 + 1;
1794
1795 result = kmalloc(len, GFP_KERNEL);
1796 if (!result)
1797 return result;
1798
1799 copied = snprintf(result, len, GRACE_START_ENV_PREFIX "%lld",
1800 grace_start);
1801 if (copied >= len) {
1802 /* just return nothing if output was truncated */
1803 kfree(result);
1804 return NULL;
1805 }
1806
1807 return result;
1808}
1809
1810static int
1811nfsd4_umh_cltrack_upcall(char *cmd, char *arg, char *env0, char *env1)
1812{
1813 char *envp[3];
1814 char *argv[4];
1815 int ret;
1816
1817 if (unlikely(!cltrack_prog[0])) {
1818 dprintk("%s: cltrack_prog is disabled\n", __func__);
1819 return -EACCES;
1820 }
1821
1822 dprintk("%s: cmd: %s\n", __func__, cmd);
1823 dprintk("%s: arg: %s\n", __func__, arg ? arg : "(null)");
1824 dprintk("%s: env0: %s\n", __func__, env0 ? env0 : "(null)");
1825 dprintk("%s: env1: %s\n", __func__, env1 ? env1 : "(null)");
1826
1827 envp[0] = env0;
1828 envp[1] = env1;
1829 envp[2] = NULL;
1830
1831 argv[0] = (char *)cltrack_prog;
1832 argv[1] = cmd;
1833 argv[2] = arg;
1834 argv[3] = NULL;
1835
1836 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
1837 /*
1838 * Disable the upcall mechanism if we're getting an ENOENT or EACCES
1839 * error. The admin can re-enable it on the fly by using sysfs
1840 * once the problem has been fixed.
1841 */
1842 if (ret == -ENOENT || ret == -EACCES) {
1843 dprintk("NFSD: %s was not found or isn't executable (%d). "
1844 "Setting cltrack_prog to blank string!",
1845 cltrack_prog, ret);
1846 cltrack_prog[0] = '\0';
1847 }
1848 dprintk("%s: %s return value: %d\n", __func__, cltrack_prog, ret);
1849
1850 return ret;
1851}
1852
1853static char *
1854bin_to_hex_dup(const unsigned char *src, int srclen)
1855{
1856 char *buf;
1857
1858 /* +1 for terminating NULL */
1859 buf = kzalloc((srclen * 2) + 1, GFP_KERNEL);
1860 if (!buf)
1861 return buf;
1862
1863 bin2hex(buf, src, srclen);
1864 return buf;
1865}
1866
1867static int
1868nfsd4_umh_cltrack_init(struct net *net)
1869{
1870 int ret;
1871 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1872 char *grace_start = nfsd4_cltrack_grace_start(nn->boot_time);
1873
1874 /* XXX: The usermode helper s not working in container yet. */
1875 if (net != &init_net) {
1876 pr_warn("NFSD: attempt to initialize umh client tracking in a container ignored.\n");
1877 kfree(grace_start);
1878 return -EINVAL;
1879 }
1880
1881 ret = nfsd4_umh_cltrack_upcall("init", NULL, grace_start, NULL);
1882 kfree(grace_start);
1883 if (!ret)
1884 pr_info("NFSD: Using UMH upcall client tracking operations.\n");
1885 return ret;
1886}
1887
1888static void
1889nfsd4_cltrack_upcall_lock(struct nfs4_client *clp)
1890{
1891 wait_on_bit_lock(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK,
1892 TASK_UNINTERRUPTIBLE);
1893}
1894
1895static void
1896nfsd4_cltrack_upcall_unlock(struct nfs4_client *clp)
1897{
1898 smp_mb__before_atomic();
1899 clear_bit(NFSD4_CLIENT_UPCALL_LOCK, &clp->cl_flags);
1900 smp_mb__after_atomic();
1901 wake_up_bit(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK);
1902}
1903
1904static void
1905nfsd4_umh_cltrack_create(struct nfs4_client *clp)
1906{
1907 char *hexid, *has_session, *grace_start;
1908 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1909
1910 /*
1911 * With v4.0 clients, there's little difference in outcome between a
1912 * create and check operation, and we can end up calling into this
1913 * function multiple times per client (once for each openowner). So,
1914 * for v4.0 clients skip upcalling once the client has been recorded
1915 * on stable storage.
1916 *
1917 * For v4.1+ clients, the outcome of the two operations is different,
1918 * so we must ensure that we upcall for the create operation. v4.1+
1919 * clients call this on RECLAIM_COMPLETE though, so we should only end
1920 * up doing a single create upcall per client.
1921 */
1922 if (clp->cl_minorversion == 0 &&
1923 test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1924 return;
1925
1926 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1927 if (!hexid) {
1928 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1929 return;
1930 }
1931
1932 has_session = nfsd4_cltrack_client_has_session(clp);
1933 grace_start = nfsd4_cltrack_grace_start(nn->boot_time);
1934
1935 nfsd4_cltrack_upcall_lock(clp);
1936 if (!nfsd4_umh_cltrack_upcall("create", hexid, has_session, grace_start))
1937 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1938 nfsd4_cltrack_upcall_unlock(clp);
1939
1940 kfree(has_session);
1941 kfree(grace_start);
1942 kfree(hexid);
1943}
1944
1945static void
1946nfsd4_umh_cltrack_remove(struct nfs4_client *clp)
1947{
1948 char *hexid;
1949
1950 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1951 return;
1952
1953 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1954 if (!hexid) {
1955 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1956 return;
1957 }
1958
1959 nfsd4_cltrack_upcall_lock(clp);
1960 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags) &&
1961 nfsd4_umh_cltrack_upcall("remove", hexid, NULL, NULL) == 0)
1962 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1963 nfsd4_cltrack_upcall_unlock(clp);
1964
1965 kfree(hexid);
1966}
1967
1968static int
1969nfsd4_umh_cltrack_check(struct nfs4_client *clp)
1970{
1971 int ret;
1972 char *hexid, *has_session, *legacy;
1973
1974 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1975 return 0;
1976
1977 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1978 if (!hexid) {
1979 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1980 return -ENOMEM;
1981 }
1982
1983 has_session = nfsd4_cltrack_client_has_session(clp);
1984 legacy = nfsd4_cltrack_legacy_recdir(&clp->cl_name);
1985
1986 nfsd4_cltrack_upcall_lock(clp);
1987 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) {
1988 ret = 0;
1989 } else {
1990 ret = nfsd4_umh_cltrack_upcall("check", hexid, has_session, legacy);
1991 if (ret == 0)
1992 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1993 }
1994 nfsd4_cltrack_upcall_unlock(clp);
1995 kfree(has_session);
1996 kfree(legacy);
1997 kfree(hexid);
1998
1999 return ret;
2000}
2001
2002static void
2003nfsd4_umh_cltrack_grace_done(struct nfsd_net *nn)
2004{
2005 char *legacy;
2006 char timestr[22]; /* FIXME: better way to determine max size? */
2007
2008 sprintf(timestr, "%lld", nn->boot_time);
2009 legacy = nfsd4_cltrack_legacy_topdir();
2010 nfsd4_umh_cltrack_upcall("gracedone", timestr, legacy, NULL);
2011 kfree(legacy);
2012}
2013
2014static const struct nfsd4_client_tracking_ops nfsd4_umh_tracking_ops = {
2015 .init = nfsd4_umh_cltrack_init,
2016 .exit = NULL,
2017 .create = nfsd4_umh_cltrack_create,
2018 .remove = nfsd4_umh_cltrack_remove,
2019 .check = nfsd4_umh_cltrack_check,
2020 .grace_done = nfsd4_umh_cltrack_grace_done,
2021 .version = 1,
2022 .msglen = 0,
2023};
2024
2025static inline int check_for_legacy_methods(int status, struct net *net)
2026{
2027 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2028 struct path path;
2029
2030 /*
2031 * Next, try the UMH upcall.
2032 */
2033 nn->client_tracking_ops = &nfsd4_umh_tracking_ops;
2034 status = nn->client_tracking_ops->init(net);
2035 if (!status)
2036 return status;
2037
2038 /*
2039 * Finally, See if the recoverydir exists and is a directory.
2040 * If it is, then use the legacy ops.
2041 */
2042 nn->client_tracking_ops = &nfsd4_legacy_tracking_ops;
2043 status = kern_path(nfs4_recoverydir(), LOOKUP_FOLLOW, &path);
2044 if (!status) {
2045 status = !d_is_dir(path.dentry);
2046 path_put(&path);
2047 if (status)
2048 return -ENOTDIR;
2049 status = nn->client_tracking_ops->init(net);
2050 }
2051 return status;
2052}
2053#else
2054static inline int check_for_legacy_methods(int status, struct net *net)
2055{
2056 return status;
2057}
2058#endif /* CONFIG_LEGACY_NFSD_CLIENT_TRACKING */
2059
2060int
2061nfsd4_client_tracking_init(struct net *net)
2062{
2063 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2064 int status;
2065
2066 /* just run the init if it the method is already decided */
2067 if (nn->client_tracking_ops)
2068 goto do_init;
2069
2070 /* First, try to use nfsdcld */
2071 nn->client_tracking_ops = &nfsd4_cld_tracking_ops;
2072 status = nn->client_tracking_ops->init(net);
2073 if (!status)
2074 return status;
2075 if (status != -ETIMEDOUT) {
2076 nn->client_tracking_ops = &nfsd4_cld_tracking_ops_v0;
2077 status = nn->client_tracking_ops->init(net);
2078 if (!status)
2079 return status;
2080 }
2081
2082 status = check_for_legacy_methods(status, net);
2083 if (status)
2084 goto out;
2085do_init:
2086 status = nn->client_tracking_ops->init(net);
2087out:
2088 if (status) {
2089 printk(KERN_WARNING "NFSD: Unable to initialize client "
2090 "recovery tracking! (%d)\n", status);
2091 nn->client_tracking_ops = NULL;
2092 }
2093 return status;
2094}
2095
2096void
2097nfsd4_client_tracking_exit(struct net *net)
2098{
2099 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2100
2101 if (nn->client_tracking_ops) {
2102 if (nn->client_tracking_ops->exit)
2103 nn->client_tracking_ops->exit(net);
2104 nn->client_tracking_ops = NULL;
2105 }
2106}
2107
2108void
2109nfsd4_client_record_create(struct nfs4_client *clp)
2110{
2111 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2112
2113 if (nn->client_tracking_ops)
2114 nn->client_tracking_ops->create(clp);
2115}
2116
2117void
2118nfsd4_client_record_remove(struct nfs4_client *clp)
2119{
2120 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2121
2122 if (nn->client_tracking_ops)
2123 nn->client_tracking_ops->remove(clp);
2124}
2125
2126int
2127nfsd4_client_record_check(struct nfs4_client *clp)
2128{
2129 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2130
2131 if (nn->client_tracking_ops)
2132 return nn->client_tracking_ops->check(clp);
2133
2134 return -EOPNOTSUPP;
2135}
2136
2137void
2138nfsd4_record_grace_done(struct nfsd_net *nn)
2139{
2140 if (nn->client_tracking_ops)
2141 nn->client_tracking_ops->grace_done(nn);
2142}
2143
2144static int
2145rpc_pipefs_event(struct notifier_block *nb, unsigned long event, void *ptr)
2146{
2147 struct super_block *sb = ptr;
2148 struct net *net = sb->s_fs_info;
2149 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2150 struct cld_net *cn = nn->cld_net;
2151 struct dentry *dentry;
2152 int ret = 0;
2153
2154 if (!try_module_get(THIS_MODULE))
2155 return 0;
2156
2157 if (!cn) {
2158 module_put(THIS_MODULE);
2159 return 0;
2160 }
2161
2162 switch (event) {
2163 case RPC_PIPEFS_MOUNT:
2164 dentry = nfsd4_cld_register_sb(sb, cn->cn_pipe);
2165 if (IS_ERR(dentry)) {
2166 ret = PTR_ERR(dentry);
2167 break;
2168 }
2169 cn->cn_pipe->dentry = dentry;
2170 break;
2171 case RPC_PIPEFS_UMOUNT:
2172 if (cn->cn_pipe->dentry)
2173 nfsd4_cld_unregister_sb(cn->cn_pipe);
2174 break;
2175 default:
2176 ret = -ENOTSUPP;
2177 break;
2178 }
2179 module_put(THIS_MODULE);
2180 return ret;
2181}
2182
2183static struct notifier_block nfsd4_cld_block = {
2184 .notifier_call = rpc_pipefs_event,
2185};
2186
2187int
2188register_cld_notifier(void)
2189{
2190 WARN_ON(!nfsd_net_id);
2191 return rpc_pipefs_notifier_register(&nfsd4_cld_block);
2192}
2193
2194void
2195unregister_cld_notifier(void)
2196{
2197 rpc_pipefs_notifier_unregister(&nfsd4_cld_block);
2198}