1 /* $NetBSD: lfs_vnops.c,v 1.340 2021/10/20 03:08:19 thorpej Exp $ */ 2 3 /*- 4 * Copyright (c) 1999, 2000, 2001, 2002, 2003 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Konrad E. Schroder <perseant@hhhh.org>. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 /* 32 * Copyright (c) 1986, 1989, 1991, 1993, 1995 33 * The Regents of the University of California. All rights reserved. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 1. Redistributions of source code must retain the above copyright 39 * notice, this list of conditions and the following disclaimer. 40 * 2. Redistributions in binary form must reproduce the above copyright 41 * notice, this list of conditions and the following disclaimer in the 42 * documentation and/or other materials provided with the distribution. 43 * 3. Neither the name of the University nor the names of its contributors 44 * may be used to endorse or promote products derived from this software 45 * without specific prior written permission. 46 * 47 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 48 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 50 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 51 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 52 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 53 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 54 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 55 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 56 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 57 * SUCH DAMAGE. 58 * 59 * @(#)lfs_vnops.c 8.13 (Berkeley) 6/10/95 60 */ 61 62 /* from NetBSD: ufs_vnops.c,v 1.232 2016/05/19 18:32:03 riastradh Exp */ 63 /*- 64 * Copyright (c) 2008 The NetBSD Foundation, Inc. 65 * All rights reserved. 66 * 67 * This code is derived from software contributed to The NetBSD Foundation 68 * by Wasabi Systems, Inc. 69 * 70 * Redistribution and use in source and binary forms, with or without 71 * modification, are permitted provided that the following conditions 72 * are met: 73 * 1. Redistributions of source code must retain the above copyright 74 * notice, this list of conditions and the following disclaimer. 75 * 2. Redistributions in binary form must reproduce the above copyright 76 * notice, this list of conditions and the following disclaimer in the 77 * documentation and/or other materials provided with the distribution. 78 * 79 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 80 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 81 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 82 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 83 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 84 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 85 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 86 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 87 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 88 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 89 * POSSIBILITY OF SUCH DAMAGE. 90 */ 91 /* 92 * Copyright (c) 1982, 1986, 1989, 1993, 1995 93 * The Regents of the University of California. All rights reserved. 94 * (c) UNIX System Laboratories, Inc. 95 * All or some portions of this file are derived from material licensed 96 * to the University of California by American Telephone and Telegraph 97 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 98 * the permission of UNIX System Laboratories, Inc. 99 * 100 * Redistribution and use in source and binary forms, with or without 101 * modification, are permitted provided that the following conditions 102 * are met: 103 * 1. Redistributions of source code must retain the above copyright 104 * notice, this list of conditions and the following disclaimer. 105 * 2. Redistributions in binary form must reproduce the above copyright 106 * notice, this list of conditions and the following disclaimer in the 107 * documentation and/or other materials provided with the distribution. 108 * 3. Neither the name of the University nor the names of its contributors 109 * may be used to endorse or promote products derived from this software 110 * without specific prior written permission. 111 * 112 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 113 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 114 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 115 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 116 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 117 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 118 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 119 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 120 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 121 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 122 * SUCH DAMAGE. 123 * 124 * @(#)ufs_vnops.c 8.28 (Berkeley) 7/31/95 125 */ 126 127 #include <sys/cdefs.h> 128 __KERNEL_RCSID(0, "$NetBSD: lfs_vnops.c,v 1.340 2021/10/20 03:08:19 thorpej Exp $"); 129 130 #ifdef _KERNEL_OPT 131 #include "opt_compat_netbsd.h" 132 #include "opt_uvm_page_trkown.h" 133 #endif 134 135 #include <sys/param.h> 136 #include <sys/systm.h> 137 #include <sys/namei.h> 138 #include <sys/resourcevar.h> 139 #include <sys/kernel.h> 140 #include <sys/file.h> 141 #include <sys/stat.h> 142 #include <sys/buf.h> 143 #include <sys/proc.h> 144 #include <sys/mount.h> 145 #include <sys/vnode.h> 146 #include <sys/pool.h> 147 #include <sys/signalvar.h> 148 #include <sys/kauth.h> 149 #include <sys/syslog.h> 150 151 #include <miscfs/fifofs/fifo.h> 152 #include <miscfs/genfs/genfs.h> 153 #include <miscfs/specfs/specdev.h> 154 155 #include <ufs/lfs/ulfs_inode.h> 156 #include <ufs/lfs/ulfsmount.h> 157 #include <ufs/lfs/ulfs_bswap.h> 158 #include <ufs/lfs/ulfs_extern.h> 159 160 #include <uvm/uvm_extern.h> 161 162 #include <ufs/lfs/lfs.h> 163 #include <ufs/lfs/lfs_accessors.h> 164 #include <ufs/lfs/lfs_kernel.h> 165 #include <ufs/lfs/lfs_extern.h> 166 167 extern kcondvar_t lfs_writerd_cv; 168 int lfs_ignore_lazy_sync = 1; 169 170 static int lfs_openextattr(void *v); 171 static int lfs_closeextattr(void *v); 172 static int lfs_getextattr(void *v); 173 static int lfs_setextattr(void *v); 174 static int lfs_listextattr(void *v); 175 static int lfs_deleteextattr(void *v); 176 177 static int lfs_makeinode(struct vattr *vap, struct vnode *, 178 const struct ulfs_lookup_results *, 179 struct vnode **, struct componentname *); 180 181 /* Global vfs data structures for lfs. */ 182 int (**lfs_vnodeop_p)(void *); 183 const struct vnodeopv_entry_desc lfs_vnodeop_entries[] = { 184 { &vop_default_desc, vn_default_error }, 185 { &vop_parsepath_desc, genfs_parsepath }, /* parsepath */ 186 { &vop_lookup_desc, ulfs_lookup }, /* lookup */ 187 { &vop_create_desc, lfs_create }, /* create */ 188 { &vop_whiteout_desc, ulfs_whiteout }, /* whiteout */ 189 { &vop_mknod_desc, lfs_mknod }, /* mknod */ 190 { &vop_open_desc, ulfs_open }, /* open */ 191 { &vop_close_desc, lfs_close }, /* close */ 192 { &vop_access_desc, ulfs_access }, /* access */ 193 { &vop_accessx_desc, genfs_accessx }, /* accessx */ 194 { &vop_getattr_desc, lfs_getattr }, /* getattr */ 195 { &vop_setattr_desc, lfs_setattr }, /* setattr */ 196 { &vop_read_desc, lfs_read }, /* read */ 197 { &vop_write_desc, lfs_write }, /* write */ 198 { &vop_fallocate_desc, genfs_eopnotsupp }, /* fallocate */ 199 { &vop_fdiscard_desc, genfs_eopnotsupp }, /* fdiscard */ 200 { &vop_ioctl_desc, genfs_enoioctl }, /* ioctl */ 201 { &vop_fcntl_desc, lfs_fcntl }, /* fcntl */ 202 { &vop_poll_desc, genfs_poll }, /* poll */ 203 { &vop_kqfilter_desc, genfs_kqfilter }, /* kqfilter */ 204 { &vop_revoke_desc, genfs_revoke }, /* revoke */ 205 { &vop_mmap_desc, lfs_mmap }, /* mmap */ 206 { &vop_fsync_desc, lfs_fsync }, /* fsync */ 207 { &vop_seek_desc, genfs_seek }, /* seek */ 208 { &vop_remove_desc, lfs_remove }, /* remove */ 209 { &vop_link_desc, lfs_link }, /* link */ 210 { &vop_rename_desc, lfs_rename }, /* rename */ 211 { &vop_mkdir_desc, lfs_mkdir }, /* mkdir */ 212 { &vop_rmdir_desc, lfs_rmdir }, /* rmdir */ 213 { &vop_symlink_desc, lfs_symlink }, /* symlink */ 214 { &vop_readdir_desc, ulfs_readdir }, /* readdir */ 215 { &vop_readlink_desc, ulfs_readlink }, /* readlink */ 216 { &vop_abortop_desc, genfs_abortop }, /* abortop */ 217 { &vop_inactive_desc, lfs_inactive }, /* inactive */ 218 { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */ 219 { &vop_lock_desc, genfs_lock }, /* lock */ 220 { &vop_unlock_desc, genfs_unlock }, /* unlock */ 221 { &vop_bmap_desc, ulfs_bmap }, /* bmap */ 222 { &vop_strategy_desc, lfs_strategy }, /* strategy */ 223 { &vop_print_desc, ulfs_print }, /* print */ 224 { &vop_islocked_desc, genfs_islocked }, /* islocked */ 225 { &vop_pathconf_desc, ulfs_pathconf }, /* pathconf */ 226 { &vop_advlock_desc, ulfs_advlock }, /* advlock */ 227 { &vop_bwrite_desc, lfs_bwrite }, /* bwrite */ 228 { &vop_getpages_desc, lfs_getpages }, /* getpages */ 229 { &vop_putpages_desc, lfs_putpages }, /* putpages */ 230 { &vop_openextattr_desc, lfs_openextattr }, /* openextattr */ 231 { &vop_closeextattr_desc, lfs_closeextattr }, /* closeextattr */ 232 { &vop_getextattr_desc, lfs_getextattr }, /* getextattr */ 233 { &vop_setextattr_desc, lfs_setextattr }, /* setextattr */ 234 { &vop_listextattr_desc, lfs_listextattr }, /* listextattr */ 235 { &vop_deleteextattr_desc, lfs_deleteextattr }, /* deleteextattr */ 236 { NULL, NULL } 237 }; 238 const struct vnodeopv_desc lfs_vnodeop_opv_desc = 239 { &lfs_vnodeop_p, lfs_vnodeop_entries }; 240 241 int (**lfs_specop_p)(void *); 242 const struct vnodeopv_entry_desc lfs_specop_entries[] = { 243 { &vop_default_desc, vn_default_error }, 244 GENFS_SPECOP_ENTRIES, 245 { &vop_close_desc, lfsspec_close }, /* close */ 246 { &vop_access_desc, ulfs_access }, /* access */ 247 { &vop_accessx_desc, genfs_accessx }, /* accessx */ 248 { &vop_getattr_desc, lfs_getattr }, /* getattr */ 249 { &vop_setattr_desc, lfs_setattr }, /* setattr */ 250 { &vop_read_desc, ulfsspec_read }, /* read */ 251 { &vop_write_desc, ulfsspec_write }, /* write */ 252 { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */ 253 { &vop_fsync_desc, spec_fsync }, /* fsync */ 254 { &vop_inactive_desc, lfs_inactive }, /* inactive */ 255 { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */ 256 { &vop_lock_desc, genfs_lock }, /* lock */ 257 { &vop_unlock_desc, genfs_unlock }, /* unlock */ 258 { &vop_print_desc, ulfs_print }, /* print */ 259 { &vop_islocked_desc, genfs_islocked }, /* islocked */ 260 { &vop_bwrite_desc, vn_bwrite }, /* bwrite */ 261 { &vop_openextattr_desc, lfs_openextattr }, /* openextattr */ 262 { &vop_closeextattr_desc, lfs_closeextattr }, /* closeextattr */ 263 { &vop_getextattr_desc, lfs_getextattr }, /* getextattr */ 264 { &vop_setextattr_desc, lfs_setextattr }, /* setextattr */ 265 { &vop_listextattr_desc, lfs_listextattr }, /* listextattr */ 266 { &vop_deleteextattr_desc, lfs_deleteextattr }, /* deleteextattr */ 267 { NULL, NULL } 268 }; 269 const struct vnodeopv_desc lfs_specop_opv_desc = 270 { &lfs_specop_p, lfs_specop_entries }; 271 272 int (**lfs_fifoop_p)(void *); 273 const struct vnodeopv_entry_desc lfs_fifoop_entries[] = { 274 { &vop_default_desc, vn_default_error }, 275 GENFS_FIFOOP_ENTRIES, 276 { &vop_close_desc, lfsfifo_close }, /* close */ 277 { &vop_access_desc, ulfs_access }, /* access */ 278 { &vop_accessx_desc, genfs_accessx }, /* accessx */ 279 { &vop_getattr_desc, lfs_getattr }, /* getattr */ 280 { &vop_setattr_desc, lfs_setattr }, /* setattr */ 281 { &vop_read_desc, ulfsfifo_read }, /* read */ 282 { &vop_write_desc, ulfsfifo_write }, /* write */ 283 { &vop_fcntl_desc, genfs_fcntl }, /* fcntl */ 284 { &vop_fsync_desc, vn_fifo_bypass }, /* fsync */ 285 { &vop_inactive_desc, lfs_inactive }, /* inactive */ 286 { &vop_reclaim_desc, lfs_reclaim }, /* reclaim */ 287 { &vop_lock_desc, genfs_lock }, /* lock */ 288 { &vop_unlock_desc, genfs_unlock }, /* unlock */ 289 { &vop_strategy_desc, vn_fifo_bypass }, /* strategy */ 290 { &vop_print_desc, ulfs_print }, /* print */ 291 { &vop_islocked_desc, genfs_islocked }, /* islocked */ 292 { &vop_bwrite_desc, lfs_bwrite }, /* bwrite */ 293 { &vop_openextattr_desc, lfs_openextattr }, /* openextattr */ 294 { &vop_closeextattr_desc, lfs_closeextattr }, /* closeextattr */ 295 { &vop_getextattr_desc, lfs_getextattr }, /* getextattr */ 296 { &vop_setextattr_desc, lfs_setextattr }, /* setextattr */ 297 { &vop_listextattr_desc, lfs_listextattr }, /* listextattr */ 298 { &vop_deleteextattr_desc, lfs_deleteextattr }, /* deleteextattr */ 299 { NULL, NULL } 300 }; 301 const struct vnodeopv_desc lfs_fifoop_opv_desc = 302 { &lfs_fifoop_p, lfs_fifoop_entries }; 303 304 #include <ufs/lfs/ulfs_readwrite.c> 305 306 /* 307 * Allocate a new inode. 308 */ 309 static int 310 lfs_makeinode(struct vattr *vap, struct vnode *dvp, 311 const struct ulfs_lookup_results *ulr, 312 struct vnode **vpp, struct componentname *cnp) 313 { 314 struct inode *ip; 315 struct vnode *tvp; 316 int error; 317 318 error = vcache_new(dvp->v_mount, dvp, vap, cnp->cn_cred, NULL, &tvp); 319 if (error) 320 return error; 321 error = vn_lock(tvp, LK_EXCLUSIVE); 322 if (error) { 323 vrele(tvp); 324 return error; 325 } 326 MARK_VNODE(tvp); 327 *vpp = tvp; 328 ip = VTOI(tvp); 329 ip->i_state |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 330 ip->i_nlink = 1; 331 DIP_ASSIGN(ip, nlink, 1); 332 333 /* Authorize setting SGID if needed. */ 334 if (ip->i_mode & ISGID) { 335 error = kauth_authorize_vnode(cnp->cn_cred, 336 KAUTH_VNODE_WRITE_SECURITY, 337 tvp, NULL, genfs_can_chmod(tvp, cnp->cn_cred, ip->i_uid, 338 ip->i_gid, MAKEIMODE(vap->va_type, vap->va_mode))); 339 if (error) { 340 ip->i_mode &= ~ISGID; 341 DIP_ASSIGN(ip, mode, ip->i_mode); 342 } 343 } 344 345 if (cnp->cn_flags & ISWHITEOUT) { 346 ip->i_flags |= UF_OPAQUE; 347 DIP_ASSIGN(ip, flags, ip->i_flags); 348 } 349 350 /* 351 * Make sure inode goes to disk before directory entry. 352 */ 353 if ((error = lfs_update(tvp, NULL, NULL, UPDATE_DIROP)) != 0) 354 goto bad; 355 error = ulfs_direnter(dvp, ulr, tvp, 356 cnp, ip->i_number, LFS_IFTODT(ip->i_mode), NULL); 357 if (error) 358 goto bad; 359 *vpp = tvp; 360 cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags); 361 KASSERT(VOP_ISLOCKED(*vpp) == LK_EXCLUSIVE); 362 return (0); 363 364 bad: 365 /* 366 * Write error occurred trying to update the inode 367 * or the directory so must deallocate the inode. 368 */ 369 ip->i_nlink = 0; 370 DIP_ASSIGN(ip, nlink, 0); 371 ip->i_state |= IN_CHANGE; 372 /* If IN_ADIROP, account for it */ 373 UNMARK_VNODE(tvp); 374 vput(tvp); 375 return (error); 376 } 377 378 /* 379 * Synch an open file. 380 */ 381 /* ARGSUSED */ 382 int 383 lfs_fsync(void *v) 384 { 385 struct vop_fsync_args /* { 386 struct vnode *a_vp; 387 kauth_cred_t a_cred; 388 int a_flags; 389 off_t offlo; 390 off_t offhi; 391 } */ *ap = v; 392 struct vnode *vp = ap->a_vp; 393 int wait; 394 struct inode *ip = VTOI(vp); 395 struct lfs *fs = ip->i_lfs; 396 int error = 0; 397 398 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 399 400 /* If we're mounted read-only, don't try to sync. */ 401 if (fs->lfs_ronly) 402 goto out; 403 404 /* If a removed vnode is being cleaned, no need to sync here. */ 405 if ((ap->a_flags & FSYNC_RECLAIM) != 0 && ip->i_mode == 0) 406 goto out; 407 408 /* 409 * Trickle sync simply adds this vnode to the pager list, as if 410 * the pagedaemon had requested a pageout. 411 */ 412 if (ap->a_flags & FSYNC_LAZY) { 413 if (lfs_ignore_lazy_sync == 0) { 414 mutex_enter(&lfs_lock); 415 if (!(ip->i_state & IN_PAGING)) { 416 ip->i_state |= IN_PAGING; 417 TAILQ_INSERT_TAIL(&fs->lfs_pchainhd, ip, 418 i_lfs_pchain); 419 } 420 cv_broadcast(&lfs_writerd_cv); 421 mutex_exit(&lfs_lock); 422 } 423 goto out; 424 } 425 426 /* 427 * If a vnode is being cleaned, flush it out before we try to 428 * reuse it. This prevents the cleaner from writing files twice 429 * in the same partial segment, causing an accounting underflow. 430 */ 431 if (ap->a_flags & FSYNC_RECLAIM && ip->i_state & IN_CLEANING) { 432 lfs_vflush(vp); 433 } 434 435 wait = (ap->a_flags & FSYNC_WAIT); 436 do { 437 rw_enter(vp->v_uobj.vmobjlock, RW_WRITER); 438 error = VOP_PUTPAGES(vp, trunc_page(ap->a_offlo), 439 round_page(ap->a_offhi), 440 PGO_CLEANIT | (wait ? PGO_SYNCIO : 0)); 441 if (error == EAGAIN) { 442 mutex_enter(&lfs_lock); 443 mtsleep(&fs->lfs_availsleep, PCATCH | PUSER, 444 "lfs_fsync", hz / 100 + 1, &lfs_lock); 445 mutex_exit(&lfs_lock); 446 } 447 } while (error == EAGAIN); 448 if (error) 449 goto out; 450 451 if ((ap->a_flags & FSYNC_DATAONLY) == 0) 452 error = lfs_update(vp, NULL, NULL, wait ? UPDATE_WAIT : 0); 453 454 if (error == 0 && ap->a_flags & FSYNC_CACHE) { 455 int l = 0; 456 error = VOP_IOCTL(ip->i_devvp, DIOCCACHESYNC, &l, FWRITE, 457 curlwp->l_cred); 458 } 459 if (wait && !VPISEMPTY(vp)) 460 LFS_SET_UINO(ip, IN_MODIFIED); 461 462 out: 463 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 464 return error; 465 } 466 467 /* 468 * Take IN_ADIROP off, then call ulfs_inactive. 469 */ 470 int 471 lfs_inactive(void *v) 472 { 473 struct vop_inactive_v2_args /* { 474 struct vnode *a_vp; 475 bool *a_recycle; 476 } */ *ap = v; 477 478 KASSERT(VOP_ISLOCKED(ap->a_vp) == LK_EXCLUSIVE); 479 480 UNMARK_VNODE(ap->a_vp); 481 482 /* 483 * The Ifile is only ever inactivated on unmount. 484 * Streamline this process by not giving it more dirty blocks. 485 */ 486 if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM) { 487 mutex_enter(&lfs_lock); 488 LFS_CLR_UINO(VTOI(ap->a_vp), IN_ALLMOD); 489 mutex_exit(&lfs_lock); 490 return 0; 491 } 492 493 #ifdef DEBUG 494 /* 495 * This might happen on unmount. 496 * XXX If it happens at any other time, it should be a panic. 497 */ 498 if (ap->a_vp->v_uflag & VU_DIROP) { 499 struct inode *ip = VTOI(ap->a_vp); 500 printf("lfs_inactive: inactivating VU_DIROP? ino = %llu\n", 501 (unsigned long long) ip->i_number); 502 } 503 #endif /* DIAGNOSTIC */ 504 505 return ulfs_inactive(v); 506 } 507 508 int 509 lfs_set_dirop(struct vnode *dvp, struct vnode *vp) 510 { 511 struct lfs *fs; 512 int error; 513 514 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 515 KASSERT(vp == NULL || VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 516 517 fs = VTOI(dvp)->i_lfs; 518 519 ASSERT_NO_SEGLOCK(fs); 520 /* 521 * LFS_NRESERVE calculates direct and indirect blocks as well 522 * as an inode block; an overestimate in most cases. 523 */ 524 if ((error = lfs_reserve(fs, dvp, vp, LFS_NRESERVE(fs))) != 0) 525 return (error); 526 527 restart: 528 mutex_enter(&lfs_lock); 529 if (fs->lfs_dirops == 0) { 530 mutex_exit(&lfs_lock); 531 lfs_check(dvp, LFS_UNUSED_LBN, 0); 532 mutex_enter(&lfs_lock); 533 } 534 while (fs->lfs_writer) { 535 error = cv_wait_sig(&fs->lfs_diropscv, &lfs_lock); 536 if (error == EINTR) { 537 mutex_exit(&lfs_lock); 538 goto unreserve; 539 } 540 } 541 if (lfs_dirvcount > LFS_MAX_DIROP && fs->lfs_dirops == 0) { 542 cv_broadcast(&lfs_writerd_cv); 543 mutex_exit(&lfs_lock); 544 preempt(); 545 goto restart; 546 } 547 548 if (lfs_dirvcount > LFS_MAX_DIROP) { 549 DLOG((DLOG_DIROP, "lfs_set_dirop: sleeping with dirops=%d, " 550 "dirvcount=%d\n", fs->lfs_dirops, lfs_dirvcount)); 551 if ((error = mtsleep(&lfs_dirvcount, 552 PCATCH | PUSER | PNORELOCK, "lfs_maxdirop", 0, 553 &lfs_lock)) != 0) { 554 mutex_exit(&lfs_lock); 555 goto unreserve; 556 } 557 mutex_exit(&lfs_lock); 558 goto restart; 559 } 560 561 ++fs->lfs_dirops; 562 /* fs->lfs_doifile = 1; */ /* XXX why? --ks */ 563 mutex_exit(&lfs_lock); 564 565 /* Hold a reference so SET_ENDOP will be happy */ 566 vref(dvp); 567 if (vp) { 568 vref(vp); 569 MARK_VNODE(vp); 570 } 571 572 MARK_VNODE(dvp); 573 return 0; 574 575 unreserve: 576 lfs_reserve(fs, dvp, vp, -LFS_NRESERVE(fs)); 577 return error; 578 } 579 580 /* 581 * Opposite of lfs_set_dirop... mostly. For now at least must call 582 * UNMARK_VNODE(dvp) explicitly first. (XXX: clean that up) 583 */ 584 void 585 lfs_unset_dirop(struct lfs *fs, struct vnode *dvp, const char *str) 586 { 587 mutex_enter(&lfs_lock); 588 --fs->lfs_dirops; 589 if (!fs->lfs_dirops) { 590 if (fs->lfs_nadirop) { 591 panic("lfs_unset_dirop: %s: no dirops but " 592 " nadirop=%d", str, 593 fs->lfs_nadirop); 594 } 595 wakeup(&fs->lfs_writer); 596 mutex_exit(&lfs_lock); 597 lfs_check(dvp, LFS_UNUSED_LBN, 0); 598 } else { 599 mutex_exit(&lfs_lock); 600 } 601 lfs_reserve(fs, dvp, NULL, -LFS_NRESERVE(fs)); 602 } 603 604 void 605 lfs_mark_vnode(struct vnode *vp) 606 { 607 struct inode *ip = VTOI(vp); 608 struct lfs *fs = ip->i_lfs; 609 610 mutex_enter(&lfs_lock); 611 if (!(ip->i_state & IN_ADIROP)) { 612 if (!(vp->v_uflag & VU_DIROP)) { 613 mutex_exit(&lfs_lock); 614 vref(vp); 615 mutex_enter(&lfs_lock); 616 ++lfs_dirvcount; 617 ++fs->lfs_dirvcount; 618 TAILQ_INSERT_TAIL(&fs->lfs_dchainhd, ip, i_lfs_dchain); 619 vp->v_uflag |= VU_DIROP; 620 } 621 ++fs->lfs_nadirop; 622 ip->i_state &= ~IN_CDIROP; 623 ip->i_state |= IN_ADIROP; 624 } else 625 KASSERT(vp->v_uflag & VU_DIROP); 626 mutex_exit(&lfs_lock); 627 } 628 629 void 630 lfs_unmark_vnode(struct vnode *vp) 631 { 632 struct inode *ip = VTOI(vp); 633 634 mutex_enter(&lfs_lock); 635 if (ip && (ip->i_state & IN_ADIROP)) { 636 KASSERT(vp->v_uflag & VU_DIROP); 637 --ip->i_lfs->lfs_nadirop; 638 ip->i_state &= ~IN_ADIROP; 639 } 640 mutex_exit(&lfs_lock); 641 } 642 643 int 644 lfs_symlink(void *v) 645 { 646 struct vop_symlink_v3_args /* { 647 struct vnode *a_dvp; 648 struct vnode **a_vpp; 649 struct componentname *a_cnp; 650 struct vattr *a_vap; 651 char *a_target; 652 } */ *ap = v; 653 struct lfs *fs; 654 struct vnode *dvp, **vpp; 655 struct inode *ip; 656 struct ulfs_lookup_results *ulr; 657 ssize_t len; /* XXX should be size_t */ 658 int error; 659 660 dvp = ap->a_dvp; 661 vpp = ap->a_vpp; 662 663 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 664 KASSERT(vpp != NULL); 665 KASSERT(*vpp == NULL); 666 KASSERT(ap->a_vap->va_type == VLNK); 667 668 /* XXX should handle this material another way */ 669 ulr = &VTOI(ap->a_dvp)->i_crap; 670 ULFS_CHECK_CRAPCOUNTER(VTOI(ap->a_dvp)); 671 672 fs = VFSTOULFS(dvp->v_mount)->um_lfs; 673 ASSERT_NO_SEGLOCK(fs); 674 if (fs->lfs_ronly) { 675 return EROFS; 676 } 677 678 error = lfs_set_dirop(dvp, NULL); 679 if (error) 680 return error; 681 682 error = lfs_makeinode(ap->a_vap, dvp, ulr, vpp, ap->a_cnp); 683 if (error) { 684 goto out; 685 } 686 KASSERT(VOP_ISLOCKED(*vpp) == LK_EXCLUSIVE); 687 688 ip = VTOI(*vpp); 689 690 /* 691 * This test is off by one. um_maxsymlinklen contains the 692 * number of bytes available, and we aren't storing a \0, so 693 * the test should properly be <=. However, it cannot be 694 * changed as this would break compatibility with existing fs 695 * images -- see the way ulfs_readlink() works. 696 */ 697 len = strlen(ap->a_target); 698 if (len < ip->i_lfs->um_maxsymlinklen) { 699 memcpy((char *)SHORTLINK(ip), ap->a_target, len); 700 ip->i_size = len; 701 DIP_ASSIGN(ip, size, len); 702 uvm_vnp_setsize(*vpp, ip->i_size); 703 ip->i_state |= IN_CHANGE | IN_UPDATE; 704 if ((*vpp)->v_mount->mnt_flag & MNT_RELATIME) 705 ip->i_state |= IN_ACCESS; 706 } else { 707 error = ulfs_bufio(UIO_WRITE, *vpp, ap->a_target, len, (off_t)0, 708 IO_NODELOCKED | IO_JOURNALLOCKED, ap->a_cnp->cn_cred, NULL, 709 NULL); 710 } 711 712 VOP_UNLOCK(*vpp); 713 if (error) 714 vrele(*vpp); 715 716 out: 717 UNMARK_VNODE(dvp); 718 /* XXX: is it even possible for the symlink to get MARK'd? */ 719 UNMARK_VNODE(*vpp); 720 if (error) { 721 *vpp = NULL; 722 } 723 lfs_unset_dirop(fs, dvp, "symlink"); 724 725 vrele(dvp); 726 return (error); 727 } 728 729 int 730 lfs_mknod(void *v) 731 { 732 struct vop_mknod_v3_args /* { 733 struct vnode *a_dvp; 734 struct vnode **a_vpp; 735 struct componentname *a_cnp; 736 struct vattr *a_vap; 737 } */ *ap = v; 738 struct lfs *fs; 739 struct vnode *dvp, **vpp; 740 struct vattr *vap; 741 struct inode *ip; 742 int error; 743 ino_t ino; 744 struct ulfs_lookup_results *ulr; 745 746 dvp = ap->a_dvp; 747 vpp = ap->a_vpp; 748 vap = ap->a_vap; 749 750 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 751 KASSERT(vpp != NULL); 752 KASSERT(*vpp == NULL); 753 754 /* XXX should handle this material another way */ 755 ulr = &VTOI(dvp)->i_crap; 756 ULFS_CHECK_CRAPCOUNTER(VTOI(dvp)); 757 758 fs = VFSTOULFS(dvp->v_mount)->um_lfs; 759 ASSERT_NO_SEGLOCK(fs); 760 if (fs->lfs_ronly) { 761 return EROFS; 762 } 763 764 error = lfs_set_dirop(dvp, NULL); 765 if (error) 766 return error; 767 768 error = lfs_makeinode(vap, dvp, ulr, vpp, ap->a_cnp); 769 770 /* Either way we're done with the dirop at this point */ 771 UNMARK_VNODE(dvp); 772 UNMARK_VNODE(*vpp); 773 lfs_unset_dirop(fs, dvp, "mknod"); 774 775 if (error) { 776 vrele(dvp); 777 *vpp = NULL; 778 return (error); 779 } 780 KASSERT(VOP_ISLOCKED(*vpp) == LK_EXCLUSIVE); 781 782 ip = VTOI(*vpp); 783 ino = ip->i_number; 784 ip->i_state |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 785 786 /* 787 * Call fsync to write the vnode so that we don't have to deal with 788 * flushing it when it's marked VU_DIROP or reclaiming. 789 * 790 * XXX KS - If we can't flush we also can't call vgone(), so must 791 * return. But, that leaves this vnode in limbo, also not good. 792 * Can this ever happen (barring hardware failure)? 793 */ 794 if ((error = VOP_FSYNC(*vpp, NOCRED, FSYNC_WAIT, 0, 0)) != 0) { 795 panic("lfs_mknod: couldn't fsync (ino %llu)", 796 (unsigned long long) ino); 797 /* return (error); */ 798 } 799 800 vrele(dvp); 801 KASSERT(error == 0); 802 VOP_UNLOCK(*vpp); 803 return (0); 804 } 805 806 /* 807 * Create a regular file 808 */ 809 int 810 lfs_create(void *v) 811 { 812 struct vop_create_v3_args /* { 813 struct vnode *a_dvp; 814 struct vnode **a_vpp; 815 struct componentname *a_cnp; 816 struct vattr *a_vap; 817 } */ *ap = v; 818 struct lfs *fs; 819 struct vnode *dvp, **vpp; 820 struct vattr *vap; 821 struct ulfs_lookup_results *ulr; 822 int error; 823 824 dvp = ap->a_dvp; 825 vpp = ap->a_vpp; 826 vap = ap->a_vap; 827 828 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 829 KASSERT(vpp != NULL); 830 KASSERT(*vpp == NULL); 831 832 /* XXX should handle this material another way */ 833 ulr = &VTOI(dvp)->i_crap; 834 ULFS_CHECK_CRAPCOUNTER(VTOI(dvp)); 835 836 fs = VFSTOULFS(dvp->v_mount)->um_lfs; 837 ASSERT_NO_SEGLOCK(fs); 838 if (fs->lfs_ronly) { 839 return EROFS; 840 } 841 842 error = lfs_set_dirop(dvp, NULL); 843 if (error) 844 return error; 845 846 error = lfs_makeinode(vap, dvp, ulr, vpp, ap->a_cnp); 847 if (error) { 848 goto out; 849 } 850 KASSERT(VOP_ISLOCKED(*vpp) == LK_EXCLUSIVE); 851 VOP_UNLOCK(*vpp); 852 853 out: 854 855 UNMARK_VNODE(dvp); 856 UNMARK_VNODE(*vpp); 857 if (error) { 858 *vpp = NULL; 859 } 860 lfs_unset_dirop(fs, dvp, "create"); 861 862 vrele(dvp); 863 return (error); 864 } 865 866 int 867 lfs_mkdir(void *v) 868 { 869 struct vop_mkdir_v3_args /* { 870 struct vnode *a_dvp; 871 struct vnode **a_vpp; 872 struct componentname *a_cnp; 873 struct vattr *a_vap; 874 } */ *ap = v; 875 struct lfs *fs; 876 struct vnode *dvp, *tvp, **vpp; 877 struct inode *dp, *ip; 878 struct componentname *cnp; 879 struct vattr *vap; 880 struct ulfs_lookup_results *ulr; 881 struct buf *bp; 882 LFS_DIRHEADER *dirp; 883 int dirblksiz; 884 int error; 885 886 dvp = ap->a_dvp; 887 tvp = NULL; 888 vpp = ap->a_vpp; 889 cnp = ap->a_cnp; 890 vap = ap->a_vap; 891 892 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 893 894 dp = VTOI(dvp); 895 ip = NULL; 896 897 KASSERT(vap->va_type == VDIR); 898 KASSERT(vpp != NULL); 899 KASSERT(*vpp == NULL); 900 901 /* XXX should handle this material another way */ 902 ulr = &dp->i_crap; 903 ULFS_CHECK_CRAPCOUNTER(dp); 904 905 fs = VFSTOULFS(dvp->v_mount)->um_lfs; 906 ASSERT_NO_SEGLOCK(fs); 907 if (fs->lfs_ronly) { 908 return EROFS; 909 } 910 911 if ((nlink_t)dp->i_nlink >= LINK_MAX) { 912 return EMLINK; 913 } 914 915 dirblksiz = fs->um_dirblksiz; 916 /* XXX dholland 20150911 I believe this to be true, but... */ 917 //KASSERT(dirblksiz == LFS_DIRBLKSIZ); 918 919 error = lfs_set_dirop(dvp, NULL); 920 if (error) 921 return error; 922 923 /* 924 * Must simulate part of lfs_makeinode here to acquire the inode, 925 * but not have it entered in the parent directory. The entry is 926 * made later after writing "." and ".." entries. 927 */ 928 error = vcache_new(dvp->v_mount, dvp, vap, cnp->cn_cred, NULL, 929 ap->a_vpp); 930 if (error) 931 goto out; 932 933 error = vn_lock(*ap->a_vpp, LK_EXCLUSIVE); 934 if (error) { 935 vrele(*ap->a_vpp); 936 *ap->a_vpp = NULL; 937 goto out; 938 } 939 940 tvp = *ap->a_vpp; 941 MARK_VNODE(tvp); 942 ip = VTOI(tvp); 943 ip->i_state |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 944 ip->i_nlink = 2; 945 DIP_ASSIGN(ip, nlink, 2); 946 if (cnp->cn_flags & ISWHITEOUT) { 947 ip->i_flags |= UF_OPAQUE; 948 DIP_ASSIGN(ip, flags, ip->i_flags); 949 } 950 951 /* 952 * Bump link count in parent directory to reflect work done below. 953 */ 954 dp->i_nlink++; 955 DIP_ASSIGN(dp, nlink, dp->i_nlink); 956 dp->i_state |= IN_CHANGE; 957 if ((error = lfs_update(dvp, NULL, NULL, UPDATE_DIROP)) != 0) 958 goto bad; 959 960 /* 961 * Initialize directory with "." and "..". This used to use a 962 * static template but that adds moving parts for very little 963 * benefit. 964 */ 965 if ((error = lfs_balloc(tvp, (off_t)0, dirblksiz, cnp->cn_cred, 966 B_CLRBUF, &bp)) != 0) 967 goto bad; 968 ip->i_size = dirblksiz; 969 DIP_ASSIGN(ip, size, dirblksiz); 970 ip->i_state |= IN_ACCESS | IN_CHANGE | IN_UPDATE; 971 uvm_vnp_setsize(tvp, ip->i_size); 972 dirp = bp->b_data; 973 974 /* . */ 975 lfs_dir_setino(fs, dirp, ip->i_number); 976 lfs_dir_setreclen(fs, dirp, LFS_DIRECTSIZ(fs, 1)); 977 lfs_dir_settype(fs, dirp, LFS_DT_DIR); 978 lfs_dir_setnamlen(fs, dirp, 1); 979 lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), ".", 1, 980 LFS_DIRECTSIZ(fs, 1)); 981 dirp = LFS_NEXTDIR(fs, dirp); 982 /* .. */ 983 lfs_dir_setino(fs, dirp, dp->i_number); 984 lfs_dir_setreclen(fs, dirp, dirblksiz - LFS_DIRECTSIZ(fs, 1)); 985 lfs_dir_settype(fs, dirp, LFS_DT_DIR); 986 lfs_dir_setnamlen(fs, dirp, 2); 987 lfs_copydirname(fs, lfs_dir_nameptr(fs, dirp), "..", 2, 988 dirblksiz - LFS_DIRECTSIZ(fs, 1)); 989 990 /* 991 * Directory set up; now install its entry in the parent directory. 992 */ 993 if ((error = VOP_BWRITE(bp->b_vp, bp)) != 0) 994 goto bad; 995 if ((error = lfs_update(tvp, NULL, NULL, UPDATE_DIROP)) != 0) { 996 goto bad; 997 } 998 error = ulfs_direnter(dvp, ulr, tvp, 999 cnp, ip->i_number, LFS_IFTODT(ip->i_mode), bp); 1000 bad: 1001 if (error == 0) { 1002 VOP_UNLOCK(tvp); 1003 } else { 1004 dp->i_nlink--; 1005 DIP_ASSIGN(dp, nlink, dp->i_nlink); 1006 dp->i_state |= IN_CHANGE; 1007 /* 1008 * No need to do an explicit lfs_truncate here, vrele will 1009 * do this for us because we set the link count to 0. 1010 */ 1011 ip->i_nlink = 0; 1012 DIP_ASSIGN(ip, nlink, 0); 1013 ip->i_state |= IN_CHANGE; 1014 /* If IN_ADIROP, account for it */ 1015 UNMARK_VNODE(tvp); 1016 vput(tvp); 1017 } 1018 1019 out: 1020 UNMARK_VNODE(dvp); 1021 UNMARK_VNODE(*vpp); 1022 if (error) { 1023 *vpp = NULL; 1024 } 1025 lfs_unset_dirop(fs, dvp, "mkdir"); 1026 1027 vrele(dvp); 1028 return (error); 1029 } 1030 1031 int 1032 lfs_remove(void *v) 1033 { 1034 struct vop_remove_v3_args /* { 1035 struct vnode *a_dvp; 1036 struct vnode *a_vp; 1037 struct componentname *a_cnp; 1038 nlink_t ctx_vp_new_nlink; 1039 } */ *ap = v; 1040 struct vnode *dvp, *vp; 1041 struct inode *ip; 1042 int error; 1043 1044 dvp = ap->a_dvp; 1045 vp = ap->a_vp; 1046 1047 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 1048 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 1049 1050 ip = VTOI(vp); 1051 if ((error = lfs_set_dirop(dvp, vp)) != 0) { 1052 if (dvp == vp) 1053 vrele(vp); 1054 else 1055 vput(vp); 1056 return error; 1057 } 1058 error = ulfs_remove(ap); 1059 if (ip->i_nlink == 0) 1060 lfs_orphan(ip->i_lfs, ip->i_number); 1061 1062 UNMARK_VNODE(dvp); 1063 if (ap->a_vp) { 1064 UNMARK_VNODE(ap->a_vp); 1065 } 1066 lfs_unset_dirop(ip->i_lfs, dvp, "remove"); 1067 vrele(dvp); 1068 if (ap->a_vp) { 1069 vrele(ap->a_vp); 1070 } 1071 1072 return (error); 1073 } 1074 1075 int 1076 lfs_rmdir(void *v) 1077 { 1078 struct vop_rmdir_v2_args /* { 1079 struct vnodeop_desc *a_desc; 1080 struct vnode *a_dvp; 1081 struct vnode *a_vp; 1082 struct componentname *a_cnp; 1083 } */ *ap = v; 1084 struct vnode *vp; 1085 struct inode *ip; 1086 int error; 1087 1088 vp = ap->a_vp; 1089 1090 KASSERT(VOP_ISLOCKED(ap->a_dvp) == LK_EXCLUSIVE); 1091 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 1092 1093 ip = VTOI(vp); 1094 if ((error = lfs_set_dirop(ap->a_dvp, ap->a_vp)) != 0) { 1095 if (ap->a_dvp == vp) 1096 vrele(vp); 1097 else 1098 vput(vp); 1099 return error; 1100 } 1101 error = ulfs_rmdir(ap); 1102 if (ip->i_nlink == 0) 1103 lfs_orphan(ip->i_lfs, ip->i_number); 1104 1105 UNMARK_VNODE(ap->a_dvp); 1106 if (ap->a_vp) { 1107 UNMARK_VNODE(ap->a_vp); 1108 } 1109 lfs_unset_dirop(ip->i_lfs, ap->a_dvp, "rmdir"); 1110 vrele(ap->a_dvp); 1111 if (ap->a_vp) { 1112 vrele(ap->a_vp); 1113 } 1114 1115 return (error); 1116 } 1117 1118 int 1119 lfs_link(void *v) 1120 { 1121 struct vop_link_v2_args /* { 1122 struct vnode *a_dvp; 1123 struct vnode *a_vp; 1124 struct componentname *a_cnp; 1125 } */ *ap = v; 1126 struct lfs *fs; 1127 struct vnode *dvp; 1128 int error; 1129 1130 dvp = ap->a_dvp; 1131 1132 KASSERT(VOP_ISLOCKED(dvp) == LK_EXCLUSIVE); 1133 1134 fs = VFSTOULFS(dvp->v_mount)->um_lfs; 1135 ASSERT_NO_SEGLOCK(fs); 1136 if (fs->lfs_ronly) { 1137 return EROFS; 1138 } 1139 1140 error = lfs_set_dirop(dvp, NULL); 1141 if (error) { 1142 return error; 1143 } 1144 1145 error = ulfs_link(ap); 1146 1147 UNMARK_VNODE(dvp); 1148 lfs_unset_dirop(fs, dvp, "link"); 1149 vrele(dvp); 1150 1151 return (error); 1152 } 1153 1154 /* XXX hack to avoid calling ITIMES in getattr */ 1155 int 1156 lfs_getattr(void *v) 1157 { 1158 struct vop_getattr_args /* { 1159 struct vnode *a_vp; 1160 struct vattr *a_vap; 1161 kauth_cred_t a_cred; 1162 } */ *ap = v; 1163 struct vnode *vp = ap->a_vp; 1164 struct inode *ip; 1165 struct vattr *vap = ap->a_vap; 1166 struct lfs *fs; 1167 1168 KASSERT(VOP_ISLOCKED(vp)); 1169 1170 ip = VTOI(vp); 1171 fs = ip->i_lfs; 1172 1173 /* 1174 * Copy from inode table 1175 */ 1176 vap->va_fsid = ip->i_dev; 1177 vap->va_fileid = ip->i_number; 1178 vap->va_mode = ip->i_mode & ~LFS_IFMT; 1179 vap->va_nlink = ip->i_nlink; 1180 vap->va_uid = ip->i_uid; 1181 vap->va_gid = ip->i_gid; 1182 switch (vp->v_type) { 1183 case VBLK: 1184 case VCHR: 1185 vap->va_rdev = (dev_t)lfs_dino_getrdev(fs, ip->i_din); 1186 break; 1187 default: 1188 vap->va_rdev = NODEV; 1189 break; 1190 } 1191 vap->va_size = vp->v_size; 1192 vap->va_atime.tv_sec = lfs_dino_getatime(fs, ip->i_din); 1193 vap->va_atime.tv_nsec = lfs_dino_getatimensec(fs, ip->i_din); 1194 vap->va_mtime.tv_sec = lfs_dino_getmtime(fs, ip->i_din); 1195 vap->va_mtime.tv_nsec = lfs_dino_getmtimensec(fs, ip->i_din); 1196 vap->va_ctime.tv_sec = lfs_dino_getctime(fs, ip->i_din); 1197 vap->va_ctime.tv_nsec = lfs_dino_getctimensec(fs, ip->i_din); 1198 vap->va_flags = ip->i_flags; 1199 vap->va_gen = ip->i_gen; 1200 /* this doesn't belong here */ 1201 if (vp->v_type == VBLK) 1202 vap->va_blocksize = BLKDEV_IOSIZE; 1203 else if (vp->v_type == VCHR) 1204 vap->va_blocksize = MAXBSIZE; 1205 else 1206 vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize; 1207 vap->va_bytes = lfs_fsbtob(fs, ip->i_lfs_effnblks); 1208 vap->va_type = vp->v_type; 1209 vap->va_filerev = ip->i_modrev; 1210 return (0); 1211 } 1212 1213 /* 1214 * Check to make sure the inode blocks won't choke the buffer 1215 * cache, then call ulfs_setattr as usual. 1216 */ 1217 int 1218 lfs_setattr(void *v) 1219 { 1220 struct vop_setattr_args /* { 1221 struct vnode *a_vp; 1222 struct vattr *a_vap; 1223 kauth_cred_t a_cred; 1224 } */ *ap = v; 1225 struct vnode *vp = ap->a_vp; 1226 1227 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 1228 lfs_check(vp, LFS_UNUSED_LBN, 0); 1229 return ulfs_setattr(v); 1230 } 1231 1232 /* 1233 * Release the block we hold on lfs_newseg wrapping. Called on file close, 1234 * or explicitly from LFCNWRAPGO. Called with the interlock held. 1235 */ 1236 static int 1237 lfs_wrapgo(struct lfs *fs, struct inode *ip, int waitfor) 1238 { 1239 if (fs->lfs_stoplwp != curlwp) 1240 return EBUSY; 1241 1242 fs->lfs_stoplwp = NULL; 1243 cv_signal(&fs->lfs_stopcv); 1244 1245 KASSERT(fs->lfs_nowrap > 0); 1246 if (fs->lfs_nowrap <= 0) { 1247 return 0; 1248 } 1249 1250 if (--fs->lfs_nowrap == 0) { 1251 log(LOG_NOTICE, "%s: re-enabled log wrap\n", 1252 lfs_sb_getfsmnt(fs)); 1253 wakeup(&fs->lfs_wrappass); 1254 lfs_wakeup_cleaner(fs); 1255 } 1256 if (waitfor) { 1257 cv_wait_sig(&fs->lfs_nextsegsleep, &lfs_lock); 1258 } 1259 1260 return 0; 1261 } 1262 1263 /* 1264 * Close called. 1265 * 1266 * Update the times on the inode. 1267 */ 1268 /* ARGSUSED */ 1269 int 1270 lfs_close(void *v) 1271 { 1272 struct vop_close_args /* { 1273 struct vnode *a_vp; 1274 int a_fflag; 1275 kauth_cred_t a_cred; 1276 } */ *ap = v; 1277 struct vnode *vp = ap->a_vp; 1278 struct inode *ip; 1279 struct lfs *fs; 1280 1281 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 1282 1283 ip = VTOI(vp); 1284 fs = ip->i_lfs; 1285 1286 if ((ip->i_number == ULFS_ROOTINO || ip->i_number == LFS_IFILE_INUM) && 1287 fs->lfs_stoplwp == curlwp) { 1288 mutex_enter(&lfs_lock); 1289 log(LOG_NOTICE, "lfs_close: releasing log wrap control\n"); 1290 lfs_wrapgo(fs, ip, 0); 1291 mutex_exit(&lfs_lock); 1292 } 1293 1294 if (vp == ip->i_lfs->lfs_ivnode && 1295 vp->v_mount->mnt_iflag & IMNT_UNMOUNT) 1296 return 0; 1297 1298 if (vrefcnt(vp) > 1 && vp != ip->i_lfs->lfs_ivnode) { 1299 LFS_ITIMES(ip, NULL, NULL, NULL); 1300 } 1301 return (0); 1302 } 1303 1304 /* 1305 * Close wrapper for special devices. 1306 * 1307 * Update the times on the inode then do device close. 1308 */ 1309 int 1310 lfsspec_close(void *v) 1311 { 1312 struct vop_close_args /* { 1313 struct vnode *a_vp; 1314 int a_fflag; 1315 kauth_cred_t a_cred; 1316 } */ *ap = v; 1317 struct vnode *vp; 1318 struct inode *ip; 1319 1320 vp = ap->a_vp; 1321 1322 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 1323 1324 ip = VTOI(vp); 1325 if (vrefcnt(vp) > 1) { 1326 LFS_ITIMES(ip, NULL, NULL, NULL); 1327 } 1328 return (VOCALL (spec_vnodeop_p, VOFFSET(vop_close), ap)); 1329 } 1330 1331 /* 1332 * Close wrapper for fifo's. 1333 * 1334 * Update the times on the inode then do device close. 1335 */ 1336 int 1337 lfsfifo_close(void *v) 1338 { 1339 struct vop_close_args /* { 1340 struct vnode *a_vp; 1341 int a_fflag; 1342 kauth_cred_ a_cred; 1343 } */ *ap = v; 1344 struct vnode *vp; 1345 struct inode *ip; 1346 1347 vp = ap->a_vp; 1348 1349 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 1350 1351 ip = VTOI(vp); 1352 if (vrefcnt(ap->a_vp) > 1) { 1353 LFS_ITIMES(ip, NULL, NULL, NULL); 1354 } 1355 return (VOCALL (fifo_vnodeop_p, VOFFSET(vop_close), ap)); 1356 } 1357 1358 /* 1359 * Reclaim an inode so that it can be used for other purposes. 1360 */ 1361 1362 int 1363 lfs_reclaim(void *v) 1364 { 1365 struct vop_reclaim_v2_args /* { 1366 struct vnode *a_vp; 1367 } */ *ap = v; 1368 struct vnode *vp = ap->a_vp; 1369 struct inode *ip; 1370 struct lfs *fs; 1371 int error; 1372 1373 VOP_UNLOCK(vp); 1374 1375 ip = VTOI(vp); 1376 fs = ip->i_lfs; 1377 1378 /* 1379 * The inode must be freed and updated before being removed 1380 * from its hash chain. Other threads trying to gain a hold 1381 * or lock on the inode will be stalled. 1382 */ 1383 if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) 1384 lfs_vfree(vp, ip->i_number, ip->i_omode); 1385 1386 mutex_enter(&lfs_lock); 1387 LFS_CLR_UINO(ip, IN_ALLMOD); 1388 mutex_exit(&lfs_lock); 1389 if ((error = ulfs_reclaim(vp))) 1390 return (error); 1391 1392 /* 1393 * Take us off the paging and/or dirop queues if we were on them. 1394 * We shouldn't be on them. 1395 */ 1396 mutex_enter(&lfs_lock); 1397 if (ip->i_state & IN_PAGING) { 1398 log(LOG_WARNING, "%s: reclaimed vnode is IN_PAGING\n", 1399 lfs_sb_getfsmnt(fs)); 1400 ip->i_state &= ~IN_PAGING; 1401 TAILQ_REMOVE(&fs->lfs_pchainhd, ip, i_lfs_pchain); 1402 } 1403 if (vp->v_uflag & VU_DIROP) 1404 panic("reclaimed vnode is VU_DIROP"); 1405 mutex_exit(&lfs_lock); 1406 1407 pool_put(&lfs_dinode_pool, ip->i_din); 1408 lfs_deregister_all(vp); 1409 pool_put(&lfs_inoext_pool, ip->inode_ext.lfs); 1410 ip->inode_ext.lfs = NULL; 1411 genfs_node_destroy(vp); 1412 pool_put(&lfs_inode_pool, vp->v_data); 1413 vp->v_data = NULL; 1414 return (0); 1415 } 1416 1417 /* 1418 * Read a block from a storage device. 1419 * 1420 * Calculate the logical to physical mapping if not done already, 1421 * then call the device strategy routine. 1422 * 1423 * In order to avoid reading blocks that are in the process of being 1424 * written by the cleaner---and hence are not mutexed by the normal 1425 * buffer cache / page cache mechanisms---check for collisions before 1426 * reading. 1427 * 1428 * We inline ulfs_strategy to make sure that the VOP_BMAP occurs *before* 1429 * the active cleaner test. 1430 * 1431 * XXX This code assumes that lfs_markv makes synchronous checkpoints. 1432 */ 1433 int 1434 lfs_strategy(void *v) 1435 { 1436 struct vop_strategy_args /* { 1437 struct vnode *a_vp; 1438 struct buf *a_bp; 1439 } */ *ap = v; 1440 struct buf *bp; 1441 struct lfs *fs; 1442 struct vnode *vp; 1443 struct inode *ip; 1444 daddr_t tbn; 1445 #define MAXLOOP 25 1446 int i, sn, error, slept, loopcount; 1447 1448 bp = ap->a_bp; 1449 vp = ap->a_vp; 1450 ip = VTOI(vp); 1451 fs = ip->i_lfs; 1452 1453 /* lfs uses its strategy routine only for read */ 1454 KASSERT(bp->b_flags & B_READ); 1455 1456 if (vp->v_type == VBLK || vp->v_type == VCHR) 1457 panic("lfs_strategy: spec"); 1458 KASSERT(bp->b_bcount != 0); 1459 if (bp->b_blkno == bp->b_lblkno) { 1460 error = VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, 1461 NULL); 1462 if (error) { 1463 bp->b_error = error; 1464 bp->b_resid = bp->b_bcount; 1465 biodone(bp); 1466 return (error); 1467 } 1468 if ((long)bp->b_blkno == -1) /* no valid data */ 1469 clrbuf(bp); 1470 } 1471 if ((long)bp->b_blkno < 0) { /* block is not on disk */ 1472 bp->b_resid = bp->b_bcount; 1473 biodone(bp); 1474 return (0); 1475 } 1476 1477 slept = 1; 1478 loopcount = 0; 1479 mutex_enter(&lfs_lock); 1480 while (slept && fs->lfs_seglock) { 1481 mutex_exit(&lfs_lock); 1482 /* 1483 * Look through list of intervals. 1484 * There will only be intervals to look through 1485 * if the cleaner holds the seglock. 1486 * Since the cleaner is synchronous, we can trust 1487 * the list of intervals to be current. 1488 */ 1489 tbn = LFS_DBTOFSB(fs, bp->b_blkno); 1490 sn = lfs_dtosn(fs, tbn); 1491 slept = 0; 1492 for (i = 0; i < fs->lfs_cleanind; i++) { 1493 if (sn == lfs_dtosn(fs, fs->lfs_cleanint[i]) && 1494 tbn >= fs->lfs_cleanint[i]) { 1495 DLOG((DLOG_CLEAN, 1496 "lfs_strategy: ino %llu lbn %" PRId64 1497 " ind %d sn %d fsb %" PRIx64 1498 " given sn %d fsb %" PRIx64 "\n", 1499 (unsigned long long) ip->i_number, 1500 bp->b_lblkno, i, 1501 lfs_dtosn(fs, fs->lfs_cleanint[i]), 1502 fs->lfs_cleanint[i], sn, tbn)); 1503 DLOG((DLOG_CLEAN, 1504 "lfs_strategy: sleeping on ino %llu lbn %" 1505 PRId64 "\n", 1506 (unsigned long long) ip->i_number, 1507 bp->b_lblkno)); 1508 mutex_enter(&lfs_lock); 1509 if (LFS_SEGLOCK_HELD(fs) && fs->lfs_iocount) { 1510 /* 1511 * Cleaner can't wait for itself. 1512 * Instead, wait for the blocks 1513 * to be written to disk. 1514 * XXX we need pribio in the test 1515 * XXX here. 1516 */ 1517 mtsleep(&fs->lfs_iocount, 1518 (PRIBIO + 1) | PNORELOCK, 1519 "clean2", hz/10 + 1, 1520 &lfs_lock); 1521 slept = 1; 1522 ++loopcount; 1523 break; 1524 } else if (fs->lfs_seglock) { 1525 mtsleep(&fs->lfs_seglock, 1526 (PRIBIO + 1) | PNORELOCK, 1527 "clean1", 0, 1528 &lfs_lock); 1529 slept = 1; 1530 break; 1531 } 1532 mutex_exit(&lfs_lock); 1533 } 1534 } 1535 mutex_enter(&lfs_lock); 1536 if (loopcount > MAXLOOP) { 1537 printf("lfs_strategy: breaking out of clean2 loop\n"); 1538 break; 1539 } 1540 } 1541 mutex_exit(&lfs_lock); 1542 1543 vp = ip->i_devvp; 1544 return VOP_STRATEGY(vp, bp); 1545 } 1546 1547 /* 1548 * Inline lfs_segwrite/lfs_writevnodes, but just for dirops. 1549 * Technically this is a checkpoint (the on-disk state is valid) 1550 * even though we are leaving out all the file data. 1551 */ 1552 int 1553 lfs_flush_dirops(struct lfs *fs) 1554 { 1555 struct inode *ip, *marker; 1556 struct vnode *vp; 1557 extern int lfs_dostats; /* XXX this does not belong here */ 1558 struct segment *sp; 1559 SEGSUM *ssp; 1560 int flags = 0; 1561 int error = 0; 1562 1563 ASSERT_MAYBE_SEGLOCK(fs); 1564 KASSERT(fs->lfs_nadirop == 0); /* stable during lfs_writer */ 1565 KASSERT(fs->lfs_dirops == 0); /* stable during lfs_writer */ 1566 1567 if (fs->lfs_ronly) 1568 return EROFS; 1569 1570 mutex_enter(&lfs_lock); 1571 if (TAILQ_FIRST(&fs->lfs_dchainhd) == NULL) { 1572 mutex_exit(&lfs_lock); 1573 return 0; 1574 } else 1575 mutex_exit(&lfs_lock); 1576 1577 if (lfs_dostats) 1578 ++lfs_stats.flush_invoked; 1579 1580 marker = pool_get(&lfs_inode_pool, PR_WAITOK); 1581 memset(marker, 0, sizeof(*marker)); 1582 marker->inode_ext.lfs = pool_get(&lfs_inoext_pool, PR_WAITOK); 1583 memset(marker->inode_ext.lfs, 0, sizeof(*marker->inode_ext.lfs)); 1584 marker->i_state = IN_MARKER; 1585 1586 lfs_imtime(fs); 1587 lfs_seglock(fs, flags); 1588 sp = fs->lfs_sp; 1589 1590 /* 1591 * lfs_writevnodes, optimized to get dirops out of the way. 1592 * Only write dirops, and don't flush files' pages, only 1593 * blocks from the directories. 1594 * 1595 * We don't need to vref these files because they are 1596 * dirops and so hold an extra reference until the 1597 * segunlock clears them of that status. 1598 * 1599 * We don't need to check for IN_ADIROP because we know that 1600 * no dirops are active. 1601 * 1602 */ 1603 mutex_enter(&lfs_lock); 1604 KASSERT(fs->lfs_writer); 1605 TAILQ_INSERT_HEAD(&fs->lfs_dchainhd, marker, i_lfs_dchain); 1606 while ((ip = TAILQ_NEXT(marker, i_lfs_dchain)) != NULL) { 1607 TAILQ_REMOVE(&fs->lfs_dchainhd, marker, i_lfs_dchain); 1608 TAILQ_INSERT_AFTER(&fs->lfs_dchainhd, ip, marker, 1609 i_lfs_dchain); 1610 if (ip->i_state & IN_MARKER) 1611 continue; 1612 vp = ITOV(ip); 1613 1614 /* 1615 * Prevent the vnode from going away if it's just been 1616 * put out in the segment and lfs_unmark_dirop is about 1617 * to release it. While it is on the list it is always 1618 * referenced, so it cannot be reclaimed until we 1619 * release it. 1620 */ 1621 vref(vp); 1622 1623 /* 1624 * Since we hold lfs_writer, the node can't be in an 1625 * active dirop. Since it's on the list and we hold a 1626 * reference to it, it can't be reclaimed now. 1627 */ 1628 KASSERT((ip->i_state & IN_ADIROP) == 0); 1629 KASSERT(vp->v_uflag & VU_DIROP); 1630 1631 /* 1632 * After we release lfs_lock, if we were in the middle 1633 * of writing a segment, lfs_unmark_dirop may end up 1634 * clearing VU_DIROP, and we have no way to stop it. 1635 * That should be OK -- we'll just have less to do 1636 * here. 1637 */ 1638 mutex_exit(&lfs_lock); 1639 1640 /* 1641 * All writes to directories come from dirops; all 1642 * writes to files' direct blocks go through the page 1643 * cache, which we're not touching. Reads to files 1644 * and/or directories will not be affected by writing 1645 * directory blocks inodes and file inodes. So we don't 1646 * really need to lock. 1647 */ 1648 if (vp->v_type != VREG && 1649 ((ip->i_state & IN_ALLMOD) || !VPISEMPTY(vp))) { 1650 error = lfs_writefile(fs, sp, vp); 1651 if (!VPISEMPTY(vp) && !WRITEINPROG(vp) && 1652 !(ip->i_state & IN_ALLMOD)) { 1653 mutex_enter(&lfs_lock); 1654 LFS_SET_UINO(ip, IN_MODIFIED); 1655 mutex_exit(&lfs_lock); 1656 } 1657 if (error && (sp->seg_flags & SEGM_SINGLE)) { 1658 vrele(vp); 1659 mutex_enter(&lfs_lock); 1660 error = EAGAIN; 1661 break; 1662 } 1663 } 1664 KASSERT(ip->i_number != LFS_IFILE_INUM); 1665 error = lfs_writeinode(fs, sp, ip); 1666 if (error && (sp->seg_flags & SEGM_SINGLE)) { 1667 vrele(vp); 1668 mutex_enter(&lfs_lock); 1669 error = EAGAIN; 1670 break; 1671 } 1672 1673 /* 1674 * We might need to update these inodes again, 1675 * for example, if they have data blocks to write. 1676 * Make sure that after this flush, they are still 1677 * marked IN_MODIFIED so that we don't forget to 1678 * write them. 1679 */ 1680 /* XXX only for non-directories? --KS */ 1681 mutex_enter(&lfs_lock); 1682 LFS_SET_UINO(ip, IN_MODIFIED); 1683 mutex_exit(&lfs_lock); 1684 1685 vrele(vp); 1686 mutex_enter(&lfs_lock); 1687 } 1688 TAILQ_REMOVE(&fs->lfs_dchainhd, marker, i_lfs_dchain); 1689 mutex_exit(&lfs_lock); 1690 1691 /* We've written all the dirops there are */ 1692 ssp = (SEGSUM *)sp->segsum; 1693 lfs_ss_setflags(fs, ssp, lfs_ss_getflags(fs, ssp) & ~(SS_CONT)); 1694 lfs_finalize_fs_seguse(fs); 1695 (void) lfs_writeseg(fs, sp); 1696 lfs_segunlock(fs); 1697 1698 pool_put(&lfs_inoext_pool, marker->inode_ext.lfs); 1699 pool_put(&lfs_inode_pool, marker); 1700 1701 return error; 1702 } 1703 1704 /* 1705 * Flush all vnodes for which the pagedaemon has requested pageouts. 1706 * Skip over any files that are marked VU_DIROP (since lfs_flush_dirop() 1707 * has just run, this would be an error). If we have to skip a vnode 1708 * for any reason, just skip it; if we have to wait for the cleaner, 1709 * abort. The writer daemon will call us again later. 1710 */ 1711 int 1712 lfs_flush_pchain(struct lfs *fs) 1713 { 1714 struct inode *ip, *nip; 1715 struct vnode *vp; 1716 extern int lfs_dostats; 1717 struct segment *sp; 1718 int error, error2; 1719 1720 ASSERT_NO_SEGLOCK(fs); 1721 KASSERT(fs->lfs_writer); 1722 1723 if (fs->lfs_ronly) 1724 return EROFS; 1725 1726 mutex_enter(&lfs_lock); 1727 if (TAILQ_FIRST(&fs->lfs_pchainhd) == NULL) { 1728 mutex_exit(&lfs_lock); 1729 return 0; 1730 } else 1731 mutex_exit(&lfs_lock); 1732 1733 /* Get dirops out of the way */ 1734 if ((error = lfs_flush_dirops(fs)) != 0) 1735 return error; 1736 1737 if (lfs_dostats) 1738 ++lfs_stats.flush_invoked; 1739 1740 /* 1741 * Inline lfs_segwrite/lfs_writevnodes, but just for pageouts. 1742 */ 1743 lfs_imtime(fs); 1744 lfs_seglock(fs, 0); 1745 sp = fs->lfs_sp; 1746 1747 /* 1748 * lfs_writevnodes, optimized to clear pageout requests. 1749 * Only write non-dirop files that are in the pageout queue. 1750 * We're very conservative about what we write; we want to be 1751 * fast and async. 1752 */ 1753 mutex_enter(&lfs_lock); 1754 top: 1755 for (ip = TAILQ_FIRST(&fs->lfs_pchainhd); ip != NULL; ip = nip) { 1756 struct mount *mp = ITOV(ip)->v_mount; 1757 ino_t ino = ip->i_number; 1758 1759 nip = TAILQ_NEXT(ip, i_lfs_pchain); 1760 1761 if (!(ip->i_state & IN_PAGING)) 1762 goto top; 1763 1764 mutex_exit(&lfs_lock); 1765 if (vcache_get(mp, &ino, sizeof(ino), &vp) != 0) { 1766 mutex_enter(&lfs_lock); 1767 continue; 1768 }; 1769 if (vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT) != 0) { 1770 vrele(vp); 1771 mutex_enter(&lfs_lock); 1772 continue; 1773 } 1774 ip = VTOI(vp); 1775 mutex_enter(&lfs_lock); 1776 if ((vp->v_uflag & VU_DIROP) != 0 || vp->v_type != VREG || 1777 !(ip->i_state & IN_PAGING)) { 1778 mutex_exit(&lfs_lock); 1779 vput(vp); 1780 mutex_enter(&lfs_lock); 1781 goto top; 1782 } 1783 mutex_exit(&lfs_lock); 1784 1785 error = lfs_writefile(fs, sp, vp); 1786 if (!VPISEMPTY(vp) && !WRITEINPROG(vp) && 1787 !(ip->i_state & IN_ALLMOD)) { 1788 mutex_enter(&lfs_lock); 1789 LFS_SET_UINO(ip, IN_MODIFIED); 1790 mutex_exit(&lfs_lock); 1791 } 1792 KASSERT(ip->i_number != LFS_IFILE_INUM); 1793 error2 = lfs_writeinode(fs, sp, ip); 1794 1795 VOP_UNLOCK(vp); 1796 vrele(vp); 1797 1798 if (error == EAGAIN || error2 == EAGAIN) { 1799 lfs_writeseg(fs, sp); 1800 mutex_enter(&lfs_lock); 1801 break; 1802 } 1803 mutex_enter(&lfs_lock); 1804 } 1805 mutex_exit(&lfs_lock); 1806 (void) lfs_writeseg(fs, sp); 1807 lfs_segunlock(fs); 1808 1809 return 0; 1810 } 1811 1812 /* 1813 * Conversion for compat. 1814 */ 1815 static void 1816 block_info_from_70(BLOCK_INFO *bi, const BLOCK_INFO_70 *bi70) 1817 { 1818 bi->bi_inode = bi70->bi_inode; 1819 bi->bi_lbn = bi70->bi_lbn; 1820 bi->bi_daddr = bi70->bi_daddr; 1821 bi->bi_segcreate = bi70->bi_segcreate; 1822 bi->bi_version = bi70->bi_version; 1823 bi->bi_bp = bi70->bi_bp; 1824 bi->bi_size = bi70->bi_size; 1825 } 1826 1827 static void 1828 block_info_to_70(BLOCK_INFO_70 *bi70, const BLOCK_INFO *bi) 1829 { 1830 bi70->bi_inode = bi->bi_inode; 1831 bi70->bi_lbn = bi->bi_lbn; 1832 bi70->bi_daddr = bi->bi_daddr; 1833 bi70->bi_segcreate = bi->bi_segcreate; 1834 bi70->bi_version = bi->bi_version; 1835 bi70->bi_bp = bi->bi_bp; 1836 bi70->bi_size = bi->bi_size; 1837 } 1838 1839 /* 1840 * Provide a fcntl interface to sys_lfs_{segwait,bmapv,markv}. 1841 */ 1842 int 1843 lfs_fcntl(void *v) 1844 { 1845 struct vop_fcntl_args /* { 1846 struct vnode *a_vp; 1847 u_int a_command; 1848 void * a_data; 1849 int a_fflag; 1850 kauth_cred_t a_cred; 1851 } */ *ap = v; 1852 struct timeval tv; 1853 struct timeval *tvp; 1854 BLOCK_INFO *blkiov; 1855 BLOCK_INFO_70 *blkiov70; 1856 CLEANERINFO *cip; 1857 SEGUSE *sup; 1858 int blkcnt, i, error; 1859 size_t fh_size; 1860 struct lfs_fcntl_markv blkvp; 1861 struct lfs_fcntl_markv_70 blkvp70; 1862 struct lwp *l; 1863 fsid_t *fsidp; 1864 struct lfs *fs; 1865 struct buf *bp; 1866 fhandle_t *fhp; 1867 daddr_t off; 1868 int oclean; 1869 1870 /* Only respect LFS fcntls on fs root or Ifile */ 1871 if (VTOI(ap->a_vp)->i_number != ULFS_ROOTINO && 1872 VTOI(ap->a_vp)->i_number != LFS_IFILE_INUM) { 1873 return genfs_fcntl(v); 1874 } 1875 1876 /* Avoid locking a draining lock */ 1877 if (ap->a_vp->v_mount->mnt_iflag & IMNT_UNMOUNT) { 1878 return ESHUTDOWN; 1879 } 1880 1881 /* LFS control and monitoring fcntls are available only to root */ 1882 l = curlwp; 1883 if (((ap->a_command & 0xff00) >> 8) == 'L' && 1884 (error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_LFS, 1885 KAUTH_REQ_SYSTEM_LFS_FCNTL, NULL, NULL, NULL)) != 0) 1886 return (error); 1887 1888 fs = VTOI(ap->a_vp)->i_lfs; 1889 fsidp = &ap->a_vp->v_mount->mnt_stat.f_fsidx; 1890 1891 error = 0; 1892 switch ((int)ap->a_command) { 1893 case LFCNSEGWAITALL_COMPAT_50: 1894 case LFCNSEGWAITALL_COMPAT: 1895 fsidp = NULL; 1896 /* FALLTHROUGH */ 1897 case LFCNSEGWAIT_COMPAT_50: 1898 case LFCNSEGWAIT_COMPAT: 1899 { 1900 struct timeval50 *tvp50 1901 = (struct timeval50 *)ap->a_data; 1902 timeval50_to_timeval(tvp50, &tv); 1903 tvp = &tv; 1904 } 1905 goto segwait_common; 1906 case LFCNSEGWAITALL: 1907 fsidp = NULL; 1908 /* FALLTHROUGH */ 1909 case LFCNSEGWAIT: 1910 tvp = (struct timeval *)ap->a_data; 1911 segwait_common: 1912 mutex_enter(&lfs_lock); 1913 ++fs->lfs_sleepers; 1914 mutex_exit(&lfs_lock); 1915 1916 error = lfs_segwait(fsidp, tvp); 1917 1918 mutex_enter(&lfs_lock); 1919 if (--fs->lfs_sleepers == 0) 1920 cv_broadcast(&fs->lfs_sleeperscv); 1921 mutex_exit(&lfs_lock); 1922 return error; 1923 1924 case LFCNBMAPV_COMPAT_70: 1925 case LFCNMARKV_COMPAT_70: 1926 blkvp70 = *(struct lfs_fcntl_markv_70 *)ap->a_data; 1927 1928 blkcnt = blkvp70.blkcnt; 1929 if ((u_int) blkcnt > LFS_MARKV_MAXBLKCNT) 1930 return (EINVAL); 1931 blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV); 1932 blkiov70 = lfs_malloc(fs, sizeof(BLOCK_INFO_70), LFS_NB_BLKIOV); 1933 for (i = 0; i < blkcnt; i++) { 1934 error = copyin(&blkvp70.blkiov[i], blkiov70, 1935 sizeof(*blkiov70)); 1936 if (error) { 1937 lfs_free(fs, blkiov70, LFS_NB_BLKIOV); 1938 lfs_free(fs, blkiov, LFS_NB_BLKIOV); 1939 return error; 1940 } 1941 block_info_from_70(&blkiov[i], blkiov70); 1942 } 1943 1944 mutex_enter(&lfs_lock); 1945 ++fs->lfs_sleepers; 1946 mutex_exit(&lfs_lock); 1947 if (ap->a_command == LFCNBMAPV) 1948 error = lfs_bmapv(l, fsidp, blkiov, blkcnt); 1949 else /* LFCNMARKV */ 1950 error = lfs_markv(l, fsidp, blkiov, blkcnt); 1951 if (error == 0) { 1952 for (i = 0; i < blkcnt; i++) { 1953 block_info_to_70(blkiov70, &blkiov[i]); 1954 error = copyout(blkiov70, &blkvp70.blkiov[i], 1955 sizeof(*blkiov70)); 1956 if (error) { 1957 break; 1958 } 1959 } 1960 } 1961 mutex_enter(&lfs_lock); 1962 if (--fs->lfs_sleepers == 0) 1963 cv_broadcast(&fs->lfs_sleeperscv); 1964 mutex_exit(&lfs_lock); 1965 lfs_free(fs, blkiov, LFS_NB_BLKIOV); 1966 return error; 1967 1968 case LFCNBMAPV: 1969 case LFCNMARKV: 1970 blkvp = *(struct lfs_fcntl_markv *)ap->a_data; 1971 1972 blkcnt = blkvp.blkcnt; 1973 if ((u_int) blkcnt > LFS_MARKV_MAXBLKCNT) 1974 return (EINVAL); 1975 blkiov = lfs_malloc(fs, blkcnt * sizeof(BLOCK_INFO), LFS_NB_BLKIOV); 1976 if ((error = copyin(blkvp.blkiov, blkiov, 1977 blkcnt * sizeof(BLOCK_INFO))) != 0) { 1978 lfs_free(fs, blkiov, LFS_NB_BLKIOV); 1979 return error; 1980 } 1981 1982 mutex_enter(&lfs_lock); 1983 ++fs->lfs_sleepers; 1984 mutex_exit(&lfs_lock); 1985 if (ap->a_command == LFCNBMAPV) 1986 error = lfs_bmapv(l, fsidp, blkiov, blkcnt); 1987 else /* LFCNMARKV */ 1988 error = lfs_markv(l, fsidp, blkiov, blkcnt); 1989 if (error == 0) 1990 error = copyout(blkiov, blkvp.blkiov, 1991 blkcnt * sizeof(BLOCK_INFO)); 1992 mutex_enter(&lfs_lock); 1993 if (--fs->lfs_sleepers == 0) 1994 cv_broadcast(&fs->lfs_sleeperscv); 1995 mutex_exit(&lfs_lock); 1996 lfs_free(fs, blkiov, LFS_NB_BLKIOV); 1997 return error; 1998 1999 case LFCNRECLAIM: 2000 /* 2001 * Flush dirops and write Ifile, allowing empty segments 2002 * to be immediately reclaimed. 2003 */ 2004 lfs_writer_enter(fs, "pndirop"); 2005 off = lfs_sb_getoffset(fs); 2006 lfs_seglock(fs, SEGM_FORCE_CKP | SEGM_CKP); 2007 lfs_flush_dirops(fs); 2008 LFS_CLEANERINFO(cip, fs, bp); 2009 oclean = lfs_ci_getclean(fs, cip); 2010 LFS_SYNC_CLEANERINFO(cip, fs, bp, 1); 2011 lfs_segwrite(ap->a_vp->v_mount, SEGM_FORCE_CKP); 2012 fs->lfs_sp->seg_flags |= SEGM_PROT; 2013 lfs_segunlock(fs); 2014 lfs_writer_leave(fs); 2015 2016 #ifdef DEBUG 2017 LFS_CLEANERINFO(cip, fs, bp); 2018 DLOG((DLOG_CLEAN, "lfs_fcntl: reclaim wrote %" PRId64 2019 " blocks, cleaned %" PRId32 " segments (activesb %d)\n", 2020 lfs_sb_getoffset(fs) - off, 2021 lfs_ci_getclean(fs, cip) - oclean, 2022 fs->lfs_activesb)); 2023 LFS_SYNC_CLEANERINFO(cip, fs, bp, 0); 2024 #else 2025 __USE(oclean); 2026 __USE(off); 2027 #endif 2028 2029 return 0; 2030 2031 case LFCNIFILEFH_COMPAT: 2032 /* Return the filehandle of the Ifile */ 2033 if ((error = kauth_authorize_system(l->l_cred, 2034 KAUTH_SYSTEM_FILEHANDLE, 0, NULL, NULL, NULL)) != 0) 2035 return (error); 2036 fhp = (struct fhandle *)ap->a_data; 2037 fhp->fh_fsid = *fsidp; 2038 fh_size = 16; /* former VFS_MAXFIDSIZ */ 2039 return lfs_vptofh(fs->lfs_ivnode, &(fhp->fh_fid), &fh_size); 2040 2041 case LFCNIFILEFH_COMPAT2: 2042 case LFCNIFILEFH: 2043 /* Return the filehandle of the Ifile */ 2044 fhp = (struct fhandle *)ap->a_data; 2045 fhp->fh_fsid = *fsidp; 2046 fh_size = sizeof(struct lfs_fhandle) - 2047 offsetof(fhandle_t, fh_fid); 2048 return lfs_vptofh(fs->lfs_ivnode, &(fhp->fh_fid), &fh_size); 2049 2050 case LFCNREWIND: 2051 /* Move lfs_offset to the lowest-numbered segment */ 2052 return lfs_rewind(fs, *(int *)ap->a_data); 2053 2054 case LFCNINVAL: 2055 /* Mark a segment SEGUSE_INVAL */ 2056 LFS_SEGENTRY(sup, fs, *(int *)ap->a_data, bp); 2057 if (sup->su_nbytes > 0) { 2058 brelse(bp, 0); 2059 lfs_unset_inval_all(fs); 2060 return EBUSY; 2061 } 2062 sup->su_flags |= SEGUSE_INVAL; 2063 VOP_BWRITE(bp->b_vp, bp); 2064 return 0; 2065 2066 case LFCNRESIZE: 2067 /* Resize the filesystem */ 2068 return lfs_resize_fs(fs, *(int *)ap->a_data); 2069 2070 case LFCNWRAPSTOP: 2071 case LFCNWRAPSTOP_COMPAT: 2072 /* 2073 * Hold lfs_newseg at segment 0; if requested, sleep until 2074 * the filesystem wraps around. To support external agents 2075 * (dump, fsck-based regression test) that need to look at 2076 * a snapshot of the filesystem, without necessarily 2077 * requiring that all fs activity stops. 2078 */ 2079 if (fs->lfs_stoplwp == curlwp) 2080 return EALREADY; 2081 2082 mutex_enter(&lfs_lock); 2083 while (fs->lfs_stoplwp != NULL) 2084 cv_wait(&fs->lfs_stopcv, &lfs_lock); 2085 fs->lfs_stoplwp = curlwp; 2086 if (fs->lfs_nowrap == 0) 2087 log(LOG_NOTICE, "%s: disabled log wrap\n", 2088 lfs_sb_getfsmnt(fs)); 2089 ++fs->lfs_nowrap; 2090 if (*(int *)ap->a_data == 1 2091 || ap->a_command == LFCNWRAPSTOP_COMPAT) { 2092 log(LOG_NOTICE, "LFCNSTOPWRAP waiting for log wrap\n"); 2093 error = mtsleep(&fs->lfs_nowrap, PCATCH | PUSER, 2094 "segwrap", 0, &lfs_lock); 2095 log(LOG_NOTICE, "LFCNSTOPWRAP done waiting\n"); 2096 if (error) { 2097 lfs_wrapgo(fs, VTOI(ap->a_vp), 0); 2098 } 2099 } 2100 mutex_exit(&lfs_lock); 2101 return 0; 2102 2103 case LFCNWRAPGO: 2104 case LFCNWRAPGO_COMPAT: 2105 /* 2106 * Having done its work, the agent wakes up the writer. 2107 * If the argument is 1, it sleeps until a new segment 2108 * is selected. 2109 */ 2110 mutex_enter(&lfs_lock); 2111 error = lfs_wrapgo(fs, VTOI(ap->a_vp), 2112 ap->a_command == LFCNWRAPGO_COMPAT ? 1 : 2113 *((int *)ap->a_data)); 2114 mutex_exit(&lfs_lock); 2115 return error; 2116 2117 case LFCNWRAPPASS: 2118 if ((VTOI(ap->a_vp)->i_lfs_iflags & LFSI_WRAPWAIT)) 2119 return EALREADY; 2120 mutex_enter(&lfs_lock); 2121 if (fs->lfs_stoplwp != curlwp) { 2122 mutex_exit(&lfs_lock); 2123 return EALREADY; 2124 } 2125 if (fs->lfs_nowrap == 0) { 2126 mutex_exit(&lfs_lock); 2127 return EBUSY; 2128 } 2129 fs->lfs_wrappass = 1; 2130 wakeup(&fs->lfs_wrappass); 2131 /* Wait for the log to wrap, if asked */ 2132 if (*(int *)ap->a_data) { 2133 vref(ap->a_vp); 2134 VTOI(ap->a_vp)->i_lfs_iflags |= LFSI_WRAPWAIT; 2135 log(LOG_NOTICE, "LFCNPASS waiting for log wrap\n"); 2136 error = mtsleep(&fs->lfs_nowrap, PCATCH | PUSER, 2137 "segwrap", 0, &lfs_lock); 2138 log(LOG_NOTICE, "LFCNPASS done waiting\n"); 2139 VTOI(ap->a_vp)->i_lfs_iflags &= ~LFSI_WRAPWAIT; 2140 vrele(ap->a_vp); 2141 } 2142 mutex_exit(&lfs_lock); 2143 return error; 2144 2145 case LFCNWRAPSTATUS: 2146 mutex_enter(&lfs_lock); 2147 *(int *)ap->a_data = fs->lfs_wrapstatus; 2148 mutex_exit(&lfs_lock); 2149 return 0; 2150 2151 default: 2152 return genfs_fcntl(v); 2153 } 2154 return 0; 2155 } 2156 2157 /* 2158 * Return the last logical file offset that should be written for this file 2159 * if we're doing a write that ends at "size". If writing, we need to know 2160 * about sizes on disk, i.e. fragments if there are any; if reading, we need 2161 * to know about entire blocks. 2162 */ 2163 void 2164 lfs_gop_size(struct vnode *vp, off_t size, off_t *eobp, int flags) 2165 { 2166 struct inode *ip = VTOI(vp); 2167 struct lfs *fs = ip->i_lfs; 2168 daddr_t olbn, nlbn; 2169 2170 olbn = lfs_lblkno(fs, ip->i_size); 2171 nlbn = lfs_lblkno(fs, size); 2172 if (!(flags & GOP_SIZE_MEM) && nlbn < ULFS_NDADDR && olbn <= nlbn) { 2173 *eobp = lfs_fragroundup(fs, size); 2174 } else { 2175 *eobp = lfs_blkroundup(fs, size); 2176 } 2177 } 2178 2179 #ifdef DEBUG 2180 void lfs_dump_vop(void *); 2181 2182 void 2183 lfs_dump_vop(void *v) 2184 { 2185 struct vop_putpages_args /* { 2186 struct vnode *a_vp; 2187 voff_t a_offlo; 2188 voff_t a_offhi; 2189 int a_flags; 2190 } */ *ap = v; 2191 2192 struct inode *ip = VTOI(ap->a_vp); 2193 struct lfs *fs = ip->i_lfs; 2194 2195 #ifdef DDB 2196 vfs_vnode_print(ap->a_vp, 0, printf); 2197 #endif 2198 lfs_dump_dinode(fs, ip->i_din); 2199 } 2200 #endif 2201 2202 int 2203 lfs_mmap(void *v) 2204 { 2205 struct vop_mmap_args /* { 2206 const struct vnodeop_desc *a_desc; 2207 struct vnode *a_vp; 2208 vm_prot_t a_prot; 2209 kauth_cred_t a_cred; 2210 } */ *ap = v; 2211 2212 if (VTOI(ap->a_vp)->i_number == LFS_IFILE_INUM) 2213 return EOPNOTSUPP; 2214 return genfs_mmap(v); 2215 } 2216 2217 static int 2218 lfs_openextattr(void *v) 2219 { 2220 struct vop_openextattr_args /* { 2221 struct vnode *a_vp; 2222 kauth_cred_t a_cred; 2223 struct proc *a_p; 2224 } */ *ap = v; 2225 struct vnode *vp = ap->a_vp; 2226 struct inode *ip; 2227 struct ulfsmount *ump; 2228 2229 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 2230 2231 ip = VTOI(vp); 2232 ump = ip->i_ump; 2233 2234 /* Not supported for ULFS1 file systems. */ 2235 if (ump->um_fstype == ULFS1) 2236 return (EOPNOTSUPP); 2237 2238 /* XXX Not implemented for ULFS2 file systems. */ 2239 return (EOPNOTSUPP); 2240 } 2241 2242 static int 2243 lfs_closeextattr(void *v) 2244 { 2245 struct vop_closeextattr_args /* { 2246 struct vnode *a_vp; 2247 int a_commit; 2248 kauth_cred_t a_cred; 2249 struct proc *a_p; 2250 } */ *ap = v; 2251 struct vnode *vp = ap->a_vp; 2252 struct inode *ip; 2253 struct ulfsmount *ump; 2254 2255 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 2256 2257 ip = VTOI(vp); 2258 ump = ip->i_ump; 2259 2260 /* Not supported for ULFS1 file systems. */ 2261 if (ump->um_fstype == ULFS1) 2262 return (EOPNOTSUPP); 2263 2264 /* XXX Not implemented for ULFS2 file systems. */ 2265 return (EOPNOTSUPP); 2266 } 2267 2268 static int 2269 lfs_getextattr(void *v) 2270 { 2271 struct vop_getextattr_args /* { 2272 struct vnode *a_vp; 2273 int a_attrnamespace; 2274 const char *a_name; 2275 struct uio *a_uio; 2276 size_t *a_size; 2277 kauth_cred_t a_cred; 2278 struct proc *a_p; 2279 } */ *ap = v; 2280 struct vnode *vp = ap->a_vp; 2281 struct inode *ip; 2282 struct ulfsmount *ump; 2283 int error; 2284 2285 KASSERT(VOP_ISLOCKED(vp)); 2286 2287 ip = VTOI(vp); 2288 ump = ip->i_ump; 2289 2290 if (ump->um_fstype == ULFS1) { 2291 #ifdef LFS_EXTATTR 2292 error = ulfs_getextattr(ap); 2293 #else 2294 error = EOPNOTSUPP; 2295 #endif 2296 return error; 2297 } 2298 2299 /* XXX Not implemented for ULFS2 file systems. */ 2300 return (EOPNOTSUPP); 2301 } 2302 2303 static int 2304 lfs_setextattr(void *v) 2305 { 2306 struct vop_setextattr_args /* { 2307 struct vnode *a_vp; 2308 int a_attrnamespace; 2309 const char *a_name; 2310 struct uio *a_uio; 2311 kauth_cred_t a_cred; 2312 struct proc *a_p; 2313 } */ *ap = v; 2314 struct vnode *vp = ap->a_vp; 2315 struct inode *ip; 2316 struct ulfsmount *ump; 2317 int error; 2318 2319 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 2320 2321 ip = VTOI(vp); 2322 ump = ip->i_ump; 2323 2324 if (ump->um_fstype == ULFS1) { 2325 #ifdef LFS_EXTATTR 2326 error = ulfs_setextattr(ap); 2327 #else 2328 error = EOPNOTSUPP; 2329 #endif 2330 return error; 2331 } 2332 2333 /* XXX Not implemented for ULFS2 file systems. */ 2334 return (EOPNOTSUPP); 2335 } 2336 2337 static int 2338 lfs_listextattr(void *v) 2339 { 2340 struct vop_listextattr_args /* { 2341 struct vnode *a_vp; 2342 int a_attrnamespace; 2343 struct uio *a_uio; 2344 size_t *a_size; 2345 kauth_cred_t a_cred; 2346 struct proc *a_p; 2347 } */ *ap = v; 2348 struct vnode *vp = ap->a_vp; 2349 struct inode *ip; 2350 struct ulfsmount *ump; 2351 int error; 2352 2353 KASSERT(VOP_ISLOCKED(vp)); 2354 2355 ip = VTOI(vp); 2356 ump = ip->i_ump; 2357 2358 if (ump->um_fstype == ULFS1) { 2359 #ifdef LFS_EXTATTR 2360 error = ulfs_listextattr(ap); 2361 #else 2362 error = EOPNOTSUPP; 2363 #endif 2364 return error; 2365 } 2366 2367 /* XXX Not implemented for ULFS2 file systems. */ 2368 return (EOPNOTSUPP); 2369 } 2370 2371 static int 2372 lfs_deleteextattr(void *v) 2373 { 2374 struct vop_deleteextattr_args /* { 2375 struct vnode *a_vp; 2376 int a_attrnamespace; 2377 kauth_cred_t a_cred; 2378 struct proc *a_p; 2379 } */ *ap = v; 2380 struct vnode *vp = ap->a_vp; 2381 struct inode *ip; 2382 struct ulfsmount *ump; 2383 int error; 2384 2385 KASSERT(VOP_ISLOCKED(vp) == LK_EXCLUSIVE); 2386 2387 ip = VTOI(vp); 2388 ump = ip->i_ump; 2389 2390 if (ump->um_fstype == ULFS1) { 2391 #ifdef LFS_EXTATTR 2392 error = ulfs_deleteextattr(ap); 2393 #else 2394 error = EOPNOTSUPP; 2395 #endif 2396 return error; 2397 } 2398 2399 /* XXX Not implemented for ULFS2 file systems. */ 2400 return (EOPNOTSUPP); 2401 } 2402 2403