git.infradead.org Git - nvme.git/blob

1 // SPDX-License-Identifier: GPL-2.0-or-later

2 /* dir.c: AFS filesystem directory handling

3 *

5 * Written by David Howells (dhowells@redhat.com)

6 */

7

8 #include <linux/kernel.h>

9 #include <linux/fs.h>

10 #include <linux/namei.h>

11 #include <linux/pagemap.h>

12 #include <linux/swap.h>

13 #include <linux/ctype.h>

14 #include <linux/sched.h>

15 #include <linux/task_io_accounting_ops.h>

16 #include "internal.h"

17 #include "afs_fs.h"

18 #include "xdr_fs.h"

19

20 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,

21 unsigned int flags);

22 static int afs_dir_open(struct inode *inode, struct file *file);

23 static int afs_readdir(struct file *file, struct dir_context *ctx);

24 static int afs_d_revalidate(struct dentry *dentry, unsigned int flags);

25 static int afs_d_delete(const struct dentry *dentry);

26 static void afs_d_iput(struct dentry *dentry, struct inode *inode);

27 static bool afs_lookup_one_filldir(struct dir_context *ctx, const char *name, int nlen,

28 loff_t fpos, u64 ino, unsigned dtype);

29 static bool afs_lookup_filldir(struct dir_context *ctx, const char *name, int nlen,

30 loff_t fpos, u64 ino, unsigned dtype);

31 static int afs_create(struct mnt_idmap *idmap, struct inode *dir,

32 struct dentry *dentry, umode_t mode, bool excl);

33 static int afs_mkdir(struct mnt_idmap *idmap, struct inode *dir,

34 struct dentry *dentry, umode_t mode);

35 static int afs_rmdir(struct inode *dir, struct dentry *dentry);

36 static int afs_unlink(struct inode *dir, struct dentry *dentry);

37 static int afs_link(struct dentry *from, struct inode *dir,

38 struct dentry *dentry);

39 static int afs_symlink(struct mnt_idmap *idmap, struct inode *dir,

40 struct dentry *dentry, const char *content);

41 static int afs_rename(struct mnt_idmap *idmap, struct inode *old_dir,

42 struct dentry *old_dentry, struct inode *new_dir,

43 struct dentry *new_dentry, unsigned int flags);

44 static bool afs_dir_release_folio(struct folio *folio, gfp_t gfp_flags);

45 static void afs_dir_invalidate_folio(struct folio *folio, size_t offset,

46 size_t length);

47

48 static bool afs_dir_dirty_folio(struct address_space *mapping,

49 struct folio *folio)

50 {

51 BUG(); /* This should never happen. */

52 }

53

54 const struct file_operations afs_dir_file_operations = {

55 .open = afs_dir_open,

56 .release = afs_release,

57 .iterate_shared = afs_readdir,

58 .lock = afs_lock,

59 .llseek = generic_file_llseek,

60 };

61

62 const struct inode_operations afs_dir_inode_operations = {

63 .create = afs_create,

64 .lookup = afs_lookup,

65 .link = afs_link,

66 .unlink = afs_unlink,

67 .symlink = afs_symlink,

68 .mkdir = afs_mkdir,

69 .rmdir = afs_rmdir,

70 .rename = afs_rename,

71 .permission = afs_permission,

72 .getattr = afs_getattr,

73 .setattr = afs_setattr,

74 };

75

76 const struct address_space_operations afs_dir_aops = {

77 .dirty_folio = afs_dir_dirty_folio,

78 .release_folio = afs_dir_release_folio,

79 .invalidate_folio = afs_dir_invalidate_folio,

80 .migrate_folio = filemap_migrate_folio,

81 };

82

83 const struct dentry_operations afs_fs_dentry_operations = {

84 .d_revalidate = afs_d_revalidate,

85 .d_delete = afs_d_delete,

86 .d_release = afs_d_release,

87 .d_automount = afs_d_automount,

88 .d_iput = afs_d_iput,

89 };

90

91 struct afs_lookup_one_cookie {

92 struct dir_context ctx;

93 struct qstr name;

94 bool found;

95 struct afs_fid fid;

96 };

97

98 struct afs_lookup_cookie {

99 struct dir_context ctx;

100 struct qstr name;

101 bool found;

102 bool one_only;

103 unsigned short nr_fids;

104 struct afs_fid fids[50];

105 };

106

107 /*

108 * Drop the refs that we're holding on the folios we were reading into. We've

109 * got refs on the first nr_pages pages.

110 */

111 static void afs_dir_read_cleanup(struct afs_read *req)

112 {

113 struct address_space *mapping = req->vnode->netfs.inode.i_mapping;

114 struct folio *folio;

115 pgoff_t last = req->nr_pages - 1;

116

117 XA_STATE(xas, &mapping->i_pages, 0);

118

119 if (unlikely(!req->nr_pages))

120 return;

121

122 rcu_read_lock();

123 xas_for_each(&xas, folio, last) {

124 if (xas_retry(&xas, folio))

125 continue;

126 BUG_ON(xa_is_value(folio));

127 ASSERTCMP(folio_file_mapping(folio), ==, mapping);

128

129 folio_put(folio);

130 }

131

132 rcu_read_unlock();

133 }

134

135 /*

136 * check that a directory folio is valid

137 */

138 static bool afs_dir_check_folio(struct afs_vnode *dvnode, struct folio *folio,

139 loff_t i_size)

140 {

141 union afs_xdr_dir_block *block;

142 size_t offset, size;

143 loff_t pos;

144

145 /* Determine how many magic numbers there should be in this folio, but

146 * we must take care because the directory may change size under us.

147 */

148 pos = folio_pos(folio);

149 if (i_size <= pos)

150 goto checked;

151

152 size = min_t(loff_t, folio_size(folio), i_size - pos);

153 for (offset = 0; offset < size; offset += sizeof(*block)) {

154 block = kmap_local_folio(folio, offset);

155 if (block->hdr.magic != AFS_DIR_MAGIC) {

156 printk("kAFS: %s(%lx): [%llx] bad magic %zx/%zx is %04hx\n",

157 __func__, dvnode->netfs.inode.i_ino,

158 pos, offset, size, ntohs(block->hdr.magic));

159 trace_afs_dir_check_failed(dvnode, pos + offset, i_size);

160 kunmap_local(block);

161 trace_afs_file_error(dvnode, -EIO, afs_file_error_dir_bad_magic);

162 goto error;

163 }

164

165 /* Make sure each block is NUL terminated so we can reasonably

166 * use string functions on it. The filenames in the folio

167 * *should* be NUL-terminated anyway.

168 */

169 ((u8 *)block)[AFS_DIR_BLOCK_SIZE - 1] = 0;

170

171 kunmap_local(block);

172 }

173 checked:

174 afs_stat_v(dvnode, n_read_dir);

175 return true;

176

177 error:

178 return false;

179 }

180

181 /*

182 * Dump the contents of a directory.

183 */

184 static void afs_dir_dump(struct afs_vnode *dvnode, struct afs_read *req)

185 {

186 union afs_xdr_dir_block *block;

187 struct address_space *mapping = dvnode->netfs.inode.i_mapping;

188 struct folio *folio;

189 pgoff_t last = req->nr_pages - 1;

190 size_t offset, size;

191

192 XA_STATE(xas, &mapping->i_pages, 0);

193

194 pr_warn("DIR %llx:%llx f=%llx l=%llx al=%llx\n",

195 dvnode->fid.vid, dvnode->fid.vnode,

196 req->file_size, req->len, req->actual_len);

197 pr_warn("DIR %llx %x %zx %zx\n",

198 req->pos, req->nr_pages,

199 req->iter->iov_offset, iov_iter_count(req->iter));

200

201 xas_for_each(&xas, folio, last) {

202 if (xas_retry(&xas, folio))

203 continue;

204

205 BUG_ON(folio_file_mapping(folio) != mapping);

206

207 size = min_t(loff_t, folio_size(folio), req->actual_len - folio_pos(folio));

208 for (offset = 0; offset < size; offset += sizeof(*block)) {

209 block = kmap_local_folio(folio, offset);

210 pr_warn("[%02lx] %32phN\n", folio_index(folio) + offset, block);

211 kunmap_local(block);

212 }

213 }

214 }

215

216 /*

217 * Check all the blocks in a directory. All the folios are held pinned.

218 */

219 static int afs_dir_check(struct afs_vnode *dvnode, struct afs_read *req)

220 {

221 struct address_space *mapping = dvnode->netfs.inode.i_mapping;

222 struct folio *folio;

223 pgoff_t last = req->nr_pages - 1;

224 int ret = 0;

225

226 XA_STATE(xas, &mapping->i_pages, 0);

227

228 if (unlikely(!req->nr_pages))

229 return 0;

230

231 rcu_read_lock();

232 xas_for_each(&xas, folio, last) {

233 if (xas_retry(&xas, folio))

234 continue;

235

236 BUG_ON(folio_file_mapping(folio) != mapping);

237

238 if (!afs_dir_check_folio(dvnode, folio, req->actual_len)) {

239 afs_dir_dump(dvnode, req);

240 ret = -EIO;

241 break;

242 }

243 }

244

245 rcu_read_unlock();

246 return ret;

247 }

248

249 /*

250 * open an AFS directory file

251 */

252 static int afs_dir_open(struct inode *inode, struct file *file)

