git.ipfire.org Git - thirdparty/kernel/stable.git/blob

1 /*

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 */

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>

47 #include "nfsd.h"

48 #include "state.h"

49 #include "vfs.h"

50 #include "netns.h"

52 #define NFSDDBG_FACILITY NFSDDBG_PROC

54 /* Declarations */

55 struct 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 };

66 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops;

67 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops_v2;

69 /* Globals */

70 static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";

72 static int

73 nfs4_save_creds(const struct cred **original_creds)

74 {

75 struct cred *new;

77 new = prepare_creds();

78 if (!new)

79 return -ENOMEM;

81 new->fsuid = GLOBAL_ROOT_UID;

82 new->fsgid = GLOBAL_ROOT_GID;

83 *original_creds = override_creds(new);

84 put_cred(new);

85 return 0;

86 }

88 static void

89 nfs4_reset_creds(const struct cred *original)

90 {

91 revert_creds(original);

92 }

94 static void

95 md5_to_hex(char *out, char *md5)

96 {

97 int i;

99 for (i=0; i<16; i++) {

100 unsigned char c = md5[i];

101

102 *out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);

103 *out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);

104 }

105 *out = '\0';

106 }

107

108 static int

109 nfs4_make_rec_clidname(char *dname, const struct xdr_netobj *clname)

110 {

111 struct xdr_netobj cksum;

112 struct crypto_shash *tfm;

113 int status;

114

115 dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n",

116 clname->len, clname->data);

117 tfm = crypto_alloc_shash("md5", 0, 0);

118 if (IS_ERR(tfm)) {

119 status = PTR_ERR(tfm);

120 goto out_no_tfm;

121 }

122

123 cksum.len = crypto_shash_digestsize(tfm);

124 cksum.data = kmalloc(cksum.len, GFP_KERNEL);

125 if (cksum.data == NULL) {

126 status = -ENOMEM;

127 goto out;

128 }

129

130 status = crypto_shash_tfm_digest(tfm, clname->data, clname->len,

131 cksum.data);

132 if (status)

133 goto out;

134

135 md5_to_hex(dname, cksum.data);

136

137 status = 0;

138 out:

139 kfree(cksum.data);

140 crypto_free_shash(tfm);

141 out_no_tfm:

142 return status;

143 }

144

145 /*

146 * If we had an error generating the recdir name for the legacy tracker

147 * then warn the admin. If the error doesn't appear to be transient,

148 * then disable recovery tracking.

149 */

150 static void

151 legacy_recdir_name_error(struct nfs4_client *clp, int error)

152 {

153 printk(KERN_ERR "NFSD: unable to generate recoverydir "

154 "name (%d).\n", error);

155

156 /*

157 * if the algorithm just doesn't exist, then disable the recovery

158 * tracker altogether. The crypto libs will generally return this if

159 * FIPS is enabled as well.

160 */

161 if (error == -ENOENT) {

162 printk(KERN_ERR "NFSD: disabling legacy clientid tracking. "

163 "Reboot recovery will not function correctly!\n");

164 nfsd4_client_tracking_exit(clp->net);

165 }

166 }

167

168 static void

169 __nfsd4_create_reclaim_record_grace(struct nfs4_client *clp,

170 const char *dname, int len, struct nfsd_net *nn)

171 {

172 struct xdr_netobj name;

173 struct xdr_netobj princhash = { .len = 0, .data = NULL };

174 struct nfs4_client_reclaim *crp;

175

176 name.data = kmemdup(dname, len, GFP_KERNEL);

177 if (!name.data) {

178 dprintk("%s: failed to allocate memory for name.data!\n",

179 __func__);

180 return;

181 }

182 name.len = len;

183 crp = nfs4_client_to_reclaim(name, princhash, nn);

184 if (!crp) {

185 kfree(name.data);

186 return;

187 }

188 crp->cr_clp = clp;

189 }

190

191 static void

192 nfsd4_create_clid_dir(struct nfs4_client *clp)

193 {

194 const struct cred *original_cred;

195 char dname[HEXDIR_LEN];

196 struct dentry *dir, *dentry;

197 int status;

198 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

199

200 if (test_and_set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

201 return;

202 if (!nn->rec_file)

203 return;

204

205 status = nfs4_make_rec_clidname(dname, &clp->cl_name);

206 if (status)

207 return legacy_recdir_name_error(clp, status);

208

209 status = nfs4_save_creds(&original_cred);

210 if (status < 0)

211 return;

212

213 status = mnt_want_write_file(nn->rec_file);

214 if (status)

215 goto out_creds;

216

217 dir = nn->rec_file->f_path.dentry;

218 /* lock the parent */

219 inode_lock(d_inode(dir));

220

221 dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);

222 if (IS_ERR(dentry)) {

223 status = PTR_ERR(dentry);

224 goto out_unlock;

225 }

226 if (d_really_is_positive(dentry))

227 /*

228 * In the 4.1 case, where we're called from

229 * reclaim_complete(), records from the previous reboot

230 * may still be left, so this is OK.

231 *

232 * In the 4.0 case, we should never get here; but we may

233 * as well be forgiving and just succeed silently.

234 */

235 goto out_put;

236 status = vfs_mkdir(d_inode(dir), dentry, S_IRWXU);

237 out_put:

238 dput(dentry);

239 out_unlock:

240 inode_unlock(d_inode(dir));

241 if (status == 0) {

242 if (nn->in_grace)

243 __nfsd4_create_reclaim_record_grace(clp, dname,

244 HEXDIR_LEN, nn);

245 vfs_fsync(nn->rec_file, 0);

246 } else {

247 printk(KERN_ERR "NFSD: failed to write recovery record"

248 " (err %d); please check that %s exists"

249 " and is writeable", status,

250 user_recovery_dirname);

251 }

252 mnt_drop_write_file(nn->rec_file);

253 out_creds:

254 nfs4_reset_creds(original_cred);

255 }

256

257 typedef int (recdir_func)(struct dentry *, struct dentry *, struct nfsd_net *);

258

259 struct name_list {

260 char name[HEXDIR_LEN];

261 struct list_head list;

262 };

263

264 struct nfs4_dir_ctx {

265 struct dir_context ctx;

266 struct list_head names;

267 };

268

269 static int

270 nfsd4_build_namelist(struct dir_context *__ctx, const char *name, int namlen,

271 loff_t offset, u64 ino, unsigned int d_type)

272 {

273 struct nfs4_dir_ctx *ctx =

274 container_of(__ctx, struct nfs4_dir_ctx, ctx);

275 struct name_list *entry;

276

277 if (namlen != HEXDIR_LEN - 1)

278 return 0;

279 entry = kmalloc(sizeof(struct name_list), GFP_KERNEL);

280 if (entry == NULL)

281 return -ENOMEM;

282 memcpy(entry->name, name, HEXDIR_LEN - 1);

283 entry->name[HEXDIR_LEN - 1] = '\0';

284 list_add(&entry->list, &ctx->names);

285 return 0;

286 }

287

288 static int

289 nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)

290 {

291 const struct cred *original_cred;

292 struct dentry *dir = nn->rec_file->f_path.dentry;

293 struct nfs4_dir_ctx ctx = {

294 .ctx.actor = nfsd4_build_namelist,

295 .names = LIST_HEAD_INIT(ctx.names)

296 };

297 struct name_list *entry, *tmp;

298 int status;

299

300 status = nfs4_save_creds(&original_cred);

301 if (status < 0)

302 return status;

303

304 status = vfs_llseek(nn->rec_file, 0, SEEK_SET);

305 if (status < 0) {

306 nfs4_reset_creds(original_cred);

307 return status;

308 }

309

310 status = iterate_dir(nn->rec_file, &ctx.ctx);

311 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);

312

313 list_for_each_entry_safe(entry, tmp, &ctx.names, list) {

314 if (!status) {

315 struct dentry *dentry;

316 dentry = lookup_one_len(entry->name, dir, HEXDIR_LEN-1);

317 if (IS_ERR(dentry)) {

318 status = PTR_ERR(dentry);

319 break;

320 }

321 status = f(dir, dentry, nn);

322 dput(dentry);

323 }

324 list_del(&entry->list);

325 kfree(entry);

326 }

327 inode_unlock(d_inode(dir));

328 nfs4_reset_creds(original_cred);

329

330 list_for_each_entry_safe(entry, tmp, &ctx.names, list) {

331 dprintk("NFSD: %s. Left entry %s\n", __func__, entry->name);

332 list_del(&entry->list);

333 kfree(entry);

334 }

335 return status;

336 }

337

338 static int

339 nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn)

