nilfs2: convert nilfs_rename() to use folios

+32 -36

fs/nilfs2/dir.c

··· 323 323 } 324 324 325 325 /* 326 - * nilfs_find_entry() 326 + * nilfs_find_entry() 327 327 * 328 - * finds an entry in the specified directory with the wanted name. It 329 - * returns the page in which the entry was found, and the entry itself 330 - * (as a parameter - res_dir). Page is returned mapped and unlocked. 331 - * Entry is guaranteed to be valid. 328 + * Finds an entry in the specified directory with the wanted name. It 329 + * returns the folio in which the entry was found, and the entry itself. 330 + * The folio is mapped and unlocked. When the caller is finished with 331 + * the entry, it should call folio_release_kmap(). 332 + * 333 + * On failure, returns NULL and the caller should ignore foliop. 332 334 */ 333 - struct nilfs_dir_entry * 334 - nilfs_find_entry(struct inode *dir, const struct qstr *qstr, 335 - struct page **res_page) 335 + struct nilfs_dir_entry *nilfs_find_entry(struct inode *dir, 336 + const struct qstr *qstr, struct folio **foliop) 336 337 { 337 338 const unsigned char *name = qstr->name; 338 339 int namelen = qstr->len; 339 340 unsigned int reclen = NILFS_DIR_REC_LEN(namelen); 340 341 unsigned long start, n; 341 342 unsigned long npages = dir_pages(dir); 342 - struct folio *folio = NULL; 343 343 struct nilfs_inode_info *ei = NILFS_I(dir); 344 344 struct nilfs_dir_entry *de; 345 345 346 346 if (npages == 0) 347 347 goto out; 348 348 349 - /* OFFSET_CACHE */ 350 - *res_page = NULL; 351 - 352 349 start = ei->i_dir_start_lookup; 353 350 if (start >= npages) 354 351 start = 0; 355 352 n = start; 356 353 do { 357 - char *kaddr = nilfs_get_folio(dir, n, &folio); 354 + char *kaddr = nilfs_get_folio(dir, n, foliop); 358 355 359 356 if (!IS_ERR(kaddr)) { 360 357 de = (struct nilfs_dir_entry *)kaddr; ··· 360 363 if (de->rec_len == 0) { 361 364 nilfs_error(dir->i_sb, 362 365 "zero-length directory entry"); 363 - folio_release_kmap(folio, kaddr); 366 + folio_release_kmap(*foliop, kaddr); 364 367 goto out; 365 368 } 366 369 if (nilfs_match(namelen, name, de)) 367 370 goto found; 368 371 de = nilfs_next_entry(de); 369 372 } 370 - folio_release_kmap(folio, kaddr); 373 + folio_release_kmap(*foliop, kaddr); 371 374 } 372 375 if (++n >= npages) 373 376 n = 0; ··· 384 387 return NULL; 385 388 386 389 found: 387 - *res_page = &folio->page; 388 390 ei->i_dir_start_lookup = n; 389 391 return de; 390 392 } 391 393 392 - struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct page **p) 394 + struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct folio **foliop) 393 395 { 394 - struct nilfs_dir_entry *de = nilfs_get_page(dir, 0, p); 396 + struct nilfs_dir_entry *de = nilfs_get_folio(dir, 0, foliop); 395 397 396 398 if (IS_ERR(de)) 397 399 return NULL; ··· 401 405 { 402 406 ino_t res = 0; 403 407 struct nilfs_dir_entry *de; 404 - struct page *page; 408 + struct folio *folio; 405 409 406 - de = nilfs_find_entry(dir, qstr, &page); 410 + de = nilfs_find_entry(dir, qstr, &folio); 407 411 if (de) { 408 412 res = le64_to_cpu(de->inode); 409 - unmap_and_put_page(page, de); 413 + folio_release_kmap(folio, de); 410 414 } 411 415 return res; 412 416 } 413 417 414 418 void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de, 415 - struct page *page, struct inode *inode) 419 + struct folio *folio, struct inode *inode) 416 420 { 417 - unsigned int from = offset_in_page(de); 418 - unsigned int to = from + nilfs_rec_len_from_disk(de->rec_len); 419 - struct address_space *mapping = page->mapping; 421 + size_t from = offset_in_folio(folio, de); 422 + size_t to = from + nilfs_rec_len_from_disk(de->rec_len); 423 + struct address_space *mapping = folio->mapping; 420 424 int err; 421 425 422 - lock_page(page); 423 - err = nilfs_prepare_chunk(page, from, to); 426 + folio_lock(folio); 427 + err = nilfs_prepare_chunk(&folio->page, from, to); 424 428 BUG_ON(err); 425 429 de->inode = cpu_to_le64(inode->i_ino); 426 430 nilfs_set_de_type(de, inode); 427 - nilfs_commit_chunk(page, mapping, from, to); 431 + nilfs_commit_chunk(&folio->page, mapping, from, to); 428 432 inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir)); 429 433 } 430 434 ··· 528 532 529 533 /* 530 534 * nilfs_delete_entry deletes a directory entry by merging it with the 531 - * previous entry. Page is up-to-date. 535 + * previous entry. Folio is up-to-date. 532 536 */ 533 - int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page) 537 + int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct folio *folio) 534 538 { 535 - struct address_space *mapping = page->mapping; 539 + struct address_space *mapping = folio->mapping; 536 540 struct inode *inode = mapping->host; 537 - char *kaddr = (char *)((unsigned long)dir & PAGE_MASK); 538 - unsigned int from, to; 541 + char *kaddr = (char *)((unsigned long)dir & ~(folio_size(folio) - 1)); 542 + size_t from, to; 539 543 struct nilfs_dir_entry *de, *pde = NULL; 540 544 int err; 541 545 ··· 555 559 } 556 560 if (pde) 557 561 from = (char *)pde - kaddr; 558 - lock_page(page); 559 - err = nilfs_prepare_chunk(page, from, to); 562 + folio_lock(folio); 563 + err = nilfs_prepare_chunk(&folio->page, from, to); 560 564 BUG_ON(err); 561 565 if (pde) 562 566 pde->rec_len = nilfs_rec_len_to_disk(to - from); 563 567 dir->inode = 0; 564 - nilfs_commit_chunk(page, mapping, from, to); 568 + nilfs_commit_chunk(&folio->page, mapping, from, to); 565 569 inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode)); 566 570 out: 567 571 return err;