253 {

254 _enter("{%lu}", inode->i_ino);

255

256 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);

257 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);

258

259 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(inode)->flags))

260 return -ENOENT;

261

262 return afs_open(inode, file);

263 }

264

265 /*

266 * Read the directory into the pagecache in one go, scrubbing the previous

267 * contents. The list of folios is returned, pinning them so that they don't

268 * get reclaimed during the iteration.

269 */

270 static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key)

271 __acquires(&dvnode->validate_lock)

272 {

273 struct address_space *mapping = dvnode->netfs.inode.i_mapping;

274 struct afs_read *req;

275 loff_t i_size;

276 int nr_pages, i;

277 int ret;

278 loff_t remote_size = 0;

279

280 _enter("");

281

282 req = kzalloc(sizeof(*req), GFP_KERNEL);

283 if (!req)

284 return ERR_PTR(-ENOMEM);

285

286 refcount_set(&req->usage, 1);

287 req->vnode = dvnode;

288 req->key = key_get(key);

289 req->cleanup = afs_dir_read_cleanup;

290

291 expand:

292 i_size = i_size_read(&dvnode->netfs.inode);

293 if (i_size < remote_size)

294 i_size = remote_size;

295 if (i_size < 2048) {

296 ret = afs_bad(dvnode, afs_file_error_dir_small);

297 goto error;

298 }

299 if (i_size > 2048 * 1024) {

300 trace_afs_file_error(dvnode, -EFBIG, afs_file_error_dir_big);

301 ret = -EFBIG;

302 goto error;

303 }

304

305 _enter("%llu", i_size);

306

307 nr_pages = (i_size + PAGE_SIZE - 1) / PAGE_SIZE;

308

309 req->actual_len = i_size; /* May change */

310 req->len = nr_pages * PAGE_SIZE; /* We can ask for more than there is */

311 req->data_version = dvnode->status.data_version; /* May change */

312 iov_iter_xarray(&req->def_iter, ITER_DEST, &dvnode->netfs.inode.i_mapping->i_pages,

313 0, i_size);

314 req->iter = &req->def_iter;

315

316 /* Fill in any gaps that we might find where the memory reclaimer has

317 * been at work and pin all the folios. If there are any gaps, we will

318 * need to reread the entire directory contents.

319 */

320 i = req->nr_pages;

321 while (i < nr_pages) {

322 struct folio *folio;

323

324 folio = filemap_get_folio(mapping, i);

325 if (IS_ERR(folio)) {

326 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))

327 afs_stat_v(dvnode, n_inval);

328 folio = __filemap_get_folio(mapping,

329 i, FGP_LOCK | FGP_CREAT,

330 mapping->gfp_mask);

331 if (IS_ERR(folio)) {

332 ret = PTR_ERR(folio);

333 goto error;

334 }

335 folio_attach_private(folio, (void *)1);

336 folio_unlock(folio);

337 }

338

339 req->nr_pages += folio_nr_pages(folio);

340 i += folio_nr_pages(folio);

341 }

342

343 /* If we're going to reload, we need to lock all the pages to prevent

344 * races.

345 */

346 ret = -ERESTARTSYS;

347 if (down_read_killable(&dvnode->validate_lock) < 0)

348 goto error;

349

350 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))

351 goto success;

352

353 up_read(&dvnode->validate_lock);

354 if (down_write_killable(&dvnode->validate_lock) < 0)

355 goto error;

356

357 if (!test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) {

358 trace_afs_reload_dir(dvnode);

359 ret = afs_fetch_data(dvnode, req);

360 if (ret < 0)

361 goto error_unlock;

362

363 task_io_account_read(PAGE_SIZE * req->nr_pages);

364

365 if (req->len < req->file_size) {

366 /* The content has grown, so we need to expand the

367 * buffer.

368 */

369 up_write(&dvnode->validate_lock);

370 remote_size = req->file_size;

371 goto expand;

372 }

373

374 /* Validate the data we just read. */

375 ret = afs_dir_check(dvnode, req);

376 if (ret < 0)

377 goto error_unlock;

378

379 // TODO: Trim excess pages

380

381 set_bit(AFS_VNODE_DIR_VALID, &dvnode->flags);

382 }

383

384 downgrade_write(&dvnode->validate_lock);

385 success:

386 return req;

387

388 error_unlock:

389 up_write(&dvnode->validate_lock);

390 error:

391 afs_put_read(req);

392 _leave(" = %d", ret);

393 return ERR_PTR(ret);

394 }

395

396 /*

397 * deal with one block in an AFS directory

398 */

399 static int afs_dir_iterate_block(struct afs_vnode *dvnode,

400 struct dir_context *ctx,

401 union afs_xdr_dir_block *block,

402 unsigned blkoff)

403 {

404 union afs_xdr_dirent *dire;

405 unsigned offset, next, curr, nr_slots;

406 size_t nlen;

407 int tmp;

408

409 _enter("%llx,%x", ctx->pos, blkoff);

410

411 curr = (ctx->pos - blkoff) / sizeof(union afs_xdr_dirent);

412

413 /* walk through the block, an entry at a time */

414 for (offset = (blkoff == 0 ? AFS_DIR_RESV_BLOCKS0 : AFS_DIR_RESV_BLOCKS);

415 offset < AFS_DIR_SLOTS_PER_BLOCK;

416 offset = next

417 ) {

418 /* skip entries marked unused in the bitmap */

419 if (!(block->hdr.bitmap[offset / 8] &

420 (1 << (offset % 8)))) {

421 _debug("ENT[%zu.%u]: unused",

422 blkoff / sizeof(union afs_xdr_dir_block), offset);

423 next = offset + 1;

424 if (offset >= curr)

425 ctx->pos = blkoff +

426 next * sizeof(union afs_xdr_dirent);

427 continue;

428 }

429

430 /* got a valid entry */

431 dire = &block->dirents[offset];

432 nlen = strnlen(dire->u.name,

433 sizeof(*block) -

434 offset * sizeof(union afs_xdr_dirent));

435 if (nlen > AFSNAMEMAX - 1) {

436 _debug("ENT[%zu]: name too long (len %u/%zu)",

437 blkoff / sizeof(union afs_xdr_dir_block),

438 offset, nlen);

439 return afs_bad(dvnode, afs_file_error_dir_name_too_long);

440 }

441

442 _debug("ENT[%zu.%u]: %s %zu \"%s\"",

443 blkoff / sizeof(union afs_xdr_dir_block), offset,

444 (offset < curr ? "skip" : "fill"),

445 nlen, dire->u.name);

446

447 nr_slots = afs_dir_calc_slots(nlen);

448 next = offset + nr_slots;

449 if (next > AFS_DIR_SLOTS_PER_BLOCK) {

450 _debug("ENT[%zu.%u]:"

451 " %u extends beyond end dir block"

452 " (len %zu)",

453 blkoff / sizeof(union afs_xdr_dir_block),

454 offset, next, nlen);

455 return afs_bad(dvnode, afs_file_error_dir_over_end);

456 }

457

458 /* Check that the name-extension dirents are all allocated */

459 for (tmp = 1; tmp < nr_slots; tmp++) {

460 unsigned int ix = offset + tmp;

461 if (!(block->hdr.bitmap[ix / 8] & (1 << (ix % 8)))) {

462 _debug("ENT[%zu.u]:"

463 " %u unmarked extension (%u/%u)",

464 blkoff / sizeof(union afs_xdr_dir_block),

465 offset, tmp, nr_slots);

466 return afs_bad(dvnode, afs_file_error_dir_unmarked_ext);

467 }

468 }

469

470 /* skip if starts before the current position */

471 if (offset < curr) {

472 if (next > curr)

473 ctx->pos = blkoff + next * sizeof(union afs_xdr_dirent);

474 continue;

475 }

476

477 /* found the next entry */

478 if (!dir_emit(ctx, dire->u.name, nlen,

479 ntohl(dire->u.vnode),

480 (ctx->actor == afs_lookup_filldir ||

481 ctx->actor == afs_lookup_one_filldir)?

482 ntohl(dire->u.unique) : DT_UNKNOWN)) {

483 _leave(" = 0 [full]");

484 return 0;

485 }

486

487 ctx->pos = blkoff + next * sizeof(union afs_xdr_dirent);

488 }

489

490 _leave(" = 1 [more]");

491 return 1;

492 }

493

494 /*

495 * iterate through the data blob that lists the contents of an AFS directory

496 */

497 static int afs_dir_iterate(struct inode *dir, struct dir_context *ctx,

498 struct key *key, afs_dataversion_t *_dir_version)

499 {

500 struct afs_vnode *dvnode = AFS_FS_I(dir);

501 union afs_xdr_dir_block *dblock;

502 struct afs_read *req;

503 struct folio *folio;

504 unsigned offset, size;

505 int ret;

506

507 _enter("{%lu},%u,,", dir->i_ino, (unsigned)ctx->pos);

508

509 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dir)->flags)) {

510 _leave(" = -ESTALE");

511 return -ESTALE;

512 }

513

514 req = afs_read_dir(dvnode, key);

515 if (IS_ERR(req))

516 return PTR_ERR(req);

517 *_dir_version = req->data_version;

518

519 /* round the file position up to the next entry boundary */

520 ctx->pos += sizeof(union afs_xdr_dirent) - 1;

521 ctx->pos &= ~(sizeof(union afs_xdr_dirent) - 1);

522

