1/* 2 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 3 * All Rights Reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it would be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write the Free Software Foundation, 16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 17 */ 18#include "xfs.h" 19#include "xfs_fs.h" 20#include "xfs_types.h" 21#include "xfs_bit.h" 22#include "xfs_log.h" 23#include "xfs_inum.h" 24#include "xfs_trans.h" 25#include "xfs_sb.h" 26#include "xfs_ag.h" 27#include "xfs_dir2.h" 28#include "xfs_dmapi.h" 29#include "xfs_mount.h" 30#include "xfs_da_btree.h" 31#include "xfs_bmap_btree.h" 32#include "xfs_ialloc_btree.h" 33#include "xfs_alloc_btree.h" 34#include "xfs_dir2_sf.h" 35#include "xfs_attr_sf.h" 36#include "xfs_dinode.h" 37#include "xfs_inode.h" 38#include "xfs_inode_item.h" 39#include "xfs_btree.h" 40#include "xfs_alloc.h" 41#include "xfs_ialloc.h" 42#include "xfs_quota.h" 43#include "xfs_error.h" 44#include "xfs_bmap.h" 45#include "xfs_rw.h" 46#include "xfs_refcache.h" 47#include "xfs_buf_item.h" 48#include "xfs_log_priv.h" 49#include "xfs_dir2_trace.h" 50#include "xfs_extfree_item.h" 51#include "xfs_acl.h" 52#include "xfs_attr.h" 53#include "xfs_clnt.h" 54#include "xfs_fsops.h" 55 56STATIC int xfs_sync(bhv_desc_t *, int, cred_t *); 57 58int 59xfs_init(void) 60{ 61 extern kmem_zone_t *xfs_bmap_free_item_zone; 62 extern kmem_zone_t *xfs_btree_cur_zone; 63 extern kmem_zone_t *xfs_trans_zone; 64 extern kmem_zone_t *xfs_buf_item_zone; 65 extern kmem_zone_t *xfs_dabuf_zone; 66#ifdef XFS_DABUF_DEBUG 67 extern lock_t xfs_dabuf_global_lock; 68 spinlock_init(&xfs_dabuf_global_lock, "xfsda"); 69#endif 70 71 /* 72 * Initialize all of the zone allocators we use. 73 */ 74 xfs_bmap_free_item_zone = kmem_zone_init(sizeof(xfs_bmap_free_item_t), 75 "xfs_bmap_free_item"); 76 xfs_btree_cur_zone = kmem_zone_init(sizeof(xfs_btree_cur_t), 77 "xfs_btree_cur"); 78 xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans"); 79 xfs_da_state_zone = 80 kmem_zone_init(sizeof(xfs_da_state_t), "xfs_da_state"); 81 xfs_dabuf_zone = kmem_zone_init(sizeof(xfs_dabuf_t), "xfs_dabuf"); 82 xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork"); 83 xfs_acl_zone_init(xfs_acl_zone, "xfs_acl"); 84 85 /* 86 * The size of the zone allocated buf log item is the maximum 87 * size possible under XFS. This wastes a little bit of memory, 88 * but it is much faster. 89 */ 90 xfs_buf_item_zone = 91 kmem_zone_init((sizeof(xfs_buf_log_item_t) + 92 (((XFS_MAX_BLOCKSIZE / XFS_BLI_CHUNK) / 93 NBWORD) * sizeof(int))), 94 "xfs_buf_item"); 95 xfs_efd_zone = 96 kmem_zone_init((sizeof(xfs_efd_log_item_t) + 97 ((XFS_EFD_MAX_FAST_EXTENTS - 1) * 98 sizeof(xfs_extent_t))), 99 "xfs_efd_item"); 100 xfs_efi_zone = 101 kmem_zone_init((sizeof(xfs_efi_log_item_t) + 102 ((XFS_EFI_MAX_FAST_EXTENTS - 1) * 103 sizeof(xfs_extent_t))), 104 "xfs_efi_item"); 105 106 /* 107 * These zones warrant special memory allocator hints 108 */ 109 xfs_inode_zone = 110 kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode", 111 KM_ZONE_HWALIGN | KM_ZONE_RECLAIM | 112 KM_ZONE_SPREAD, NULL); 113 xfs_ili_zone = 114 kmem_zone_init_flags(sizeof(xfs_inode_log_item_t), "xfs_ili", 115 KM_ZONE_SPREAD, NULL); 116 xfs_chashlist_zone = 117 kmem_zone_init_flags(sizeof(xfs_chashlist_t), "xfs_chashlist", 118 KM_ZONE_SPREAD, NULL); 119 120 /* 121 * Allocate global trace buffers. 122 */ 123#ifdef XFS_ALLOC_TRACE 124 xfs_alloc_trace_buf = ktrace_alloc(XFS_ALLOC_TRACE_SIZE, KM_SLEEP); 125#endif 126#ifdef XFS_BMAP_TRACE 127 xfs_bmap_trace_buf = ktrace_alloc(XFS_BMAP_TRACE_SIZE, KM_SLEEP); 128#endif 129#ifdef XFS_BMBT_TRACE 130 xfs_bmbt_trace_buf = ktrace_alloc(XFS_BMBT_TRACE_SIZE, KM_SLEEP); 131#endif 132#ifdef XFS_ATTR_TRACE 133 xfs_attr_trace_buf = ktrace_alloc(XFS_ATTR_TRACE_SIZE, KM_SLEEP); 134#endif 135#ifdef XFS_DIR2_TRACE 136 xfs_dir2_trace_buf = ktrace_alloc(XFS_DIR2_GTRACE_SIZE, KM_SLEEP); 137#endif 138 139 xfs_dir_startup(); 140 141#if (defined(DEBUG) || defined(INDUCE_IO_ERROR)) 142 xfs_error_test_init(); 143#endif /* DEBUG || INDUCE_IO_ERROR */ 144 145 xfs_init_procfs(); 146 xfs_sysctl_register(); 147 return 0; 148} 149 150void 151xfs_cleanup(void) 152{ 153 extern kmem_zone_t *xfs_bmap_free_item_zone; 154 extern kmem_zone_t *xfs_btree_cur_zone; 155 extern kmem_zone_t *xfs_inode_zone; 156 extern kmem_zone_t *xfs_trans_zone; 157 extern kmem_zone_t *xfs_da_state_zone; 158 extern kmem_zone_t *xfs_dabuf_zone; 159 extern kmem_zone_t *xfs_efd_zone; 160 extern kmem_zone_t *xfs_efi_zone; 161 extern kmem_zone_t *xfs_buf_item_zone; 162 extern kmem_zone_t *xfs_chashlist_zone; 163 164 xfs_cleanup_procfs(); 165 xfs_sysctl_unregister(); 166 xfs_refcache_destroy(); 167 xfs_acl_zone_destroy(xfs_acl_zone); 168 169#ifdef XFS_DIR2_TRACE 170 ktrace_free(xfs_dir2_trace_buf); 171#endif 172#ifdef XFS_ATTR_TRACE 173 ktrace_free(xfs_attr_trace_buf); 174#endif 175#ifdef XFS_BMBT_TRACE 176 ktrace_free(xfs_bmbt_trace_buf); 177#endif 178#ifdef XFS_BMAP_TRACE 179 ktrace_free(xfs_bmap_trace_buf); 180#endif 181#ifdef XFS_ALLOC_TRACE 182 ktrace_free(xfs_alloc_trace_buf); 183#endif 184 185 kmem_zone_destroy(xfs_bmap_free_item_zone); 186 kmem_zone_destroy(xfs_btree_cur_zone); 187 kmem_zone_destroy(xfs_inode_zone); 188 kmem_zone_destroy(xfs_trans_zone); 189 kmem_zone_destroy(xfs_da_state_zone); 190 kmem_zone_destroy(xfs_dabuf_zone); 191 kmem_zone_destroy(xfs_buf_item_zone); 192 kmem_zone_destroy(xfs_efd_zone); 193 kmem_zone_destroy(xfs_efi_zone); 194 kmem_zone_destroy(xfs_ifork_zone); 195 kmem_zone_destroy(xfs_ili_zone); 196 kmem_zone_destroy(xfs_chashlist_zone); 197} 198 199/* 200 * xfs_start_flags 201 * 202 * This function fills in xfs_mount_t fields based on mount args. 203 * Note: the superblock has _not_ yet been read in. 204 */ 205STATIC int 206xfs_start_flags( 207 struct bhv_vfs *vfs, 208 struct xfs_mount_args *ap, 209 struct xfs_mount *mp) 210{ 211 /* Values are in BBs */ 212 if ((ap->flags & XFSMNT_NOALIGN) != XFSMNT_NOALIGN) { 213 /* 214 * At this point the superblock has not been read 215 * in, therefore we do not know the block size. 216 * Before the mount call ends we will convert 217 * these to FSBs. 218 */ 219 mp->m_dalign = ap->sunit; 220 mp->m_swidth = ap->swidth; 221 } 222 223 if (ap->logbufs != -1 && 224 ap->logbufs != 0 && 225 (ap->logbufs < XLOG_MIN_ICLOGS || 226 ap->logbufs > XLOG_MAX_ICLOGS)) { 227 cmn_err(CE_WARN, 228 "XFS: invalid logbufs value: %d [not %d-%d]", 229 ap->logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS); 230 return XFS_ERROR(EINVAL); 231 } 232 mp->m_logbufs = ap->logbufs; 233 if (ap->logbufsize != -1 && 234 ap->logbufsize != 0 && 235 ap->logbufsize != 16 * 1024 && 236 ap->logbufsize != 32 * 1024 && 237 ap->logbufsize != 64 * 1024 && 238 ap->logbufsize != 128 * 1024 && 239 ap->logbufsize != 256 * 1024) { 240 cmn_err(CE_WARN, 241 "XFS: invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]", 242 ap->logbufsize); 243 return XFS_ERROR(EINVAL); 244 } 245 mp->m_ihsize = ap->ihashsize; 246 mp->m_logbsize = ap->logbufsize; 247 mp->m_fsname_len = strlen(ap->fsname) + 1; 248 mp->m_fsname = kmem_alloc(mp->m_fsname_len, KM_SLEEP); 249 strcpy(mp->m_fsname, ap->fsname); 250 if (ap->rtname[0]) { 251 mp->m_rtname = kmem_alloc(strlen(ap->rtname) + 1, KM_SLEEP); 252 strcpy(mp->m_rtname, ap->rtname); 253 } 254 if (ap->logname[0]) { 255 mp->m_logname = kmem_alloc(strlen(ap->logname) + 1, KM_SLEEP); 256 strcpy(mp->m_logname, ap->logname); 257 } 258 259 if (ap->flags & XFSMNT_WSYNC) 260 mp->m_flags |= XFS_MOUNT_WSYNC; 261#if XFS_BIG_INUMS 262 if (ap->flags & XFSMNT_INO64) { 263 mp->m_flags |= XFS_MOUNT_INO64; 264 mp->m_inoadd = XFS_INO64_OFFSET; 265 } 266#endif 267 if (ap->flags & XFSMNT_RETERR) 268 mp->m_flags |= XFS_MOUNT_RETERR; 269 if (ap->flags & XFSMNT_NOALIGN) 270 mp->m_flags |= XFS_MOUNT_NOALIGN; 271 if (ap->flags & XFSMNT_SWALLOC) 272 mp->m_flags |= XFS_MOUNT_SWALLOC; 273 if (ap->flags & XFSMNT_OSYNCISOSYNC) 274 mp->m_flags |= XFS_MOUNT_OSYNCISOSYNC; 275 if (ap->flags & XFSMNT_32BITINODES) 276 mp->m_flags |= XFS_MOUNT_32BITINODES; 277 278 if (ap->flags & XFSMNT_IOSIZE) { 279 if (ap->iosizelog > XFS_MAX_IO_LOG || 280 ap->iosizelog < XFS_MIN_IO_LOG) { 281 cmn_err(CE_WARN, 282 "XFS: invalid log iosize: %d [not %d-%d]", 283 ap->iosizelog, XFS_MIN_IO_LOG, 284 XFS_MAX_IO_LOG); 285 return XFS_ERROR(EINVAL); 286 } 287 288 mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE; 289 mp->m_readio_log = mp->m_writeio_log = ap->iosizelog; 290 } 291 292 if (ap->flags & XFSMNT_IHASHSIZE) 293 mp->m_flags |= XFS_MOUNT_IHASHSIZE; 294 if (ap->flags & XFSMNT_IDELETE) 295 mp->m_flags |= XFS_MOUNT_IDELETE; 296 if (ap->flags & XFSMNT_DIRSYNC) 297 mp->m_flags |= XFS_MOUNT_DIRSYNC; 298 if (ap->flags & XFSMNT_ATTR2) 299 mp->m_flags |= XFS_MOUNT_ATTR2; 300 301 if (ap->flags2 & XFSMNT2_COMPAT_IOSIZE) 302 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE; 303 304 /* 305 * no recovery flag requires a read-only mount 306 */ 307 if (ap->flags & XFSMNT_NORECOVERY) { 308 if (!(vfs->vfs_flag & VFS_RDONLY)) { 309 cmn_err(CE_WARN, 310 "XFS: tried to mount a FS read-write without recovery!"); 311 return XFS_ERROR(EINVAL); 312 } 313 mp->m_flags |= XFS_MOUNT_NORECOVERY; 314 } 315 316 if (ap->flags & XFSMNT_NOUUID) 317 mp->m_flags |= XFS_MOUNT_NOUUID; 318 if (ap->flags & XFSMNT_BARRIER) 319 mp->m_flags |= XFS_MOUNT_BARRIER; 320 else 321 mp->m_flags &= ~XFS_MOUNT_BARRIER; 322 323 return 0; 324} 325 326/* 327 * This function fills in xfs_mount_t fields based on mount args. 328 * Note: the superblock _has_ now been read in. 329 */ 330STATIC int 331xfs_finish_flags( 332 struct bhv_vfs *vfs, 333 struct xfs_mount_args *ap, 334 struct xfs_mount *mp) 335{ 336 int ronly = (vfs->vfs_flag & VFS_RDONLY); 337 338 /* Fail a mount where the logbuf is smaller then the log stripe */ 339 if (XFS_SB_VERSION_HASLOGV2(&mp->m_sb)) { 340 if ((ap->logbufsize <= 0) && 341 (mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE)) { 342 mp->m_logbsize = mp->m_sb.sb_logsunit; 343 } else if (ap->logbufsize > 0 && 344 ap->logbufsize < mp->m_sb.sb_logsunit) { 345 cmn_err(CE_WARN, 346 "XFS: logbuf size must be greater than or equal to log stripe size"); 347 return XFS_ERROR(EINVAL); 348 } 349 } else { 350 /* Fail a mount if the logbuf is larger than 32K */ 351 if (ap->logbufsize > XLOG_BIG_RECORD_BSIZE) { 352 cmn_err(CE_WARN, 353 "XFS: logbuf size for version 1 logs must be 16K or 32K"); 354 return XFS_ERROR(EINVAL); 355 } 356 } 357 358 if (XFS_SB_VERSION_HASATTR2(&mp->m_sb)) { 359 mp->m_flags |= XFS_MOUNT_ATTR2; 360 } 361 362 /* 363 * prohibit r/w mounts of read-only filesystems 364 */ 365 if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) { 366 cmn_err(CE_WARN, 367 "XFS: cannot mount a read-only filesystem as read-write"); 368 return XFS_ERROR(EROFS); 369 } 370 371 /* 372 * check for shared mount. 373 */ 374 if (ap->flags & XFSMNT_SHARED) { 375 if (!XFS_SB_VERSION_HASSHARED(&mp->m_sb)) 376 return XFS_ERROR(EINVAL); 377 378 /* 379 * For IRIX 6.5, shared mounts must have the shared 380 * version bit set, have the persistent readonly 381 * field set, must be version 0 and can only be mounted 382 * read-only. 383 */ 384 if (!ronly || !(mp->m_sb.sb_flags & XFS_SBF_READONLY) || 385 (mp->m_sb.sb_shared_vn != 0)) 386 return XFS_ERROR(EINVAL); 387 388 mp->m_flags |= XFS_MOUNT_SHARED; 389 390 /* 391 * Shared XFS V0 can't deal with DMI. Return EINVAL. 392 */ 393 if (mp->m_sb.sb_shared_vn == 0 && (ap->flags & XFSMNT_DMAPI)) 394 return XFS_ERROR(EINVAL); 395 } 396 397 return 0; 398} 399 400/* 401 * xfs_mount 402 * 403 * The file system configurations are: 404 * (1) device (partition) with data and internal log 405 * (2) logical volume with data and log subvolumes. 406 * (3) logical volume with data, log, and realtime subvolumes. 407 * 408 * We only have to handle opening the log and realtime volumes here if 409 * they are present. The data subvolume has already been opened by 410 * get_sb_bdev() and is stored in vfsp->vfs_super->s_bdev. 411 */ 412STATIC int 413xfs_mount( 414 struct bhv_desc *bhvp, 415 struct xfs_mount_args *args, 416 cred_t *credp) 417{ 418 struct bhv_vfs *vfsp = bhvtovfs(bhvp); 419 struct bhv_desc *p; 420 struct xfs_mount *mp = XFS_BHVTOM(bhvp); 421 struct block_device *ddev, *logdev, *rtdev; 422 int flags = 0, error; 423 424 ddev = vfsp->vfs_super->s_bdev; 425 logdev = rtdev = NULL; 426 427 /* 428 * Setup xfs_mount function vectors from available behaviors 429 */ 430 p = vfs_bhv_lookup(vfsp, VFS_POSITION_DM); 431 mp->m_dm_ops = p ? *(xfs_dmops_t *) vfs_bhv_custom(p) : xfs_dmcore_stub; 432 p = vfs_bhv_lookup(vfsp, VFS_POSITION_QM); 433 mp->m_qm_ops = p ? *(xfs_qmops_t *) vfs_bhv_custom(p) : xfs_qmcore_stub; 434 p = vfs_bhv_lookup(vfsp, VFS_POSITION_IO); 435 mp->m_io_ops = p ? *(xfs_ioops_t *) vfs_bhv_custom(p) : xfs_iocore_xfs; 436 437 if (args->flags & XFSMNT_QUIET) 438 flags |= XFS_MFSI_QUIET; 439 440 /* 441 * Open real time and log devices - order is important. 442 */ 443 if (args->logname[0]) { 444 error = xfs_blkdev_get(mp, args->logname, &logdev); 445 if (error) 446 return error; 447 } 448 if (args->rtname[0]) { 449 error = xfs_blkdev_get(mp, args->rtname, &rtdev); 450 if (error) { 451 xfs_blkdev_put(logdev); 452 return error; 453 } 454 455 if (rtdev == ddev || rtdev == logdev) { 456 cmn_err(CE_WARN, 457 "XFS: Cannot mount filesystem with identical rtdev and ddev/logdev."); 458 xfs_blkdev_put(logdev); 459 xfs_blkdev_put(rtdev); 460 return EINVAL; 461 } 462 } 463 464 /* 465 * Setup xfs_mount buffer target pointers 466 */ 467 error = ENOMEM; 468 mp->m_ddev_targp = xfs_alloc_buftarg(ddev, 0); 469 if (!mp->m_ddev_targp) { 470 xfs_blkdev_put(logdev); 471 xfs_blkdev_put(rtdev); 472 return error; 473 } 474 if (rtdev) { 475 mp->m_rtdev_targp = xfs_alloc_buftarg(rtdev, 1); 476 if (!mp->m_rtdev_targp) 477 goto error0; 478 } 479 mp->m_logdev_targp = (logdev && logdev != ddev) ? 480 xfs_alloc_buftarg(logdev, 1) : mp->m_ddev_targp; 481 if (!mp->m_logdev_targp) 482 goto error0; 483 484 /* 485 * Setup flags based on mount(2) options and then the superblock 486 */ 487 error = xfs_start_flags(vfsp, args, mp); 488 if (error) 489 goto error1; 490 error = xfs_readsb(mp, flags); 491 if (error) 492 goto error1; 493 error = xfs_finish_flags(vfsp, args, mp); 494 if (error) 495 goto error2; 496 497 /* 498 * Setup xfs_mount buffer target pointers based on superblock 499 */ 500 error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_blocksize, 501 mp->m_sb.sb_sectsize); 502 if (!error && logdev && logdev != ddev) { 503 unsigned int log_sector_size = BBSIZE; 504 505 if (XFS_SB_VERSION_HASSECTOR(&mp->m_sb)) 506 log_sector_size = mp->m_sb.sb_logsectsize; 507 error = xfs_setsize_buftarg(mp->m_logdev_targp, 508 mp->m_sb.sb_blocksize, 509 log_sector_size); 510 } 511 if (!error && rtdev) 512 error = xfs_setsize_buftarg(mp->m_rtdev_targp, 513 mp->m_sb.sb_blocksize, 514 mp->m_sb.sb_sectsize); 515 if (error) 516 goto error2; 517 518 if (mp->m_flags & XFS_MOUNT_BARRIER) 519 xfs_mountfs_check_barriers(mp); 520 521 error = XFS_IOINIT(vfsp, args, flags); 522 if (error) 523 goto error2; 524 525 return 0; 526 527error2: 528 if (mp->m_sb_bp) 529 xfs_freesb(mp); 530error1: 531 xfs_binval(mp->m_ddev_targp); 532 if (logdev && logdev != ddev) 533 xfs_binval(mp->m_logdev_targp); 534 if (rtdev) 535 xfs_binval(mp->m_rtdev_targp); 536error0: 537 xfs_unmountfs_close(mp, credp); 538 return error; 539} 540 541STATIC int 542xfs_unmount( 543 bhv_desc_t *bdp, 544 int flags, 545 cred_t *credp) 546{ 547 bhv_vfs_t *vfsp = bhvtovfs(bdp); 548 xfs_mount_t *mp = XFS_BHVTOM(bdp); 549 xfs_inode_t *rip; 550 bhv_vnode_t *rvp; 551 int unmount_event_wanted = 0; 552 int unmount_event_flags = 0; 553 int xfs_unmountfs_needed = 0; 554 int error; 555 556 rip = mp->m_rootip; 557 rvp = XFS_ITOV(rip); 558 559 if (vfsp->vfs_flag & VFS_DMI) { 560 error = XFS_SEND_PREUNMOUNT(mp, vfsp, 561 rvp, DM_RIGHT_NULL, rvp, DM_RIGHT_NULL, 562 NULL, NULL, 0, 0, 563 (mp->m_dmevmask & (1<<DM_EVENT_PREUNMOUNT))? 564 0:DM_FLAGS_UNWANTED); 565 if (error) 566 return XFS_ERROR(error); 567 unmount_event_wanted = 1; 568 unmount_event_flags = (mp->m_dmevmask & (1<<DM_EVENT_UNMOUNT))? 569 0 : DM_FLAGS_UNWANTED; 570 } 571 572 /* 573 * First blow any referenced inode from this file system 574 * out of the reference cache, and delete the timer. 575 */ 576 xfs_refcache_purge_mp(mp); 577 578 XFS_bflush(mp->m_ddev_targp); 579 error = xfs_unmount_flush(mp, 0); 580 if (error) 581 goto out; 582 583 ASSERT(vn_count(rvp) == 1); 584 585 /* 586 * Drop the reference count 587 */ 588 VN_RELE(rvp); 589 590 /* 591 * If we're forcing a shutdown, typically because of a media error, 592 * we want to make sure we invalidate dirty pages that belong to 593 * referenced vnodes as well. 594 */ 595 if (XFS_FORCED_SHUTDOWN(mp)) { 596 error = xfs_sync(&mp->m_bhv, 597 (SYNC_WAIT | SYNC_CLOSE), credp); 598 ASSERT(error != EFSCORRUPTED); 599 } 600 xfs_unmountfs_needed = 1; 601 602out: 603 /* Send DMAPI event, if required. 604 * Then do xfs_unmountfs() if needed. 605 * Then return error (or zero). 606 */ 607 if (unmount_event_wanted) { 608 /* Note: mp structure must still exist for 609 * XFS_SEND_UNMOUNT() call. 610 */ 611 XFS_SEND_UNMOUNT(mp, vfsp, error == 0 ? rvp : NULL, 612 DM_RIGHT_NULL, 0, error, unmount_event_flags); 613 } 614 if (xfs_unmountfs_needed) { 615 /* 616 * Call common unmount function to flush to disk 617 * and free the super block buffer & mount structures. 618 */ 619 xfs_unmountfs(mp, credp); 620 } 621 622 return XFS_ERROR(error); 623} 624 625STATIC int 626xfs_quiesce_fs( 627 xfs_mount_t *mp) 628{ 629 int count = 0, pincount; 630 631 xfs_refcache_purge_mp(mp); 632 xfs_flush_buftarg(mp->m_ddev_targp, 0); 633 xfs_finish_reclaim_all(mp, 0); 634 635 /* This loop must run at least twice. 636 * The first instance of the loop will flush 637 * most meta data but that will generate more 638 * meta data (typically directory updates). 639 * Which then must be flushed and logged before 640 * we can write the unmount record. 641 */ 642 do { 643 xfs_syncsub(mp, SYNC_REMOUNT|SYNC_ATTR|SYNC_WAIT, NULL); 644 pincount = xfs_flush_buftarg(mp->m_ddev_targp, 1); 645 if (!pincount) { 646 delay(50); 647 count++; 648 } 649 } while (count < 2); 650 651 return 0; 652} 653 654STATIC int 655xfs_mntupdate( 656 bhv_desc_t *bdp, 657 int *flags, 658 struct xfs_mount_args *args) 659{ 660 bhv_vfs_t *vfsp = bhvtovfs(bdp); 661 xfs_mount_t *mp = XFS_BHVTOM(bdp); 662 663 if (!(*flags & MS_RDONLY)) { /* rw/ro -> rw */ 664 if (vfsp->vfs_flag & VFS_RDONLY) 665 vfsp->vfs_flag &= ~VFS_RDONLY; 666 if (args->flags & XFSMNT_BARRIER) { 667 mp->m_flags |= XFS_MOUNT_BARRIER; 668 xfs_mountfs_check_barriers(mp); 669 } else { 670 mp->m_flags &= ~XFS_MOUNT_BARRIER; 671 } 672 } else if (!(vfsp->vfs_flag & VFS_RDONLY)) { /* rw -> ro */ 673 bhv_vfs_sync(vfsp, SYNC_FSDATA|SYNC_BDFLUSH|SYNC_ATTR, NULL); 674 xfs_quiesce_fs(mp); 675 xfs_log_unmount_write(mp); 676 xfs_unmountfs_writesb(mp); 677 vfsp->vfs_flag |= VFS_RDONLY; 678 } 679 return 0; 680} 681 682/* 683 * xfs_unmount_flush implements a set of flush operation on special 684 * inodes, which are needed as a separate set of operations so that 685 * they can be called as part of relocation process. 686 */ 687int 688xfs_unmount_flush( 689 xfs_mount_t *mp, /* Mount structure we are getting 690 rid of. */ 691 int relocation) /* Called from vfs relocation. */ 692{ 693 xfs_inode_t *rip = mp->m_rootip; 694 xfs_inode_t *rbmip; 695 xfs_inode_t *rsumip = NULL; 696 bhv_vnode_t *rvp = XFS_ITOV(rip); 697 int error; 698 699 xfs_ilock(rip, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT); 700 xfs_iflock(rip); 701 702 /* 703 * Flush out the real time inodes. 704 */ 705 if ((rbmip = mp->m_rbmip) != NULL) { 706 xfs_ilock(rbmip, XFS_ILOCK_EXCL); 707 xfs_iflock(rbmip); 708 error = xfs_iflush(rbmip, XFS_IFLUSH_SYNC); 709 xfs_iunlock(rbmip, XFS_ILOCK_EXCL); 710 711 if (error == EFSCORRUPTED) 712 goto fscorrupt_out; 713 714 ASSERT(vn_count(XFS_ITOV(rbmip)) == 1); 715 716 rsumip = mp->m_rsumip; 717 xfs_ilock(rsumip, XFS_ILOCK_EXCL); 718 xfs_iflock(rsumip); 719 error = xfs_iflush(rsumip, XFS_IFLUSH_SYNC); 720 xfs_iunlock(rsumip, XFS_ILOCK_EXCL); 721 722 if (error == EFSCORRUPTED) 723 goto fscorrupt_out; 724 725 ASSERT(vn_count(XFS_ITOV(rsumip)) == 1); 726 } 727 728 /* 729 * Synchronously flush root inode to disk 730 */ 731 error = xfs_iflush(rip, XFS_IFLUSH_SYNC); 732 if (error == EFSCORRUPTED) 733 goto fscorrupt_out2; 734 735 if (vn_count(rvp) != 1 && !relocation) { 736 xfs_iunlock(rip, XFS_ILOCK_EXCL); 737 return XFS_ERROR(EBUSY); 738 } 739 740 /* 741 * Release dquot that rootinode, rbmino and rsumino might be holding, 742 * flush and purge the quota inodes. 743 */ 744 error = XFS_QM_UNMOUNT(mp); 745 if (error == EFSCORRUPTED) 746 goto fscorrupt_out2; 747 748 if (rbmip) { 749 VN_RELE(XFS_ITOV(rbmip)); 750 VN_RELE(XFS_ITOV(rsumip)); 751 } 752 753 xfs_iunlock(rip, XFS_ILOCK_EXCL); 754 return 0; 755 756fscorrupt_out: 757 xfs_ifunlock(rip); 758 759fscorrupt_out2: 760 xfs_iunlock(rip, XFS_ILOCK_EXCL); 761 762 return XFS_ERROR(EFSCORRUPTED); 763} 764 765/* 766 * xfs_root extracts the root vnode from a vfs. 767 * 768 * vfsp -- the vfs struct for the desired file system 769 * vpp -- address of the caller's vnode pointer which should be 770 * set to the desired fs root vnode 771 */ 772STATIC int 773xfs_root( 774 bhv_desc_t *bdp, 775 bhv_vnode_t **vpp) 776{ 777 bhv_vnode_t *vp; 778 779 vp = XFS_ITOV((XFS_BHVTOM(bdp))->m_rootip); 780 VN_HOLD(vp); 781 *vpp = vp; 782 return 0; 783} 784 785/* 786 * xfs_statvfs 787 * 788 * Fill in the statvfs structure for the given file system. We use 789 * the superblock lock in the mount structure to ensure a consistent 790 * snapshot of the counters returned. 791 */ 792STATIC int 793xfs_statvfs( 794 bhv_desc_t *bdp, 795 bhv_statvfs_t *statp, 796 bhv_vnode_t *vp) 797{ 798 __uint64_t fakeinos; 799 xfs_extlen_t lsize; 800 xfs_mount_t *mp; 801 xfs_sb_t *sbp; 802 unsigned long s; 803 804 mp = XFS_BHVTOM(bdp); 805 sbp = &(mp->m_sb); 806 807 statp->f_type = XFS_SB_MAGIC; 808 809 xfs_icsb_sync_counters_flags(mp, XFS_ICSB_LAZY_COUNT); 810 s = XFS_SB_LOCK(mp); 811 statp->f_bsize = sbp->sb_blocksize; 812 lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0; 813 statp->f_blocks = sbp->sb_dblocks - lsize; 814 statp->f_bfree = statp->f_bavail = 815 sbp->sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp); 816 fakeinos = statp->f_bfree << sbp->sb_inopblog; 817#if XFS_BIG_INUMS 818 fakeinos += mp->m_inoadd; 819#endif 820 statp->f_files = 821 MIN(sbp->sb_icount + fakeinos, (__uint64_t)XFS_MAXINUMBER); 822 if (mp->m_maxicount) 823#if XFS_BIG_INUMS 824 if (!mp->m_inoadd) 825#endif 826 statp->f_files = min_t(typeof(statp->f_files), 827 statp->f_files, 828 mp->m_maxicount); 829 statp->f_ffree = statp->f_files - (sbp->sb_icount - sbp->sb_ifree); 830 XFS_SB_UNLOCK(mp, s); 831 832 xfs_statvfs_fsid(statp, mp); 833 statp->f_namelen = MAXNAMELEN - 1; 834 835 return 0; 836} 837 838 839/* 840 * xfs_sync flushes any pending I/O to file system vfsp. 841 * 842 * This routine is called by vfs_sync() to make sure that things make it 843 * out to disk eventually, on sync() system calls to flush out everything, 844 * and when the file system is unmounted. For the vfs_sync() case, all 845 * we really need to do is sync out the log to make all of our meta-data 846 * updates permanent (except for timestamps). For calls from pflushd(), 847 * dirty pages are kept moving by calling pdflush() on the inodes 848 * containing them. We also flush the inodes that we can lock without 849 * sleeping and the superblock if we can lock it without sleeping from 850 * vfs_sync() so that items at the tail of the log are always moving out. 851 * 852 * Flags: 853 * SYNC_BDFLUSH - We're being called from vfs_sync() so we don't want 854 * to sleep if we can help it. All we really need 855 * to do is ensure that the log is synced at least 856 * periodically. We also push the inodes and 857 * superblock if we can lock them without sleeping 858 * and they are not pinned. 859 * SYNC_ATTR - We need to flush the inodes. If SYNC_BDFLUSH is not 860 * set, then we really want to lock each inode and flush 861 * it. 862 * SYNC_WAIT - All the flushes that take place in this call should 863 * be synchronous. 864 * SYNC_DELWRI - This tells us to push dirty pages associated with 865 * inodes. SYNC_WAIT and SYNC_BDFLUSH are used to 866 * determine if they should be flushed sync, async, or 867 * delwri. 868 * SYNC_CLOSE - This flag is passed when the system is being 869 * unmounted. We should sync and invalidate everything. 870 * SYNC_FSDATA - This indicates that the caller would like to make 871 * sure the superblock is safe on disk. We can ensure 872 * this by simply making sure the log gets flushed 873 * if SYNC_BDFLUSH is set, and by actually writing it 874 * out otherwise. 875 * SYNC_IOWAIT - The caller wants us to wait for all data I/O to complete 876 * before we return (including direct I/O). Forms the drain 877 * side of the write barrier needed to safely quiesce the 878 * filesystem. 879 * 880 */ 881/*ARGSUSED*/ 882STATIC int 883xfs_sync( 884 bhv_desc_t *bdp, 885 int flags, 886 cred_t *credp) 887{ 888 xfs_mount_t *mp = XFS_BHVTOM(bdp); 889 890 return xfs_syncsub(mp, flags, NULL); 891} 892 893/* 894 * xfs sync routine for internal use 895 * 896 * This routine supports all of the flags defined for the generic vfs_sync 897 * interface as explained above under xfs_sync. 898 * 899 */ 900int 901xfs_sync_inodes( 902 xfs_mount_t *mp, 903 int flags, 904 int *bypassed) 905{ 906 xfs_inode_t *ip = NULL; 907 xfs_inode_t *ip_next; 908 xfs_buf_t *bp; 909 bhv_vnode_t *vp = NULL; 910 int error; 911 int last_error; 912 uint64_t fflag; 913 uint lock_flags; 914 uint base_lock_flags; 915 boolean_t mount_locked; 916 boolean_t vnode_refed; 917 int preempt; 918 xfs_dinode_t *dip; 919 xfs_iptr_t *ipointer; 920#ifdef DEBUG 921 boolean_t ipointer_in = B_FALSE; 922 923#define IPOINTER_SET ipointer_in = B_TRUE 924#define IPOINTER_CLR ipointer_in = B_FALSE 925#else 926#define IPOINTER_SET 927#define IPOINTER_CLR 928#endif 929 930 931/* Insert a marker record into the inode list after inode ip. The list 932 * must be locked when this is called. After the call the list will no 933 * longer be locked. 934 */ 935#define IPOINTER_INSERT(ip, mp) { \ 936 ASSERT(ipointer_in == B_FALSE); \ 937 ipointer->ip_mnext = ip->i_mnext; \ 938 ipointer->ip_mprev = ip; \ 939 ip->i_mnext = (xfs_inode_t *)ipointer; \ 940 ipointer->ip_mnext->i_mprev = (xfs_inode_t *)ipointer; \ 941 preempt = 0; \ 942 XFS_MOUNT_IUNLOCK(mp); \ 943 mount_locked = B_FALSE; \ 944 IPOINTER_SET; \ 945 } 946 947/* Remove the marker from the inode list. If the marker was the only item 948 * in the list then there are no remaining inodes and we should zero out 949 * the whole list. If we are the current head of the list then move the head 950 * past us. 951 */ 952#define IPOINTER_REMOVE(ip, mp) { \ 953 ASSERT(ipointer_in == B_TRUE); \ 954 if (ipointer->ip_mnext != (xfs_inode_t *)ipointer) { \ 955 ip = ipointer->ip_mnext; \ 956 ip->i_mprev = ipointer->ip_mprev; \ 957 ipointer->ip_mprev->i_mnext = ip; \ 958 if (mp->m_inodes == (xfs_inode_t *)ipointer) { \ 959 mp->m_inodes = ip; \ 960 } \ 961 } else { \ 962 ASSERT(mp->m_inodes == (xfs_inode_t *)ipointer); \ 963 mp->m_inodes = NULL; \ 964 ip = NULL; \ 965 } \ 966 IPOINTER_CLR; \ 967 } 968 969#define XFS_PREEMPT_MASK 0x7f 970 971 if (bypassed) 972 *bypassed = 0; 973 if (XFS_MTOVFS(mp)->vfs_flag & VFS_RDONLY) 974 return 0; 975 error = 0; 976 last_error = 0; 977 preempt = 0; 978 979 /* Allocate a reference marker */ 980 ipointer = (xfs_iptr_t *)kmem_zalloc(sizeof(xfs_iptr_t), KM_SLEEP); 981 982 fflag = XFS_B_ASYNC; /* default is don't wait */ 983 if (flags & (SYNC_BDFLUSH | SYNC_DELWRI)) 984 fflag = XFS_B_DELWRI; 985 if (flags & SYNC_WAIT) 986 fflag = 0; /* synchronous overrides all */ 987 988 base_lock_flags = XFS_ILOCK_SHARED; 989 if (flags & (SYNC_DELWRI | SYNC_CLOSE)) { 990 /* 991 * We need the I/O lock if we're going to call any of 992 * the flush/inval routines. 993 */ 994 base_lock_flags |= XFS_IOLOCK_SHARED; 995 } 996 997 XFS_MOUNT_ILOCK(mp); 998 999 ip = mp->m_inodes; 1000 1001 mount_locked = B_TRUE; 1002 vnode_refed = B_FALSE; 1003 1004 IPOINTER_CLR; 1005 1006 do { 1007 ASSERT(ipointer_in == B_FALSE); 1008 ASSERT(vnode_refed == B_FALSE); 1009 1010 lock_flags = base_lock_flags; 1011 1012 /* 1013 * There were no inodes in the list, just break out 1014 * of the loop. 1015 */ 1016 if (ip == NULL) { 1017 break; 1018 } 1019 1020 /* 1021 * We found another sync thread marker - skip it 1022 */ 1023 if (ip->i_mount == NULL) { 1024 ip = ip->i_mnext; 1025 continue; 1026 } 1027 1028 vp = XFS_ITOV_NULL(ip); 1029 1030 /* 1031 * If the vnode is gone then this is being torn down, 1032 * call reclaim if it is flushed, else let regular flush 1033 * code deal with it later in the loop. 1034 */ 1035 1036 if (vp == NULL) { 1037 /* Skip ones already in reclaim */ 1038 if (ip->i_flags & XFS_IRECLAIM) { 1039 ip = ip->i_mnext; 1040 continue; 1041 } 1042 if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL) == 0) { 1043 ip = ip->i_mnext; 1044 } else if ((xfs_ipincount(ip) == 0) && 1045 xfs_iflock_nowait(ip)) { 1046 IPOINTER_INSERT(ip, mp); 1047 1048 xfs_finish_reclaim(ip, 1, 1049 XFS_IFLUSH_DELWRI_ELSE_ASYNC); 1050 1051 XFS_MOUNT_ILOCK(mp); 1052 mount_locked = B_TRUE; 1053 IPOINTER_REMOVE(ip, mp); 1054 } else { 1055 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1056 ip = ip->i_mnext; 1057 } 1058 continue; 1059 } 1060 1061 if (VN_BAD(vp)) { 1062 ip = ip->i_mnext; 1063 continue; 1064 } 1065 1066 if (XFS_FORCED_SHUTDOWN(mp) && !(flags & SYNC_CLOSE)) { 1067 XFS_MOUNT_IUNLOCK(mp); 1068 kmem_free(ipointer, sizeof(xfs_iptr_t)); 1069 return 0; 1070 } 1071 1072 /* 1073 * If this is just vfs_sync() or pflushd() calling 1074 * then we can skip inodes for which it looks like 1075 * there is nothing to do. Since we don't have the 1076 * inode locked this is racy, but these are periodic 1077 * calls so it doesn't matter. For the others we want 1078 * to know for sure, so we at least try to lock them. 1079 */ 1080 if (flags & SYNC_BDFLUSH) { 1081 if (((ip->i_itemp == NULL) || 1082 !(ip->i_itemp->ili_format.ilf_fields & 1083 XFS_ILOG_ALL)) && 1084 (ip->i_update_core == 0)) { 1085 ip = ip->i_mnext; 1086 continue; 1087 } 1088 } 1089 1090 /* 1091 * Try to lock without sleeping. We're out of order with 1092 * the inode list lock here, so if we fail we need to drop 1093 * the mount lock and try again. If we're called from 1094 * bdflush() here, then don't bother. 1095 * 1096 * The inode lock here actually coordinates with the 1097 * almost spurious inode lock in xfs_ireclaim() to prevent 1098 * the vnode we handle here without a reference from 1099 * being freed while we reference it. If we lock the inode 1100 * while it's on the mount list here, then the spurious inode 1101 * lock in xfs_ireclaim() after the inode is pulled from 1102 * the mount list will sleep until we release it here. 1103 * This keeps the vnode from being freed while we reference 1104 * it. 1105 */ 1106 if (xfs_ilock_nowait(ip, lock_flags) == 0) { 1107 if ((flags & SYNC_BDFLUSH) || (vp == NULL)) { 1108 ip = ip->i_mnext; 1109 continue; 1110 } 1111 1112 vp = vn_grab(vp); 1113 if (vp == NULL) { 1114 ip = ip->i_mnext; 1115 continue; 1116 } 1117 1118 IPOINTER_INSERT(ip, mp); 1119 xfs_ilock(ip, lock_flags); 1120 1121 ASSERT(vp == XFS_ITOV(ip)); 1122 ASSERT(ip->i_mount == mp); 1123 1124 vnode_refed = B_TRUE; 1125 } 1126 1127 /* From here on in the loop we may have a marker record 1128 * in the inode list. 1129 */ 1130 1131 if ((flags & SYNC_CLOSE) && (vp != NULL)) { 1132 /* 1133 * This is the shutdown case. We just need to 1134 * flush and invalidate all the pages associated 1135 * with the inode. Drop the inode lock since 1136 * we can't hold it across calls to the buffer 1137 * cache. 1138 * 1139 * We don't set the VREMAPPING bit in the vnode 1140 * here, because we don't hold the vnode lock 1141 * exclusively. It doesn't really matter, though, 1142 * because we only come here when we're shutting 1143 * down anyway. 1144 */ 1145 xfs_iunlock(ip, XFS_ILOCK_SHARED); 1146 1147 if (XFS_FORCED_SHUTDOWN(mp)) { 1148 bhv_vop_toss_pages(vp, 0, -1, FI_REMAPF); 1149 } else { 1150 error = bhv_vop_flushinval_pages(vp, 0, -1, FI_REMAPF); 1151 } 1152 1153 xfs_ilock(ip, XFS_ILOCK_SHARED); 1154 1155 } else if ((flags & SYNC_DELWRI) && (vp != NULL)) { 1156 if (VN_DIRTY(vp)) { 1157 /* We need to have dropped the lock here, 1158 * so insert a marker if we have not already 1159 * done so. 1160 */ 1161 if (mount_locked) { 1162 IPOINTER_INSERT(ip, mp); 1163 } 1164 1165 /* 1166 * Drop the inode lock since we can't hold it 1167 * across calls to the buffer cache. 1168 */ 1169 xfs_iunlock(ip, XFS_ILOCK_SHARED); 1170 error = bhv_vop_flush_pages(vp, (xfs_off_t)0, 1171 -1, fflag, FI_NONE); 1172 xfs_ilock(ip, XFS_ILOCK_SHARED); 1173 } 1174 1175 } 1176 /* 1177 * When freezing, we need to wait ensure all I/O (including direct 1178 * I/O) is complete to ensure no further data modification can take 1179 * place after this point 1180 */ 1181 if (flags & SYNC_IOWAIT) 1182 vn_iowait(vp); 1183 1184 if (flags & SYNC_BDFLUSH) { 1185 if ((flags & SYNC_ATTR) && 1186 ((ip->i_update_core) || 1187 ((ip->i_itemp != NULL) && 1188 (ip->i_itemp->ili_format.ilf_fields != 0)))) { 1189 1190 /* Insert marker and drop lock if not already 1191 * done. 1192 */ 1193 if (mount_locked) { 1194 IPOINTER_INSERT(ip, mp); 1195 } 1196 1197 /* 1198 * We don't want the periodic flushing of the 1199 * inodes by vfs_sync() to interfere with 1200 * I/O to the file, especially read I/O 1201 * where it is only the access time stamp 1202 * that is being flushed out. To prevent 1203 * long periods where we have both inode 1204 * locks held shared here while reading the 1205 * inode's buffer in from disk, we drop the 1206 * inode lock while reading in the inode 1207 * buffer. We have to release the buffer 1208 * and reacquire the inode lock so that they 1209 * are acquired in the proper order (inode 1210 * locks first). The buffer will go at the 1211 * end of the lru chain, though, so we can 1212 * expect it to still be there when we go 1213 * for it again in xfs_iflush(). 1214 */ 1215 if ((xfs_ipincount(ip) == 0) && 1216 xfs_iflock_nowait(ip)) { 1217 1218 xfs_ifunlock(ip); 1219 xfs_iunlock(ip, XFS_ILOCK_SHARED); 1220 1221 error = xfs_itobp(mp, NULL, ip, 1222 &dip, &bp, 0, 0); 1223 if (!error) { 1224 xfs_buf_relse(bp); 1225 } else { 1226 /* Bailing out, remove the 1227 * marker and free it. 1228 */ 1229 XFS_MOUNT_ILOCK(mp); 1230 IPOINTER_REMOVE(ip, mp); 1231 XFS_MOUNT_IUNLOCK(mp); 1232 1233 ASSERT(!(lock_flags & 1234 XFS_IOLOCK_SHARED)); 1235 1236 kmem_free(ipointer, 1237 sizeof(xfs_iptr_t)); 1238 return (0); 1239 } 1240 1241 /* 1242 * Since we dropped the inode lock, 1243 * the inode may have been reclaimed. 1244 * Therefore, we reacquire the mount 1245 * lock and check to see if we were the 1246 * inode reclaimed. If this happened 1247 * then the ipointer marker will no 1248 * longer point back at us. In this 1249 * case, move ip along to the inode 1250 * after the marker, remove the marker 1251 * and continue. 1252 */ 1253 XFS_MOUNT_ILOCK(mp); 1254 mount_locked = B_TRUE; 1255 1256 if (ip != ipointer->ip_mprev) { 1257 IPOINTER_REMOVE(ip, mp); 1258 1259 ASSERT(!vnode_refed); 1260 ASSERT(!(lock_flags & 1261 XFS_IOLOCK_SHARED)); 1262 continue; 1263 } 1264 1265 ASSERT(ip->i_mount == mp); 1266 1267 if (xfs_ilock_nowait(ip, 1268 XFS_ILOCK_SHARED) == 0) { 1269 ASSERT(ip->i_mount == mp); 1270 /* 1271 * We failed to reacquire 1272 * the inode lock without 1273 * sleeping, so just skip 1274 * the inode for now. We 1275 * clear the ILOCK bit from 1276 * the lock_flags so that we 1277 * won't try to drop a lock 1278 * we don't hold below. 1279 */ 1280 lock_flags &= ~XFS_ILOCK_SHARED; 1281 IPOINTER_REMOVE(ip_next, mp); 1282 } else if ((xfs_ipincount(ip) == 0) && 1283 xfs_iflock_nowait(ip)) { 1284 ASSERT(ip->i_mount == mp); 1285 /* 1286 * Since this is vfs_sync() 1287 * calling we only flush the 1288 * inode out if we can lock 1289 * it without sleeping and 1290 * it is not pinned. Drop 1291 * the mount lock here so 1292 * that we don't hold it for 1293 * too long. We already have 1294 * a marker in the list here. 1295 */ 1296 XFS_MOUNT_IUNLOCK(mp); 1297 mount_locked = B_FALSE; 1298 error = xfs_iflush(ip, 1299 XFS_IFLUSH_DELWRI); 1300 } else { 1301 ASSERT(ip->i_mount == mp); 1302 IPOINTER_REMOVE(ip_next, mp); 1303 } 1304 } 1305 1306 } 1307 1308 } else { 1309 if ((flags & SYNC_ATTR) && 1310 ((ip->i_update_core) || 1311 ((ip->i_itemp != NULL) && 1312 (ip->i_itemp->ili_format.ilf_fields != 0)))) { 1313 if (mount_locked) { 1314 IPOINTER_INSERT(ip, mp); 1315 } 1316 1317 if (flags & SYNC_WAIT) { 1318 xfs_iflock(ip); 1319 error = xfs_iflush(ip, 1320 XFS_IFLUSH_SYNC); 1321 } else { 1322 /* 1323 * If we can't acquire the flush 1324 * lock, then the inode is already 1325 * being flushed so don't bother 1326 * waiting. If we can lock it then 1327 * do a delwri flush so we can 1328 * combine multiple inode flushes 1329 * in each disk write. 1330 */ 1331 if (xfs_iflock_nowait(ip)) { 1332 error = xfs_iflush(ip, 1333 XFS_IFLUSH_DELWRI); 1334 } 1335 else if (bypassed) 1336 (*bypassed)++; 1337 } 1338 } 1339 } 1340 1341 if (lock_flags != 0) { 1342 xfs_iunlock(ip, lock_flags); 1343 } 1344 1345 if (vnode_refed) { 1346 /* 1347 * If we had to take a reference on the vnode 1348 * above, then wait until after we've unlocked 1349 * the inode to release the reference. This is 1350 * because we can be already holding the inode 1351 * lock when VN_RELE() calls xfs_inactive(). 1352 * 1353 * Make sure to drop the mount lock before calling 1354 * VN_RELE() so that we don't trip over ourselves if 1355 * we have to go for the mount lock again in the 1356 * inactive code. 1357 */ 1358 if (mount_locked) { 1359 IPOINTER_INSERT(ip, mp); 1360 } 1361 1362 VN_RELE(vp); 1363 1364 vnode_refed = B_FALSE; 1365 } 1366 1367 if (error) { 1368 last_error = error; 1369 } 1370 1371 /* 1372 * bail out if the filesystem is corrupted. 1373 */ 1374 if (error == EFSCORRUPTED) { 1375 if (!mount_locked) { 1376 XFS_MOUNT_ILOCK(mp); 1377 IPOINTER_REMOVE(ip, mp); 1378 } 1379 XFS_MOUNT_IUNLOCK(mp); 1380 ASSERT(ipointer_in == B_FALSE); 1381 kmem_free(ipointer, sizeof(xfs_iptr_t)); 1382 return XFS_ERROR(error); 1383 } 1384 1385 /* Let other threads have a chance at the mount lock 1386 * if we have looped many times without dropping the 1387 * lock. 1388 */ 1389 if ((++preempt & XFS_PREEMPT_MASK) == 0) { 1390 if (mount_locked) { 1391 IPOINTER_INSERT(ip, mp); 1392 } 1393 } 1394 1395 if (mount_locked == B_FALSE) { 1396 XFS_MOUNT_ILOCK(mp); 1397 mount_locked = B_TRUE; 1398 IPOINTER_REMOVE(ip, mp); 1399 continue; 1400 } 1401 1402 ASSERT(ipointer_in == B_FALSE); 1403 ip = ip->i_mnext; 1404 1405 } while (ip != mp->m_inodes); 1406 1407 XFS_MOUNT_IUNLOCK(mp); 1408 1409 ASSERT(ipointer_in == B_FALSE); 1410 1411 kmem_free(ipointer, sizeof(xfs_iptr_t)); 1412 return XFS_ERROR(last_error); 1413} 1414 1415/* 1416 * xfs sync routine for internal use 1417 * 1418 * This routine supports all of the flags defined for the generic vfs_sync 1419 * interface as explained above under xfs_sync. 1420 * 1421 */ 1422int 1423xfs_syncsub( 1424 xfs_mount_t *mp, 1425 int flags, 1426 int *bypassed) 1427{ 1428 int error = 0; 1429 int last_error = 0; 1430 uint log_flags = XFS_LOG_FORCE; 1431 xfs_buf_t *bp; 1432 xfs_buf_log_item_t *bip; 1433 1434 /* 1435 * Sync out the log. This ensures that the log is periodically 1436 * flushed even if there is not enough activity to fill it up. 1437 */ 1438 if (flags & SYNC_WAIT) 1439 log_flags |= XFS_LOG_SYNC; 1440 1441 xfs_log_force(mp, (xfs_lsn_t)0, log_flags); 1442 1443 if (flags & (SYNC_ATTR|SYNC_DELWRI)) { 1444 if (flags & SYNC_BDFLUSH) 1445 xfs_finish_reclaim_all(mp, 1); 1446 else 1447 error = xfs_sync_inodes(mp, flags, bypassed); 1448 } 1449 1450 /* 1451 * Flushing out dirty data above probably generated more 1452 * log activity, so if this isn't vfs_sync() then flush 1453 * the log again. 1454 */ 1455 if (flags & SYNC_DELWRI) { 1456 xfs_log_force(mp, (xfs_lsn_t)0, log_flags); 1457 } 1458 1459 if (flags & SYNC_FSDATA) { 1460 /* 1461 * If this is vfs_sync() then only sync the superblock 1462 * if we can lock it without sleeping and it is not pinned. 1463 */ 1464 if (flags & SYNC_BDFLUSH) { 1465 bp = xfs_getsb(mp, XFS_BUF_TRYLOCK); 1466 if (bp != NULL) { 1467 bip = XFS_BUF_FSPRIVATE(bp,xfs_buf_log_item_t*); 1468 if ((bip != NULL) && 1469 xfs_buf_item_dirty(bip)) { 1470 if (!(XFS_BUF_ISPINNED(bp))) { 1471 XFS_BUF_ASYNC(bp); 1472 error = xfs_bwrite(mp, bp); 1473 } else { 1474 xfs_buf_relse(bp); 1475 } 1476 } else { 1477 xfs_buf_relse(bp); 1478 } 1479 } 1480 } else { 1481 bp = xfs_getsb(mp, 0); 1482 /* 1483 * If the buffer is pinned then push on the log so 1484 * we won't get stuck waiting in the write for 1485 * someone, maybe ourselves, to flush the log. 1486 * Even though we just pushed the log above, we 1487 * did not have the superblock buffer locked at 1488 * that point so it can become pinned in between 1489 * there and here. 1490 */ 1491 if (XFS_BUF_ISPINNED(bp)) 1492 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE); 1493 if (flags & SYNC_WAIT) 1494 XFS_BUF_UNASYNC(bp); 1495 else 1496 XFS_BUF_ASYNC(bp); 1497 error = xfs_bwrite(mp, bp); 1498 } 1499 if (error) { 1500 last_error = error; 1501 } 1502 } 1503 1504 /* 1505 * If this is the periodic sync, then kick some entries out of 1506 * the reference cache. This ensures that idle entries are 1507 * eventually kicked out of the cache. 1508 */ 1509 if (flags & SYNC_REFCACHE) { 1510 if (flags & SYNC_WAIT) 1511 xfs_refcache_purge_mp(mp); 1512 else 1513 xfs_refcache_purge_some(mp); 1514 } 1515 1516 /* 1517 * Now check to see if the log needs a "dummy" transaction. 1518 */ 1519 1520 if (!(flags & SYNC_REMOUNT) && xfs_log_need_covered(mp)) { 1521 xfs_trans_t *tp; 1522 xfs_inode_t *ip; 1523 1524 /* 1525 * Put a dummy transaction in the log to tell 1526 * recovery that all others are OK. 1527 */ 1528 tp = xfs_trans_alloc(mp, XFS_TRANS_DUMMY1); 1529 if ((error = xfs_trans_reserve(tp, 0, 1530 XFS_ICHANGE_LOG_RES(mp), 1531 0, 0, 0))) { 1532 xfs_trans_cancel(tp, 0); 1533 return error; 1534 } 1535 1536 ip = mp->m_rootip; 1537 xfs_ilock(ip, XFS_ILOCK_EXCL); 1538 1539 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 1540 xfs_trans_ihold(tp, ip); 1541 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 1542 error = xfs_trans_commit(tp, 0); 1543 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1544 xfs_log_force(mp, (xfs_lsn_t)0, log_flags); 1545 } 1546 1547 /* 1548 * When shutting down, we need to insure that the AIL is pushed 1549 * to disk or the filesystem can appear corrupt from the PROM. 1550 */ 1551 if ((flags & (SYNC_CLOSE|SYNC_WAIT)) == (SYNC_CLOSE|SYNC_WAIT)) { 1552 XFS_bflush(mp->m_ddev_targp); 1553 if (mp->m_rtdev_targp) { 1554 XFS_bflush(mp->m_rtdev_targp); 1555 } 1556 } 1557 1558 return XFS_ERROR(last_error); 1559} 1560 1561/* 1562 * xfs_vget - called by DMAPI and NFSD to get vnode from file handle 1563 */ 1564STATIC int 1565xfs_vget( 1566 bhv_desc_t *bdp, 1567 bhv_vnode_t **vpp, 1568 fid_t *fidp) 1569{ 1570 xfs_mount_t *mp = XFS_BHVTOM(bdp); 1571 xfs_fid_t *xfid = (struct xfs_fid *)fidp; 1572 xfs_inode_t *ip; 1573 int error; 1574 xfs_ino_t ino; 1575 unsigned int igen; 1576 1577 /* 1578 * Invalid. Since handles can be created in user space and passed in 1579 * via gethandle(), this is not cause for a panic. 1580 */ 1581 if (xfid->xfs_fid_len != sizeof(*xfid) - sizeof(xfid->xfs_fid_len)) 1582 return XFS_ERROR(EINVAL); 1583 1584 ino = xfid->xfs_fid_ino; 1585 igen = xfid->xfs_fid_gen; 1586 1587 /* 1588 * NFS can sometimes send requests for ino 0. Fail them gracefully. 1589 */ 1590 if (ino == 0) 1591 return XFS_ERROR(ESTALE); 1592 1593 error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_SHARED, &ip, 0); 1594 if (error) { 1595 *vpp = NULL; 1596 return error; 1597 } 1598 1599 if (ip == NULL) { 1600 *vpp = NULL; 1601 return XFS_ERROR(EIO); 1602 } 1603 1604 if (ip->i_d.di_mode == 0 || ip->i_d.di_gen != igen) { 1605 xfs_iput_new(ip, XFS_ILOCK_SHARED); 1606 *vpp = NULL; 1607 return XFS_ERROR(ENOENT); 1608 } 1609 1610 *vpp = XFS_ITOV(ip); 1611 xfs_iunlock(ip, XFS_ILOCK_SHARED); 1612 return 0; 1613} 1614 1615 1616#define MNTOPT_LOGBUFS "logbufs" /* number of XFS log buffers */ 1617#define MNTOPT_LOGBSIZE "logbsize" /* size of XFS log buffers */ 1618#define MNTOPT_LOGDEV "logdev" /* log device */ 1619#define MNTOPT_RTDEV "rtdev" /* realtime I/O device */ 1620#define MNTOPT_BIOSIZE "biosize" /* log2 of preferred buffered io size */ 1621#define MNTOPT_WSYNC "wsync" /* safe-mode nfs compatible mount */ 1622#define MNTOPT_INO64 "ino64" /* force inodes into 64-bit range */ 1623#define MNTOPT_NOALIGN "noalign" /* turn off stripe alignment */ 1624#define MNTOPT_SWALLOC "swalloc" /* turn on stripe width allocation */ 1625#define MNTOPT_SUNIT "sunit" /* data volume stripe unit */ 1626#define MNTOPT_SWIDTH "swidth" /* data volume stripe width */ 1627#define MNTOPT_NOUUID "nouuid" /* ignore filesystem UUID */ 1628#define MNTOPT_MTPT "mtpt" /* filesystem mount point */ 1629#define MNTOPT_GRPID "grpid" /* group-ID from parent directory */ 1630#define MNTOPT_NOGRPID "nogrpid" /* group-ID from current process */ 1631#define MNTOPT_BSDGROUPS "bsdgroups" /* group-ID from parent directory */ 1632#define MNTOPT_SYSVGROUPS "sysvgroups" /* group-ID from current process */ 1633#define MNTOPT_ALLOCSIZE "allocsize" /* preferred allocation size */ 1634#define MNTOPT_IHASHSIZE "ihashsize" /* size of inode hash table */ 1635#define MNTOPT_NORECOVERY "norecovery" /* don't run XFS recovery */ 1636#define MNTOPT_BARRIER "barrier" /* use writer barriers for log write and 1637 * unwritten extent conversion */ 1638#define MNTOPT_NOBARRIER "nobarrier" /* .. disable */ 1639#define MNTOPT_OSYNCISOSYNC "osyncisosync" /* o_sync is REALLY o_sync */ 1640#define MNTOPT_64BITINODE "inode64" /* inodes can be allocated anywhere */ 1641#define MNTOPT_IKEEP "ikeep" /* do not free empty inode clusters */ 1642#define MNTOPT_NOIKEEP "noikeep" /* free empty inode clusters */ 1643#define MNTOPT_LARGEIO "largeio" /* report large I/O sizes in stat() */ 1644#define MNTOPT_NOLARGEIO "nolargeio" /* do not report large I/O sizes 1645 * in stat(). */ 1646#define MNTOPT_ATTR2 "attr2" /* do use attr2 attribute format */ 1647#define MNTOPT_NOATTR2 "noattr2" /* do not use attr2 attribute format */ 1648 1649STATIC unsigned long 1650suffix_strtoul(char *s, char **endp, unsigned int base) 1651{ 1652 int last, shift_left_factor = 0; 1653 char *value = s; 1654 1655 last = strlen(value) - 1; 1656 if (value[last] == 'K' || value[last] == 'k') { 1657 shift_left_factor = 10; 1658 value[last] = '\0'; 1659 } 1660 if (value[last] == 'M' || value[last] == 'm') { 1661 shift_left_factor = 20; 1662 value[last] = '\0'; 1663 } 1664 if (value[last] == 'G' || value[last] == 'g') { 1665 shift_left_factor = 30; 1666 value[last] = '\0'; 1667 } 1668 1669 return simple_strtoul((const char *)s, endp, base) << shift_left_factor; 1670} 1671 1672STATIC int 1673xfs_parseargs( 1674 struct bhv_desc *bhv, 1675 char *options, 1676 struct xfs_mount_args *args, 1677 int update) 1678{ 1679 bhv_vfs_t *vfsp = bhvtovfs(bhv); 1680 char *this_char, *value, *eov; 1681 int dsunit, dswidth, vol_dsunit, vol_dswidth; 1682 int iosize; 1683 1684 args->flags |= XFSMNT_IDELETE; 1685 args->flags |= XFSMNT_BARRIER; 1686 args->flags2 |= XFSMNT2_COMPAT_IOSIZE; 1687 1688 if (!options) 1689 goto done; 1690 1691 iosize = dsunit = dswidth = vol_dsunit = vol_dswidth = 0; 1692 1693 while ((this_char = strsep(&options, ",")) != NULL) { 1694 if (!*this_char) 1695 continue; 1696 if ((value = strchr(this_char, '=')) != NULL) 1697 *value++ = 0; 1698 1699 if (!strcmp(this_char, MNTOPT_LOGBUFS)) { 1700 if (!value || !*value) { 1701 cmn_err(CE_WARN, 1702 "XFS: %s option requires an argument", 1703 this_char); 1704 return EINVAL; 1705 } 1706 args->logbufs = simple_strtoul(value, &eov, 10); 1707 } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) { 1708 if (!value || !*value) { 1709 cmn_err(CE_WARN, 1710 "XFS: %s option requires an argument", 1711 this_char); 1712 return EINVAL; 1713 } 1714 args->logbufsize = suffix_strtoul(value, &eov, 10); 1715 } else if (!strcmp(this_char, MNTOPT_LOGDEV)) { 1716 if (!value || !*value) { 1717 cmn_err(CE_WARN, 1718 "XFS: %s option requires an argument", 1719 this_char); 1720 return EINVAL; 1721 } 1722 strncpy(args->logname, value, MAXNAMELEN); 1723 } else if (!strcmp(this_char, MNTOPT_MTPT)) { 1724 if (!value || !*value) { 1725 cmn_err(CE_WARN, 1726 "XFS: %s option requires an argument", 1727 this_char); 1728 return EINVAL; 1729 } 1730 strncpy(args->mtpt, value, MAXNAMELEN); 1731 } else if (!strcmp(this_char, MNTOPT_RTDEV)) { 1732 if (!value || !*value) { 1733 cmn_err(CE_WARN, 1734 "XFS: %s option requires an argument", 1735 this_char); 1736 return EINVAL; 1737 } 1738 strncpy(args->rtname, value, MAXNAMELEN); 1739 } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) { 1740 if (!value || !*value) { 1741 cmn_err(CE_WARN, 1742 "XFS: %s option requires an argument", 1743 this_char); 1744 return EINVAL; 1745 } 1746 iosize = simple_strtoul(value, &eov, 10); 1747 args->flags |= XFSMNT_IOSIZE; 1748 args->iosizelog = (uint8_t) iosize; 1749 } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) { 1750 if (!value || !*value) { 1751 cmn_err(CE_WARN, 1752 "XFS: %s option requires an argument", 1753 this_char); 1754 return EINVAL; 1755 } 1756 iosize = suffix_strtoul(value, &eov, 10); 1757 args->flags |= XFSMNT_IOSIZE; 1758 args->iosizelog = ffs(iosize) - 1; 1759 } else if (!strcmp(this_char, MNTOPT_IHASHSIZE)) { 1760 if (!value || !*value) { 1761 cmn_err(CE_WARN, 1762 "XFS: %s option requires an argument", 1763 this_char); 1764 return EINVAL; 1765 } 1766 args->flags |= XFSMNT_IHASHSIZE; 1767 args->ihashsize = simple_strtoul(value, &eov, 10); 1768 } else if (!strcmp(this_char, MNTOPT_GRPID) || 1769 !strcmp(this_char, MNTOPT_BSDGROUPS)) { 1770 vfsp->vfs_flag |= VFS_GRPID; 1771 } else if (!strcmp(this_char, MNTOPT_NOGRPID) || 1772 !strcmp(this_char, MNTOPT_SYSVGROUPS)) { 1773 vfsp->vfs_flag &= ~VFS_GRPID; 1774 } else if (!strcmp(this_char, MNTOPT_WSYNC)) { 1775 args->flags |= XFSMNT_WSYNC; 1776 } else if (!strcmp(this_char, MNTOPT_OSYNCISOSYNC)) { 1777 args->flags |= XFSMNT_OSYNCISOSYNC; 1778 } else if (!strcmp(this_char, MNTOPT_NORECOVERY)) { 1779 args->flags |= XFSMNT_NORECOVERY; 1780 } else if (!strcmp(this_char, MNTOPT_INO64)) { 1781 args->flags |= XFSMNT_INO64; 1782#if !XFS_BIG_INUMS 1783 cmn_err(CE_WARN, 1784 "XFS: %s option not allowed on this system", 1785 this_char); 1786 return EINVAL; 1787#endif 1788 } else if (!strcmp(this_char, MNTOPT_NOALIGN)) { 1789 args->flags |= XFSMNT_NOALIGN; 1790 } else if (!strcmp(this_char, MNTOPT_SWALLOC)) { 1791 args->flags |= XFSMNT_SWALLOC; 1792 } else if (!strcmp(this_char, MNTOPT_SUNIT)) { 1793 if (!value || !*value) { 1794 cmn_err(CE_WARN, 1795 "XFS: %s option requires an argument", 1796 this_char); 1797 return EINVAL; 1798 } 1799 dsunit = simple_strtoul(value, &eov, 10); 1800 } else if (!strcmp(this_char, MNTOPT_SWIDTH)) { 1801 if (!value || !*value) { 1802 cmn_err(CE_WARN, 1803 "XFS: %s option requires an argument", 1804 this_char); 1805 return EINVAL; 1806 } 1807 dswidth = simple_strtoul(value, &eov, 10); 1808 } else if (!strcmp(this_char, MNTOPT_64BITINODE)) { 1809 args->flags &= ~XFSMNT_32BITINODES; 1810#if !XFS_BIG_INUMS 1811 cmn_err(CE_WARN, 1812 "XFS: %s option not allowed on this system", 1813 this_char); 1814 return EINVAL; 1815#endif 1816 } else if (!strcmp(this_char, MNTOPT_NOUUID)) { 1817 args->flags |= XFSMNT_NOUUID; 1818 } else if (!strcmp(this_char, MNTOPT_BARRIER)) { 1819 args->flags |= XFSMNT_BARRIER; 1820 } else if (!strcmp(this_char, MNTOPT_NOBARRIER)) { 1821 args->flags &= ~XFSMNT_BARRIER; 1822 } else if (!strcmp(this_char, MNTOPT_IKEEP)) { 1823 args->flags &= ~XFSMNT_IDELETE; 1824 } else if (!strcmp(this_char, MNTOPT_NOIKEEP)) { 1825 args->flags |= XFSMNT_IDELETE; 1826 } else if (!strcmp(this_char, MNTOPT_LARGEIO)) { 1827 args->flags2 &= ~XFSMNT2_COMPAT_IOSIZE; 1828 } else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) { 1829 args->flags2 |= XFSMNT2_COMPAT_IOSIZE; 1830 } else if (!strcmp(this_char, MNTOPT_ATTR2)) { 1831 args->flags |= XFSMNT_ATTR2; 1832 } else if (!strcmp(this_char, MNTOPT_NOATTR2)) { 1833 args->flags &= ~XFSMNT_ATTR2; 1834 } else if (!strcmp(this_char, "osyncisdsync")) { 1835 /* no-op, this is now the default */ 1836 cmn_err(CE_WARN, 1837 "XFS: osyncisdsync is now the default, option is deprecated."); 1838 } else if (!strcmp(this_char, "irixsgid")) { 1839 cmn_err(CE_WARN, 1840 "XFS: irixsgid is now a sysctl(2) variable, option is deprecated."); 1841 } else { 1842 cmn_err(CE_WARN, 1843 "XFS: unknown mount option [%s].", this_char); 1844 return EINVAL; 1845 } 1846 } 1847 1848 if (args->flags & XFSMNT_NORECOVERY) { 1849 if ((vfsp->vfs_flag & VFS_RDONLY) == 0) { 1850 cmn_err(CE_WARN, 1851 "XFS: no-recovery mounts must be read-only."); 1852 return EINVAL; 1853 } 1854 } 1855 1856 if ((args->flags & XFSMNT_NOALIGN) && (dsunit || dswidth)) { 1857 cmn_err(CE_WARN, 1858 "XFS: sunit and swidth options incompatible with the noalign option"); 1859 return EINVAL; 1860 } 1861 1862 if ((dsunit && !dswidth) || (!dsunit && dswidth)) { 1863 cmn_err(CE_WARN, 1864 "XFS: sunit and swidth must be specified together"); 1865 return EINVAL; 1866 } 1867 1868 if (dsunit && (dswidth % dsunit != 0)) { 1869 cmn_err(CE_WARN, 1870 "XFS: stripe width (%d) must be a multiple of the stripe unit (%d)", 1871 dswidth, dsunit); 1872 return EINVAL; 1873 } 1874 1875 if ((args->flags & XFSMNT_NOALIGN) != XFSMNT_NOALIGN) { 1876 if (dsunit) { 1877 args->sunit = dsunit; 1878 args->flags |= XFSMNT_RETERR; 1879 } else { 1880 args->sunit = vol_dsunit; 1881 } 1882 dswidth ? (args->swidth = dswidth) : 1883 (args->swidth = vol_dswidth); 1884 } else { 1885 args->sunit = args->swidth = 0; 1886 } 1887 1888done: 1889 if (args->flags & XFSMNT_32BITINODES) 1890 vfsp->vfs_flag |= VFS_32BITINODES; 1891 if (args->flags2) 1892 args->flags |= XFSMNT_FLAGS2; 1893 return 0; 1894} 1895 1896STATIC int 1897xfs_showargs( 1898 struct bhv_desc *bhv, 1899 struct seq_file *m) 1900{ 1901 static struct proc_xfs_info { 1902 int flag; 1903 char *str; 1904 } xfs_info[] = { 1905 /* the few simple ones we can get from the mount struct */ 1906 { XFS_MOUNT_WSYNC, "," MNTOPT_WSYNC }, 1907 { XFS_MOUNT_INO64, "," MNTOPT_INO64 }, 1908 { XFS_MOUNT_NOALIGN, "," MNTOPT_NOALIGN }, 1909 { XFS_MOUNT_SWALLOC, "," MNTOPT_SWALLOC }, 1910 { XFS_MOUNT_NOUUID, "," MNTOPT_NOUUID }, 1911 { XFS_MOUNT_NORECOVERY, "," MNTOPT_NORECOVERY }, 1912 { XFS_MOUNT_OSYNCISOSYNC, "," MNTOPT_OSYNCISOSYNC }, 1913 { 0, NULL } 1914 }; 1915 struct proc_xfs_info *xfs_infop; 1916 struct xfs_mount *mp = XFS_BHVTOM(bhv); 1917 struct bhv_vfs *vfsp = XFS_MTOVFS(mp); 1918 1919 for (xfs_infop = xfs_info; xfs_infop->flag; xfs_infop++) { 1920 if (mp->m_flags & xfs_infop->flag) 1921 seq_puts(m, xfs_infop->str); 1922 } 1923 1924 if (mp->m_flags & XFS_MOUNT_IHASHSIZE) 1925 seq_printf(m, "," MNTOPT_IHASHSIZE "=%d", (int)mp->m_ihsize); 1926 1927 if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE) 1928 seq_printf(m, "," MNTOPT_ALLOCSIZE "=%dk", 1929 (int)(1 << mp->m_writeio_log) >> 10); 1930 1931 if (mp->m_logbufs > 0) 1932 seq_printf(m, "," MNTOPT_LOGBUFS "=%d", mp->m_logbufs); 1933 if (mp->m_logbsize > 0) 1934 seq_printf(m, "," MNTOPT_LOGBSIZE "=%dk", mp->m_logbsize >> 10); 1935 1936 if (mp->m_logname) 1937 seq_printf(m, "," MNTOPT_LOGDEV "=%s", mp->m_logname); 1938 if (mp->m_rtname) 1939 seq_printf(m, "," MNTOPT_RTDEV "=%s", mp->m_rtname); 1940 1941 if (mp->m_dalign > 0) 1942 seq_printf(m, "," MNTOPT_SUNIT "=%d", 1943 (int)XFS_FSB_TO_BB(mp, mp->m_dalign)); 1944 if (mp->m_swidth > 0) 1945 seq_printf(m, "," MNTOPT_SWIDTH "=%d", 1946 (int)XFS_FSB_TO_BB(mp, mp->m_swidth)); 1947 1948 if (!(mp->m_flags & XFS_MOUNT_IDELETE)) 1949 seq_printf(m, "," MNTOPT_IKEEP); 1950 if (!(mp->m_flags & XFS_MOUNT_COMPAT_IOSIZE)) 1951 seq_printf(m, "," MNTOPT_LARGEIO); 1952 1953 if (!(vfsp->vfs_flag & VFS_32BITINODES)) 1954 seq_printf(m, "," MNTOPT_64BITINODE); 1955 if (vfsp->vfs_flag & VFS_GRPID) 1956 seq_printf(m, "," MNTOPT_GRPID); 1957 1958 return 0; 1959} 1960 1961/* 1962 * Second stage of a freeze. The data is already frozen, now we have to take 1963 * care of the metadata. New transactions are already blocked, so we need to 1964 * wait for any remaining transactions to drain out before proceding. 1965 */ 1966STATIC void 1967xfs_freeze( 1968 bhv_desc_t *bdp) 1969{ 1970 xfs_mount_t *mp = XFS_BHVTOM(bdp); 1971 1972 /* wait for all modifications to complete */ 1973 while (atomic_read(&mp->m_active_trans) > 0) 1974 delay(100); 1975 1976 /* flush inodes and push all remaining buffers out to disk */ 1977 xfs_quiesce_fs(mp); 1978 1979 ASSERT_ALWAYS(atomic_read(&mp->m_active_trans) == 0); 1980 1981 /* Push the superblock and write an unmount record */ 1982 xfs_log_unmount_write(mp); 1983 xfs_unmountfs_writesb(mp); 1984 xfs_fs_log_dummy(mp); 1985} 1986 1987 1988bhv_vfsops_t xfs_vfsops = { 1989 BHV_IDENTITY_INIT(VFS_BHV_XFS,VFS_POSITION_XFS), 1990 .vfs_parseargs = xfs_parseargs, 1991 .vfs_showargs = xfs_showargs, 1992 .vfs_mount = xfs_mount, 1993 .vfs_unmount = xfs_unmount, 1994 .vfs_mntupdate = xfs_mntupdate, 1995 .vfs_root = xfs_root, 1996 .vfs_statvfs = xfs_statvfs, 1997 .vfs_sync = xfs_sync, 1998 .vfs_vget = xfs_vget, 1999 .vfs_dmapiops = (vfs_dmapiops_t)fs_nosys, 2000 .vfs_quotactl = (vfs_quotactl_t)fs_nosys, 2001 .vfs_init_vnode = xfs_initialize_vnode, 2002 .vfs_force_shutdown = xfs_do_force_shutdown, 2003 .vfs_freeze = xfs_freeze, 2004}; 2005