340 {

341 struct dentry *dir, *dentry;

342 int status;

343

344 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);

345

346 dir = nn->rec_file->f_path.dentry;

347 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT);

348 dentry = lookup_one_len(name, dir, namlen);

349 if (IS_ERR(dentry)) {

350 status = PTR_ERR(dentry);

351 goto out_unlock;

352 }

353 status = -ENOENT;

354 if (d_really_is_negative(dentry))

355 goto out;

356 status = vfs_rmdir(d_inode(dir), dentry);

357 out:

358 dput(dentry);

359 out_unlock:

360 inode_unlock(d_inode(dir));

361 return status;

362 }

363

364 static void

365 __nfsd4_remove_reclaim_record_grace(const char *dname, int len,

366 struct nfsd_net *nn)

367 {

368 struct xdr_netobj name;

369 struct nfs4_client_reclaim *crp;

370

371 name.data = kmemdup(dname, len, GFP_KERNEL);

372 if (!name.data) {

373 dprintk("%s: failed to allocate memory for name.data!\n",

374 __func__);

375 return;

376 }

377 name.len = len;

378 crp = nfsd4_find_reclaim_client(name, nn);

379 kfree(name.data);

380 if (crp)

381 nfs4_remove_reclaim_record(crp, nn);

382 }

383

384 static void

385 nfsd4_remove_clid_dir(struct nfs4_client *clp)

386 {

387 const struct cred *original_cred;

388 char dname[HEXDIR_LEN];

389 int status;

390 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

391

392 if (!nn->rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

393 return;

394

395 status = nfs4_make_rec_clidname(dname, &clp->cl_name);

396 if (status)

397 return legacy_recdir_name_error(clp, status);

398

399 status = mnt_want_write_file(nn->rec_file);

400 if (status)

401 goto out;

402 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);

403

404 status = nfs4_save_creds(&original_cred);

405 if (status < 0)

406 goto out_drop_write;

407

408 status = nfsd4_unlink_clid_dir(dname, HEXDIR_LEN-1, nn);

409 nfs4_reset_creds(original_cred);

410 if (status == 0) {

411 vfs_fsync(nn->rec_file, 0);

412 if (nn->in_grace)

413 __nfsd4_remove_reclaim_record_grace(dname,

414 HEXDIR_LEN, nn);

415 }

416 out_drop_write:

417 mnt_drop_write_file(nn->rec_file);

418 out:

419 if (status)

420 printk("NFSD: Failed to remove expired client state directory"

421 " %.*s\n", HEXDIR_LEN, dname);

422 }

423

424 static int

425 purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)

426 {

427 int status;

428 struct xdr_netobj name;

429

430 if (child->d_name.len != HEXDIR_LEN - 1) {

431 printk("%s: illegal name %pd in recovery directory\n",

432 __func__, child);

433 /* Keep trying; maybe the others are OK: */

434 return 0;

435 }

436 name.data = kmemdup_nul(child->d_name.name, child->d_name.len, GFP_KERNEL);

437 if (!name.data) {

438 dprintk("%s: failed to allocate memory for name.data!\n",

439 __func__);

440 goto out;

441 }

442 name.len = HEXDIR_LEN;

443 if (nfs4_has_reclaimed_state(name, nn))

444 goto out_free;

445

446 status = vfs_rmdir(d_inode(parent), child);

447 if (status)

448 printk("failed to remove client recovery directory %pd\n",

449 child);

450 out_free:

451 kfree(name.data);

452 out:

453 /* Keep trying, success or failure: */

454 return 0;

455 }

456

457 static void

458 nfsd4_recdir_purge_old(struct nfsd_net *nn)

459 {

460 int status;

461

462 nn->in_grace = false;

463 if (!nn->rec_file)

464 return;

465 status = mnt_want_write_file(nn->rec_file);

466 if (status)

467 goto out;

468 status = nfsd4_list_rec_dir(purge_old, nn);

469 if (status == 0)

470 vfs_fsync(nn->rec_file, 0);

471 mnt_drop_write_file(nn->rec_file);

472 out:

473 nfs4_release_reclaim(nn);

474 if (status)

475 printk("nfsd4: failed to purge old clients from recovery"

476 " directory %pD\n", nn->rec_file);

477 }

478

479 static int

480 load_recdir(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)

481 {

482 struct xdr_netobj name;

483 struct xdr_netobj princhash = { .len = 0, .data = NULL };

484

485 if (child->d_name.len != HEXDIR_LEN - 1) {

486 printk("%s: illegal name %pd in recovery directory\n",

487 __func__, child);

488 /* Keep trying; maybe the others are OK: */

489 return 0;

490 }

491 name.data = kmemdup_nul(child->d_name.name, child->d_name.len, GFP_KERNEL);

492 if (!name.data) {

493 dprintk("%s: failed to allocate memory for name.data!\n",

494 __func__);

495 goto out;

496 }

497 name.len = HEXDIR_LEN;

498 if (!nfs4_client_to_reclaim(name, princhash, nn))

499 kfree(name.data);

500 out:

501 return 0;

502 }

503

504 static int

505 nfsd4_recdir_load(struct net *net) {

506 int status;

507 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

508

509 if (!nn->rec_file)

510 return 0;

511

512 status = nfsd4_list_rec_dir(load_recdir, nn);

513 if (status)

514 printk("nfsd4: failed loading clients from recovery"

515 " directory %pD\n", nn->rec_file);

516 return status;

517 }

518

519 /*

520 * Hold reference to the recovery directory.

521 */

522

523 static int

524 nfsd4_init_recdir(struct net *net)

525 {

526 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

527 const struct cred *original_cred;

528 int status;

529

530 printk("NFSD: Using %s as the NFSv4 state recovery directory\n",

531 user_recovery_dirname);

532

533 BUG_ON(nn->rec_file);

534

535 status = nfs4_save_creds(&original_cred);

536 if (status < 0) {

537 printk("NFSD: Unable to change credentials to find recovery"

538 " directory: error %d\n",

539 status);

540 return status;

541 }

542

543 nn->rec_file = filp_open(user_recovery_dirname, O_RDONLY | O_DIRECTORY, 0);

544 if (IS_ERR(nn->rec_file)) {

545 printk("NFSD: unable to find recovery directory %s\n",

546 user_recovery_dirname);

547 status = PTR_ERR(nn->rec_file);

548 nn->rec_file = NULL;

549 }

550

551 nfs4_reset_creds(original_cred);

552 if (!status)

553 nn->in_grace = true;

554 return status;

555 }

556

557 static void

558 nfsd4_shutdown_recdir(struct net *net)

559 {

560 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

561

562 if (!nn->rec_file)

563 return;

564 fput(nn->rec_file);

565 nn->rec_file = NULL;

566 }

567

568 static int

569 nfs4_legacy_state_init(struct net *net)

570 {

571 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

572 int i;

573

574 nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,

575 sizeof(struct list_head),

576 GFP_KERNEL);

577 if (!nn->reclaim_str_hashtbl)

578 return -ENOMEM;

579

580 for (i = 0; i < CLIENT_HASH_SIZE; i++)

581 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]);

582 nn->reclaim_str_hashtbl_size = 0;

583

584 return 0;

585 }

586

587 static void

588 nfs4_legacy_state_shutdown(struct net *net)

589 {

590 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

591

592 kfree(nn->reclaim_str_hashtbl);

593 }

594

595 static int

596 nfsd4_load_reboot_recovery_data(struct net *net)

597 {

598 int status;

599

600 status = nfsd4_init_recdir(net);

601 if (status)

602 return status;

603

604 status = nfsd4_recdir_load(net);

605 if (status)

606 nfsd4_shutdown_recdir(net);

607

608 return status;

609 }

610

611 static int

612 nfsd4_legacy_tracking_init(struct net *net)

613 {

614 int status;

615

616 /* XXX: The legacy code won't work in a container */

617 if (net != &init_net) {

618 pr_warn("NFSD: attempt to initialize legacy client tracking in a container ignored.\n");

619 return -EINVAL;

620 }

621

622 status = nfs4_legacy_state_init(net);

623 if (status)

624 return status;

625

626 status = nfsd4_load_reboot_recovery_data(net);

627 if (status)

628 goto err;

629 pr_info("NFSD: Using legacy client tracking operations.\n");

630 return 0;

631

632 err:

633 nfs4_legacy_state_shutdown(net);

634 return status;

635 }

636

637 static void

638 nfsd4_legacy_tracking_exit(struct net *net)

639 {

640 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

641

642 nfs4_release_reclaim(nn);

643 nfsd4_shutdown_recdir(net);

644 nfs4_legacy_state_shutdown(net);

645 }