+18 -18

fs/nilfs2/namei.c

··· 260 260 { 261 261 struct inode *inode; 262 262 struct nilfs_dir_entry *de; 263 - struct page *page; 263 + struct folio *folio; 264 264 int err; 265 265 266 266 err = -ENOENT; 267 - de = nilfs_find_entry(dir, &dentry->d_name, &page); 267 + de = nilfs_find_entry(dir, &dentry->d_name, &folio); 268 268 if (!de) 269 269 goto out; 270 270 ··· 279 279 inode->i_ino, inode->i_nlink); 280 280 set_nlink(inode, 1); 281 281 } 282 - err = nilfs_delete_entry(de, page); 283 - unmap_and_put_page(page, de); 282 + err = nilfs_delete_entry(de, folio); 283 + folio_release_kmap(folio, de); 284 284 if (err) 285 285 goto out; 286 286 ··· 348 348 { 349 349 struct inode *old_inode = d_inode(old_dentry); 350 350 struct inode *new_inode = d_inode(new_dentry); 351 - struct page *dir_page = NULL; 351 + struct folio *dir_folio = NULL; 352 352 struct nilfs_dir_entry *dir_de = NULL; 353 - struct page *old_page; 353 + struct folio *old_folio; 354 354 struct nilfs_dir_entry *old_de; 355 355 struct nilfs_transaction_info ti; 356 356 int err; ··· 363 363 return err; 364 364 365 365 err = -ENOENT; 366 - old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_page); 366 + old_de = nilfs_find_entry(old_dir, &old_dentry->d_name, &old_folio); 367 367 if (!old_de) 368 368 goto out; 369 369 370 370 if (S_ISDIR(old_inode->i_mode)) { 371 371 err = -EIO; 372 - dir_de = nilfs_dotdot(old_inode, &dir_page); 372 + dir_de = nilfs_dotdot(old_inode, &dir_folio); 373 373 if (!dir_de) 374 374 goto out_old; 375 375 } 376 376 377 377 if (new_inode) { 378 - struct page *new_page; 378 + struct folio *new_folio; 379 379 struct nilfs_dir_entry *new_de; 380 380 381 381 err = -ENOTEMPTY; ··· 383 383 goto out_dir; 384 384 385 385 err = -ENOENT; 386 - new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_page); 386 + new_de = nilfs_find_entry(new_dir, &new_dentry->d_name, &new_folio); 387 387 if (!new_de) 388 388 goto out_dir; 389 - nilfs_set_link(new_dir, new_de, new_page, old_inode); 390 - unmap_and_put_page(new_page, new_de); 389 + nilfs_set_link(new_dir, new_de, new_folio, old_inode); 390 + folio_release_kmap(new_folio, new_de); 391 391 nilfs_mark_inode_dirty(new_dir); 392 392 inode_set_ctime_current(new_inode); 393 393 if (dir_de) ··· 410 410 */ 411 411 inode_set_ctime_current(old_inode); 412 412 413 - nilfs_delete_entry(old_de, old_page); 413 + nilfs_delete_entry(old_de, old_folio); 414 414 415 415 if (dir_de) { 416 - nilfs_set_link(old_inode, dir_de, dir_page, new_dir); 417 - unmap_and_put_page(dir_page, dir_de); 416 + nilfs_set_link(old_inode, dir_de, dir_folio, new_dir); 417 + folio_release_kmap(dir_folio, dir_de); 418 418 drop_nlink(old_dir); 419 419 } 420 - unmap_and_put_page(old_page, old_de); 420 + folio_release_kmap(old_folio, old_de); 421 421 422 422 nilfs_mark_inode_dirty(old_dir); 423 423 nilfs_mark_inode_dirty(old_inode); ··· 427 427 428 428 out_dir: 429 429 if (dir_de) 430 - unmap_and_put_page(dir_page, dir_de); 430 + folio_release_kmap(dir_folio, dir_de); 431 431 out_old: 432 - unmap_and_put_page(old_page, old_de); 432 + folio_release_kmap(old_folio, old_de); 433 433 out: 434 434 nilfs_transaction_abort(old_dir->i_sb); 435 435 return err;