523 /* walk through the blocks in sequence */

524 ret = 0;

525 while (ctx->pos < req->actual_len) {

526 /* Fetch the appropriate folio from the directory and re-add it

527 * to the LRU. We have all the pages pinned with an extra ref.

528 */

529 folio = __filemap_get_folio(dir->i_mapping, ctx->pos / PAGE_SIZE,

530 FGP_ACCESSED, 0);

531 if (IS_ERR(folio)) {

532 ret = afs_bad(dvnode, afs_file_error_dir_missing_page);

533 break;

534 }

535

536 offset = round_down(ctx->pos, sizeof(*dblock)) - folio_file_pos(folio);

537 size = min_t(loff_t, folio_size(folio),

538 req->actual_len - folio_file_pos(folio));

539

540 do {

541 dblock = kmap_local_folio(folio, offset);

542 ret = afs_dir_iterate_block(dvnode, ctx, dblock,

543 folio_file_pos(folio) + offset);

544 kunmap_local(dblock);

545 if (ret != 1)

546 goto out;

547

548 } while (offset += sizeof(*dblock), offset < size);

549

550 ret = 0;

551 }

552

553 out:

554 up_read(&dvnode->validate_lock);

555 afs_put_read(req);

556 _leave(" = %d", ret);

557 return ret;

558 }

559

560 /*

561 * read an AFS directory

562 */

563 static int afs_readdir(struct file *file, struct dir_context *ctx)

564 {

565 afs_dataversion_t dir_version;

566

567 return afs_dir_iterate(file_inode(file), ctx, afs_file_key(file),

568 &dir_version);

569 }

570

571 /*

572 * Search the directory for a single name

573 * - if afs_dir_iterate_block() spots this function, it'll pass the FID

574 * uniquifier through dtype

575 */

576 static bool afs_lookup_one_filldir(struct dir_context *ctx, const char *name,

577 int nlen, loff_t fpos, u64 ino, unsigned dtype)

578 {

579 struct afs_lookup_one_cookie *cookie =

580 container_of(ctx, struct afs_lookup_one_cookie, ctx);

581

582 _enter("{%s,%u},%s,%u,,%llu,%u",

583 cookie->name.name, cookie->name.len, name, nlen,

584 (unsigned long long) ino, dtype);

585

586 /* insanity checks first */

587 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);

588 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);

589

590 if (cookie->name.len != nlen ||

591 memcmp(cookie->name.name, name, nlen) != 0) {

592 _leave(" = true [keep looking]");

593 return true;

594 }

595

596 cookie->fid.vnode = ino;

597 cookie->fid.unique = dtype;

598 cookie->found = 1;

599

600 _leave(" = false [found]");

601 return false;

602 }

603

604 /*

605 * Do a lookup of a single name in a directory

606 * - just returns the FID the dentry name maps to if found

607 */

608 static int afs_do_lookup_one(struct inode *dir, struct dentry *dentry,

609 struct afs_fid *fid, struct key *key,

610 afs_dataversion_t *_dir_version)

611 {

612 struct afs_super_info *as = dir->i_sb->s_fs_info;

613 struct afs_lookup_one_cookie cookie = {

614 .ctx.actor = afs_lookup_one_filldir,

615 .name = dentry->d_name,

616 .fid.vid = as->volume->vid

617 };

618 int ret;

619

620 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);

621

622 /* search the directory */

623 ret = afs_dir_iterate(dir, &cookie.ctx, key, _dir_version);

624 if (ret < 0) {

625 _leave(" = %d [iter]", ret);

626 return ret;

627 }

628

629 if (!cookie.found) {

630 _leave(" = -ENOENT [not found]");

631 return -ENOENT;

632 }

633

634 *fid = cookie.fid;

635 _leave(" = 0 { vn=%llu u=%u }", fid->vnode, fid->unique);

636 return 0;

637 }

638

639 /*

640 * search the directory for a name

641 * - if afs_dir_iterate_block() spots this function, it'll pass the FID

642 * uniquifier through dtype

643 */

644 static bool afs_lookup_filldir(struct dir_context *ctx, const char *name,

645 int nlen, loff_t fpos, u64 ino, unsigned dtype)

646 {

647 struct afs_lookup_cookie *cookie =

648 container_of(ctx, struct afs_lookup_cookie, ctx);

649

650 _enter("{%s,%u},%s,%u,,%llu,%u",

651 cookie->name.name, cookie->name.len, name, nlen,

652 (unsigned long long) ino, dtype);

653

654 /* insanity checks first */

655 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);

656 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);

657

658 if (cookie->found) {

659 if (cookie->nr_fids < 50) {

660 cookie->fids[cookie->nr_fids].vnode = ino;

661 cookie->fids[cookie->nr_fids].unique = dtype;

662 cookie->nr_fids++;

663 }

664 } else if (cookie->name.len == nlen &&

665 memcmp(cookie->name.name, name, nlen) == 0) {

666 cookie->fids[1].vnode = ino;

667 cookie->fids[1].unique = dtype;

668 cookie->found = 1;

669 if (cookie->one_only)

670 return false;

671 }

672

673 return cookie->nr_fids < 50;

674 }

675

676 /*

677 * Deal with the result of a successful lookup operation. Turn all the files

678 * into inodes and save the first one - which is the one we actually want.

679 */

680 static void afs_do_lookup_success(struct afs_operation *op)

681 {

682 struct afs_vnode_param *vp;

683 struct afs_vnode *vnode;

684 struct inode *inode;

685 u32 abort_code;

686 int i;

687

688 _enter("");

689

690 for (i = 0; i < op->nr_files; i++) {

691 switch (i) {

692 case 0:

693 vp = &op->file[0];

694 abort_code = vp->scb.status.abort_code;

695 if (abort_code != 0) {

696 op->call_abort_code = abort_code;

697 afs_op_set_error(op, afs_abort_to_error(abort_code));

698 op->cumul_error.abort_code = abort_code;

699 }

700 break;

701

702 case 1:

703 vp = &op->file[1];

704 break;

705

706 default:

707 vp = &op->more_files[i - 2];

708 break;

709 }

710

711 if (!vp->scb.have_status && !vp->scb.have_error)

712 continue;

713

714 _debug("do [%u]", i);

715 if (vp->vnode) {

716 if (!test_bit(AFS_VNODE_UNSET, &vp->vnode->flags))

717 afs_vnode_commit_status(op, vp);

718 } else if (vp->scb.status.abort_code == 0) {

719 inode = afs_iget(op, vp);

720 if (!IS_ERR(inode)) {

721 vnode = AFS_FS_I(inode);

722 afs_cache_permit(vnode, op->key,

723 0 /* Assume vnode->cb_break is 0 */ +

724 op->cb_v_break,

725 &vp->scb);

726 vp->vnode = vnode;

727 vp->put_vnode = true;

728 }

729 } else {

730 _debug("- abort %d %llx:%llx.%x",

731 vp->scb.status.abort_code,

732 vp->fid.vid, vp->fid.vnode, vp->fid.unique);

733 }

734 }

735

736 _leave("");

737 }

738

739 static const struct afs_operation_ops afs_inline_bulk_status_operation = {

740 .issue_afs_rpc = afs_fs_inline_bulk_status,

741 .issue_yfs_rpc = yfs_fs_inline_bulk_status,

742 .success = afs_do_lookup_success,

743 };

744

745 static const struct afs_operation_ops afs_lookup_fetch_status_operation = {

746 .issue_afs_rpc = afs_fs_fetch_status,

747 .issue_yfs_rpc = yfs_fs_fetch_status,

748 .success = afs_do_lookup_success,

749 .aborted = afs_check_for_remote_deletion,

750 };

751

752 /*

753 * See if we know that the server we expect to use doesn't support

754 * FS.InlineBulkStatus.

755 */

756 static bool afs_server_supports_ibulk(struct afs_vnode *dvnode)

757 {

758 struct afs_server_list *slist;

759 struct afs_volume *volume = dvnode->volume;

760 struct afs_server *server;

761 bool ret = true;

762 int i;

763

764 if (!test_bit(AFS_VOLUME_MAYBE_NO_IBULK, &volume->flags))

765 return true;

766

767 rcu_read_lock();

768 slist = rcu_dereference(volume->servers);

769

770 for (i = 0; i < slist->nr_servers; i++) {

771 server = slist->servers[i].server;

772 if (server == dvnode->cb_server) {

773 if (test_bit(AFS_SERVER_FL_NO_IBULK, &server->flags))

774 ret = false;

775 break;

776 }

777 }

778

779 rcu_read_unlock();

780 return ret;

781 }

782

783 /*

784 * Do a lookup in a directory. We make use of bulk lookup to query a slew of

785 * files in one go and create inodes for them. The inode of the file we were

786 * asked for is returned.

787 */

788 static struct inode *afs_do_lookup(struct inode *dir, struct dentry *dentry,

789 struct key *key)

790 {

791 struct afs_lookup_cookie *cookie;

792 struct afs_vnode_param *vp;

793 struct afs_operation *op;

794 struct afs_vnode *dvnode = AFS_FS_I(dir), *vnode;

795 struct inode *inode = NULL, *ti;

796 afs_dataversion_t data_version = READ_ONCE(dvnode->status.data_version);

797 long ret;

798 int i;

799

800 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);

801

802 cookie = kzalloc(sizeof(struct afs_lookup_cookie), GFP_KERNEL);