646

647 /*

648 * Change the NFSv4 recovery directory to recdir.

649 */

650 int

651 nfs4_reset_recoverydir(char *recdir)

652 {

653 int status;

654 struct path path;

655

656 status = kern_path(recdir, LOOKUP_FOLLOW, &path);

657 if (status)

658 return status;

659 status = -ENOTDIR;

660 if (d_is_dir(path.dentry)) {

661 strcpy(user_recovery_dirname, recdir);

662 status = 0;

663 }

664 path_put(&path);

665 return status;

666 }

667

668 char *

669 nfs4_recoverydir(void)

670 {

671 return user_recovery_dirname;

672 }

673

674 static int

675 nfsd4_check_legacy_client(struct nfs4_client *clp)

676 {

677 int status;

678 char dname[HEXDIR_LEN];

679 struct nfs4_client_reclaim *crp;

680 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

681 struct xdr_netobj name;

682

683 /* did we already find that this client is stable? */

684 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

685 return 0;

686

687 status = nfs4_make_rec_clidname(dname, &clp->cl_name);

688 if (status) {

689 legacy_recdir_name_error(clp, status);

690 return status;

691 }

692

693 /* look for it in the reclaim hashtable otherwise */

694 name.data = kmemdup(dname, HEXDIR_LEN, GFP_KERNEL);

695 if (!name.data) {

696 dprintk("%s: failed to allocate memory for name.data!\n",

697 __func__);

698 goto out_enoent;

699 }

700 name.len = HEXDIR_LEN;

701 crp = nfsd4_find_reclaim_client(name, nn);

702 kfree(name.data);

703 if (crp) {

704 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);

705 crp->cr_clp = clp;

706 return 0;

707 }

708

709 out_enoent:

710 return -ENOENT;

711 }

712

713 static const struct nfsd4_client_tracking_ops nfsd4_legacy_tracking_ops = {

714 .init = nfsd4_legacy_tracking_init,

715 .exit = nfsd4_legacy_tracking_exit,

716 .create = nfsd4_create_clid_dir,

717 .remove = nfsd4_remove_clid_dir,

718 .check = nfsd4_check_legacy_client,

719 .grace_done = nfsd4_recdir_purge_old,

720 .version = 1,

721 .msglen = 0,

722 };

723

724 /* Globals */

725 #define NFSD_PIPE_DIR "nfsd"

726 #define NFSD_CLD_PIPE "cld"

727

728 /* per-net-ns structure for holding cld upcall info */

729 struct cld_net {

730 struct rpc_pipe *cn_pipe;

731 spinlock_t cn_lock;

732 struct list_head cn_list;

733 unsigned int cn_xid;

734 bool cn_has_legacy;

735 struct crypto_shash *cn_tfm;

736 };

737

738 struct cld_upcall {

739 struct list_head cu_list;

740 struct cld_net *cu_net;

741 struct completion cu_done;

742 union {

743 struct cld_msg_hdr cu_hdr;

744 struct cld_msg cu_msg;

745 struct cld_msg_v2 cu_msg_v2;

746 } cu_u;

747 };

748

749 static int

750 __cld_pipe_upcall(struct rpc_pipe *pipe, void *cmsg, struct nfsd_net *nn)

751 {

752 int ret;

753 struct rpc_pipe_msg msg;

754 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall, cu_u);

755

756 memset(&msg, 0, sizeof(msg));

757 msg.data = cmsg;

758 msg.len = nn->client_tracking_ops->msglen;

759

760 ret = rpc_queue_upcall(pipe, &msg);

761 if (ret < 0) {

762 goto out;

763 }

764

765 wait_for_completion(&cup->cu_done);

766

767 if (msg.errno < 0)

768 ret = msg.errno;

769 out:

770 return ret;

771 }

772

773 static int

774 cld_pipe_upcall(struct rpc_pipe *pipe, void *cmsg, struct nfsd_net *nn)

775 {

776 int ret;

777

778 /*

779 * -EAGAIN occurs when pipe is closed and reopened while there are

780 * upcalls queued.

781 */

782 do {

783 ret = __cld_pipe_upcall(pipe, cmsg, nn);

784 } while (ret == -EAGAIN);

785

786 return ret;

787 }

788

789 static ssize_t

790 __cld_pipe_inprogress_downcall(const struct cld_msg_v2 __user *cmsg,

791 struct nfsd_net *nn)

792 {

793 uint8_t cmd, princhashlen;

794 struct xdr_netobj name, princhash = { .len = 0, .data = NULL };

795 uint16_t namelen;

796 struct cld_net *cn = nn->cld_net;

797

798 if (get_user(cmd, &cmsg->cm_cmd)) {

799 dprintk("%s: error when copying cmd from userspace", __func__);

800 return -EFAULT;

801 }

802 if (cmd == Cld_GraceStart) {

803 if (nn->client_tracking_ops->version >= 2) {

804 const struct cld_clntinfo __user *ci;

805

806 ci = &cmsg->cm_u.cm_clntinfo;

807 if (get_user(namelen, &ci->cc_name.cn_len))

808 return -EFAULT;

809 if (!namelen) {

810 dprintk("%s: namelen should not be zero", __func__);

811 return -EINVAL;

812 }

813 name.data = memdup_user(&ci->cc_name.cn_id, namelen);

814 if (IS_ERR(name.data))

815 return PTR_ERR(name.data);

816 name.len = namelen;

817 get_user(princhashlen, &ci->cc_princhash.cp_len);

818 if (princhashlen > 0) {

819 princhash.data = memdup_user(

820 &ci->cc_princhash.cp_data,

821 princhashlen);

822 if (IS_ERR(princhash.data)) {

823 kfree(name.data);

824 return PTR_ERR(princhash.data);

825 }

826 princhash.len = princhashlen;

827 } else

828 princhash.len = 0;

829 } else {

830 const struct cld_name __user *cnm;

831

832 cnm = &cmsg->cm_u.cm_name;

833 if (get_user(namelen, &cnm->cn_len))

834 return -EFAULT;

835 if (!namelen) {

836 dprintk("%s: namelen should not be zero", __func__);

837 return -EINVAL;

838 }

839 name.data = memdup_user(&cnm->cn_id, namelen);

840 if (IS_ERR(name.data))

841 return PTR_ERR(name.data);

842 name.len = namelen;

843 }

844 if (name.len > 5 && memcmp(name.data, "hash:", 5) == 0) {

845 name.len = name.len - 5;

846 memmove(name.data, name.data + 5, name.len);

847 cn->cn_has_legacy = true;

848 }

849 if (!nfs4_client_to_reclaim(name, princhash, nn)) {

850 kfree(name.data);

851 kfree(princhash.data);

852 return -EFAULT;

853 }

854 return nn->client_tracking_ops->msglen;

855 }

856 return -EFAULT;

857 }

858

859 static ssize_t

860 cld_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)

861 {

862 struct cld_upcall *tmp, *cup;

863 struct cld_msg_hdr __user *hdr = (struct cld_msg_hdr __user *)src;

864 struct cld_msg_v2 __user *cmsg = (struct cld_msg_v2 __user *)src;

865 uint32_t xid;

866 struct nfsd_net *nn = net_generic(file_inode(filp)->i_sb->s_fs_info,

867 nfsd_net_id);

868 struct cld_net *cn = nn->cld_net;

869 int16_t status;

870

871 if (mlen != nn->client_tracking_ops->msglen) {

872 dprintk("%s: got %zu bytes, expected %zu\n", __func__, mlen,

873 nn->client_tracking_ops->msglen);

874 return -EINVAL;

875 }

876

877 /* copy just the xid so we can try to find that */

878 if (copy_from_user(&xid, &hdr->cm_xid, sizeof(xid)) != 0) {

879 dprintk("%s: error when copying xid from userspace", __func__);

880 return -EFAULT;

881 }

882

883 /*

884 * copy the status so we know whether to remove the upcall from the

885 * list (for -EINPROGRESS, we just want to make sure the xid is

886 * valid, not remove the upcall from the list)

887 */

888 if (get_user(status, &hdr->cm_status)) {

889 dprintk("%s: error when copying status from userspace", __func__);

890 return -EFAULT;

891 }

892

893 /* walk the list and find corresponding xid */

894 cup = NULL;

895 spin_lock(&cn->cn_lock);

896 list_for_each_entry(tmp, &cn->cn_list, cu_list) {

897 if (get_unaligned(&tmp->cu_u.cu_hdr.cm_xid) == xid) {

898 cup = tmp;

899 if (status != -EINPROGRESS)

900 list_del_init(&cup->cu_list);

901 break;

902 }

903 }

904 spin_unlock(&cn->cn_lock);

905

906 /* couldn't find upcall? */

907 if (!cup) {

908 dprintk("%s: couldn't find upcall -- xid=%u\n", __func__, xid);

909 return -EINVAL;

910 }

911

912 if (status == -EINPROGRESS)

913 return __cld_pipe_inprogress_downcall(cmsg, nn);

914

915 if (copy_from_user(&cup->cu_u.cu_msg_v2, src, mlen) != 0)

916 return -EFAULT;

917

918 complete(&cup->cu_done);

919 return mlen;

920 }