+10 -10

fs/nilfs2/nilfs.h

··· 226 226 } 227 227 228 228 /* dir.c */ 229 - extern int nilfs_add_link(struct dentry *, struct inode *); 230 - extern ino_t nilfs_inode_by_name(struct inode *, const struct qstr *); 231 - extern int nilfs_make_empty(struct inode *, struct inode *); 232 - extern struct nilfs_dir_entry * 233 - nilfs_find_entry(struct inode *, const struct qstr *, struct page **); 234 - extern int nilfs_delete_entry(struct nilfs_dir_entry *, struct page *); 235 - extern int nilfs_empty_dir(struct inode *); 236 - extern struct nilfs_dir_entry *nilfs_dotdot(struct inode *, struct page **); 237 - extern void nilfs_set_link(struct inode *, struct nilfs_dir_entry *, 238 - struct page *, struct inode *); 229 + int nilfs_add_link(struct dentry *, struct inode *); 230 + ino_t nilfs_inode_by_name(struct inode *, const struct qstr *); 231 + int nilfs_make_empty(struct inode *, struct inode *); 232 + struct nilfs_dir_entry *nilfs_find_entry(struct inode *, const struct qstr *, 233 + struct folio **); 234 + int nilfs_delete_entry(struct nilfs_dir_entry *, struct folio *); 235 + int nilfs_empty_dir(struct inode *); 236 + struct nilfs_dir_entry *nilfs_dotdot(struct inode *, struct folio **); 237 + void nilfs_set_link(struct inode *, struct nilfs_dir_entry *, 238 + struct folio *, struct inode *); 239 239 240 240 /* file.c */ 241 241 extern int nilfs_sync_file(struct file *, loff_t, loff_t, int);

Configure Feed

Configure Feed