803 if (!cookie)

804 return ERR_PTR(-ENOMEM);

805

806 for (i = 0; i < ARRAY_SIZE(cookie->fids); i++)

807 cookie->fids[i].vid = dvnode->fid.vid;

808 cookie->ctx.actor = afs_lookup_filldir;

809 cookie->name = dentry->d_name;

810 cookie->nr_fids = 2; /* slot 1 is saved for the fid we actually want

811 * and slot 0 for the directory */

812

813 if (!afs_server_supports_ibulk(dvnode))

814 cookie->one_only = true;

815

816 /* search the directory */

817 ret = afs_dir_iterate(dir, &cookie->ctx, key, &data_version);

818 if (ret < 0)

819 goto out;

820

821 dentry->d_fsdata = (void *)(unsigned long)data_version;

822

823 ret = -ENOENT;

824 if (!cookie->found)

825 goto out;

826

827 /* Check to see if we already have an inode for the primary fid. */

828 inode = ilookup5(dir->i_sb, cookie->fids[1].vnode,

829 afs_ilookup5_test_by_fid, &cookie->fids[1]);

830 if (inode)

831 goto out; /* We do */

832

833 /* Okay, we didn't find it. We need to query the server - and whilst

834 * we're doing that, we're going to attempt to look up a bunch of other

835 * vnodes also.

836 */

837 op = afs_alloc_operation(NULL, dvnode->volume);

838 if (IS_ERR(op)) {

839 ret = PTR_ERR(op);

840 goto out;

841 }

842

843 afs_op_set_vnode(op, 0, dvnode);

844 afs_op_set_fid(op, 1, &cookie->fids[1]);

845

846 op->nr_files = cookie->nr_fids;

847 _debug("nr_files %u", op->nr_files);

848

849 /* Need space for examining all the selected files */

850 if (op->nr_files > 2) {

851 op->more_files = kvcalloc(op->nr_files - 2,

852 sizeof(struct afs_vnode_param),

853 GFP_KERNEL);

854 if (!op->more_files) {

855 afs_op_nomem(op);

856 goto out_op;

857 }

858

859 for (i = 2; i < op->nr_files; i++) {

860 vp = &op->more_files[i - 2];

861 vp->fid = cookie->fids[i];

862

863 /* Find any inodes that already exist and get their

864 * callback counters.

865 */

866 ti = ilookup5_nowait(dir->i_sb, vp->fid.vnode,

867 afs_ilookup5_test_by_fid, &vp->fid);

868 if (!IS_ERR_OR_NULL(ti)) {

869 vnode = AFS_FS_I(ti);

870 vp->dv_before = vnode->status.data_version;

871 vp->cb_break_before = afs_calc_vnode_cb_break(vnode);

872 vp->vnode = vnode;

873 vp->put_vnode = true;

874 vp->speculative = true; /* vnode not locked */

875 }

876 }

877 }

878

879 /* Try FS.InlineBulkStatus first. Abort codes for the individual

880 * lookups contained therein are stored in the reply without aborting

881 * the whole operation.

882 */

883 afs_op_set_error(op, -ENOTSUPP);

884 if (!cookie->one_only) {

885 op->ops = &afs_inline_bulk_status_operation;

886 afs_begin_vnode_operation(op);

887 afs_wait_for_operation(op);

888 }

889

890 if (afs_op_error(op) == -ENOTSUPP) {

891 /* We could try FS.BulkStatus next, but this aborts the entire

892 * op if any of the lookups fails - so, for the moment, revert

893 * to FS.FetchStatus for op->file[1].

894 */

895 op->fetch_status.which = 1;

896 op->ops = &afs_lookup_fetch_status_operation;

897 afs_begin_vnode_operation(op);

898 afs_wait_for_operation(op);

899 }

900 inode = ERR_PTR(afs_op_error(op));

901

902 out_op:

903 if (!afs_op_error(op)) {

904 inode = &op->file[1].vnode->netfs.inode;

905 op->file[1].vnode = NULL;

906 }

907

908 if (op->file[0].scb.have_status)

909 dentry->d_fsdata = (void *)(unsigned long)op->file[0].scb.status.data_version;

910 else

911 dentry->d_fsdata = (void *)(unsigned long)op->file[0].dv_before;

912 ret = afs_put_operation(op);

913 out:

914 kfree(cookie);

915 _leave("");

916 return inode ?: ERR_PTR(ret);

917 }

918

919 /*

920 * Look up an entry in a directory with @sys substitution.

921 */

922 static struct dentry *afs_lookup_atsys(struct inode *dir, struct dentry *dentry,

923 struct key *key)

924 {

925 struct afs_sysnames *subs;

926 struct afs_net *net = afs_i2net(dir);

927 struct dentry *ret;

928 char *buf, *p, *name;

929 int len, i;

930

931 _enter("");

932

933 ret = ERR_PTR(-ENOMEM);

934 p = buf = kmalloc(AFSNAMEMAX, GFP_KERNEL);

935 if (!buf)

936 goto out_p;

937 if (dentry->d_name.len > 4) {

938 memcpy(p, dentry->d_name.name, dentry->d_name.len - 4);

939 p += dentry->d_name.len - 4;

940 }

941

942 /* There is an ordered list of substitutes that we have to try. */

943 read_lock(&net->sysnames_lock);

944 subs = net->sysnames;

945 refcount_inc(&subs->usage);

946 read_unlock(&net->sysnames_lock);

947

948 for (i = 0; i < subs->nr; i++) {

949 name = subs->subs[i];

950 len = dentry->d_name.len - 4 + strlen(name);

951 if (len >= AFSNAMEMAX) {

952 ret = ERR_PTR(-ENAMETOOLONG);

953 goto out_s;

954 }

955

956 strcpy(p, name);

957 ret = lookup_one_len(buf, dentry->d_parent, len);

958 if (IS_ERR(ret) || d_is_positive(ret))

959 goto out_s;

960 dput(ret);

961 }

962

963 /* We don't want to d_add() the @sys dentry here as we don't want to

964 * the cached dentry to hide changes to the sysnames list.

965 */

966 ret = NULL;

967 out_s:

968 afs_put_sysnames(subs);

969 kfree(buf);

970 out_p:

971 key_put(key);

972 return ret;

973 }

974

975 /*

976 * look up an entry in a directory

977 */

978 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,

979 unsigned int flags)

980 {

981 struct afs_vnode *dvnode = AFS_FS_I(dir);

982 struct afs_fid fid = {};

983 struct inode *inode;

984 struct dentry *d;

985 struct key *key;

986 int ret;

987

988 _enter("{%llx:%llu},%p{%pd},",

989 dvnode->fid.vid, dvnode->fid.vnode, dentry, dentry);

990

991 ASSERTCMP(d_inode(dentry), ==, NULL);

992

993 if (dentry->d_name.len >= AFSNAMEMAX) {

994 _leave(" = -ENAMETOOLONG");

995 return ERR_PTR(-ENAMETOOLONG);

996 }

997

998 if (test_bit(AFS_VNODE_DELETED, &dvnode->flags)) {

999 _leave(" = -ESTALE");

1000 return ERR_PTR(-ESTALE);

1001 }

1002

1003 key = afs_request_key(dvnode->volume->cell);

1004 if (IS_ERR(key)) {

1005 _leave(" = %ld [key]", PTR_ERR(key));

1006 return ERR_CAST(key);

1007 }

1008

1009 ret = afs_validate(dvnode, key);

1010 if (ret < 0) {

1011 key_put(key);

1012 _leave(" = %d [val]", ret);

1013 return ERR_PTR(ret);

1014 }

1015

1016 if (dentry->d_name.len >= 4 &&

1017 dentry->d_name.name[dentry->d_name.len - 4] == '@' &&

1018 dentry->d_name.name[dentry->d_name.len - 3] == 's' &&

1019 dentry->d_name.name[dentry->d_name.len - 2] == 'y' &&

1020 dentry->d_name.name[dentry->d_name.len - 1] == 's')

1021 return afs_lookup_atsys(dir, dentry, key);

1022

1023 afs_stat_v(dvnode, n_lookup);

1024 inode = afs_do_lookup(dir, dentry, key);

1025 key_put(key);

1026 if (inode == ERR_PTR(-ENOENT))

1027 inode = afs_try_auto_mntpt(dentry, dir);

1028

1029 if (!IS_ERR_OR_NULL(inode))

1030 fid = AFS_FS_I(inode)->fid;

1031

1032 _debug("splice %p", dentry->d_inode);

1033 d = d_splice_alias(inode, dentry);

1034 if (!IS_ERR_OR_NULL(d)) {

1035 d->d_fsdata = dentry->d_fsdata;

1036 trace_afs_lookup(dvnode, &d->d_name, &fid);

1037 } else {

1038 trace_afs_lookup(dvnode, &dentry->d_name, &fid);

1039 }

1040 _leave("");

1041 return d;

1042 }

1043

1044 /*

1045 * Check the validity of a dentry under RCU conditions.

1046 */

1047 static int afs_d_revalidate_rcu(struct dentry *dentry)