921

922 static void

923 cld_pipe_destroy_msg(struct rpc_pipe_msg *msg)

924 {

925 struct cld_msg *cmsg = msg->data;

926 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall,

927 cu_u.cu_msg);

928

929 /* errno >= 0 means we got a downcall */

930 if (msg->errno >= 0)

931 return;

932

933 complete(&cup->cu_done);

934 }

935

936 static const struct rpc_pipe_ops cld_upcall_ops = {

937 .upcall = rpc_pipe_generic_upcall,

938 .downcall = cld_pipe_downcall,

939 .destroy_msg = cld_pipe_destroy_msg,

940 };

941

942 static struct dentry *

943 nfsd4_cld_register_sb(struct super_block *sb, struct rpc_pipe *pipe)

944 {

945 struct dentry *dir, *dentry;

946

947 dir = rpc_d_lookup_sb(sb, NFSD_PIPE_DIR);

948 if (dir == NULL)

949 return ERR_PTR(-ENOENT);

950 dentry = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe);

951 dput(dir);

952 return dentry;

953 }

954

955 static void

956 nfsd4_cld_unregister_sb(struct rpc_pipe *pipe)

957 {

958 if (pipe->dentry)

959 rpc_unlink(pipe->dentry);

960 }

961

962 static struct dentry *

963 nfsd4_cld_register_net(struct net *net, struct rpc_pipe *pipe)

964 {

965 struct super_block *sb;

966 struct dentry *dentry;

967

968 sb = rpc_get_sb_net(net);

969 if (!sb)

970 return NULL;

971 dentry = nfsd4_cld_register_sb(sb, pipe);

972 rpc_put_sb_net(net);

973 return dentry;

974 }

975

976 static void

977 nfsd4_cld_unregister_net(struct net *net, struct rpc_pipe *pipe)

978 {

979 struct super_block *sb;

980

981 sb = rpc_get_sb_net(net);

982 if (sb) {

983 nfsd4_cld_unregister_sb(pipe);

984 rpc_put_sb_net(net);

985 }

986 }

987

988 /* Initialize rpc_pipefs pipe for communication with client tracking daemon */

989 static int

990 __nfsd4_init_cld_pipe(struct net *net)

991 {

992 int ret;

993 struct dentry *dentry;

994 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

995 struct cld_net *cn;

996

997 if (nn->cld_net)

998 return 0;

999

1000 cn = kzalloc(sizeof(*cn), GFP_KERNEL);

1001 if (!cn) {

1002 ret = -ENOMEM;

1003 goto err;

1004 }

1005

1006 cn->cn_pipe = rpc_mkpipe_data(&cld_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);

1007 if (IS_ERR(cn->cn_pipe)) {

1008 ret = PTR_ERR(cn->cn_pipe);

1009 goto err;

1010 }

1011 spin_lock_init(&cn->cn_lock);

1012 INIT_LIST_HEAD(&cn->cn_list);

1013

1014 dentry = nfsd4_cld_register_net(net, cn->cn_pipe);

1015 if (IS_ERR(dentry)) {

1016 ret = PTR_ERR(dentry);

1017 goto err_destroy_data;

1018 }

1019

1020 cn->cn_pipe->dentry = dentry;

1021 cn->cn_has_legacy = false;

1022 nn->cld_net = cn;

1023 return 0;

1024

1025 err_destroy_data:

1026 rpc_destroy_pipe_data(cn->cn_pipe);

1027 err:

1028 kfree(cn);

1029 printk(KERN_ERR "NFSD: unable to create nfsdcld upcall pipe (%d)\n",

1030 ret);

1031 return ret;

1032 }

1033

1034 static int

1035 nfsd4_init_cld_pipe(struct net *net)

1036 {

1037 int status;

1038

1039 status = __nfsd4_init_cld_pipe(net);

1040 if (!status)

1041 pr_info("NFSD: Using old nfsdcld client tracking operations.\n");

1042 return status;

1043 }

1044

1045 static void

1046 nfsd4_remove_cld_pipe(struct net *net)

1047 {

1048 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

1049 struct cld_net *cn = nn->cld_net;

1050

1051 nfsd4_cld_unregister_net(net, cn->cn_pipe);

1052 rpc_destroy_pipe_data(cn->cn_pipe);

1053 if (cn->cn_tfm)

1054 crypto_free_shash(cn->cn_tfm);

1055 kfree(nn->cld_net);

1056 nn->cld_net = NULL;

1057 }

1058

1059 static struct cld_upcall *

1060 alloc_cld_upcall(struct nfsd_net *nn)

1061 {

1062 struct cld_upcall *new, *tmp;

1063 struct cld_net *cn = nn->cld_net;

1064

1065 new = kzalloc(sizeof(*new), GFP_KERNEL);

1066 if (!new)

1067 return new;

1068

1069 /* FIXME: hard cap on number in flight? */

1070 restart_search:

1071 spin_lock(&cn->cn_lock);

1072 list_for_each_entry(tmp, &cn->cn_list, cu_list) {

1073 if (tmp->cu_u.cu_msg.cm_xid == cn->cn_xid) {

1074 cn->cn_xid++;

1075 spin_unlock(&cn->cn_lock);

1076 goto restart_search;

1077 }

1078 }

1079 init_completion(&new->cu_done);

1080 new->cu_u.cu_msg.cm_vers = nn->client_tracking_ops->version;

1081 put_unaligned(cn->cn_xid++, &new->cu_u.cu_msg.cm_xid);

1082 new->cu_net = cn;

1083 list_add(&new->cu_list, &cn->cn_list);

1084 spin_unlock(&cn->cn_lock);

1085

1086 dprintk("%s: allocated xid %u\n", __func__, new->cu_u.cu_msg.cm_xid);

1087

1088 return new;

1089 }

1090

1091 static void

1092 free_cld_upcall(struct cld_upcall *victim)

1093 {

1094 struct cld_net *cn = victim->cu_net;

1095

1096 spin_lock(&cn->cn_lock);

1097 list_del(&victim->cu_list);

1098 spin_unlock(&cn->cn_lock);

1099 kfree(victim);

1100 }

1101

1102 /* Ask daemon to create a new record */

1103 static void

1104 nfsd4_cld_create(struct nfs4_client *clp)

1105 {

1106 int ret;

1107 struct cld_upcall *cup;

1108 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

1109 struct cld_net *cn = nn->cld_net;

1110

1111 /* Don't upcall if it's already stored */

1112 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

1113 return;

1114

1115 cup = alloc_cld_upcall(nn);

1116 if (!cup) {

1117 ret = -ENOMEM;

1118 goto out_err;

1119 }

1120

1121 cup->cu_u.cu_msg.cm_cmd = Cld_Create;

1122 cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;

1123 memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,

1124 clp->cl_name.len);

1125

1126 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);

1127 if (!ret) {

1128 ret = cup->cu_u.cu_msg.cm_status;

1129 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);

1130 }

1131

1132 free_cld_upcall(cup);

1133 out_err:

1134 if (ret)

1135 printk(KERN_ERR "NFSD: Unable to create client "

1136 "record on stable storage: %d\n", ret);

1137 }

1138

1139 /* Ask daemon to create a new record */

1140 static void

1141 nfsd4_cld_create_v2(struct nfs4_client *clp)

