lfs_rename.c revision 1.22
1/* $NetBSD: lfs_rename.c,v 1.22 2017/06/10 05:29:36 maya Exp $ */ 2/* from NetBSD: ufs_rename.c,v 1.12 2015/03/27 17:27:56 riastradh Exp */ 3 4/*- 5 * Copyright (c) 2012 The NetBSD Foundation, Inc. 6 * All rights reserved. 7 * 8 * This code is derived from software contributed to The NetBSD Foundation 9 * by Taylor R Campbell. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32/*- 33 * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc. 34 * All rights reserved. 35 * 36 * This code is derived from software contributed to The NetBSD Foundation 37 * by Konrad E. Schroder <perseant@hhhh.org>. 38 * 39 * Redistribution and use in source and binary forms, with or without 40 * modification, are permitted provided that the following conditions 41 * are met: 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 48 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 49 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 50 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 51 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 52 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 53 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 54 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 55 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 56 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 57 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 58 * POSSIBILITY OF SUCH DAMAGE. 59 */ 60/* 61 * Copyright (c) 1986, 1989, 1991, 1993, 1995 62 * The Regents of the University of California. All rights reserved. 63 * 64 * Redistribution and use in source and binary forms, with or without 65 * modification, are permitted provided that the following conditions 66 * are met: 67 * 1. Redistributions of source code must retain the above copyright 68 * notice, this list of conditions and the following disclaimer. 69 * 2. Redistributions in binary form must reproduce the above copyright 70 * notice, this list of conditions and the following disclaimer in the 71 * documentation and/or other materials provided with the distribution. 72 * 3. Neither the name of the University nor the names of its contributors 73 * may be used to endorse or promote products derived from this software 74 * without specific prior written permission. 75 * 76 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 77 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 78 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 79 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 80 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 81 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 82 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 83 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 84 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 85 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 86 * SUCH DAMAGE. 87 * 88 * @(#)lfs_vnops.c 8.13 (Berkeley) 6/10/95 89 */ 90 91#include <sys/cdefs.h> 92__KERNEL_RCSID(0, "$NetBSD: lfs_rename.c,v 1.22 2017/06/10 05:29:36 maya Exp $"); 93 94#include <sys/param.h> 95#include <sys/systm.h> 96#include <sys/errno.h> 97#include <sys/namei.h> 98#include <sys/resourcevar.h> 99#include <sys/kernel.h> 100#include <sys/file.h> 101#include <sys/stat.h> 102#include <sys/buf.h> 103#include <sys/proc.h> 104#include <sys/mount.h> 105#include <sys/vnode.h> 106#include <sys/vnode_if.h> 107#include <sys/pool.h> 108#include <sys/signalvar.h> 109#include <sys/kauth.h> 110#include <sys/syslog.h> 111 112#include <uvm/uvm.h> 113#include <uvm/uvm_pmap.h> 114#include <uvm/uvm_stat.h> 115#include <uvm/uvm_pager.h> 116 117#include <miscfs/fifofs/fifo.h> 118#include <miscfs/genfs/genfs.h> 119#include <miscfs/specfs/specdev.h> 120 121#include <ufs/lfs/ulfs_inode.h> 122#include <ufs/lfs/ulfsmount.h> 123#include <ufs/lfs/ulfs_bswap.h> 124#include <ufs/lfs/ulfs_extern.h> 125 126#include <ufs/lfs/lfs.h> 127#include <ufs/lfs/lfs_accessors.h> 128#include <ufs/lfs/lfs_extern.h> 129 130/* 131 * ulfs_gro_directory_empty_p: Return true if the directory vp is 132 * empty. dvp is its parent. 133 * 134 * vp and dvp must be locked and referenced. 135 */ 136static bool 137ulfs_gro_directory_empty_p(struct mount *mp, kauth_cred_t cred, 138 struct vnode *vp, struct vnode *dvp) 139{ 140 141 (void)mp; 142 KASSERT(mp != NULL); 143 KASSERT(vp != NULL); 144 KASSERT(dvp != NULL); 145 KASSERT(vp != dvp); 146 KASSERT(vp->v_mount == mp); 147 KASSERT(dvp->v_mount == mp); 148 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 149 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 150 151 return ulfs_dirempty(VTOI(vp), VTOI(dvp)->i_number, cred); 152} 153 154/* 155 * ulfs_gro_rename_check_possible: Check whether a rename is possible 156 * independent of credentials. 157 */ 158static int 159ulfs_gro_rename_check_possible(struct mount *mp, 160 struct vnode *fdvp, struct vnode *fvp, 161 struct vnode *tdvp, struct vnode *tvp) 162{ 163 164 (void)mp; 165 KASSERT(mp != NULL); 166 KASSERT(fdvp != NULL); 167 KASSERT(fvp != NULL); 168 KASSERT(tdvp != NULL); 169 KASSERT(fdvp != fvp); 170 KASSERT(fdvp != tvp); 171 KASSERT(tdvp != fvp); 172 KASSERT(tdvp != tvp); 173 KASSERT(fvp != tvp); 174 KASSERT(fdvp->v_type == VDIR); 175 KASSERT(tdvp->v_type == VDIR); 176 KASSERT(fdvp->v_mount == mp); 177 KASSERT(fvp->v_mount == mp); 178 KASSERT(tdvp->v_mount == mp); 179 KASSERT((tvp == NULL) || (tvp->v_mount == mp)); 180 KASSERT(VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE); 181 KASSERT(VOP_ISLOCKED(fvp) == LK_EXCLUSIVE); 182 KASSERT(VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE); 183 KASSERT((tvp == NULL) || (VOP_ISLOCKED(tvp) == LK_EXCLUSIVE)); 184 185 return genfs_ufslike_rename_check_possible( 186 VTOI(fdvp)->i_flags, VTOI(fvp)->i_flags, 187 VTOI(tdvp)->i_flags, (tvp? VTOI(tvp)->i_flags : 0), 188 (tvp != NULL), 189 IMMUTABLE, APPEND); 190} 191 192/* 193 * ulfs_gro_rename_check_permitted: Check whether a rename is permitted 194 * given our credentials. 195 */ 196static int 197ulfs_gro_rename_check_permitted(struct mount *mp, kauth_cred_t cred, 198 struct vnode *fdvp, struct vnode *fvp, 199 struct vnode *tdvp, struct vnode *tvp) 200{ 201 202 (void)mp; 203 KASSERT(mp != NULL); 204 KASSERT(fdvp != NULL); 205 KASSERT(fvp != NULL); 206 KASSERT(tdvp != NULL); 207 KASSERT(fdvp != fvp); 208 KASSERT(fdvp != tvp); 209 KASSERT(tdvp != fvp); 210 KASSERT(tdvp != tvp); 211 KASSERT(fvp != tvp); 212 KASSERT(fdvp->v_type == VDIR); 213 KASSERT(tdvp->v_type == VDIR); 214 KASSERT(fdvp->v_mount == mp); 215 KASSERT(fvp->v_mount == mp); 216 KASSERT(tdvp->v_mount == mp); 217 KASSERT((tvp == NULL) || (tvp->v_mount == mp)); 218 KASSERT(VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE); 219 KASSERT(VOP_ISLOCKED(fvp) == LK_EXCLUSIVE); 220 KASSERT(VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE); 221 KASSERT((tvp == NULL) || (VOP_ISLOCKED(tvp) == LK_EXCLUSIVE)); 222 223 return genfs_ufslike_rename_check_permitted(cred, 224 fdvp, VTOI(fdvp)->i_mode, VTOI(fdvp)->i_uid, 225 fvp, VTOI(fvp)->i_uid, 226 tdvp, VTOI(tdvp)->i_mode, VTOI(tdvp)->i_uid, 227 tvp, (tvp? VTOI(tvp)->i_uid : 0)); 228} 229 230/* 231 * ulfs_gro_remove_check_possible: Check whether a remove is possible 232 * independent of credentials. 233 */ 234static int 235ulfs_gro_remove_check_possible(struct mount *mp, 236 struct vnode *dvp, struct vnode *vp) 237{ 238 239 (void)mp; 240 KASSERT(mp != NULL); 241 KASSERT(dvp != NULL); 242 KASSERT(vp != NULL); 243 KASSERT(dvp != vp); 244 KASSERT(dvp->v_type == VDIR); 245 KASSERT(vp->v_type != VDIR); 246 KASSERT(dvp->v_mount == mp); 247 KASSERT(vp->v_mount == mp); 248 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 249 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 250 251 return genfs_ufslike_remove_check_possible( 252 VTOI(dvp)->i_flags, VTOI(vp)->i_flags, 253 IMMUTABLE, APPEND); 254} 255 256/* 257 * ulfs_gro_remove_check_permitted: Check whether a remove is permitted 258 * given our credentials. 259 */ 260static int 261ulfs_gro_remove_check_permitted(struct mount *mp, kauth_cred_t cred, 262 struct vnode *dvp, struct vnode *vp) 263{ 264 265 (void)mp; 266 KASSERT(mp != NULL); 267 KASSERT(dvp != NULL); 268 KASSERT(vp != NULL); 269 KASSERT(dvp != vp); 270 KASSERT(dvp->v_type == VDIR); 271 KASSERT(vp->v_type != VDIR); 272 KASSERT(dvp->v_mount == mp); 273 KASSERT(vp->v_mount == mp); 274 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 275 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 276 277 return genfs_ufslike_remove_check_permitted(cred, 278 dvp, VTOI(dvp)->i_mode, VTOI(dvp)->i_uid, vp, VTOI(vp)->i_uid); 279} 280 281/* 282 * ulfs_rename_ulr_overlap_p: True iff tulr overlaps with fulr so that 283 * entering a directory entry at tulr may move fulr. 284 */ 285static bool 286ulfs_rename_ulr_overlap_p(const struct ulfs_lookup_results *fulr, 287 const struct ulfs_lookup_results *tulr) 288{ 289 doff_t from_prev_start, from_prev_end, to_start, to_end; 290 291 KASSERT(fulr != NULL); 292 KASSERT(tulr != NULL); 293 KASSERT(fulr != tulr); 294 295 /* 296 * fulr is from a DELETE lookup, so fulr->ulr_count is the size 297 * of the preceding entry (d_reclen). 298 */ 299 from_prev_end = fulr->ulr_offset; 300 KASSERT(fulr->ulr_count <= from_prev_end); 301 from_prev_start = (from_prev_end - fulr->ulr_count); 302 303 /* 304 * tulr is from a RENAME lookup, so tulr->ulr_count is the size 305 * of the free space for an entry that we are about to fill. 306 */ 307 to_start = tulr->ulr_offset; 308 KASSERT(tulr->ulr_count < (LFS_MAXDIRSIZE - to_start)); 309 to_end = (to_start + tulr->ulr_count); 310 311 return 312 (((to_start <= from_prev_start) && (from_prev_start < to_end)) || 313 ((to_start <= from_prev_end) && (from_prev_end < to_end))); 314} 315 316/* 317 * ulfs_direct_namlen: Return the namlen of the directory entry ep from 318 * the directory vp. 319 */ 320static int /* XXX int? uint8_t? */ 321ulfs_direct_namlen(const LFS_DIRHEADER *ep, const struct vnode *vp) 322{ 323 struct lfs *fs; 324 325 KASSERT(ep != NULL); 326 KASSERT(vp != NULL); 327 KASSERT(VTOI(vp) != NULL); 328 KASSERT(VTOI(vp)->i_ump != NULL); 329 KASSERT(VTOI(vp)->i_lfs != NULL); 330 fs = VTOI(vp)->i_lfs; 331 332 return lfs_dir_getnamlen(fs, ep); 333} 334 335/* 336 * ulfs_rename_recalculate_fulr: If we have just entered a directory into 337 * dvp at tulr, and we were about to remove one at fulr for an entry 338 * named fcnp, fulr may be invalid. So, if necessary, recalculate it. 339 */ 340static int 341ulfs_rename_recalculate_fulr(struct vnode *dvp, 342 struct ulfs_lookup_results *fulr, const struct ulfs_lookup_results *tulr, 343 const struct componentname *fcnp) 344{ 345 struct mount *mp; 346 struct lfs *fs; 347 struct ulfsmount *ump; 348 /* XXX int is a silly type for this; blame ulfsmount::um_dirblksiz. */ 349 int dirblksiz; 350 doff_t search_start, search_end; 351 doff_t offset; /* Offset of entry we're examining. */ 352 struct buf *bp; /* I/O block we're examining. */ 353 char *dirbuf; /* Pointer into directory at search_start. */ 354 LFS_DIRHEADER *ep; /* Pointer to the entry we're examining. */ 355 /* XXX direct::d_reclen is 16-bit; 356 * ulfs_lookup_results::ulr_reclen is 32-bit. Blah. */ 357 uint32_t reclen; /* Length of the entry we're examining. */ 358 uint32_t prev_reclen; /* Length of the preceding entry. */ 359 int error; 360 361 KASSERT(dvp != NULL); 362 KASSERT(dvp->v_mount != NULL); 363 KASSERT(VTOI(dvp) != NULL); 364 KASSERT(fulr != NULL); 365 KASSERT(tulr != NULL); 366 KASSERT(fulr != tulr); 367 KASSERT(ulfs_rename_ulr_overlap_p(fulr, tulr)); 368 369 mp = dvp->v_mount; 370 ump = VFSTOULFS(mp); 371 fs = ump->um_lfs; 372 KASSERT(ump != NULL); 373 KASSERT(ump == VTOI(dvp)->i_ump); 374 KASSERT(fs == VTOI(dvp)->i_lfs); 375 376 dirblksiz = fs->um_dirblksiz; 377 KASSERT(0 < dirblksiz); 378 KASSERT((dirblksiz & (dirblksiz - 1)) == 0); 379 380 /* A directory block may not span across multiple I/O blocks. */ 381 KASSERT(dirblksiz <= mp->mnt_stat.f_iosize); 382 383 /* Find the bounds of the search. */ 384 search_start = tulr->ulr_offset; 385 KASSERT(fulr->ulr_reclen < (LFS_MAXDIRSIZE - fulr->ulr_offset)); 386 search_end = (fulr->ulr_offset + fulr->ulr_reclen); 387 388 /* Compaction must happen only within a directory block. (*) */ 389 KASSERT(search_start <= search_end); 390 KASSERT((search_end - (search_start &~ (dirblksiz - 1))) <= dirblksiz); 391 392 dirbuf = NULL; 393 bp = NULL; 394 error = ulfs_blkatoff(dvp, (off_t)search_start, &dirbuf, &bp, false); 395 if (error) 396 return error; 397 KASSERT(dirbuf != NULL); 398 KASSERT(bp != NULL); 399 400 /* 401 * Guarantee we sha'n't go past the end of the buffer we got. 402 * dirbuf is bp->b_data + (search_start & (iosize - 1)), and 403 * the valid range is [bp->b_data, bp->b_data + bp->b_bcount). 404 */ 405 KASSERT((search_end - search_start) <= 406 (bp->b_bcount - (search_start & (mp->mnt_stat.f_iosize - 1)))); 407 408 prev_reclen = fulr->ulr_count; 409 offset = search_start; 410 411 /* 412 * Search from search_start to search_end for the entry matching 413 * fcnp, which must be there because we found it before and it 414 * should only at most have moved earlier. 415 */ 416 for (;;) { 417 KASSERT(search_start <= offset); 418 KASSERT(offset < search_end); 419 420 /* 421 * Examine the directory entry at offset. 422 */ 423 ep = (LFS_DIRHEADER *)(dirbuf + (offset - search_start)); 424 reclen = lfs_dir_getreclen(fs, ep); 425 426 if (lfs_dir_getino(fs, ep) == 0) 427 goto next; /* Entry is unused. */ 428 429 if (lfs_dir_getino(fs, ep) == ULFS_WINO) 430 goto next; /* Entry is whiteout. */ 431 432 if (fcnp->cn_namelen != ulfs_direct_namlen(ep, dvp)) 433 goto next; /* Wrong name length. */ 434 435 if (memcmp(lfs_dir_nameptr(fs, ep), fcnp->cn_nameptr, fcnp->cn_namelen)) 436 goto next; /* Wrong name. */ 437 438 /* Got it! */ 439 break; 440 441next: 442 if (! ((reclen < search_end) && 443 (offset < (search_end - reclen)))) { 444 brelse(bp, 0); 445 return EIO; /* XXX Panic? What? */ 446 } 447 448 /* We may not move past the search end. */ 449 KASSERT(reclen < search_end); 450 KASSERT(offset < (search_end - reclen)); 451 452 /* 453 * We may not move across a directory block boundary; 454 * see (*) above. 455 */ 456 KASSERT((offset &~ (dirblksiz - 1)) == 457 ((offset + reclen) &~ (dirblksiz - 1))); 458 459 prev_reclen = reclen; 460 offset += reclen; 461 } 462 463 /* 464 * Found the entry. Record where. 465 */ 466 fulr->ulr_offset = offset; 467 fulr->ulr_reclen = reclen; 468 469 /* 470 * Record the preceding record length, but not if we're at the 471 * start of a directory block. 472 */ 473 fulr->ulr_count = ((offset & (dirblksiz - 1))? prev_reclen : 0); 474 475 brelse(bp, 0); 476 return 0; 477} 478 479/* 480 * ulfs_gro_remove: Rename an object over another link to itself, 481 * effectively removing just the original link. 482 */ 483static int 484ulfs_gro_remove(struct mount *mp, kauth_cred_t cred, 485 struct vnode *dvp, struct componentname *cnp, void *de, struct vnode *vp) 486{ 487 struct ulfs_lookup_results *ulr = de; 488 int error; 489 490 KASSERT(mp != NULL); 491 KASSERT(dvp != NULL); 492 KASSERT(cnp != NULL); 493 KASSERT(ulr != NULL); 494 KASSERT(vp != NULL); 495 KASSERT(dvp != vp); 496 KASSERT(dvp->v_mount == mp); 497 KASSERT(vp->v_mount == mp); 498 KASSERT(dvp->v_type == VDIR); 499 KASSERT(vp->v_type != VDIR); 500 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 501 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 502 KASSERT(cnp->cn_nameiop == DELETE); 503 504 /* XXX ulfs_dirremove decrements vp's link count for us. */ 505 error = ulfs_dirremove(dvp, ulr, VTOI(vp), cnp->cn_flags, 0); 506 if (error) 507 goto out1; 508 509 VN_KNOTE(dvp, NOTE_WRITE); 510 VN_KNOTE(vp, (VTOI(vp)->i_nlink? NOTE_LINK : NOTE_DELETE)); 511 512out1: 513 return error; 514} 515 516/* 517 * ulfs_gro_lookup: Look up and save the lookup results. 518 */ 519static int 520ulfs_gro_lookup(struct mount *mp, struct vnode *dvp, 521 struct componentname *cnp, void *de_ret, struct vnode **vp_ret) 522{ 523 struct ulfs_lookup_results *ulr_ret = de_ret; 524 struct vnode *vp = NULL; 525 int error; 526 527 (void)mp; 528 KASSERT(mp != NULL); 529 KASSERT(dvp != NULL); 530 KASSERT(cnp != NULL); 531 KASSERT(ulr_ret != NULL); 532 KASSERT(vp_ret != NULL); 533 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 534 535 /* Kludge cargo-culted from dholland's ulfs_rename. */ 536 cnp->cn_flags &=~ MODMASK; 537 cnp->cn_flags |= (LOCKPARENT | LOCKLEAF); 538 539 error = relookup(dvp, &vp, cnp, 0 /* dummy */); 540 if ((error == 0) && (vp == NULL)) { 541 error = ENOENT; 542 goto out; 543 } else if (error) { 544 return error; 545 } 546 547 /* 548 * Thanks to VFS insanity, relookup locks vp, which screws us 549 * in various ways. 550 */ 551 KASSERT(vp != NULL); 552 VOP_UNLOCK(vp); 553 554out: *ulr_ret = VTOI(dvp)->i_crap; 555 *vp_ret = vp; 556 return error; 557} 558 559/* 560 * ulfs_rmdired_p: Check whether the directory vp has been rmdired. 561 * 562 * vp must be locked and referenced. 563 */ 564static bool 565ulfs_rmdired_p(struct vnode *vp) 566{ 567 568 KASSERT(vp != NULL); 569 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 570 KASSERT(vp->v_type == VDIR); 571 572 /* XXX Is this correct? */ 573 return (VTOI(vp)->i_size == 0); 574} 575 576/* 577 * ulfs_read_dotdot: Store in *ino_ret the inode number of the parent 578 * of the directory vp. 579 */ 580static int 581ulfs_read_dotdot(struct vnode *vp, kauth_cred_t cred, ino_t *ino_ret) 582{ 583 struct lfs *fs; 584 union lfs_dirtemplate dirbuf; 585 LFS_DIRHEADER *dotdot; 586 const char *name; 587 int error; 588 589 KASSERT(vp != NULL); 590 KASSERT(ino_ret != NULL); 591 KASSERT(vp->v_type == VDIR); 592 593 KASSERT(VTOI(vp) != NULL); 594 KASSERT(VTOI(vp)->i_lfs != NULL); 595 fs = VTOI(vp)->i_lfs; 596 597 error = ulfs_bufio(UIO_READ, vp, &dirbuf, sizeof dirbuf, (off_t)0, 598 IO_NODELOCKED, cred, NULL, NULL); 599 if (error) 600 return error; 601 602 dotdot = lfs_dirtemplate_dotdot(fs, &dirbuf); 603 name = lfs_dirtemplate_dotdotname(fs, &dirbuf); 604 if (lfs_dir_getnamlen(fs, dotdot) != 2 || 605 name[0] != '.' || 606 name[1] != '.') 607 /* XXX Panic? Print warning? */ 608 return ENOTDIR; 609 610 *ino_ret = lfs_dir_getino(fs, dotdot); 611 return 0; 612} 613 614/* 615 * ulfs_gro_lock_directory: Lock the directory vp, but fail if it has 616 * been rmdir'd. 617 */ 618static int 619ulfs_gro_lock_directory(struct mount *mp, struct vnode *vp) 620{ 621 622 (void)mp; 623 KASSERT(mp != NULL); 624 KASSERT(vp != NULL); 625 KASSERT(vp->v_mount == mp); 626 627 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 628 629 if (ulfs_rmdired_p(vp)) { 630 VOP_UNLOCK(vp); 631 return ENOENT; 632 } 633 634 return 0; 635} 636 637/* 638 * ulfs_gro_genealogy: Analyze the genealogy of the source and target 639 * directories. 640 */ 641static int 642ulfs_gro_genealogy(struct mount *mp, kauth_cred_t cred, 643 struct vnode *fdvp, struct vnode *tdvp, 644 struct vnode **intermediate_node_ret) 645{ 646 struct vnode *vp, *dvp; 647 ino_t dotdot_ino = -1; /* XXX gcc 4.8: maybe-uninitialized */ 648 int error; 649 650 KASSERT(mp != NULL); 651 KASSERT(fdvp != NULL); 652 KASSERT(tdvp != NULL); 653 KASSERT(fdvp != tdvp); 654 KASSERT(intermediate_node_ret != NULL); 655 KASSERT(fdvp->v_mount == mp); 656 KASSERT(tdvp->v_mount == mp); 657 KASSERT(fdvp->v_type == VDIR); 658 KASSERT(tdvp->v_type == VDIR); 659 660 /* 661 * We need to provisionally lock tdvp to keep rmdir from 662 * deleting it -- or any ancestor -- at an inopportune moment. 663 */ 664 error = ulfs_gro_lock_directory(mp, tdvp); 665 if (error) 666 return error; 667 668 vp = tdvp; 669 vref(vp); 670 671 for (;;) { 672 KASSERT(vp != NULL); 673 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 674 KASSERT(vp->v_mount == mp); 675 KASSERT(vp->v_type == VDIR); 676 KASSERT(!ulfs_rmdired_p(vp)); 677 678 /* Did we hit the root without finding fdvp? */ 679 if (VTOI(vp)->i_number == ULFS_ROOTINO) { 680 vput(vp); 681 *intermediate_node_ret = NULL; 682 return 0; 683 } 684 685 error = ulfs_read_dotdot(vp, cred, &dotdot_ino); 686 if (error) { 687 vput(vp); 688 return error; 689 } 690 691 /* Did we find that fdvp is an ancestor of tdvp? */ 692 if (VTOI(fdvp)->i_number == dotdot_ino) { 693 /* Unlock vp, but keep it referenced. */ 694 VOP_UNLOCK(vp); 695 *intermediate_node_ret = vp; 696 return 0; 697 } 698 699 /* Neither -- keep ascending the family tree. */ 700 error = vcache_get(mp, &dotdot_ino, sizeof(dotdot_ino), &dvp); 701 vput(vp); 702 if (error) 703 return error; 704 error = vn_lock(dvp, LK_EXCLUSIVE); 705 if (error) { 706 vrele(dvp); 707 return error; 708 } 709 710 KASSERT(dvp != NULL); 711 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 712 vp = dvp; 713 714 if (vp->v_type != VDIR) { 715 /* 716 * XXX Panic? Print a warning? Can this 717 * happen if we lose the race I suspect to 718 * exist above, and the `..' inode number has 719 * been recycled? 720 */ 721 vput(vp); 722 return ENOTDIR; 723 } 724 725 if (ulfs_rmdired_p(vp)) { 726 vput(vp); 727 return ENOENT; 728 } 729 } 730} 731 732/* 733 * ulfs_gro_rename: Actually perform the rename operation. 734 */ 735static int 736ulfs_gro_rename(struct mount *mp, kauth_cred_t cred, 737 struct vnode *fdvp, struct componentname *fcnp, 738 void *fde, struct vnode *fvp, 739 struct vnode *tdvp, struct componentname *tcnp, 740 void *tde, struct vnode *tvp) 741{ 742 struct lfs *fs; 743 struct ulfs_lookup_results *fulr = fde; 744 struct ulfs_lookup_results *tulr = tde; 745 bool directory_p, reparent_p; 746 int error; 747 748 KASSERT(mp != NULL); 749 KASSERT(fdvp != NULL); 750 KASSERT(fcnp != NULL); 751 KASSERT(fulr != NULL); 752 KASSERT(fvp != NULL); 753 KASSERT(tdvp != NULL); 754 KASSERT(tcnp != NULL); 755 KASSERT(tulr != NULL); 756 KASSERT(fulr != tulr); 757 KASSERT(fdvp != fvp); 758 KASSERT(fdvp != tvp); 759 KASSERT(tdvp != fvp); 760 KASSERT(tdvp != tvp); 761 KASSERT(fvp != tvp); 762 KASSERT(fdvp->v_mount == mp); 763 KASSERT(fvp->v_mount == mp); 764 KASSERT(tdvp->v_mount == mp); 765 KASSERT((tvp == NULL) || (tvp->v_mount == mp)); 766 KASSERT(VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE); 767 KASSERT(VOP_ISLOCKED(fvp) == LK_EXCLUSIVE); 768 KASSERT(VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE); 769 KASSERT((tvp == NULL) || (VOP_ISLOCKED(tvp) == LK_EXCLUSIVE)); 770 771 fs = VTOI(fdvp)->i_lfs; 772 KASSERT(fs == VTOI(tdvp)->i_lfs); 773 774 /* 775 * We shall need to temporarily bump the link count, so make 776 * sure there is room to do so. 777 */ 778 if ((nlink_t)VTOI(fvp)->i_nlink >= LINK_MAX) 779 return EMLINK; 780 781 directory_p = (fvp->v_type == VDIR); 782 KASSERT(directory_p == ((VTOI(fvp)->i_mode & LFS_IFMT) == LFS_IFDIR)); 783 KASSERT((tvp == NULL) || (directory_p == (tvp->v_type == VDIR))); 784 KASSERT((tvp == NULL) || (directory_p == 785 ((VTOI(tvp)->i_mode & LFS_IFMT) == LFS_IFDIR))); 786 787 reparent_p = (fdvp != tdvp); 788 KASSERT(reparent_p == (VTOI(fdvp)->i_number != VTOI(tdvp)->i_number)); 789 790 /* 791 * Commence hacking of the data on disk. 792 */ 793 794 error = 0; 795 796 /* 797 * 1) Bump link count while we're moving stuff 798 * around. If we crash somewhere before 799 * completing our work, the link count 800 * may be wrong, but correctable. 801 */ 802 803 KASSERT((nlink_t)VTOI(fvp)->i_nlink < LINK_MAX); 804 VTOI(fvp)->i_nlink++; 805 DIP_ASSIGN(VTOI(fvp), nlink, VTOI(fvp)->i_nlink); 806 VTOI(fvp)->i_state |= IN_CHANGE; 807 error = lfs_update(fvp, NULL, NULL, UPDATE_DIROP); 808 if (error) 809 goto whymustithurtsomuch; 810 811 /* 812 * 2) If target doesn't exist, link the target 813 * to the source and unlink the source. 814 * Otherwise, rewrite the target directory 815 * entry to reference the source inode and 816 * expunge the original entry's existence. 817 */ 818 819 if (tvp == NULL) { 820 /* 821 * Account for ".." in new directory. 822 * When source and destination have the same 823 * parent we don't fool with the link count. 824 */ 825 if (directory_p && reparent_p) { 826 if ((nlink_t)VTOI(tdvp)->i_nlink >= LINK_MAX) { 827 error = EMLINK; 828 goto whymustithurtsomuch; 829 } 830 KASSERT((nlink_t)VTOI(tdvp)->i_nlink < LINK_MAX); 831 VTOI(tdvp)->i_nlink++; 832 DIP_ASSIGN(VTOI(tdvp), nlink, VTOI(tdvp)->i_nlink); 833 VTOI(tdvp)->i_state |= IN_CHANGE; 834 error = lfs_update(tdvp, NULL, NULL, UPDATE_DIROP); 835 if (error) { 836 /* 837 * Link count update didn't take -- 838 * back out the in-memory link count. 839 */ 840 KASSERT(0 < VTOI(tdvp)->i_nlink); 841 VTOI(tdvp)->i_nlink--; 842 DIP_ASSIGN(VTOI(tdvp), nlink, 843 VTOI(tdvp)->i_nlink); 844 VTOI(tdvp)->i_state |= IN_CHANGE; 845 goto whymustithurtsomuch; 846 } 847 } 848 849 error = ulfs_direnter(tdvp, tulr, 850 NULL, tcnp, VTOI(fvp)->i_number, LFS_IFTODT(VTOI(fvp)->i_mode), 851 NULL); 852 if (error) { 853 if (directory_p && reparent_p) { 854 /* 855 * Directory update didn't take, but 856 * the link count update did -- back 857 * out the in-memory link count and the 858 * on-disk link count. 859 */ 860 KASSERT(0 < VTOI(tdvp)->i_nlink); 861 VTOI(tdvp)->i_nlink--; 862 DIP_ASSIGN(VTOI(tdvp), nlink, 863 VTOI(tdvp)->i_nlink); 864 VTOI(tdvp)->i_state |= IN_CHANGE; 865 (void)lfs_update(tdvp, NULL, NULL, 866 UPDATE_WAIT | UPDATE_DIROP); 867 } 868 goto whymustithurtsomuch; 869 } 870 } else { 871 if (directory_p) 872 /* XXX WTF? Why purge here? Why not purge others? */ 873 cache_purge(tdvp); 874 875 /* 876 * Make the target directory's entry for tcnp point at 877 * the source node. 878 * 879 * XXX ulfs_dirrewrite decrements tvp's link count, but 880 * doesn't touch the link count of the new inode. Go 881 * figure. 882 */ 883 error = ulfs_dirrewrite(VTOI(tdvp), tulr->ulr_offset, 884 VTOI(tvp), VTOI(fvp)->i_number, LFS_IFTODT(VTOI(fvp)->i_mode), 885 ((directory_p && reparent_p) ? reparent_p : directory_p), 886 IN_CHANGE | IN_UPDATE); 887 if (error) 888 goto whymustithurtsomuch; 889 890 /* 891 * If the source and target are directories, and the 892 * target is in the same directory as the source, 893 * decrement the link count of the common parent 894 * directory, since we are removing the target from 895 * that directory. 896 */ 897 if (directory_p && !reparent_p) { 898 KASSERT(fdvp == tdvp); 899 /* XXX check, don't kassert */ 900 KASSERT(0 < VTOI(tdvp)->i_nlink); 901 VTOI(tdvp)->i_nlink--; 902 DIP_ASSIGN(VTOI(tdvp), nlink, VTOI(tdvp)->i_nlink); 903 VTOI(tdvp)->i_state |= IN_CHANGE; 904 } 905 906 if (directory_p) { 907 /* 908 * XXX I don't understand the following comment 909 * from ulfs_rename -- in particular, the part 910 * about `there may be other hard links'. 911 * 912 * Truncate inode. The only stuff left in the directory 913 * is "." and "..". The "." reference is inconsequential 914 * since we are quashing it. We have removed the "." 915 * reference and the reference in the parent directory, 916 * but there may be other hard links. 917 * 918 * XXX The ulfs_dirempty call earlier does 919 * not guarantee anything about nlink. 920 */ 921 if (VTOI(tvp)->i_nlink != 1) 922 ulfs_dirbad(VTOI(tvp), (doff_t)0, 923 "hard-linked directory"); 924 VTOI(tvp)->i_nlink = 0; 925 DIP_ASSIGN(VTOI(tvp), nlink, 0); 926 error = lfs_truncate(tvp, (off_t)0, IO_SYNC, cred); 927 if (error) 928 goto whymustithurtsomuch; 929 } 930 } 931 932 /* 933 * If the source is a directory with a new parent, the link 934 * count of the old parent directory must be decremented and 935 * ".." set to point to the new parent. 936 * 937 * XXX ulfs_dirrewrite updates the link count of fdvp, but not 938 * the link count of fvp or the link count of tdvp. Go figure. 939 */ 940 if (directory_p && reparent_p) { 941 off_t position; 942 943 /* 944 * The .. entry goes immediately after the . entry, so 945 * the position is the record length of the . entry, 946 * namely LFS_DIRECTSIZ(1). 947 */ 948 position = LFS_DIRECTSIZ(fs, 1); 949 error = ulfs_dirrewrite(VTOI(fvp), position, 950 VTOI(fdvp), VTOI(tdvp)->i_number, LFS_DT_DIR, 0, IN_CHANGE); 951#if 0 /* XXX This branch was not in ulfs_rename! */ 952 if (error) 953 goto whymustithurtsomuch; 954#endif 955 956 /* XXX WTF? Why purge here? Why not purge others? */ 957 cache_purge(fdvp); 958 } 959 960 /* 961 * 3) Unlink the source. 962 */ 963 964 /* 965 * ulfs_direnter may compact the directory in the process of 966 * inserting a new entry. That may invalidate fulr, which we 967 * need in order to remove the old entry. In that case, we 968 * need to recalculate what fulr should be. 969 */ 970 if (!reparent_p && (tvp == NULL) && 971 ulfs_rename_ulr_overlap_p(fulr, tulr)) { 972 error = ulfs_rename_recalculate_fulr(fdvp, fulr, tulr, fcnp); 973#if 0 /* XXX */ 974 if (error) /* XXX Try to back out changes? */ 975 goto whymustithurtsomuch; 976#endif 977 } 978 979 /* 980 * XXX 0 means !isrmdir. But can't this be an rmdir? 981 * XXX Well, turns out that argument to ulfs_dirremove is ignored... 982 * XXX And it turns out ulfs_dirremove updates the link count of fvp. 983 * XXX But it doesn't update the link count of fdvp. Go figure. 984 * XXX fdvp's link count is updated in ulfs_dirrewrite instead. 985 * XXX Actually, sometimes it doesn't update fvp's link count. 986 * XXX I hate the world. 987 */ 988 error = ulfs_dirremove(fdvp, fulr, VTOI(fvp), fcnp->cn_flags, 0); 989 if (error) 990#if 0 /* XXX */ 991 goto whymustithurtsomuch; 992#endif 993 goto arghmybrainhurts; 994 995 /* 996 * XXX Perhaps this should go at the top, in case the file 997 * system is modified but incompletely so because of an 998 * intermediate error. 999 */ 1000 genfs_rename_knote(fdvp, fvp, tdvp, tvp, 1001 ((tvp != NULL) && (VTOI(tvp)->i_nlink == 0))); 1002#if 0 /* XXX */ 1003 genfs_rename_cache_purge(fdvp, fvp, tdvp, tvp); 1004#endif 1005 goto arghmybrainhurts; 1006 1007whymustithurtsomuch: 1008 KASSERT(0 < VTOI(fvp)->i_nlink); 1009 VTOI(fvp)->i_nlink--; 1010 DIP_ASSIGN(VTOI(fvp), nlink, VTOI(fvp)->i_nlink); 1011 VTOI(fvp)->i_state |= IN_CHANGE; 1012 1013arghmybrainhurts: 1014/*ihateyou:*/ 1015 return error; 1016} 1017 1018/* 1019 * lfs_gro_rename: Actually perform the rename operation. Do a little 1020 * LFS bookkeeping and then defer to ulfs_gro_rename. 1021 */ 1022static int 1023lfs_gro_rename(struct mount *mp, kauth_cred_t cred, 1024 struct vnode *fdvp, struct componentname *fcnp, 1025 void *fde, struct vnode *fvp, 1026 struct vnode *tdvp, struct componentname *tcnp, 1027 void *tde, struct vnode *tvp) 1028{ 1029 int error; 1030 1031 KASSERT(mp != NULL); 1032 KASSERT(fdvp != NULL); 1033 KASSERT(fcnp != NULL); 1034 KASSERT(fde != NULL); 1035 KASSERT(fvp != NULL); 1036 KASSERT(tdvp != NULL); 1037 KASSERT(tcnp != NULL); 1038 KASSERT(tde != NULL); 1039 KASSERT(fdvp != fvp); 1040 KASSERT(fdvp != tvp); 1041 KASSERT(tdvp != fvp); 1042 KASSERT(tdvp != tvp); 1043 KASSERT(fvp != tvp); 1044 KASSERT(fdvp->v_mount == mp); 1045 KASSERT(fvp->v_mount == mp); 1046 KASSERT(tdvp->v_mount == mp); 1047 KASSERT((tvp == NULL) || (tvp->v_mount == mp)); 1048 KASSERT(VOP_ISLOCKED(fdvp) == LK_EXCLUSIVE); 1049 KASSERT(VOP_ISLOCKED(fvp) == LK_EXCLUSIVE); 1050 KASSERT(VOP_ISLOCKED(tdvp) == LK_EXCLUSIVE); 1051 KASSERT((tvp == NULL) || (VOP_ISLOCKED(tvp) == LK_EXCLUSIVE)); 1052 1053 error = lfs_set_dirop(tdvp, tvp); 1054 if (error != 0) 1055 return error; 1056 1057 MARK_VNODE(fdvp); 1058 MARK_VNODE(fvp); 1059 1060 error = ulfs_gro_rename(mp, cred, 1061 fdvp, fcnp, fde, fvp, 1062 tdvp, tcnp, tde, tvp); 1063 1064 UNMARK_VNODE(fdvp); 1065 UNMARK_VNODE(fvp); 1066 UNMARK_VNODE(tdvp); 1067 if (tvp) { 1068 UNMARK_VNODE(tvp); 1069 } 1070 lfs_unset_dirop(VFSTOULFS(mp)->um_lfs, tdvp, "rename"); 1071 vrele(tdvp); 1072 if (tvp) { 1073 vrele(tvp); 1074 } 1075 1076 return error; 1077} 1078 1079static const struct genfs_rename_ops lfs_genfs_rename_ops = { 1080 .gro_directory_empty_p = ulfs_gro_directory_empty_p, 1081 .gro_rename_check_possible = ulfs_gro_rename_check_possible, 1082 .gro_rename_check_permitted = ulfs_gro_rename_check_permitted, 1083 .gro_remove_check_possible = ulfs_gro_remove_check_possible, 1084 .gro_remove_check_permitted = ulfs_gro_remove_check_permitted, 1085 .gro_rename = lfs_gro_rename, 1086 .gro_remove = ulfs_gro_remove, 1087 .gro_lookup = ulfs_gro_lookup, 1088 .gro_genealogy = ulfs_gro_genealogy, 1089 .gro_lock_directory = ulfs_gro_lock_directory, 1090}; 1091 1092/* 1093 * lfs_sane_rename: The hairiest vop, with the saner API. 1094 * 1095 * Arguments: 1096 * 1097 * . fdvp (from directory vnode), 1098 * . fcnp (from component name), 1099 * . tdvp (to directory vnode), 1100 * . tcnp (to component name), 1101 * . cred (credentials structure), and 1102 * . posixly_correct (flag for behaviour if target & source link same file). 1103 * 1104 * fdvp and tdvp may be the same, and must be referenced and unlocked. 1105 */ 1106static int 1107lfs_sane_rename( 1108 struct vnode *fdvp, struct componentname *fcnp, 1109 struct vnode *tdvp, struct componentname *tcnp, 1110 kauth_cred_t cred, bool posixly_correct) 1111{ 1112 struct ulfs_lookup_results fulr, tulr; 1113 1114 /* 1115 * XXX Provisional kludge -- ulfs_lookup does not reject rename 1116 * of . or .. (from or to), so we hack it here. This is not 1117 * the right place: it should be caller's responsibility to 1118 * reject this case. 1119 */ 1120 KASSERT(fcnp != NULL); 1121 KASSERT(tcnp != NULL); 1122 KASSERT(fcnp != tcnp); 1123 KASSERT(fcnp->cn_nameptr != NULL); 1124 KASSERT(tcnp->cn_nameptr != NULL); 1125 1126 if ((fcnp->cn_flags | tcnp->cn_flags) & ISDOTDOT) 1127 return EINVAL; /* XXX EISDIR? */ 1128 if ((fcnp->cn_namelen == 1) && (fcnp->cn_nameptr[0] == '.')) 1129 return EINVAL; 1130 if ((tcnp->cn_namelen == 1) && (tcnp->cn_nameptr[0] == '.')) 1131 return EINVAL; 1132 1133 return genfs_sane_rename(&lfs_genfs_rename_ops, 1134 fdvp, fcnp, &fulr, tdvp, tcnp, &tulr, 1135 cred, posixly_correct); 1136} 1137 1138/* 1139 * lfs_rename: The hairiest vop, with the insanest API. Defer to 1140 * genfs_insane_rename immediately. 1141 */ 1142int 1143lfs_rename(void *v) 1144{ 1145 1146 return genfs_insane_rename(v, &lfs_sane_rename); 1147} 1148