1048 {

1049 struct afs_vnode *dvnode;

1050 struct dentry *parent;

1051 struct inode *dir;

1052 long dir_version, de_version;

1053

1054 _enter("%p", dentry);

1055

1056 /* Check the parent directory is still valid first. */

1057 parent = READ_ONCE(dentry->d_parent);

1058 dir = d_inode_rcu(parent);

1059 if (!dir)

1060 return -ECHILD;

1061 dvnode = AFS_FS_I(dir);

1062 if (test_bit(AFS_VNODE_DELETED, &dvnode->flags))

1063 return -ECHILD;

1064

1065 if (!afs_check_validity(dvnode))

1066 return -ECHILD;

1067

1068 /* We only need to invalidate a dentry if the server's copy changed

1069 * behind our back. If we made the change, it's no problem. Note that

1070 * on a 32-bit system, we only have 32 bits in the dentry to store the

1071 * version.

1072 */

1073 dir_version = (long)READ_ONCE(dvnode->status.data_version);

1074 de_version = (long)READ_ONCE(dentry->d_fsdata);

1075 if (de_version != dir_version) {

1076 dir_version = (long)READ_ONCE(dvnode->invalid_before);

1077 if (de_version - dir_version < 0)

1078 return -ECHILD;

1079 }

1080

1081 return 1; /* Still valid */

1082 }

1083

1084 /*

1085 * check that a dentry lookup hit has found a valid entry

1086 * - NOTE! the hit can be a negative hit too, so we can't assume we have an

1087 * inode

1088 */

1089 static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)

1090 {

1091 struct afs_vnode *vnode, *dir;

1092 struct afs_fid fid;

1093 struct dentry *parent;

1094 struct inode *inode;

1095 struct key *key;

1096 afs_dataversion_t dir_version, invalid_before;

1097 long de_version;

1098 int ret;

1099

1100 if (flags & LOOKUP_RCU)

1101 return afs_d_revalidate_rcu(dentry);

1102

1103 if (d_really_is_positive(dentry)) {

1104 vnode = AFS_FS_I(d_inode(dentry));

1105 _enter("{v={%llx:%llu} n=%pd fl=%lx},",

1106 vnode->fid.vid, vnode->fid.vnode, dentry,

1107 vnode->flags);

1108 } else {

1109 _enter("{neg n=%pd}", dentry);

1110 }

1111

1112 key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell);

1113 if (IS_ERR(key))

1114 key = NULL;

1115

1116 /* Hold the parent dentry so we can peer at it */

1117 parent = dget_parent(dentry);

1118 dir = AFS_FS_I(d_inode(parent));

1119

1120 /* validate the parent directory */

1121 ret = afs_validate(dir, key);

1122 if (ret == -ERESTARTSYS) {

1123 dput(parent);

1124 key_put(key);

1125 return ret;

1126 }

1127

1128 if (test_bit(AFS_VNODE_DELETED, &dir->flags)) {

1129 _debug("%pd: parent dir deleted", dentry);

1130 goto not_found;

1131 }

1132

1133 /* We only need to invalidate a dentry if the server's copy changed

1134 * behind our back. If we made the change, it's no problem. Note that

1135 * on a 32-bit system, we only have 32 bits in the dentry to store the

1136 * version.

1137 */

1138 dir_version = dir->status.data_version;

1139 de_version = (long)dentry->d_fsdata;

1140 if (de_version == (long)dir_version)

1141 goto out_valid_noupdate;

1142

1143 invalid_before = dir->invalid_before;

1144 if (de_version - (long)invalid_before >= 0)

1145 goto out_valid;

1146

1147 _debug("dir modified");

1148 afs_stat_v(dir, n_reval);

1149

1150 /* search the directory for this vnode */

1151 ret = afs_do_lookup_one(&dir->netfs.inode, dentry, &fid, key, &dir_version);

1152 switch (ret) {

1153 case 0:

1154 /* the filename maps to something */

1155 if (d_really_is_negative(dentry))

1156 goto not_found;

1157 inode = d_inode(dentry);

1158 if (is_bad_inode(inode)) {

1159 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",

1160 dentry);

1161 goto not_found;

1162 }

1163

1164 vnode = AFS_FS_I(inode);

1165

1166 /* if the vnode ID has changed, then the dirent points to a

1167 * different file */

1168 if (fid.vnode != vnode->fid.vnode) {

1169 _debug("%pd: dirent changed [%llu != %llu]",

1170 dentry, fid.vnode,

1171 vnode->fid.vnode);

1172 goto not_found;

1173 }

1174

1175 /* if the vnode ID uniqifier has changed, then the file has

1176 * been deleted and replaced, and the original vnode ID has

1177 * been reused */

1178 if (fid.unique != vnode->fid.unique) {

1179 _debug("%pd: file deleted (uq %u -> %u I:%u)",

1180 dentry, fid.unique,

1181 vnode->fid.unique,

1182 vnode->netfs.inode.i_generation);

1183 goto not_found;

1184 }

1185 goto out_valid;

1186

1187 case -ENOENT:

1188 /* the filename is unknown */

1189 _debug("%pd: dirent not found", dentry);

1190 if (d_really_is_positive(dentry))

1191 goto not_found;

1192 goto out_valid;

1193

1194 default:

1195 _debug("failed to iterate dir %pd: %d",

1196 parent, ret);

1197 goto not_found;

1198 }

1199

1200 out_valid:

1201 dentry->d_fsdata = (void *)(unsigned long)dir_version;

1202 out_valid_noupdate:

1203 dput(parent);

1204 key_put(key);

1205 _leave(" = 1 [valid]");

1206 return 1;

1207

1208 not_found:

1209 _debug("dropping dentry %pd2", dentry);

1210 dput(parent);

1211 key_put(key);

1212

1213 _leave(" = 0 [bad]");

1214 return 0;

1215 }

1216

1217 /*

1218 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't

1219 * sleep)

1220 * - called from dput() when d_count is going to 0.

1221 * - return 1 to request dentry be unhashed, 0 otherwise

1222 */

1223 static int afs_d_delete(const struct dentry *dentry)

1224 {

1225 _enter("%pd", dentry);

1226

1227 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)

1228 goto zap;

1229

1230 if (d_really_is_positive(dentry) &&

1231 (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(d_inode(dentry))->flags) ||

1232 test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags)))

1233 goto zap;

1234

1235 _leave(" = 0 [keep]");

1236 return 0;

1237

1238 zap:

1239 _leave(" = 1 [zap]");

1240 return 1;

1241 }

1242

1243 /*

1244 * Clean up sillyrename files on dentry removal.

1245 */

1246 static void afs_d_iput(struct dentry *dentry, struct inode *inode)

1247 {

1248 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)

1249 afs_silly_iput(dentry, inode);

1250 iput(inode);

1251 }

1252

1253 /*

1254 * handle dentry release

1255 */

1256 void afs_d_release(struct dentry *dentry)

1257 {

1258 _enter("%pd", dentry);

1259 }

1260

1261 void afs_check_for_remote_deletion(struct afs_operation *op)

1262 {

1263 struct afs_vnode *vnode = op->file[0].vnode;

1264

1265 switch (afs_op_abort_code(op)) {

1266 case VNOVNODE:

1267 set_bit(AFS_VNODE_DELETED, &vnode->flags);

1268 clear_nlink(&vnode->netfs.inode);

1269 afs_break_callback(vnode, afs_cb_break_for_deleted);

1270 }

1271 }

1272

1273 /*

1274 * Create a new inode for create/mkdir/symlink

1275 */

1276 static void afs_vnode_new_inode(struct afs_operation *op)

1277 {

1278 struct afs_vnode_param *vp = &op->file[1];

1279 struct afs_vnode *vnode;

1280 struct inode *inode;

1281

1282 _enter("");

1283

1284 ASSERTCMP(afs_op_error(op), ==, 0);

1285

1286 inode = afs_iget(op, vp);

1287 if (IS_ERR(inode)) {

1288 /* ENOMEM or EINTR at a really inconvenient time - just abandon

1289 * the new directory on the server.

1290 */

1291 afs_op_accumulate_error(op, PTR_ERR(inode), 0);

1292 return;

1293 }

1294

1295 vnode = AFS_FS_I(inode);

1296 set_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);

1297 if (!afs_op_error(op))

1298 afs_cache_permit(vnode, op->key, vnode->cb_break, &vp->scb);

1299 d_instantiate(op->dentry, inode);

1300 }

1301

1302 static void afs_create_success(struct afs_operation *op)

1303 {

1304 _enter("op=%08x", op->debug_id);

1305 op->ctime = op->file[0].scb.status.mtime_client;

1306 afs_vnode_commit_status(op, &op->file[0]);

1307 afs_update_dentry_version(op, &op->file[0], op->dentry);

1308 afs_vnode_new_inode(op);

1309 }

1310

1311 static void afs_create_edit_dir(struct afs_operation *op)

1312 {

1313 struct afs_vnode_param *dvp = &op->file[0];

1314 struct afs_vnode_param *vp = &op->file[1];

1315 struct afs_vnode *dvnode = dvp->vnode;

1316

1317 _enter("op=%08x", op->debug_id);

1318

1319 down_write(&dvnode->validate_lock);

1320 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&

1321 dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)

1322 afs_edit_dir_add(dvnode, &op->dentry->d_name, &vp->fid,

1323 op->create.reason);

1324 up_write(&dvnode->validate_lock);

1325 }

1326

1327 static void afs_create_put(struct afs_operation *op)

1328 {

1329 _enter("op=%08x", op->debug_id);

1330

1331 if (afs_op_error(op))

1332 d_drop(op->dentry);

1333 }