1142 {

1143 int ret;

1144 struct cld_upcall *cup;

1145 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

1146 struct cld_net *cn = nn->cld_net;

1147 struct cld_msg_v2 *cmsg;

1148 struct crypto_shash *tfm = cn->cn_tfm;

1149 struct xdr_netobj cksum;

1150 char *principal = NULL;

1151

1152 /* Don't upcall if it's already stored */

1153 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

1154 return;

1155

1156 cup = alloc_cld_upcall(nn);

1157 if (!cup) {

1158 ret = -ENOMEM;

1159 goto out_err;

1160 }

1161

1162 cmsg = &cup->cu_u.cu_msg_v2;

1163 cmsg->cm_cmd = Cld_Create;

1164 cmsg->cm_u.cm_clntinfo.cc_name.cn_len = clp->cl_name.len;

1165 memcpy(cmsg->cm_u.cm_clntinfo.cc_name.cn_id, clp->cl_name.data,

1166 clp->cl_name.len);

1167 if (clp->cl_cred.cr_raw_principal)

1168 principal = clp->cl_cred.cr_raw_principal;

1169 else if (clp->cl_cred.cr_principal)

1170 principal = clp->cl_cred.cr_principal;

1171 if (principal) {

1172 cksum.len = crypto_shash_digestsize(tfm);

1173 cksum.data = kmalloc(cksum.len, GFP_KERNEL);

1174 if (cksum.data == NULL) {

1175 ret = -ENOMEM;

1176 goto out;

1177 }

1178 ret = crypto_shash_tfm_digest(tfm, principal, strlen(principal),

1179 cksum.data);

1180 if (ret) {

1181 kfree(cksum.data);

1182 goto out;

1183 }

1184 cmsg->cm_u.cm_clntinfo.cc_princhash.cp_len = cksum.len;

1185 memcpy(cmsg->cm_u.cm_clntinfo.cc_princhash.cp_data,

1186 cksum.data, cksum.len);

1187 kfree(cksum.data);

1188 } else

1189 cmsg->cm_u.cm_clntinfo.cc_princhash.cp_len = 0;

1190

1191 ret = cld_pipe_upcall(cn->cn_pipe, cmsg, nn);

1192 if (!ret) {

1193 ret = cmsg->cm_status;

1194 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);

1195 }

1196

1197 out:

1198 free_cld_upcall(cup);

1199 out_err:

1200 if (ret)

1201 pr_err("NFSD: Unable to create client record on stable storage: %d\n",

1202 ret);

1203 }

1204

1205 /* Ask daemon to create a new record */

1206 static void

1207 nfsd4_cld_remove(struct nfs4_client *clp)

1208 {

1209 int ret;

1210 struct cld_upcall *cup;

1211 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

1212 struct cld_net *cn = nn->cld_net;

1213

1214 /* Don't upcall if it's already removed */

1215 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

1216 return;

1217

1218 cup = alloc_cld_upcall(nn);

1219 if (!cup) {

1220 ret = -ENOMEM;

1221 goto out_err;

1222 }

1223

1224 cup->cu_u.cu_msg.cm_cmd = Cld_Remove;

1225 cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;

1226 memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,

1227 clp->cl_name.len);

1228

1229 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);

1230 if (!ret) {

1231 ret = cup->cu_u.cu_msg.cm_status;

1232 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);

1233 }

1234

1235 free_cld_upcall(cup);

1236 out_err:

1237 if (ret)

1238 printk(KERN_ERR "NFSD: Unable to remove client "

1239 "record from stable storage: %d\n", ret);

1240 }

1241

1242 /*

1243 * For older nfsdcld's that do not allow us to "slurp" the clients

1244 * from the tracking database during startup.

1245 *

1246 * Check for presence of a record, and update its timestamp

1247 */

1248 static int

1249 nfsd4_cld_check_v0(struct nfs4_client *clp)

1250 {

1251 int ret;

1252 struct cld_upcall *cup;

1253 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

1254 struct cld_net *cn = nn->cld_net;

1255

1256 /* Don't upcall if one was already stored during this grace pd */

1257 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

1258 return 0;

1259

1260 cup = alloc_cld_upcall(nn);

1261 if (!cup) {

1262 printk(KERN_ERR "NFSD: Unable to check client record on "

1263 "stable storage: %d\n", -ENOMEM);

1264 return -ENOMEM;

1265 }

1266

1267 cup->cu_u.cu_msg.cm_cmd = Cld_Check;

1268 cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;

1269 memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,

1270 clp->cl_name.len);

1271

1272 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);

1273 if (!ret) {

1274 ret = cup->cu_u.cu_msg.cm_status;

1275 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);

1276 }

1277

1278 free_cld_upcall(cup);

1279 return ret;

1280 }

1281

1282 /*

1283 * For newer nfsdcld's that allow us to "slurp" the clients

1284 * from the tracking database during startup.

1285 *

1286 * Check for presence of a record in the reclaim_str_hashtbl

1287 */

1288 static int

1289 nfsd4_cld_check(struct nfs4_client *clp)

1290 {

1291 struct nfs4_client_reclaim *crp;

1292 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

1293 struct cld_net *cn = nn->cld_net;

1294 int status;

1295 char dname[HEXDIR_LEN];

1296 struct xdr_netobj name;

1297

1298 /* did we already find that this client is stable? */

1299 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

1300 return 0;

1301

1302 /* look for it in the reclaim hashtable otherwise */

1303 crp = nfsd4_find_reclaim_client(clp->cl_name, nn);

1304 if (crp)

1305 goto found;

1306

1307 if (cn->cn_has_legacy) {

1308 status = nfs4_make_rec_clidname(dname, &clp->cl_name);

1309 if (status)

1310 return -ENOENT;

1311

1312 name.data = kmemdup(dname, HEXDIR_LEN, GFP_KERNEL);

1313 if (!name.data) {

1314 dprintk("%s: failed to allocate memory for name.data!\n",

1315 __func__);

1316 return -ENOENT;

1317 }

1318 name.len = HEXDIR_LEN;

1319 crp = nfsd4_find_reclaim_client(name, nn);

1320 kfree(name.data);

1321 if (crp)

1322 goto found;

1323

1324 }

1325 return -ENOENT;

1326 found:

1327 crp->cr_clp = clp;

1328 return 0;

1329 }

1330

1331 static int

1332 nfsd4_cld_check_v2(struct nfs4_client *clp)

1333 {

1334 struct nfs4_client_reclaim *crp;

1335 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

1336 struct cld_net *cn = nn->cld_net;

1337 int status;

1338 char dname[HEXDIR_LEN];

1339 struct xdr_netobj name;

1340 struct crypto_shash *tfm = cn->cn_tfm;

1341 struct xdr_netobj cksum;

1342 char *principal = NULL;

1343

1344 /* did we already find that this client is stable? */

1345 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

1346 return 0;

1347

1348 /* look for it in the reclaim hashtable otherwise */

1349 crp = nfsd4_find_reclaim_client(clp->cl_name, nn);

1350 if (crp)

1351 goto found;

1352

1353 if (cn->cn_has_legacy) {

1354 status = nfs4_make_rec_clidname(dname, &clp->cl_name);

1355 if (status)

1356 return -ENOENT;

1357

1358 name.data = kmemdup(dname, HEXDIR_LEN, GFP_KERNEL);

1359 if (!name.data) {

1360 dprintk("%s: failed to allocate memory for name.data\n",

1361 __func__);

1362 return -ENOENT;

1363 }

1364 name.len = HEXDIR_LEN;

1365 crp = nfsd4_find_reclaim_client(name, nn);

1366 kfree(name.data);

1367 if (crp)

1368 goto found;

1369

1370 }

1371 return -ENOENT;

1372 found:

1373 if (crp->cr_princhash.len) {

1374 if (clp->cl_cred.cr_raw_principal)

1375 principal = clp->cl_cred.cr_raw_principal;

1376 else if (clp->cl_cred.cr_principal)

1377 principal = clp->cl_cred.cr_principal;

1378 if (principal == NULL)

1379 return -ENOENT;

1380 cksum.len = crypto_shash_digestsize(tfm);

1381 cksum.data = kmalloc(cksum.len, GFP_KERNEL);

1382 if (cksum.data == NULL)

1383 return -ENOENT;

1384 status = crypto_shash_tfm_digest(tfm, principal,

1385 strlen(principal), cksum.data);

1386 if (status) {

1387 kfree(cksum.data);

1388 return -ENOENT;

1389 }

1390 if (memcmp(crp->cr_princhash.data, cksum.data,

1391 crp->cr_princhash.len)) {

1392 kfree(cksum.data);

1393 return -ENOENT;

1394 }

1395 kfree(cksum.data);

1396 }

1397 crp->cr_clp = clp;

1398 return 0;

1399 }

1400

1401 static int

1402 nfsd4_cld_grace_start(struct nfsd_net *nn)

1403 {

1404 int ret;

1405 struct cld_upcall *cup;

1406 struct cld_net *cn = nn->cld_net;

1407

1408 cup = alloc_cld_upcall(nn);

1409 if (!cup) {

1410 ret = -ENOMEM;

1411 goto out_err;

1412 }

1413

1414 cup->cu_u.cu_msg.cm_cmd = Cld_GraceStart;

1415 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);

1416 if (!ret)

1417 ret = cup->cu_u.cu_msg.cm_status;

1418

