/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* University Copyright- Copyright (c) 1982, 1986, 1988
* The Regents of the University of California
* All Rights Reserved
*
* University Acknowledgment- Portions of this document are derived from
* software developed by the University of California, Berkeley, and its
* contributors.
*/
#include <sys/sysmacros.h>
#include <sys/pathname.h>
#include <sys/vfs_opreg.h>
#include <sys/fssnap_if.h>
#include <sys/bootconf.h>
/*
* This is the loadable module wrapper.
*/
int ufsfstype;
static int ufsinit(int, char *);
static int mountfs();
extern int highbit();
/*
* Cylinder group summary information handling tunable.
* This defines when these deltas get logged.
* If the number of cylinders in the file system is over the
* tunable then we log csum updates. Otherwise the updates are only
* done for performance on unmount. After a panic they can be
* quickly constructed during mounting. See ufs_construct_si()
* called from ufs_getsummaryinfo().
*
* This performance feature can of course be disabled by setting
* ufs_ncg_log to 0, and fully enabled by setting it to 0xffffffff.
*/
/*
* ufs_clean_root indicates whether the root fs went down cleanly
*/
static int ufs_clean_root = 0;
/*
* UFS Mount options table
*/
/*
* option name cancel option default arg flags
* ufs arg flag
*/
(void *)0 },
(void *)UFSMNT_NOINTR },
(void *)UFSMNT_SYNCDIR },
(void *)UFSMNT_FORCEDIRECTIO },
(void *)UFSMNT_NOFORCEDIRECTIO },
(void *)UFSMNT_NOSETSEC },
(void *)UFSMNT_LARGEFILES },
(void *)0 },
(void *)UFSMNT_LOGGING },
(void *)0 },
MO_NODISPLAY|MO_DEFAULT, (void *)0 },
(void *)0 },
(void *)0 },
(void *)0 },
(void *)UFSMNT_NOATIME },
(void *)0 },
MO_DEFAULT|MO_HASVALUE, (void *)0 },
};
};
"ufs",
};
/*
* Module linkage information for the kernel.
*/
};
};
/*
* An attempt has been made to make this module unloadable. In order to
* test it, we need a system in which the root fs is NOT ufs. THIS HAS NOT
* BEEN DONE
*/
extern kstat_t *ufs_inode_kstat;
extern uint_t ufs_lockfs_key;
extern void ufs_lockfs_tsd_destructor(void *);
extern uint_t bypass_snapshot_throttle_key;
int
_init(void)
{
/*
* Create an index into the per thread array so that any thread doing
* VOP will have a lockfs mark on it.
*/
return (mod_install(&modlinkage));
}
int
_fini(void)
{
return (EBUSY);
}
int
{
}
extern kmutex_t ufs_scan_lock;
struct cred *, int, void *, int);
static int
{
int error;
return (error);
return (ENOTDIR);
return (EBUSY);
}
/*
* Get arguments
*/
int copy_result = 0;
return (EINVAL);
else
if (copy_result)
return (EFAULT);
} else {
datalen = 0;
}
} else {
}
/*
* Read in the mount point pathname
* (so we can record the directory the file system was last mounted on).
*/
return (error);
/*
* Resolve path name of special file being mounted.
*/
return (error);
}
if (error > 0) {
return (error);
} else if (error == 0) {
goto out;
}
} else {
return (ENOTBLK);
}
goto out;
}
/*
* In SunCluster, requests to a global device are
* satisfied by a local device. We substitute the global
* pxfs node with a local spec node here.
*/
}
return (error);
}
}
why = ROOT_REMOUNT;
/*
* the caller has sufficient rights to access the resource in
* question. When bio is fixed for vnodes this can all be vnode
* operations.
*/
goto out;
/*
* Ensure that this device isn't already mounted or in progress on a
* mount unless this is a REMOUNT request or we are told to suppress
* mount checks. Global mounts require special handling.
*/
goto out;
}
if (vfs_devismounted(dev)) {
goto out;
}
}
}
/*
* If the device is a tape, mount it read only
*/
}
/*
* Mount the filesystem, free the device vnode on error.
*/
if (error == 0) {
/*
* If lofi, drop our reference to the original file.
*/
}
out:
if (error) {
}
return (error);
}
/*
* Mount root file system.
* "why" is ROOT_INIT on initial call ROOT_REMOUNT if called to
* remount the root file system, and ROOT_UNMOUNT if called to
* unmount the root (e.g., as part of a system shutdown).
*
* XXX - this may be partially machine-dependent; it, along with the VFS_SWAPVP
* operation, goes along with auto-configuration. A mechanism should be
* provided by which machine-INdependent code in the kernel can say "get me the
* right root file system" and "get me the right initial swap area", and have
* that done in what may well be a machine-dependent fashion.
* Unfortunately, it is also file-system-type dependent (NFS gets it via
* bootparams calls, UFS gets it from various and sundry machine-dependent
* mechanisms, as SPECFS does for swap).
*/
static int
{
int error;
static int ufsrootdone = 0;
int ovflags;
int doclkset;
if (ufsrootdone++)
return (EBUSY);
rootdev = getrootdev();
return (ENODEV);
} else if (why == ROOT_REMOUNT) {
(void) dnlc_purge_vfsp(vfsp, 0);
} else if (why == ROOT_UNMOUNT) {
/*
* Mark the log as fully rolled
*/
if (TRANS_ISTRANS(ufsvfsp) &&
!TRANS_ISERROR(ufsvfsp) &&
if (error == 0) {
}
}
} else {
ufs_update(0);
}
return (0);
}
if (error)
return (error);
/* If RO media, don't call clkset() (see below) */
doclkset = 1;
if (error == 0) {
} else {
doclkset = 0;
}
}
/*
* XXX - assumes root device is not indirect, because we don't set
* rootvp. Is rootvp used for anything? If so, make another arg
* to mountfs.
*/
if (error) {
if (why == ROOT_REMOUNT)
if (rootvp) {
}
return (error);
}
}
return (0);
}
static int
{
int error = 0;
int flags = 0;
/* cannot remount to RDONLY */
return (ENOTSUP);
/* whoops, wrong dev */
return (EINVAL);
/*
*/
/*
* reset options
*/
else /* dfratime, default behavior */
if (flags & UFSMNT_FORCEDIRECTIO)
else /* default is no direct I/O */
ufsvfsp->vfs_forcedirectio = 0;
/*
* set largefiles flag in ufsvfs equal to the
* value passed in by the mount command. If
* it is "nolargefiles", and the flag is set
* in the superblock, the mount fails.
*/
goto remounterr;
}
} else /* "largefiles" */
/*
*/
goto remounterr;
/*
* fix-on-panic assumes RO->RW remount implies system-critical fs
* if it is shortly after boot; so, don't attempt to lock and fix
* (unless the user explicitly asked for another action on error)
* XXX UFSMNT_ONERROR_RDONLY rather than UFSMNT_ONERROR_PANIC
*/
if (!(flags & UFSMNT_ONERROR_FLGMASK) &&
ddi_get_lbolt() < BOOT_TIME_LIMIT) {
}
goto remounterr;
/*
* quiesce the file system
*/
if (error)
goto remounterr;
goto remounterr;
}
goto remounterr;
}
}
if (TRANS_ISERROR(ufsvfsp))
goto remounterr;
ufsvfsp->vfs_domatamap = 0;
goto remounterr;
}
/*
* Ensure that ufs_getsummaryinfo doesn't reconstruct
* the summary info.
*/
if (error)
goto remounterr;
/* preserve mount name */
/* free the old cg space */
/* switch in the new superblock */
} /* superblock updated in memory */
tpt = 0;
goto remounterr;
}
if (TRANS_ISTRANS(ufsvfsp)) {
} else
if (TRANS_ISTRANS(ufsvfsp)) {
/*
* start the delete thread
*/
/*
* start the reclaim thread
*/
}
}
return (0);
if (tpt)
return (error);
}
/*
* If the device maxtransfer size is not available, we use ufs_maxmaxphys
* along with the system value for maxphys to determine the value for
* maxtransfer.
*/
static int
{
int error = 0;
int needclose = 0;
int needtrans = 0;
int flags = 0;
int elapsed;
int status;
extern int maxphys;
/*
* Open block device mounted on.
* When bio is fixed for vnodes this can all be vnode
* operations.
*/
if (error)
goto out;
needclose = 1;
/*
* Refuse to go any further if this
* device is being used for swapping.
*/
goto out;
}
}
/*
* check for dev already mounted on
*/
if (error == 0)
return (error);
}
/*
* Flush back any dirty pages on the block device to
* try and keep the buffer cache in sync with the page
* cache if someone is trying to use block devices when
* they really should be using the raw device.
*/
/*
* read in superblock
*/
goto out;
goto out;
}
"mount: unrecognized version of UFS on-disk format: %d",
fsp->fs_version);
goto out;
}
"mount: unrecognized version of UFS on-disk format: %d",
fsp->fs_version);
goto out;
}
#ifndef _LP64
/*
* Find the size of the device in sectors. If the
* the size in sectors is greater than INT_MAX, it's
* a multi-terabyte file system, which can't be
* mounted by a 32-bit kernel. We can't use the
* fsbtodb() macro in the next line because the macro
* casts the intermediate values to daddr_t, which is
* a 32-bit quantity in a 32-bit kernel. Here we
* really do need the intermediate values to be held
* in 64-bit quantities because we're checking for
* overflow of a 32-bit field.
*/
> INT_MAX) {
"mount: multi-terabyte UFS cannot be"
" mounted by a 32-bit kernel");
goto out;
}
}
#endif
goto out;
}
/*
* Allocate VFS private data.
*/
vfsp->vfs_bcount = 0;
/*
* Cross-link with vfs and add to instance list.
*/
/*
* if mount allows largefiles, indicate so in ufsvfs
*/
if (flags & UFSMNT_LARGEFILES)
/*
* Initialize threads
*/
/*
* Chicken and egg problem. The superblock may have deltas
* in the log. So after the log is scanned we reread the
* superblock. We guarantee that the fields needed to
* scan the log will not be in the log.
*/
if (error) {
/*
* Allow a ro mount to continue even if the
* log cannot be processed - yet.
*/
"log for %s; Please run fsck(1M)", path);
goto out;
}
}
goto out;
}
/*
* Set logging mounted flag used by lockfs
*/
/*
* Copy the super block into a buffer in its native size.
* Use ngeteblk to allocate the buffer
*/
tp = 0;
/*
* Mount fails if superblock flag indicates presence of large
* files and filesystem is attempted to be mounted 'nolargefiles'.
* The exception is for a read only mount of root, which we
* always want to succeed, so fsck can fix potential problems.
* The assumption is that we will remount root at some point,
* and the remount will enforce the mount option.
*/
!(flags & UFSMNT_LARGEFILES)) {
goto out;
}
if (isroot) {
ufs_clean_root = 1;
}
} else {
ufs_clean_root = 1;
}
}
} else {
}
} else {
if ((TRANS_ISERROR(ufsvfsp)) ||
ufsvfsp->vfs_domatamap = 0;
goto out;
}
else {
if (isroot) {
/*
* allow root partition to be mounted even
* when fs_state is not ok
* will be fixed later by a remount root
*/
ufsvfsp->vfs_domatamap = 0;
} else {
goto out;
}
}
}
needtrans = 1;
/*
* Read in summary info
*/
goto out;
/*
* lastwhinetime is set to zero rather than lbolt, so that after
* mounting if the filesystem is found to be full, then immediately the
* "file system message" will be logged.
*/
ufsvfsp->vfs_lastwhinetime = 0L;
/*
* Sanity checks for old file systems
*/
else
/*
* Initialize lockfs structure to support file system locking
*/
sizeof (struct lockfs));
/*
* We don't need to grab vfs_dqrwlock for this ufs_iget() call.
* We are in the process of mounting the file system so there
* is no need to grab the quota lock. If a quota applies to the
* root inode, then it will be updated when quotas are enabled.
*
* However, we have an ASSERT(RW_LOCK_HELD(&ufsvfsp->vfs_dqrwlock))
* in getinoquota() that we want to keep so grab it anyway.
*/
if (error)
goto out;
/*
* make sure root inode is a directory. Returning ENOTDIR might
* be confused with the mount point not being a directory, so
* we use EIO instead.
*/
/*
* Mark this inode as subject for cleanup
* to avoid stray inodes in the cache.
*/
goto out;
}
/* The buffer for the root inode does not contain a valid b_vp */
/* options */
else /* dfratime, default behavior */
if (flags & UFSMNT_FORCEDIRECTIO)
else if (flags & UFSMNT_NOFORCEDIRECTIO)
ufsvfsp->vfs_forcedirectio = 0;
} else {
}
if (ufsvfsp->vfs_iotransz <= 0) {
}
/*
* When logging, used to reserve log space for writes and truncs
*/
/*
* Determine whether to log cylinder group summary info.
*/
if (TRANS_ISTRANS(ufsvfsp)) {
/*
* start the delete thread
*/
/*
* start reclaim thread if the filesystem was not mounted
* read only.
*/
(FS_RECLAIM|FS_RECLAIMING))) {
}
/* Mark the fs as unrolled */
(FS_RECLAIM|FS_RECLAIMING))) {
/*
* If a file system that is mounted nologging, after
* having previously been mounted logging, becomes
* unmounted whilst the reclaim thread is in the throes
* of such a file system with logging disabled could lead
* to inodes becoming lost. So, start reclaim now, even
* though logging was disabled for the previous mount, to
* tidy things up.
*/
}
goto out;
}
/* fix-on-panic initialization */
goto out;
return (0);
out:
if (error == 0)
if (rvp) {
/* the following sequence is similar to ufs_unmount() */
/*
* There's a problem that ufs_iget() puts inodes into
* the inode cache before it returns them. If someone
* traverses that cache and gets a reference to our
* inode, there's a chance they'll still be using it
* after we've destroyed it. This is a hard race to
* hit, but it's happened (putting in a medium delay
* here, and a large delay in ufs_scan_inodes() for
* inodes on the device we're bailing out on, makes
* the race easy to demonstrate). The symptom is some
* other part of UFS faulting on bad inode contents,
* or when grabbing one of the locks inside the inode,
* etc. The usual victim is ufs_scan_inodes() or
* someone called by it.
*/
/*
* First, isolate it so that no new references can be
* gotten via the inode cache.
*/
/*
* Now wait for all outstanding references except our
* own to drain. This could, in theory, take forever,
* so don't wait *too* long. If we time out, mark
* it stale and leak it, so we don't hit the problem
* described above.
*
* Note that v_count is an int, which means we can read
* it in one operation. Thus, there's no need to lock
* around our tests.
*/
elapsed = 0;
}
"Timed out while cleaning up after "
"failed mount of %s", path);
} else {
/*
* Now we're the only one with a handle left, so tear
* it down the rest of the way.
*/
if (ufs_rmidle(rip))
}
}
if (needtrans) {
}
if (ufsvfsp) {
}
}
if (bp) {
}
if (tp) {
}
if (needclose) {
}
return (error);
}
/*
* vfs operations
*/
static int
{
extern struct pollhead ufs_pollhd;
return (EPERM);
/*
* Forced unmount is now supported through the
* lockfs protocol.
*/
/*
* Mark the filesystem as being unmounted now in
* case of a forcible umount before we take any
* locks inside UFS to prevent racing with a VFS_VGET()
* request. Throw these VFS_VGET() requests away for
* the duration of the forcible umount so they won't
* use stale or even freed data later on when we're done.
* It may happen that the VFS has had a additional hold
* placed on it by someone other than UFS and thus will
* not get freed immediately once we're done with the
* umount by dounmount() - use VFS_UNMOUNTED to inform
* users of this still-alive VFS that its corresponding
* filesystem being gone so they can detect that and error
* out.
*/
/*
* If file system is already hard locked,
* unmount the file system, otherwise
* hard lock it before unmounting.
*/
if (!ULOCKFS_IS_HLOCK(ulp)) {
(void) ufs_quiesce(ulp);
poll_events |= POLLERR;
}
}
/* let all types of writes go through */
/* coordinate with global hlock thread */
/*
* last possibility for a forced umount to fail hence clear
* VFS_UNMOUNTED if appropriate.
*/
return (EAGAIN);
}
/* kill the reclaim thread */
/* suspend the delete thread */
/*
* drain the delete and idle queues
*/
/*
* use the lockfs protocol to prevent new ops from starting
* a forcible umount can not fail beyond this point as
* we hard-locked the filesystem and drained all current consumers
* before.
*/
/*
* if the file system is busy; return EBUSY
*/
goto out;
}
/*
* get rid of every inode except the root and quota inodes
* also, commit any outstanding transactions
*/
goto out;
/*
* ignore inodes in the cache if fs is hard locked or error locked
*/
/*
* Otherwise, only the quota and root inodes are in the cache.
*
* Avoid racing with ufs_update() and ufs_sync().
*/
mutex_enter(&ih_lock[i]);
continue;
continue;
continue;
mutex_exit(&ih_lock[i]);
goto out;
}
mutex_exit(&ih_lock[i]);
}
}
/*
* if a snapshot exists and this is a forced unmount, then delete
* the snapshot. Otherwise return EBUSY. This will insure the
* snapshot always belongs to a valid file system.
*/
if (ufsvfsp->vfs_snapshot) {
} else {
goto out;
}
}
/*
* Close the quota file and invalidate anything left in the quota
* cache for this file system. Pass kcred to allow all quota
* manipulations.
*/
/*
* drain the delete and idle queues
*/
/*
* discard the inodes for this fs (including root, shadow, and quota)
*/
mutex_enter(&ih_lock[i]);
continue;
/*
* We've found the inode in the cache and as we
* hold the hash mutex the inode can not
* disappear from underneath us.
* We also know it must have at least a vnode
* reference count of 1.
* We perform an additional VN_HOLD so the VN_RELE
* in case we take the inode off the idle queue
* can not be the last one.
* It is safe to grab the writer contents lock here
* to prevent a race with ufs_iinactive() putting
* inodes into the idle queue while we operate on
* this inode.
*/
if (ufs_rmidle(ip))
ufs_si_del(ip);
/*
* rip->i_ufsvfsp is needed by bflush()
*/
/*
* Set vnode's vfsops to dummy ops, which return
* EIO. This is needed to forced unmounts to work
*/
else
}
mutex_exit(&ih_lock[i]);
}
/*
* kill the delete thread and drain the idle queue
*/
if (flag) {
}
if (TRANS_ISTRANS(ufsvfsp) &&
!TRANS_ISERROR(ufsvfsp) &&
!ULOCKFS_IS_HLOCK(ulp) &&
/*
* ufs_flush() above has flushed the last Moby.
* This is needed to ensure the following superblock
* update really is the last metadata update
*/
if (error == 0) {
}
}
/*
* push this last transaction
*/
error);
if (!error)
}
/*
* It is now safe to NULL out the ufsvfs pointer and discard
* the root inode.
*/
/* free up lockfs comment structure, if any */
/*
* Remove from instance list.
*/
/*
* For a forcible unmount, threads may be asleep in
* ufs_lockfs_begin/ufs_check_lockfs. These threads will need
* the ufsvfs structure so we don't free it, yet. ufs_update
* will free it up after awhile.
*/
extern kmutex_t ufsvfs_mutex;
extern struct ufsvfs *ufsvfslist;
/* wakeup any suspended threads */
} else {
}
/*
* Now mark the filesystem as unmounted since we're done with it.
*/
return (0);
out:
/* open the fs to new ops */
if (TRANS_ISTRANS(ufsvfsp)) {
/* allow the delete thread to continue */
/* restart the reclaim thread */
vfsp);
/* coordinate with global hlock thread */
/* check for trans errors during umount */
/*
* if we have a separate /usr it will never unmount
* when halting. In order to not re-read all the
* cylinder group summary info on mounting after
* reboot the logging of summary info is re-enabled
* and the super block written out.
*/
ufsvfsp->vfs_nolog_si = 0;
}
}
return (error);
}
static int
{
if (!vfsp)
return (EIO);
return (EIO); /* forced unmount */
return (0);
}
/*
* Get file system statistics.
*/
static int
{
int blk, i;
return (EIO);
return (EINVAL);
return (EINVAL);
return (EINVAL);
/*
* get the basic numbers
*/
/*
* Adjust the numbers based on things waiting to be deleted.
* modifies f_bfree and f_ffree. Afterwards, everything we
* come up with will be self-consistent. By definition, this
* is a point-in-time snapshot, so the fact that the delete
* thread's probably already invalidated the results is not a
* problem. Note that if the delete thread is ever extended to
* non-logging ufs, this adjustment must always be made.
*/
if (TRANS_ISTRANS(ufsvfsp))
/*
* avail = MAX(max_avail - used, 0)
*/
else
/* keep coordinated with ufs_l_pathconf() */
return (0);
}
/* void */;
return (0);
}
/*
* Flush any pending I/O to file system vfsp.
* The ufs_update() routine will only flush *all* ufs files.
* If vfsp is non-NULL, only sync this ufs (in preparation
* for a umount).
*/
/*ARGSUSED*/
static int
{
int error;
/*
* SYNC_CLOSE means we're rebooting. Toss everything
* on the idle queue so we don't have to slog through
* a bunch of uninteresting inodes over and over again.
*/
if (flag & SYNC_CLOSE)
return (0);
}
/* Flush a single ufs */
return (0);
if (!ufsvfsp)
return (EIO);
/* turn off fast-io on unmount, so no fsck needed (4029401) */
}
/* Write back modified superblock */
} else {
}
}
/*
* Avoid racing with ufs_update() and ufs_unmount().
*
*/
/*
* commit any outstanding async transactions
*/
if (!error) {
}
return (0);
}
void
{
int blks;
int i;
/*
* for ulockfs processing, limit the superblock writes
*/
/* process later */
return;
}
if (TRANS_ISTRANS(ufsvfsp)) {
return;
}
}
}
static int
{
int error = 0;
/*
* Check for unmounted filesystem.
*/
goto errout;
}
/*
* Keep the idle queue from getting too long by
* idling an inode before attempting to allocate another.
* This operation must be performed before entering
* lockfs or a transaction.
*/
}
goto errout;
if (error)
goto errout;
/*
* Check if the inode has been deleted or freed or is in transient state
* since the last VFS_VGET() request for it, release it and don't return
* it to the caller, presumably NFS, as it's no longer valid.
*/
goto errout;
}
return (0);
return (error);
}
static int
{
};
int error;
if (error != 0) {
return (error);
}
if (error != 0) {
(void) vfs_freevfsops_by_type(fstype);
return (error);
}
ufs_iinit();
return (0);
}
#ifdef __sparc
/*
* Mounting a mirrored SVM volume is only supported on ufs,
* this is special-case boot code to support that configuration.
* At this point, we have booted and mounted root on a
* single component of the mirror. Complete the boot
* by configuring SVM and converting the root to the
* dev_t of the mirrored root device. This dev_t conversion
* only works because the underlying device doesn't change.
*/
int
{
int i;
old_rootvp = rootvp;
new_rootdev = getrootdev();
return (ENODEV);
}
if (error) {
"Cannot open mirrored root device, error %d\n", error);
return (error);
}
return (EBUSY);
}
(void) ufs_quiesce(ulp);
/*
* Convert root vfs to new dev_t, including vfs hash
* table and fs id.
*/
/*
* The buffer for the root inode does not contain a valid b_vp
*/
(void) bfinval(new_rootdev, 0);
/*
* Here we hand-craft inodes with old root device
* references to refer to the new device instead.
*/
mutex_enter(&ih_lock[i]);
continue;
continue;
}
}
}
mutex_exit(&ih_lock[i]);
}
/*
* Make Sure logging structures are using the new device
* if logging is enabled. Also start any logging thread that
* needs to write to the device and couldn't earlier.
*/
/*
* Update the main logging structure.
*/
/*
* Get a new bp for the on disk structures.
*/
/*
* Allocate new circular buffers.
*/
/*
* Clear the noroll bit which indicates that logging
* can't roll the log yet and start the logmap roll thread
* unless the filesystem is still read-only in which case
* remountfs() will do it when going to read-write.
*/
}
/*
* Start the reclaim thread if needed.
*/
(FS_RECLAIM|FS_RECLAIMING))) {
"Remountroot failed to update Reclaim"
"state for filesystem %s "
"Error writing SuperBlock %d",
}
}
}
rootvp = new_rootvp;
if (error) {
"close of root device component failed, error %d\n",
error);
}
}
#endif /* __sparc */