1334

1335 static const struct afs_operation_ops afs_mkdir_operation = {

1336 .issue_afs_rpc = afs_fs_make_dir,

1337 .issue_yfs_rpc = yfs_fs_make_dir,

1338 .success = afs_create_success,

1339 .aborted = afs_check_for_remote_deletion,

1340 .edit_dir = afs_create_edit_dir,

1341 .put = afs_create_put,

1342 };

1343

1344 /*

1345 * create a directory on an AFS filesystem

1346 */

1347 static int afs_mkdir(struct mnt_idmap *idmap, struct inode *dir,

1348 struct dentry *dentry, umode_t mode)

1349 {

1350 struct afs_operation *op;

1351 struct afs_vnode *dvnode = AFS_FS_I(dir);

1352

1353 _enter("{%llx:%llu},{%pd},%ho",

1354 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);

1355

1356 op = afs_alloc_operation(NULL, dvnode->volume);

1357 if (IS_ERR(op)) {

1358 d_drop(dentry);

1359 return PTR_ERR(op);

1360 }

1361

1362 afs_op_set_vnode(op, 0, dvnode);

1363 op->file[0].dv_delta = 1;

1364 op->file[0].modification = true;

1365 op->file[0].update_ctime = true;

1366 op->dentry = dentry;

1367 op->create.mode = S_IFDIR | mode;

1368 op->create.reason = afs_edit_dir_for_mkdir;

1369 op->mtime = current_time(dir);

1370 op->ops = &afs_mkdir_operation;

1371 return afs_do_sync_operation(op);

1372 }

1373

1374 /*

1375 * Remove a subdir from a directory.

1376 */

1377 static void afs_dir_remove_subdir(struct dentry *dentry)

1378 {

1379 if (d_really_is_positive(dentry)) {

1380 struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));

1381

1382 clear_nlink(&vnode->netfs.inode);

1383 set_bit(AFS_VNODE_DELETED, &vnode->flags);

1384 atomic64_set(&vnode->cb_expires_at, AFS_NO_CB_PROMISE);

1385 clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags);

1386 }

1387 }

1388

1389 static void afs_rmdir_success(struct afs_operation *op)

1390 {

1391 _enter("op=%08x", op->debug_id);

1392 op->ctime = op->file[0].scb.status.mtime_client;

1393 afs_vnode_commit_status(op, &op->file[0]);

1394 afs_update_dentry_version(op, &op->file[0], op->dentry);

1395 }

1396

1397 static void afs_rmdir_edit_dir(struct afs_operation *op)

1398 {

1399 struct afs_vnode_param *dvp = &op->file[0];

1400 struct afs_vnode *dvnode = dvp->vnode;

1401

1402 _enter("op=%08x", op->debug_id);

1403 afs_dir_remove_subdir(op->dentry);

1404

1405 down_write(&dvnode->validate_lock);

1406 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&

1407 dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)

1408 afs_edit_dir_remove(dvnode, &op->dentry->d_name,

1409 afs_edit_dir_for_rmdir);

1410 up_write(&dvnode->validate_lock);

1411 }

1412

1413 static void afs_rmdir_put(struct afs_operation *op)

1414 {

1415 _enter("op=%08x", op->debug_id);

1416 if (op->file[1].vnode)

1417 up_write(&op->file[1].vnode->rmdir_lock);

1418 }

1419

1420 static const struct afs_operation_ops afs_rmdir_operation = {

1421 .issue_afs_rpc = afs_fs_remove_dir,

1422 .issue_yfs_rpc = yfs_fs_remove_dir,

1423 .success = afs_rmdir_success,

1424 .aborted = afs_check_for_remote_deletion,

1425 .edit_dir = afs_rmdir_edit_dir,

1426 .put = afs_rmdir_put,

1427 };

1428

1429 /*

1430 * remove a directory from an AFS filesystem

1431 */

1432 static int afs_rmdir(struct inode *dir, struct dentry *dentry)

1433 {

1434 struct afs_operation *op;

1435 struct afs_vnode *dvnode = AFS_FS_I(dir), *vnode = NULL;

1436 int ret;

1437

1438 _enter("{%llx:%llu},{%pd}",

1439 dvnode->fid.vid, dvnode->fid.vnode, dentry);

1440

1441 op = afs_alloc_operation(NULL, dvnode->volume);

1442 if (IS_ERR(op))

1443 return PTR_ERR(op);

1444

1445 afs_op_set_vnode(op, 0, dvnode);

1446 op->file[0].dv_delta = 1;

1447 op->file[0].modification = true;

1448 op->file[0].update_ctime = true;

1449

1450 op->dentry = dentry;

1451 op->ops = &afs_rmdir_operation;

1452

1453 /* Try to make sure we have a callback promise on the victim. */

1454 if (d_really_is_positive(dentry)) {

1455 vnode = AFS_FS_I(d_inode(dentry));

1456 ret = afs_validate(vnode, op->key);

1457 if (ret < 0)

1458 goto error;

1459 }

1460

1461 if (vnode) {

1462 ret = down_write_killable(&vnode->rmdir_lock);

1463 if (ret < 0)

1464 goto error;

1465 op->file[1].vnode = vnode;

1466 }

1467

1468 return afs_do_sync_operation(op);

1469

1470 error:

1471 return afs_put_operation(op);

1472 }

1473

1474 /*

1475 * Remove a link to a file or symlink from a directory.

1476 *

1477 * If the file was not deleted due to excess hard links, the fileserver will

1478 * break the callback promise on the file - if it had one - before it returns

1479 * to us, and if it was deleted, it won't

1480 *

1481 * However, if we didn't have a callback promise outstanding, or it was

1482 * outstanding on a different server, then it won't break it either...

1483 */

1484 static void afs_dir_remove_link(struct afs_operation *op)

1485 {

1486 struct afs_vnode *dvnode = op->file[0].vnode;

1487 struct afs_vnode *vnode = op->file[1].vnode;

1488 struct dentry *dentry = op->dentry;

1489 int ret;

1490

1491 if (afs_op_error(op) ||

1492 (op->file[1].scb.have_status && op->file[1].scb.have_error))

1493 return;

1494 if (d_really_is_positive(dentry))

1495 return;

1496

1497 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {

1498 /* Already done */

1499 } else if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) {

1500 write_seqlock(&vnode->cb_lock);

1501 drop_nlink(&vnode->netfs.inode);

1502 if (vnode->netfs.inode.i_nlink == 0) {

1503 set_bit(AFS_VNODE_DELETED, &vnode->flags);

1504 __afs_break_callback(vnode, afs_cb_break_for_unlink);

1505 }

1506 write_sequnlock(&vnode->cb_lock);

1507 } else {

1508 afs_break_callback(vnode, afs_cb_break_for_unlink);

1509

1510 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))

1511 _debug("AFS_VNODE_DELETED");

1512

1513 ret = afs_validate(vnode, op->key);

1514 if (ret != -ESTALE)

1515 afs_op_set_error(op, ret);

1516 }

1517

1518 _debug("nlink %d [val %d]", vnode->netfs.inode.i_nlink, afs_op_error(op));

1519 }

1520

1521 static void afs_unlink_success(struct afs_operation *op)

1522 {

1523 _enter("op=%08x", op->debug_id);

1524 op->ctime = op->file[0].scb.status.mtime_client;

1525 afs_check_dir_conflict(op, &op->file[0]);

1526 afs_vnode_commit_status(op, &op->file[0]);

1527 afs_vnode_commit_status(op, &op->file[1]);

1528 afs_update_dentry_version(op, &op->file[0], op->dentry);

1529 afs_dir_remove_link(op);

1530 }

1531

1532 static void afs_unlink_edit_dir(struct afs_operation *op)

1533 {

1534 struct afs_vnode_param *dvp = &op->file[0];

1535 struct afs_vnode *dvnode = dvp->vnode;

1536

1537 _enter("op=%08x", op->debug_id);

1538 down_write(&dvnode->validate_lock);

1539 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&

1540 dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)

1541 afs_edit_dir_remove(dvnode, &op->dentry->d_name,

1542 afs_edit_dir_for_unlink);

1543 up_write(&dvnode->validate_lock);

1544 }

1545

1546 static void afs_unlink_put(struct afs_operation *op)

1547 {

1548 _enter("op=%08x", op->debug_id);

1549 if (op->unlink.need_rehash && afs_op_error(op) < 0 && afs_op_error(op) != -ENOENT)

1550 d_rehash(op->dentry);

1551 }

1552

1553 static const struct afs_operation_ops afs_unlink_operation = {

1554 .issue_afs_rpc = afs_fs_remove_file,

1555 .issue_yfs_rpc = yfs_fs_remove_file,

1556 .success = afs_unlink_success,

1557 .aborted = afs_check_for_remote_deletion,

1558 .edit_dir = afs_unlink_edit_dir,

1559 .put = afs_unlink_put,

1560 };

1561

1562 /*

1563 * Remove a file or symlink from an AFS filesystem.

1564 */

1565 static int afs_unlink(struct inode *dir, struct dentry *dentry)

1566 {

1567 struct afs_operation *op;

1568 struct afs_vnode *dvnode = AFS_FS_I(dir);

1569 struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));

1570 int ret;

1571

1572 _enter("{%llx:%llu},{%pd}",

1573 dvnode->fid.vid, dvnode->fid.vnode, dentry);

1574