1419 free_cld_upcall(cup);

1420 out_err:

1421 if (ret)

1422 dprintk("%s: Unable to get clients from userspace: %d\n",

1423 __func__, ret);

1424 return ret;

1425 }

1426

1427 /* For older nfsdcld's that need cm_gracetime */

1428 static void

1429 nfsd4_cld_grace_done_v0(struct nfsd_net *nn)

1430 {

1431 int ret;

1432 struct cld_upcall *cup;

1433 struct cld_net *cn = nn->cld_net;

1434

1435 cup = alloc_cld_upcall(nn);

1436 if (!cup) {

1437 ret = -ENOMEM;

1438 goto out_err;

1439 }

1440

1441 cup->cu_u.cu_msg.cm_cmd = Cld_GraceDone;

1442 cup->cu_u.cu_msg.cm_u.cm_gracetime = nn->boot_time;

1443 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);

1444 if (!ret)

1445 ret = cup->cu_u.cu_msg.cm_status;

1446

1447 free_cld_upcall(cup);

1448 out_err:

1449 if (ret)

1450 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret);

1451 }

1452

1453 /*

1454 * For newer nfsdcld's that do not need cm_gracetime. We also need to call

1455 * nfs4_release_reclaim() to clear out the reclaim_str_hashtbl.

1456 */

1457 static void

1458 nfsd4_cld_grace_done(struct nfsd_net *nn)

1459 {

1460 int ret;

1461 struct cld_upcall *cup;

1462 struct cld_net *cn = nn->cld_net;

1463

1464 cup = alloc_cld_upcall(nn);

1465 if (!cup) {

1466 ret = -ENOMEM;

1467 goto out_err;

1468 }

1469

1470 cup->cu_u.cu_msg.cm_cmd = Cld_GraceDone;

1471 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);

1472 if (!ret)

1473 ret = cup->cu_u.cu_msg.cm_status;

1474

1475 free_cld_upcall(cup);

1476 out_err:

1477 nfs4_release_reclaim(nn);

1478 if (ret)

1479 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret);

1480 }

1481

1482 static int

1483 nfs4_cld_state_init(struct net *net)

1484 {

1485 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

1486 int i;

1487

1488 nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,

1489 sizeof(struct list_head),

1490 GFP_KERNEL);

1491 if (!nn->reclaim_str_hashtbl)

1492 return -ENOMEM;

1493

1494 for (i = 0; i < CLIENT_HASH_SIZE; i++)

1495 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]);

1496 nn->reclaim_str_hashtbl_size = 0;

1497 nn->track_reclaim_completes = true;

1498 atomic_set(&nn->nr_reclaim_complete, 0);

1499

1500 return 0;

1501 }

1502

1503 static void

1504 nfs4_cld_state_shutdown(struct net *net)

1505 {

1506 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

1507

1508 nn->track_reclaim_completes = false;

1509 kfree(nn->reclaim_str_hashtbl);

1510 }

1511

1512 static bool

1513 cld_running(struct nfsd_net *nn)

1514 {

1515 struct cld_net *cn = nn->cld_net;

1516 struct rpc_pipe *pipe = cn->cn_pipe;

1517

1518 return pipe->nreaders || pipe->nwriters;

1519 }

1520

1521 static int

1522 nfsd4_cld_get_version(struct nfsd_net *nn)

1523 {

1524 int ret = 0;

1525 struct cld_upcall *cup;

1526 struct cld_net *cn = nn->cld_net;

1527 uint8_t version;

1528

1529 cup = alloc_cld_upcall(nn);

1530 if (!cup) {

1531 ret = -ENOMEM;

1532 goto out_err;

1533 }

1534 cup->cu_u.cu_msg.cm_cmd = Cld_GetVersion;

1535 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg, nn);

1536 if (!ret) {

1537 ret = cup->cu_u.cu_msg.cm_status;

1538 if (ret)

1539 goto out_free;

1540 version = cup->cu_u.cu_msg.cm_u.cm_version;

1541 dprintk("%s: userspace returned version %u\n",

1542 __func__, version);

1543 if (version < 1)

1544 version = 1;

1545 else if (version > CLD_UPCALL_VERSION)

1546 version = CLD_UPCALL_VERSION;

1547

1548 switch (version) {

1549 case 1:

1550 nn->client_tracking_ops = &nfsd4_cld_tracking_ops;

1551 break;

1552 case 2:

1553 nn->client_tracking_ops = &nfsd4_cld_tracking_ops_v2;

1554 break;

1555 default:

1556 break;

1557 }

1558 }

1559 out_free:

1560 free_cld_upcall(cup);

1561 out_err:

1562 if (ret)

1563 dprintk("%s: Unable to get version from userspace: %d\n",

1564 __func__, ret);

1565 return ret;

1566 }

1567

1568 static int

1569 nfsd4_cld_tracking_init(struct net *net)

1570 {

1571 int status;

1572 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

1573 bool running;

1574 int retries = 10;

1575 struct crypto_shash *tfm;

1576

1577 status = nfs4_cld_state_init(net);

1578 if (status)

1579 return status;

1580

1581 status = __nfsd4_init_cld_pipe(net);

1582 if (status)

1583 goto err_shutdown;

1584

1585 /*

1586 * rpc pipe upcalls take 30 seconds to time out, so we don't want to

1587 * queue an upcall unless we know that nfsdcld is running (because we

1588 * want this to fail fast so that nfsd4_client_tracking_init() can try

1589 * the next client tracking method). nfsdcld should already be running

1590 * before nfsd is started, so the wait here is for nfsdcld to open the

1591 * pipefs file we just created.

1592 */

1593 while (!(running = cld_running(nn)) && retries--)

1594 msleep(100);

1595

1596 if (!running) {

1597 status = -ETIMEDOUT;

1598 goto err_remove;

1599 }

1600 tfm = crypto_alloc_shash("sha256", 0, 0);

1601 if (IS_ERR(tfm)) {

1602 status = PTR_ERR(tfm);

1603 goto err_remove;

1604 }

1605 nn->cld_net->cn_tfm = tfm;

1606

1607 status = nfsd4_cld_get_version(nn);

1608 if (status == -EOPNOTSUPP)

1609 pr_warn("NFSD: nfsdcld GetVersion upcall failed. Please upgrade nfsdcld.\n");

1610

1611 status = nfsd4_cld_grace_start(nn);

1612 if (status) {

1613 if (status == -EOPNOTSUPP)

1614 pr_warn("NFSD: nfsdcld GraceStart upcall failed. Please upgrade nfsdcld.\n");

1615 nfs4_release_reclaim(nn);

1616 goto err_remove;

1617 } else

1618 pr_info("NFSD: Using nfsdcld client tracking operations.\n");

1619 return 0;

1620

1621 err_remove:

1622 nfsd4_remove_cld_pipe(net);

1623 err_shutdown:

1624 nfs4_cld_state_shutdown(net);

1625 return status;

1626 }

1627

1628 static void

1629 nfsd4_cld_tracking_exit(struct net *net)

1630 {

1631 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

1632

1633 nfs4_release_reclaim(nn);

1634 nfsd4_remove_cld_pipe(net);

1635 nfs4_cld_state_shutdown(net);

1636 }

1637

1638 /* For older nfsdcld's */

1639 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops_v0 = {

1640 .init = nfsd4_init_cld_pipe,

1641 .exit = nfsd4_remove_cld_pipe,

1642 .create = nfsd4_cld_create,

1643 .remove = nfsd4_cld_remove,

1644 .check = nfsd4_cld_check_v0,

1645 .grace_done = nfsd4_cld_grace_done_v0,

1646 .version = 1,

1647 .msglen = sizeof(struct cld_msg),

1648 };

1649

1650 /* For newer nfsdcld's */

1651 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops = {

1652 .init = nfsd4_cld_tracking_init,

1653 .exit = nfsd4_cld_tracking_exit,

1654 .create = nfsd4_cld_create,

1655 .remove = nfsd4_cld_remove,

1656 .check = nfsd4_cld_check,

1657 .grace_done = nfsd4_cld_grace_done,

1658 .version = 1,

1659 .msglen = sizeof(struct cld_msg),

1660 };

1661

1662 /* v2 create/check ops include the principal, if available */

1663 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops_v2 = {

1664 .init = nfsd4_cld_tracking_init,

1665 .exit = nfsd4_cld_tracking_exit,

1666 .create = nfsd4_cld_create_v2,

1667 .remove = nfsd4_cld_remove,

1668 .check = nfsd4_cld_check_v2,

1669 .grace_done = nfsd4_cld_grace_done,

1670 .version = 2,

1671 .msglen = sizeof(struct cld_msg_v2),

1672 };

1673

1674 /* upcall via usermodehelper */

1675 static char cltrack_prog[PATH_MAX] = "/sbin/nfsdcltrack";

1676 module_param_string(cltrack_prog, cltrack_prog, sizeof(cltrack_prog),

1677 S_IRUGO|S_IWUSR);

1678 MODULE_PARM_DESC(cltrack_prog, "Path to the nfsdcltrack upcall program");

1679

1680 static bool cltrack_legacy_disable;

1681 module_param(cltrack_legacy_disable, bool, S_IRUGO|S_IWUSR);

1682 MODULE_PARM_DESC(cltrack_legacy_disable,

1683 "Disable legacy recoverydir conversion. Default: false");

1684

1685 #define LEGACY_TOPDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_TOPDIR="

1686 #define LEGACY_RECDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_RECDIR="

1687 #define HAS_SESSION_ENV_PREFIX "NFSDCLTRACK_CLIENT_HAS_SESSION="

1688 #define GRACE_START_ENV_PREFIX "NFSDCLTRACK_GRACE_START="

1689

1690 static char *

1691 nfsd4_cltrack_legacy_topdir(void)

1692 {

1693 int copied;

1694 size_t len;

1695 char *result;

1696

1697 if (cltrack_legacy_disable)

1698 return NULL;

1699

1700 len = strlen(LEGACY_TOPDIR_ENV_PREFIX) +

1701 strlen(nfs4_recoverydir()) + 1;

1702

1703 result = kmalloc(len, GFP_KERNEL);

1704 if (!result)

1705 return result;

1706

1707 copied = snprintf(result, len, LEGACY_TOPDIR_ENV_PREFIX "%s",

1708 nfs4_recoverydir());

1709 if (copied >= len) {

1710 /* just return nothing if output was truncated */

1711 kfree(result);

1712 return NULL;

1713 }

1714

1715 return result;

1716 }

1717

1718 static char *

1719 nfsd4_cltrack_legacy_recdir(const struct xdr_netobj *name)

1720 {

1721 int copied;

1722 size_t len;

1723 char *result;

1724

1725 if (cltrack_legacy_disable)

1726 return NULL;

1727

1728 /* +1 is for '/' between "topdir" and "recdir" */

1729 len = strlen(LEGACY_RECDIR_ENV_PREFIX) +

1730 strlen(nfs4_recoverydir()) + 1 + HEXDIR_LEN;

1731

1732 result = kmalloc(len, GFP_KERNEL);

1733 if (!result)

1734 return result;

1735

1736 copied = snprintf(result, len, LEGACY_RECDIR_ENV_PREFIX "%s/",

1737 nfs4_recoverydir());

1738 if (copied > (len - HEXDIR_LEN)) {

1739 /* just return nothing if output will be truncated */

1740 kfree(result);

1741 return NULL;

1742 }

1743

1744 copied = nfs4_make_rec_clidname(result + copied, name);

1745 if (copied) {

1746 kfree(result);

1747 return NULL;

1748 }

1749

1750 return result;

1751 }

1752

1753 static char *

1754 nfsd4_cltrack_client_has_session(struct nfs4_client *clp)

1755 {

1756 int copied;

1757 size_t len;

1758 char *result;

1759

1760 /* prefix + Y/N character + terminating NULL */

1761 len = strlen(HAS_SESSION_ENV_PREFIX) + 1 + 1;

1762

1763 result = kmalloc(len, GFP_KERNEL);

1764 if (!result)

1765 return result;

1766

1767 copied = snprintf(result, len, HAS_SESSION_ENV_PREFIX "%c",

1768 clp->cl_minorversion ? 'Y' : 'N');

1769 if (copied >= len) {

1770 /* just return nothing if output was truncated */

1771 kfree(result);

1772 return NULL;

1773 }

1774

1775 return result;

1776 }

1777

1778 static char *

1779 nfsd4_cltrack_grace_start(time64_t grace_start)

1780 {

1781 int copied;

1782 size_t len;

1783 char *result;

1784

1785 /* prefix + max width of int64_t string + terminating NULL */

1786 len = strlen(GRACE_START_ENV_PREFIX) + 22 + 1;

1787

1788 result = kmalloc(len, GFP_KERNEL);

1789 if (!result)

1790 return result;

1791

1792 copied = snprintf(result, len, GRACE_START_ENV_PREFIX "%lld",

1793 grace_start);

1794 if (copied >= len) {

1795 /* just return nothing if output was truncated */

1796 kfree(result);

1797 return NULL;

1798 }

1799

1800 return result;

1801 }

1802

1803 static int

1804 nfsd4_umh_cltrack_upcall(char *cmd, char *arg, char *env0, char *env1)

1805 {

1806 char *envp[3];

1807 char *argv[4];

1808 int ret;

1809

1810 if (unlikely(!cltrack_prog[0])) {

1811 dprintk("%s: cltrack_prog is disabled\n", __func__);

1812 return -EACCES;

1813 }

1814

1815 dprintk("%s: cmd: %s\n", __func__, cmd);

1816 dprintk("%s: arg: %s\n", __func__, arg ? arg : "(null)");

1817 dprintk("%s: env0: %s\n", __func__, env0 ? env0 : "(null)");

1818 dprintk("%s: env1: %s\n", __func__, env1 ? env1 : "(null)");

1819

1820 envp[0] = env0;

1821 envp[1] = env1;

1822 envp[2] = NULL;

1823

1824 argv[0] = (char *)cltrack_prog;

1825 argv[1] = cmd;

1826 argv[2] = arg;

1827 argv[3] = NULL;

1828

1829 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);

1830 /*

1831 * Disable the upcall mechanism if we're getting an ENOENT or EACCES

1832 * error. The admin can re-enable it on the fly by using sysfs

1833 * once the problem has been fixed.

1834 */

1835 if (ret == -ENOENT || ret == -EACCES) {

1836 dprintk("NFSD: %s was not found or isn't executable (%d). "

1837 "Setting cltrack_prog to blank string!",

1838 cltrack_prog, ret);

1839 cltrack_prog[0] = '\0';

1840 }

1841 dprintk("%s: %s return value: %d\n", __func__, cltrack_prog, ret);

1842

1843 return ret;

1844 }

1845

1846 static char *

1847 bin_to_hex_dup(const unsigned char *src, int srclen)

1848 {

1849 char *buf;

1850

1851 /* +1 for terminating NULL */

1852 buf = kzalloc((srclen * 2) + 1, GFP_KERNEL);

1853 if (!buf)

1854 return buf;

1855

1856 bin2hex(buf, src, srclen);

1857 return buf;

1858 }

1859

1860 static int

1861 nfsd4_umh_cltrack_init(struct net *net)

1862 {

1863 int ret;

1864 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

1865 char *grace_start = nfsd4_cltrack_grace_start(nn->boot_time);

1866

1867 /* XXX: The usermode helper s not working in container yet. */

1868 if (net != &init_net) {

1869 pr_warn("NFSD: attempt to initialize umh client tracking in a container ignored.\n");

1870 kfree(grace_start);

1871 return -EINVAL;

1872 }

1873

1874 ret = nfsd4_umh_cltrack_upcall("init", NULL, grace_start, NULL);

1875 kfree(grace_start);

1876 if (!ret)

1877 pr_info("NFSD: Using UMH upcall client tracking operations.\n");

1878 return ret;

1879 }

1880

1881 static void

1882 nfsd4_cltrack_upcall_lock(struct nfs4_client *clp)

1883 {

1884 wait_on_bit_lock(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK,

1885 TASK_UNINTERRUPTIBLE);

1886 }

1887

1888 static void

1889 nfsd4_cltrack_upcall_unlock(struct nfs4_client *clp)

1890 {

1891 smp_mb__before_atomic();

1892 clear_bit(NFSD4_CLIENT_UPCALL_LOCK, &clp->cl_flags);

1893 smp_mb__after_atomic();

1894 wake_up_bit(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK);

1895 }

1896

1897 static void

1898 nfsd4_umh_cltrack_create(struct nfs4_client *clp)