1575 if (dentry->d_name.len >= AFSNAMEMAX)

1576 return -ENAMETOOLONG;

1577

1578 op = afs_alloc_operation(NULL, dvnode->volume);

1579 if (IS_ERR(op))

1580 return PTR_ERR(op);

1581

1582 afs_op_set_vnode(op, 0, dvnode);

1583 op->file[0].dv_delta = 1;

1584 op->file[0].modification = true;

1585 op->file[0].update_ctime = true;

1586

1587 /* Try to make sure we have a callback promise on the victim. */

1588 ret = afs_validate(vnode, op->key);

1589 if (ret < 0) {

1590 afs_op_set_error(op, ret);

1591 goto error;

1592 }

1593

1594 spin_lock(&dentry->d_lock);

1595 if (d_count(dentry) > 1) {

1596 spin_unlock(&dentry->d_lock);

1597 /* Start asynchronous writeout of the inode */

1598 write_inode_now(d_inode(dentry), 0);

1599 afs_op_set_error(op, afs_sillyrename(dvnode, vnode, dentry, op->key));

1600 goto error;

1601 }

1602 if (!d_unhashed(dentry)) {

1603 /* Prevent a race with RCU lookup. */

1604 __d_drop(dentry);

1605 op->unlink.need_rehash = true;

1606 }

1607 spin_unlock(&dentry->d_lock);

1608

1609 op->file[1].vnode = vnode;

1610 op->file[1].update_ctime = true;

1611 op->file[1].op_unlinked = true;

1612 op->dentry = dentry;

1613 op->ops = &afs_unlink_operation;

1614 afs_begin_vnode_operation(op);

1615 afs_wait_for_operation(op);

1616

1617 /* If there was a conflict with a third party, check the status of the

1618 * unlinked vnode.

1619 */

1620 if (afs_op_error(op) == 0 && (op->flags & AFS_OPERATION_DIR_CONFLICT)) {

1621 op->file[1].update_ctime = false;

1622 op->fetch_status.which = 1;

1623 op->ops = &afs_fetch_status_operation;

1624 afs_begin_vnode_operation(op);

1625 afs_wait_for_operation(op);

1626 }

1627

1628 return afs_put_operation(op);

1629

1630 error:

1631 return afs_put_operation(op);

1632 }

1633

1634 static const struct afs_operation_ops afs_create_operation = {

1635 .issue_afs_rpc = afs_fs_create_file,

1636 .issue_yfs_rpc = yfs_fs_create_file,

1637 .success = afs_create_success,

1638 .aborted = afs_check_for_remote_deletion,

1639 .edit_dir = afs_create_edit_dir,

1640 .put = afs_create_put,

1641 };

1642

1643 /*

1644 * create a regular file on an AFS filesystem

1645 */

1646 static int afs_create(struct mnt_idmap *idmap, struct inode *dir,

1647 struct dentry *dentry, umode_t mode, bool excl)

1648 {

1649 struct afs_operation *op;

1650 struct afs_vnode *dvnode = AFS_FS_I(dir);

1651 int ret = -ENAMETOOLONG;

1652

1653 _enter("{%llx:%llu},{%pd},%ho",

1654 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);

1655

1656 if (dentry->d_name.len >= AFSNAMEMAX)

1657 goto error;

1658

1659 op = afs_alloc_operation(NULL, dvnode->volume);

1660 if (IS_ERR(op)) {

1661 ret = PTR_ERR(op);

1662 goto error;

1663 }

1664

1665 afs_op_set_vnode(op, 0, dvnode);

1666 op->file[0].dv_delta = 1;

1667 op->file[0].modification = true;

1668 op->file[0].update_ctime = true;

1669

1670 op->dentry = dentry;

1671 op->create.mode = S_IFREG | mode;

1672 op->create.reason = afs_edit_dir_for_create;

1673 op->mtime = current_time(dir);

1674 op->ops = &afs_create_operation;

1675 return afs_do_sync_operation(op);

1676

1677 error:

1678 d_drop(dentry);

1679 _leave(" = %d", ret);

1680 return ret;

1681 }

1682

1683 static void afs_link_success(struct afs_operation *op)

1684 {

1685 struct afs_vnode_param *dvp = &op->file[0];

1686 struct afs_vnode_param *vp = &op->file[1];

1687

1688 _enter("op=%08x", op->debug_id);

1689 op->ctime = dvp->scb.status.mtime_client;

1690 afs_vnode_commit_status(op, dvp);

1691 afs_vnode_commit_status(op, vp);

1692 afs_update_dentry_version(op, dvp, op->dentry);

1693 if (op->dentry_2->d_parent == op->dentry->d_parent)

1694 afs_update_dentry_version(op, dvp, op->dentry_2);

1695 ihold(&vp->vnode->netfs.inode);

1696 d_instantiate(op->dentry, &vp->vnode->netfs.inode);

1697 }

1698

1699 static void afs_link_put(struct afs_operation *op)

1700 {

1701 _enter("op=%08x", op->debug_id);

1702 if (afs_op_error(op))

1703 d_drop(op->dentry);

1704 }

1705

1706 static const struct afs_operation_ops afs_link_operation = {

1707 .issue_afs_rpc = afs_fs_link,

1708 .issue_yfs_rpc = yfs_fs_link,

1709 .success = afs_link_success,

1710 .aborted = afs_check_for_remote_deletion,

1711 .edit_dir = afs_create_edit_dir,

1712 .put = afs_link_put,

1713 };

1714

1715 /*

1716 * create a hard link between files in an AFS filesystem

1717 */

1718 static int afs_link(struct dentry *from, struct inode *dir,

1719 struct dentry *dentry)

1720 {

1721 struct afs_operation *op;

1722 struct afs_vnode *dvnode = AFS_FS_I(dir);

1723 struct afs_vnode *vnode = AFS_FS_I(d_inode(from));

1724 int ret = -ENAMETOOLONG;

1725

1726 _enter("{%llx:%llu},{%llx:%llu},{%pd}",

1727 vnode->fid.vid, vnode->fid.vnode,

1728 dvnode->fid.vid, dvnode->fid.vnode,

1729 dentry);

1730

1731 if (dentry->d_name.len >= AFSNAMEMAX)

1732 goto error;

1733

1734 op = afs_alloc_operation(NULL, dvnode->volume);

1735 if (IS_ERR(op)) {

1736 ret = PTR_ERR(op);

1737 goto error;

1738 }

1739

1740 ret = afs_validate(vnode, op->key);

1741 if (ret < 0)

1742 goto error_op;

1743

1744 afs_op_set_vnode(op, 0, dvnode);

1745 afs_op_set_vnode(op, 1, vnode);

1746 op->file[0].dv_delta = 1;

1747 op->file[0].modification = true;

1748 op->file[0].update_ctime = true;

1749 op->file[1].update_ctime = true;

1750

1751 op->dentry = dentry;

1752 op->dentry_2 = from;

1753 op->ops = &afs_link_operation;

1754 op->create.reason = afs_edit_dir_for_link;

1755 return afs_do_sync_operation(op);

1756

1757 error_op:

1758 afs_put_operation(op);

1759 error:

1760 d_drop(dentry);

1761 _leave(" = %d", ret);

1762 return ret;

1763 }

1764

1765 static const struct afs_operation_ops afs_symlink_operation = {

1766 .issue_afs_rpc = afs_fs_symlink,

1767 .issue_yfs_rpc = yfs_fs_symlink,

1768 .success = afs_create_success,

1769 .aborted = afs_check_for_remote_deletion,

1770 .edit_dir = afs_create_edit_dir,

1771 .put = afs_create_put,

1772 };

1773

1774 /*

1775 * create a symlink in an AFS filesystem

1776 */

1777 static int afs_symlink(struct mnt_idmap *idmap, struct inode *dir,

1778 struct dentry *dentry, const char *content)

1779 {

1780 struct afs_operation *op;

1781 struct afs_vnode *dvnode = AFS_FS_I(dir);

1782 int ret;

1783

1784 _enter("{%llx:%llu},{%pd},%s",

1785 dvnode->fid.vid, dvnode->fid.vnode, dentry,

1786 content);

1787

1788 ret = -ENAMETOOLONG;

1789 if (dentry->d_name.len >= AFSNAMEMAX)

1790 goto error;

1791

1792 ret = -EINVAL;

1793 if (strlen(content) >= AFSPATHMAX)

1794 goto error;

1795

1796 op = afs_alloc_operation(NULL, dvnode->volume);

1797 if (IS_ERR(op)) {

1798 ret = PTR_ERR(op);

1799 goto error;

1800 }

1801

1802 afs_op_set_vnode(op, 0, dvnode);

1803 op->file[0].dv_delta = 1;

1804

1805 op->dentry = dentry;

1806 op->ops = &afs_symlink_operation;

1807 op->create.reason = afs_edit_dir_for_symlink;

1808 op->create.symlink = content;

1809 op->mtime = current_time(dir);

1810 return afs_do_sync_operation(op);

1811

1812 error:

1813 d_drop(dentry);

1814 _leave(" = %d", ret);

1815 return ret;

1816 }

1817

1818 static void afs_rename_success(struct afs_operation *op)