1899 {

1900 char *hexid, *has_session, *grace_start;

1901 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

1902

1903 /*

1904 * With v4.0 clients, there's little difference in outcome between a

1905 * create and check operation, and we can end up calling into this

1906 * function multiple times per client (once for each openowner). So,

1907 * for v4.0 clients skip upcalling once the client has been recorded

1908 * on stable storage.

1909 *

1910 * For v4.1+ clients, the outcome of the two operations is different,

1911 * so we must ensure that we upcall for the create operation. v4.1+

1912 * clients call this on RECLAIM_COMPLETE though, so we should only end

1913 * up doing a single create upcall per client.

1914 */

1915 if (clp->cl_minorversion == 0 &&

1916 test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

1917 return;

1918

1919 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);

1920 if (!hexid) {

1921 dprintk("%s: can't allocate memory for upcall!\n", __func__);

1922 return;

1923 }

1924

1925 has_session = nfsd4_cltrack_client_has_session(clp);

1926 grace_start = nfsd4_cltrack_grace_start(nn->boot_time);

1927

1928 nfsd4_cltrack_upcall_lock(clp);

1929 if (!nfsd4_umh_cltrack_upcall("create", hexid, has_session, grace_start))

1930 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);

1931 nfsd4_cltrack_upcall_unlock(clp);

1932

1933 kfree(has_session);

1934 kfree(grace_start);

1935 kfree(hexid);

1936 }

1937

1938 static void

1939 nfsd4_umh_cltrack_remove(struct nfs4_client *clp)

1940 {

1941 char *hexid;

1942

1943 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

1944 return;

1945

1946 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);

1947 if (!hexid) {

1948 dprintk("%s: can't allocate memory for upcall!\n", __func__);

1949 return;

1950 }

1951

1952 nfsd4_cltrack_upcall_lock(clp);

1953 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags) &&

1954 nfsd4_umh_cltrack_upcall("remove", hexid, NULL, NULL) == 0)

1955 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);

1956 nfsd4_cltrack_upcall_unlock(clp);

1957

1958 kfree(hexid);

1959 }

1960

1961 static int

1962 nfsd4_umh_cltrack_check(struct nfs4_client *clp)

1963 {

1964 int ret;

1965 char *hexid, *has_session, *legacy;

1966

1967 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))

1968 return 0;

1969

1970 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);

1971 if (!hexid) {

1972 dprintk("%s: can't allocate memory for upcall!\n", __func__);

1973 return -ENOMEM;

1974 }

1975

1976 has_session = nfsd4_cltrack_client_has_session(clp);

1977 legacy = nfsd4_cltrack_legacy_recdir(&clp->cl_name);

1978

1979 nfsd4_cltrack_upcall_lock(clp);

1980 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) {

1981 ret = 0;

1982 } else {

1983 ret = nfsd4_umh_cltrack_upcall("check", hexid, has_session, legacy);

1984 if (ret == 0)

1985 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);

1986 }

1987 nfsd4_cltrack_upcall_unlock(clp);

1988 kfree(has_session);

1989 kfree(legacy);

1990 kfree(hexid);

1991

1992 return ret;

1993 }

1994

1995 static void

1996 nfsd4_umh_cltrack_grace_done(struct nfsd_net *nn)

1997 {

1998 char *legacy;

1999 char timestr[22]; /* FIXME: better way to determine max size? */

2000

2001 sprintf(timestr, "%lld", nn->boot_time);

2002 legacy = nfsd4_cltrack_legacy_topdir();

2003 nfsd4_umh_cltrack_upcall("gracedone", timestr, legacy, NULL);

2004 kfree(legacy);

2005 }

2006

2007 static const struct nfsd4_client_tracking_ops nfsd4_umh_tracking_ops = {

2008 .init = nfsd4_umh_cltrack_init,

2009 .exit = NULL,

2010 .create = nfsd4_umh_cltrack_create,

2011 .remove = nfsd4_umh_cltrack_remove,

2012 .check = nfsd4_umh_cltrack_check,

2013 .grace_done = nfsd4_umh_cltrack_grace_done,

2014 .version = 1,

2015 .msglen = 0,

2016 };

2017

2018 int

2019 nfsd4_client_tracking_init(struct net *net)

2020 {

2021 int status;

2022 struct path path;

2023 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

2024

2025 /* just run the init if it the method is already decided */

2026 if (nn->client_tracking_ops)

2027 goto do_init;

2028

2029 /* First, try to use nfsdcld */

2030 nn->client_tracking_ops = &nfsd4_cld_tracking_ops;

2031 status = nn->client_tracking_ops->init(net);

2032 if (!status)

2033 return status;

2034 if (status != -ETIMEDOUT) {

2035 nn->client_tracking_ops = &nfsd4_cld_tracking_ops_v0;

2036 status = nn->client_tracking_ops->init(net);

2037 if (!status)

2038 return status;

2039 }

2040

2041 /*

2042 * Next, try the UMH upcall.

2043 */

2044 nn->client_tracking_ops = &nfsd4_umh_tracking_ops;

2045 status = nn->client_tracking_ops->init(net);

2046 if (!status)

2047 return status;

2048

2049 /*

2050 * Finally, See if the recoverydir exists and is a directory.

2051 * If it is, then use the legacy ops.

2052 */

2053 nn->client_tracking_ops = &nfsd4_legacy_tracking_ops;

2054 status = kern_path(nfs4_recoverydir(), LOOKUP_FOLLOW, &path);

2055 if (!status) {

2056 status = d_is_dir(path.dentry);

2057 path_put(&path);

2058 if (!status) {

2059 status = -EINVAL;

2060 goto out;

2061 }

2062 }

2063

2064 do_init:

2065 status = nn->client_tracking_ops->init(net);

2066 out:

2067 if (status) {

2068 printk(KERN_WARNING "NFSD: Unable to initialize client "

2069 "recovery tracking! (%d)\n", status);

2070 nn->client_tracking_ops = NULL;

2071 }

2072 return status;

2073 }

2074

2075 void

2076 nfsd4_client_tracking_exit(struct net *net)

2077 {

2078 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

2079

2080 if (nn->client_tracking_ops) {

2081 if (nn->client_tracking_ops->exit)

2082 nn->client_tracking_ops->exit(net);

2083 nn->client_tracking_ops = NULL;

2084 }

2085 }

2086

2087 void

2088 nfsd4_client_record_create(struct nfs4_client *clp)

2089 {

2090 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

2091

2092 if (nn->client_tracking_ops)

2093 nn->client_tracking_ops->create(clp);

2094 }

2095

2096 void

2097 nfsd4_client_record_remove(struct nfs4_client *clp)

2098 {

2099 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

2100

2101 if (nn->client_tracking_ops)

2102 nn->client_tracking_ops->remove(clp);

2103 }

2104

2105 int

2106 nfsd4_client_record_check(struct nfs4_client *clp)

2107 {

2108 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);

2109

2110 if (nn->client_tracking_ops)

2111 return nn->client_tracking_ops->check(clp);

2112

2113 return -EOPNOTSUPP;

2114 }

2115

2116 void

2117 nfsd4_record_grace_done(struct nfsd_net *nn)

2118 {

2119 if (nn->client_tracking_ops)

2120 nn->client_tracking_ops->grace_done(nn);

2121 }

2122

2123 static int

2124 rpc_pipefs_event(struct notifier_block *nb, unsigned long event, void *ptr)

2125 {

2126 struct super_block *sb = ptr;

2127 struct net *net = sb->s_fs_info;

2128 struct nfsd_net *nn = net_generic(net, nfsd_net_id);

2129 struct cld_net *cn = nn->cld_net;

2130 struct dentry *dentry;

2131 int ret = 0;

2132

2133 if (!try_module_get(THIS_MODULE))

2134 return 0;

2135

2136 if (!cn) {

2137 module_put(THIS_MODULE);

2138 return 0;

2139 }

2140

2141 switch (event) {

2142 case RPC_PIPEFS_MOUNT:

2143 dentry = nfsd4_cld_register_sb(sb, cn->cn_pipe);

2144 if (IS_ERR(dentry)) {

2145 ret = PTR_ERR(dentry);

2146 break;

2147 }

2148 cn->cn_pipe->dentry = dentry;

2149 break;

2150 case RPC_PIPEFS_UMOUNT:

2151 if (cn->cn_pipe->dentry)

2152 nfsd4_cld_unregister_sb(cn->cn_pipe);

2153 break;

2154 default:

2155 ret = -ENOTSUPP;

2156 break;

2157 }

2158 module_put(THIS_MODULE);

2159 return ret;

2160 }

2161

2162 static struct notifier_block nfsd4_cld_block = {

2163 .notifier_call = rpc_pipefs_event,

2164 };

2165

2166 int

2167 register_cld_notifier(void)

2168 {

2169 WARN_ON(!nfsd_net_id);

2170 return rpc_pipefs_notifier_register(&nfsd4_cld_block);

2171 }

2172

2173 void

2174 unregister_cld_notifier(void)

2175 {

2176 rpc_pipefs_notifier_unregister(&nfsd4_cld_block);

2177 }