1819 {

1820 _enter("op=%08x", op->debug_id);

1821

1822 op->ctime = op->file[0].scb.status.mtime_client;

1823 afs_check_dir_conflict(op, &op->file[1]);

1824 afs_vnode_commit_status(op, &op->file[0]);

1825 if (op->file[1].vnode != op->file[0].vnode) {

1826 op->ctime = op->file[1].scb.status.mtime_client;

1827 afs_vnode_commit_status(op, &op->file[1]);

1828 }

1829 }

1830

1831 static void afs_rename_edit_dir(struct afs_operation *op)

1832 {

1833 struct afs_vnode_param *orig_dvp = &op->file[0];

1834 struct afs_vnode_param *new_dvp = &op->file[1];

1835 struct afs_vnode *orig_dvnode = orig_dvp->vnode;

1836 struct afs_vnode *new_dvnode = new_dvp->vnode;

1837 struct afs_vnode *vnode = AFS_FS_I(d_inode(op->dentry));

1838 struct dentry *old_dentry = op->dentry;

1839 struct dentry *new_dentry = op->dentry_2;

1840 struct inode *new_inode;

1841

1842 _enter("op=%08x", op->debug_id);

1843

1844 if (op->rename.rehash) {

1845 d_rehash(op->rename.rehash);

1846 op->rename.rehash = NULL;

1847 }

1848

1849 down_write(&orig_dvnode->validate_lock);

1850 if (test_bit(AFS_VNODE_DIR_VALID, &orig_dvnode->flags) &&

1851 orig_dvnode->status.data_version == orig_dvp->dv_before + orig_dvp->dv_delta)

1852 afs_edit_dir_remove(orig_dvnode, &old_dentry->d_name,

1853 afs_edit_dir_for_rename_0);

1854

1855 if (new_dvnode != orig_dvnode) {

1856 up_write(&orig_dvnode->validate_lock);

1857 down_write(&new_dvnode->validate_lock);

1858 }

1859

1860 if (test_bit(AFS_VNODE_DIR_VALID, &new_dvnode->flags) &&

1861 new_dvnode->status.data_version == new_dvp->dv_before + new_dvp->dv_delta) {

1862 if (!op->rename.new_negative)

1863 afs_edit_dir_remove(new_dvnode, &new_dentry->d_name,

1864 afs_edit_dir_for_rename_1);

1865

1866 afs_edit_dir_add(new_dvnode, &new_dentry->d_name,

1867 &vnode->fid, afs_edit_dir_for_rename_2);

1868 }

1869

1870 new_inode = d_inode(new_dentry);

1871 if (new_inode) {

1872 spin_lock(&new_inode->i_lock);

1873 if (S_ISDIR(new_inode->i_mode))

1874 clear_nlink(new_inode);

1875 else if (new_inode->i_nlink > 0)

1876 drop_nlink(new_inode);

1877 spin_unlock(&new_inode->i_lock);

1878 }

1879

1880 /* Now we can update d_fsdata on the dentries to reflect their

1881 * new parent's data_version.

1882 *

1883 * Note that if we ever implement RENAME_EXCHANGE, we'll have

1884 * to update both dentries with opposing dir versions.

1885 */

1886 afs_update_dentry_version(op, new_dvp, op->dentry);

1887 afs_update_dentry_version(op, new_dvp, op->dentry_2);

1888

1889 d_move(old_dentry, new_dentry);

1890

1891 up_write(&new_dvnode->validate_lock);

1892 }

1893

1894 static void afs_rename_put(struct afs_operation *op)

1895 {

1896 _enter("op=%08x", op->debug_id);

1897 if (op->rename.rehash)

1898 d_rehash(op->rename.rehash);

1899 dput(op->rename.tmp);

1900 if (afs_op_error(op))

1901 d_rehash(op->dentry);

1902 }

1903

1904 static const struct afs_operation_ops afs_rename_operation = {

1905 .issue_afs_rpc = afs_fs_rename,

1906 .issue_yfs_rpc = yfs_fs_rename,

1907 .success = afs_rename_success,

1908 .edit_dir = afs_rename_edit_dir,

1909 .put = afs_rename_put,

1910 };

1911

1912 /*

1913 * rename a file in an AFS filesystem and/or move it between directories

1914 */

1915 static int afs_rename(struct mnt_idmap *idmap, struct inode *old_dir,

1916 struct dentry *old_dentry, struct inode *new_dir,

1917 struct dentry *new_dentry, unsigned int flags)

1918 {

1919 struct afs_operation *op;

1920 struct afs_vnode *orig_dvnode, *new_dvnode, *vnode;

1921 int ret;

1922

1923 if (flags)

1924 return -EINVAL;

1925

1926 /* Don't allow silly-rename files be moved around. */

1927 if (old_dentry->d_flags & DCACHE_NFSFS_RENAMED)

1928 return -EINVAL;

1929

1930 vnode = AFS_FS_I(d_inode(old_dentry));

1931 orig_dvnode = AFS_FS_I(old_dir);

1932 new_dvnode = AFS_FS_I(new_dir);

1933

1934 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",

1935 orig_dvnode->fid.vid, orig_dvnode->fid.vnode,

1936 vnode->fid.vid, vnode->fid.vnode,

1937 new_dvnode->fid.vid, new_dvnode->fid.vnode,

1938 new_dentry);

1939

1940 op = afs_alloc_operation(NULL, orig_dvnode->volume);

1941 if (IS_ERR(op))

1942 return PTR_ERR(op);

1943

1944 ret = afs_validate(vnode, op->key);

1945 afs_op_set_error(op, ret);

1946 if (ret < 0)

1947 goto error;

1948

1949 afs_op_set_vnode(op, 0, orig_dvnode);

1950 afs_op_set_vnode(op, 1, new_dvnode); /* May be same as orig_dvnode */

1951 op->file[0].dv_delta = 1;

1952 op->file[1].dv_delta = 1;

1953 op->file[0].modification = true;

1954 op->file[1].modification = true;

1955 op->file[0].update_ctime = true;

1956 op->file[1].update_ctime = true;

1957

1958 op->dentry = old_dentry;

1959 op->dentry_2 = new_dentry;

1960 op->rename.new_negative = d_is_negative(new_dentry);

1961 op->ops = &afs_rename_operation;

1962

1963 /* For non-directories, check whether the target is busy and if so,

1964 * make a copy of the dentry and then do a silly-rename. If the

1965 * silly-rename succeeds, the copied dentry is hashed and becomes the

1966 * new target.

1967 */

1968 if (d_is_positive(new_dentry) && !d_is_dir(new_dentry)) {

1969 /* To prevent any new references to the target during the

1970 * rename, we unhash the dentry in advance.

1971 */

1972 if (!d_unhashed(new_dentry)) {

1973 d_drop(new_dentry);

1974 op->rename.rehash = new_dentry;

1975 }

1976

1977 if (d_count(new_dentry) > 2) {

1978 /* copy the target dentry's name */

1979 op->rename.tmp = d_alloc(new_dentry->d_parent,

1980 &new_dentry->d_name);

1981 if (!op->rename.tmp) {

1982 afs_op_nomem(op);

1983 goto error;

1984 }

1985

1986 ret = afs_sillyrename(new_dvnode,

1987 AFS_FS_I(d_inode(new_dentry)),

1988 new_dentry, op->key);

1989 if (ret) {

1990 afs_op_set_error(op, ret);

1991 goto error;

1992 }

1993

1994 op->dentry_2 = op->rename.tmp;

1995 op->rename.rehash = NULL;

1996 op->rename.new_negative = true;

1997 }

1998 }

1999

2000 /* This bit is potentially nasty as there's a potential race with

2001 * afs_d_revalidate{,_rcu}(). We have to change d_fsdata on the dentry

2002 * to reflect it's new parent's new data_version after the op, but

2003 * d_revalidate may see old_dentry between the op having taken place

2004 * and the version being updated.

2005 *

2006 * So drop the old_dentry for now to make other threads go through

2007 * lookup instead - which we hold a lock against.

2008 */

2009 d_drop(old_dentry);

2010

2011 return afs_do_sync_operation(op);

2012

2013 error:

2014 return afs_put_operation(op);

2015 }

2016

2017 /*

2018 * Release a directory folio and clean up its private state if it's not busy

2019 * - return true if the folio can now be released, false if not

2020 */

2021 static bool afs_dir_release_folio(struct folio *folio, gfp_t gfp_flags)

2022 {

2023 struct afs_vnode *dvnode = AFS_FS_I(folio_inode(folio));

2024

2025 _enter("{{%llx:%llu}[%lu]}", dvnode->fid.vid, dvnode->fid.vnode, folio_index(folio));

2026

2027 folio_detach_private(folio);

2028

2029 /* The directory will need reloading. */

2030 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))

2031 afs_stat_v(dvnode, n_relpg);

2032 return true;

2033 }

2034

2035 /*

2036 * Invalidate part or all of a folio.

2037 */

2038 static void afs_dir_invalidate_folio(struct folio *folio, size_t offset,

2039 size_t length)

2040 {

2041 struct afs_vnode *dvnode = AFS_FS_I(folio_inode(folio));

2042

2043 _enter("{%lu},%zu,%zu", folio->index, offset, length);

2044

2045 BUG_ON(!folio_test_locked(folio));

2046

2047 /* The directory will need reloading. */

2048 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))

2049 afs_stat_v(dvnode, n_inval);

2050

2051 /* we clean up only if the entire folio is being invalidated */

2052 if (offset == 0 && length == folio_size(folio))

2053 folio_detach_private(folio);

2054 }