Differential D19706

zlib.
ClosedPublic
Actions

Authored by delphij on Mar 26 2019, 2:43 AM.

Details

Reviewers

jmg
imp
kib
markm
mav
avg
mmacy
ota_j.email.ne.jp
delphij

Group Reviewers

manpages
ZFS

Commits

rS350496: Allow Kernel to link in both legacy libkern/zlib and new sys/contrib/zlib,

Summary

The 1st large review have been separated into multiple pieces based on modules and functionalities.

This change-set updates the kernel to link both old and new ZLIB versions so that we can migrate one component at a time.

I created sys/dev/zlib directory to have some std compatible header files, also place kernel module C file, and kernel versions memory allocation functions like zcalloc, zcfree and few others.

Test Plan

% make buildkernel

Diff Detail

Lint

Lint Passed

Unit

No Test Coverage

Build Status

Buildable 25614
Build 24211: arc lint + arc unit

Event Timeline

There are a very large number of changes, so older changes are hidden. Show Older Changes

Added sys/contrib/zlib/crc32.c to zlib kernel module.

Harbormaster completed remote builds in B25100: Diff 59136.Jun 27 2019, 11:23 PM

delphij requested changes to this revision.Jul 1 2019, 4:40 PM

delphij added inline comments.

sys/conf/kern.pre.mk
178	The two additional -D's are only specified for zutil.c for sys/modules/zlib (kmod.mk version of ZLIB_CFLAGS don't have these). Since the sys/conf/files already have them, should they be removed here?
sys/dev/zlib/errno.h
1 ↗	(On Diff #59136)	I still prefer a way to not use these "fake" headers (I can't really work on this until mid-July but will take a look as soon as I can).
sys/opencrypto/cryptodeflate.c
124	I think the probes needs to match their definitions? (Also, is there some specific reason not to convert this to use new zlib?)

This revision now requires changes to proceed.Jul 1 2019, 4:40 PM

ota_j.email.ne.jp added inline comments.Jul 5 2019, 10:50 AM

sys/conf/kern.pre.mk
178	The extra flags will be changed for Z_SOLO.
sys/dev/zlib/errno.h
1 ↗	(On Diff #59136)	We can delay this action by using -DZ_SOLO. ZFS needs non Z_SOLO zlib and we can revisit that time.
sys/opencrypto/cryptodeflate.c
124	The probes need to be matching ABI, the binary symbol. I can put cryptodefate changes together. One of suggestion was break one large changeset into smaller ones; this one looks better be a part of this one to avoid changing probe names.

Use -DZ_SOLO to avoid standard C header files.
ZFS requires Non-Z_SOLO ZLIB and we will revisit when we work on ZFS.
Combined opencrypto conversion to avoid dtrace probe name changes.

Harbormaster completed remote builds in B25210: Diff 59436.Jul 5 2019, 10:56 AM

Drop -DMY_ZCALLOC as no use under -DZ_SOLO.

Harbormaster completed remote builds in B25215: Diff 59455.Jul 5 2019, 10:50 PM

Drop -DMY_ZCALLOC from kmod.mk but put zcfree() back.

Harbormaster completed remote builds in B25235: Diff 59520.Jul 7 2019, 8:17 PM

Missed zcallc.h/c files from last update.

Harbormaster completed remote builds in B25236: Diff 59521.Jul 7 2019, 8:19 PM

I had missed zcalloc.c in sys/modules/Makefile, too.

Harbormaster completed remote builds in B25237: Diff 59522.Jul 7 2019, 8:21 PM

Drop NO_GZIP compile option changes in zlib as these aren't necessary at this stage.

Harbormaster completed remote builds in B25238: Diff 59524.Jul 7 2019, 8:30 PM

Thanks! This looks mostly good to me. I intend to commit this version with some minor tweaks after some testing in a day or two, so please yell if you don't agree with some change proposals (commented inline).

sys/contrib/zlib/zconf.h
442–443	This seems to be my bad (rS206708 derived from vendor 7147f24cd7b27dd95f6e841851a111cb311a9c07). Initially, in rS205306, we #if 0'ed Z_HAVE_UNISTD_H, which used to determine if we would include sys/types.h. Later, the upstream have decided to include it for all platforms, and sys/types.h was included again, so when upgrading zlib I have decided to just take it and removed the include below, right before our hardcoded configuration. May I ask a favor that we revert the change here to vendor version, and instead, add a block of: #ifdef Z_SOLO # include <sys/types.h> /* for off_t */ #endif under "This is hard-configured for FreeBSD." so we keep the local changes together? Potentially, that would make it easier for future upgrades.
sys/opencrypto/cryptodeflate.c
63	the new line before crypto_zalloc() is not necessary.
64	[OPTIONAL] Personally I'd remove the variable names in prototype definition. Alternatively, you can move these functions' bodies here because these are static functions.
sys/sys/zlib.h
99	[OPTIONAL] I wonder if we can make deflate_copyright and inflate_copyright in sys/libkern/zlib.c static instead?

delphij accepted this revision.Jul 8 2019, 9:25 PM

ota_j.email.ne.jp added inline comments.Jul 9 2019, 9:44 AM

sys/contrib/zlib/zconf.h
442–443	Ok.
sys/opencrypto/cryptodeflate.c
64	I will move implementations here.
sys/sys/zlib.h
99	It appeared that these 2 variables are not used at all. Converting to static variable resulted in error.

Adjusted sys/type.h include to FreeBSD section and also moved crypto_z* function implementations to top of file.

Harbormaster completed remote builds in B25262: Diff 59565.Jul 9 2019, 9:49 AM

Disable broken gzipped aout executable support and rename zlib in ZFS to avoid filename conflicts.

gzipped aout supports has been broken for more than few years now. Disable it to avoid inflate() ABI conflict. I'm interested in reimplementing it with zlib but it will be one of the last zlib update processes.

Add opensolaris_ prefix to zlib files in ZFS to avoid object filename conflicts. Zlib in ZFS is compiled with different options and they are not ABI compatible.
This will also address https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=205822

These changes address link errors found by LINT:
% make buildLINT
% make buildkernel KERNCONF=LINT

Harbormaster completed remote builds in B25328: Diff 59717.Jul 13 2019, 12:41 AM

Actually, this file rename doesn't fix https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=205822.
I don't think it is worth addressing this bug report here as removing the zlib in zfs also fixes this issue and we are aiming for this serious of changes.

D21072, "Remove support for kernel.tramp and kernel.tramp.gz", precedes this revision. This removes obsolete use of legacy zlib version.

D21099 removed gzip'ed a.out support. Rebased and adjusted.

Harbormaster completed remote builds in B25611: Diff 60312.Jul 30 2019, 10:49 PM

Rebase.

Harbormaster completed remote builds in B25613: Diff 60316.Jul 31 2019, 5:16 AM

Add license plate for sys/dev/zlib/zlib_mod.c.

Harbormaster completed remote builds in B25614: Diff 60318.Jul 31 2019, 5:44 AM

+@markm (Please confirm if the license is Okay for sys/dev/zlib/zlib_mod.c, the file is largely based on your change rS130799 in 2004 for sys/net/zlib.c).

sys/dev/zlib/zcalloc.c
2	A license plate should be added.
sys/dev/zlib/zcalloc.h
2	A license plate should be added.

+@mav @avg @mmacy for ZFS portion of change as a FYI (sys/cddl/contrib/opensolaris/uts/common/zmod). TL;DR: the bundled zlib (1.2.3) was removed in favor of new zlib; alloc/free functions merged from zmod_subr.c into zmod.c.

LGTM otherwise.

sys/dev/zlib/zlib_mod.c
2	This file is 99.999% boilerplate; I'm happy for the copyright to revert to FreeBSD Foundation without mentioning me.

Modified zlib_mod.c to use standard FreeBSD Foundation license.

Harbormaster completed remote builds in B25615: Diff 60319.Jul 31 2019, 7:43 AM

It looks ZFS changes, dropping zlib files in zfs, are melded into this one.
I recall needing to add -DGZIP and/or -DGUNZIP option for zfs compression=gzip to properly uncompress gzipped zfs devices with older version; there was gzip header regression...

I'd like to test to ensure I can read zfs with compresssion=gzip from 12-RELEASE.

sys/dev/zlib/zcalloc.c
2	Please use /* This file is in the public domain. */ It is a clone of multiple copies of same functions.
sys/dev/zlib/zcalloc.h
2	Please use /* This file is in the public domain. */ It is a clone of multiple copies of same functions.

I tested reads and writes on gzipped ZFS between 12.0-RELEASE and 13-CURRENT with this changes.
The test result was good.

Do we need to bump kernel version for this change like we did for gzip'ed a.out support removal?

Update license for zcalloc;

Fix tinderbox build (needs upstream).

Harbormaster completed remote builds in B25628: Diff 60351.Aug 1 2019, 6:26 AM

delphij accepted this revision.Aug 1 2019, 6:36 AM

Submitted as rS350496.

ota_j.email.ne.jp accepted this revision.Aug 3 2019, 2:27 PM

This revision was not accepted when it landed; it landed in state Needs Review.Aug 6 2019, 1:32 PM

Closed by commit rS350496: Allow Kernel to link in both legacy libkern/zlib and new sys/contrib/zlib, (authored by delphij). · Explain Why

This revision was automatically updated to reflect the committed changes.

delphij added a commit: rS350496: Allow Kernel to link in both legacy libkern/zlib and new sys/contrib/zlib,.

ota_j.email.ne.jp mentioned this in D21175: bxe to update zlib version 1.0.4 to 1.2.11..Aug 7 2019, 4:28 AM

ota_j.email.ne.jp mentioned this in D21176: DDB_CTF to update zlib version 1.0.4 to 1.2.11.Aug 7 2019, 4:45 AM

Revision Contents
Changeset List

Path

Size

sys/

cddl/

contrib/

opensolaris/

uts/

common/

fs/

zfs/

zfs_ioctl.c

1 line

zmod/

46 lines

conf/

2 lines

44 lines

4 lines

2 lines

contrib/

zlib/

deflate.c

2 lines

zconf.h

3 lines

zutil.h

3 lines

dev/

zlib/

zcalloc.h

8 lines

zcalloc.c

27 lines

zlib_mod.c

51 lines

libkern/

zlib.c

42 lines

modules/

crypto/

Makefile

1 line

zfs/

Makefile

10 lines

zlib/

Makefile

20 lines

opencrypto/

cryptodeflate.c

46 lines

deflate.h

4 lines

sys/

zlib.h

64 lines

Diff 60318

View Options

sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zfs_ioctl.c

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
*		*
* The environment variable vfs.root.mountfrom.options is a comma delimited		* The environment variable vfs.root.mountfrom.options is a comma delimited
* set of string mount options. These mount options must be parseable		* set of string mount options. These mount options must be parseable
* by nmount() in the kernel.		* by nmount() in the kernel.
*/		*/

static int parse_mount(char **);		static int parse_mount(char **);
static struct mntarg parse_mountroot_options(struct mntarg , const char *);		static struct mntarg parse_mountroot_options(struct mntarg , const char *);
		static int vfs_mountroot_wait_if_neccessary(const char fs, const char dev);

/*		/*
* The vnode of the system's root (/ in the filesystem, without chroot		* The vnode of the system's root (/ in the filesystem, without chroot
* active.)		* active.)
*/		*/
struct vnode *rootvnode;		struct vnode *rootvnode;

/*		/*
▲ Show 20 Lines • Show All 579 Lines • ▼ Show 20 Lines	parse_mount_dev_present(const char *dev)
struct nameidata nd;		struct nameidata nd;
int error;		int error;

NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);		NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);
error = namei(&nd);		error = namei(&nd);
if (!error)		if (!error)
vput(nd.ni_vp);		vput(nd.ni_vp);
NDFREE(&nd, NDF_ONLY_PNBUF);		NDFREE(&nd, NDF_ONLY_PNBUF);
		if (error != 0)
		printf("%s: %s not present, error %d\n", __func__, dev, error);
		marcelUnsubmitted Done Inline Actions This looks like it's more for debugging than for an end user. Maybe put this under boot verbose? The reason is that it's not an error until it's an error, meaning that if we're going to wait for the device when it's not there yet, then printing errors is confusing. Putting it under boot verbose is a nice way for people to get insight into why a boot may be stalled... marcel: This looks like it's more for debugging than for an end user. Maybe put this under boot verbose?
return (error != 0) ? 0 : 1;		return (error != 0) ? 0 : 1;
}		}
		traszAuthorUnsubmitted Not Done Inline Actions Actually, it was a debugging printf that snuck in. Removed. trasz: Actually, it was a debugging printf that snuck in. Removed.

#define ERRMSGL 255		#define ERRMSGL 255
static int		static int
parse_mount(char **conf)		parse_mount(char **conf)
{		{
char *errmsg;		char *errmsg;
struct mntarg *ma;		struct mntarg *ma;
char dev, fs, opts, tok;		char dev, fs, opts, tok;
int delay, error, timeout;		int error;

error = parse_token(conf, &tok);		error = parse_token(conf, &tok);
if (error)		if (error)
return (error);		return (error);
fs = tok;		fs = tok;
error = parse_skipto(&tok, ':');		error = parse_skipto(&tok, ':');
if (error) {		if (error) {
free(fs, M_TEMP);		free(fs, M_TEMP);
Show All 20 Lines	parse_mount(char **conf)
errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);		errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);

if (vfs_byname(fs) == NULL) {		if (vfs_byname(fs) == NULL) {
strlcpy(errmsg, "unknown file system", ERRMSGL);		strlcpy(errmsg, "unknown file system", ERRMSGL);
error = ENOENT;		error = ENOENT;
goto out;		goto out;
}		}

if (strcmp(fs, "zfs") != 0 && strstr(fs, "nfs") == NULL &&		error = vfs_mountroot_wait_if_neccessary(fs, dev);
dev[0] != '\0' && !parse_mount_dev_present(dev)) {		if (error != 0)
printf("mountroot: waiting for device %s ...\n", dev);
delay = hz / 10;
timeout = root_mount_timeout * hz;
do {
pause("rmdev", delay);
timeout -= delay;
} while (timeout > 0 && !parse_mount_dev_present(dev));
if (timeout <= 0) {
error = ENODEV;
goto out;		goto out;
}
}

ma = NULL;		ma = NULL;
ma = mount_arg(ma, "fstype", fs, -1);		ma = mount_arg(ma, "fstype", fs, -1);
ma = mount_arg(ma, "fspath", "/", -1);		ma = mount_arg(ma, "fspath", "/", -1);
ma = mount_arg(ma, "from", dev, -1);		ma = mount_arg(ma, "from", dev, -1);
ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);		ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);
ma = mount_arg(ma, "ro", NULL, 0);		ma = mount_arg(ma, "ro", NULL, 0);
ma = parse_mountroot_options(ma, opts);		ma = parse_mountroot_options(ma, opts);
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines	if (ppsratecheck(&lastfail, &curfail, 1)) {
printf(" %s", h->who);		printf(" %s", h->who);
printf("\n");		printf("\n");
}		}
msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",		msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",
hz);		hz);
}		}
}		}

		static int
		vfs_mountroot_wait_if_neccessary(const char fs, const char dev)
		kibUnsubmitted Not Done Inline Actions Please come with much shorter name for the function. kib: Please come with much shorter name for the function.
		{
		int delay, timeout;

		/*
		* In case of ZFS and NFS we don't have a way to wait for
		* specific device.
		*/
		if (strcmp(fs, "zfs") == 0 \|\| strstr(fs, "nfs") != NULL \|\|
		dev[0] == '\0') {
		vfs_mountroot_wait();
		return (0);
		}

		/*
		* Otherwise, no point in waiting if the device is already there.
		* Note that we must wait for GEOM to finish reconfiguring itself,
		* eg for geom_part(4) to finish tasting.
		*/
		DROP_GIANT();
		g_waitidle();
		kibUnsubmitted Not Done Inline Actions I think this is not needed, and probably even dangerous, for the nfs case. I have no better suggestion than ugly strstr("nfs") hack, but it is still much better than preventing nfs mount due to the issues with the local storage subsystem. kib: I think this is not needed, and probably even dangerous, for the nfs case. I have no better…
		traszAuthorUnsubmitted Not Done Inline Actions For the non-NFS case it's definitely needed, because without it, partitions don't get created before we check for the device presence, and we end up doing the full wait in all cases, defying the purpose of this patch. For the NFS case, this code is not reached - just like for ZFS, we call vfs_mountroot_wait() and return few lines earlier. trasz: For the non-NFS case it's definitely needed, because without it, partitions don't get created…
		PICKUP_GIANT();
		if (parse_mount_dev_present(dev))
		return (0);

		/*
		* No luck. Let's wait. This code looks weird, but it's that way
		* to behave exactly as it used to work before.
		*/
		vfs_mountroot_wait();
		printf("mountroot: waiting for device %s...\n", dev);
		delay = hz / 10;
		timeout = root_mount_timeout * hz;
		do {
		pause("rmdev", delay);
		timeout -= delay;
		} while (timeout > 0 && !parse_mount_dev_present(dev));

		if (timeout <= 0)
		return (ENODEV);

		kibUnsubmitted Not Done Inline Actions This blank line is not needed. kib: This blank line is not needed.
		return (0);
		}

void		void
vfs_mountroot(void)		vfs_mountroot(void)
{		{
struct mount *mp;		struct mount *mp;
struct sbuf *sb;		struct sbuf *sb;
struct thread *td;		struct thread *td;
time_t timebase;		time_t timebase;
int error;		int error;

td = curthread;		td = curthread;

vfs_mountroot_wait();

sb = sbuf_new_auto();		sb = sbuf_new_auto();
vfs_mountroot_conf0(sb);		vfs_mountroot_conf0(sb);
sbuf_finish(sb);		sbuf_finish(sb);

error = vfs_mountroot_devfs(td, &mp);		error = vfs_mountroot_devfs(td, &mp);
while (!error) {		while (!error) {
error = vfs_mountroot_parse(sb, mp);		error = vfs_mountroot_parse(sb, mp);
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

View Options

sys/cddl/contrib/opensolaris/uts/common/zmod/adler32.c

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
*		*
* The environment variable vfs.root.mountfrom.options is a comma delimited		* The environment variable vfs.root.mountfrom.options is a comma delimited
* set of string mount options. These mount options must be parseable		* set of string mount options. These mount options must be parseable
* by nmount() in the kernel.		* by nmount() in the kernel.
*/		*/

static int parse_mount(char **);		static int parse_mount(char **);
static struct mntarg parse_mountroot_options(struct mntarg , const char *);		static struct mntarg parse_mountroot_options(struct mntarg , const char *);
		static int vfs_mountroot_wait_if_neccessary(const char fs, const char dev);

/*		/*
* The vnode of the system's root (/ in the filesystem, without chroot		* The vnode of the system's root (/ in the filesystem, without chroot
* active.)		* active.)
*/		*/
struct vnode *rootvnode;		struct vnode *rootvnode;

/*		/*
▲ Show 20 Lines • Show All 579 Lines • ▼ Show 20 Lines	parse_mount_dev_present(const char *dev)
struct nameidata nd;		struct nameidata nd;
int error;		int error;

NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);		NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);
error = namei(&nd);		error = namei(&nd);
if (!error)		if (!error)
vput(nd.ni_vp);		vput(nd.ni_vp);
NDFREE(&nd, NDF_ONLY_PNBUF);		NDFREE(&nd, NDF_ONLY_PNBUF);
		if (error != 0)
		printf("%s: %s not present, error %d\n", __func__, dev, error);
		marcelUnsubmitted Done Inline Actions This looks like it's more for debugging than for an end user. Maybe put this under boot verbose? The reason is that it's not an error until it's an error, meaning that if we're going to wait for the device when it's not there yet, then printing errors is confusing. Putting it under boot verbose is a nice way for people to get insight into why a boot may be stalled... marcel: This looks like it's more for debugging than for an end user. Maybe put this under boot verbose?
return (error != 0) ? 0 : 1;		return (error != 0) ? 0 : 1;
}		}
		traszAuthorUnsubmitted Not Done Inline Actions Actually, it was a debugging printf that snuck in. Removed. trasz: Actually, it was a debugging printf that snuck in. Removed.

#define ERRMSGL 255		#define ERRMSGL 255
static int		static int
parse_mount(char **conf)		parse_mount(char **conf)
{		{
char *errmsg;		char *errmsg;
struct mntarg *ma;		struct mntarg *ma;
char dev, fs, opts, tok;		char dev, fs, opts, tok;
int delay, error, timeout;		int error;

error = parse_token(conf, &tok);		error = parse_token(conf, &tok);
if (error)		if (error)
return (error);		return (error);
fs = tok;		fs = tok;
error = parse_skipto(&tok, ':');		error = parse_skipto(&tok, ':');
if (error) {		if (error) {
free(fs, M_TEMP);		free(fs, M_TEMP);
Show All 20 Lines	parse_mount(char **conf)
errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);		errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);

if (vfs_byname(fs) == NULL) {		if (vfs_byname(fs) == NULL) {
strlcpy(errmsg, "unknown file system", ERRMSGL);		strlcpy(errmsg, "unknown file system", ERRMSGL);
error = ENOENT;		error = ENOENT;
goto out;		goto out;
}		}

if (strcmp(fs, "zfs") != 0 && strstr(fs, "nfs") == NULL &&		error = vfs_mountroot_wait_if_neccessary(fs, dev);
dev[0] != '\0' && !parse_mount_dev_present(dev)) {		if (error != 0)
printf("mountroot: waiting for device %s ...\n", dev);
delay = hz / 10;
timeout = root_mount_timeout * hz;
do {
pause("rmdev", delay);
timeout -= delay;
} while (timeout > 0 && !parse_mount_dev_present(dev));
if (timeout <= 0) {
error = ENODEV;
goto out;		goto out;
}
}

ma = NULL;		ma = NULL;
ma = mount_arg(ma, "fstype", fs, -1);		ma = mount_arg(ma, "fstype", fs, -1);
ma = mount_arg(ma, "fspath", "/", -1);		ma = mount_arg(ma, "fspath", "/", -1);
ma = mount_arg(ma, "from", dev, -1);		ma = mount_arg(ma, "from", dev, -1);
ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);		ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);
ma = mount_arg(ma, "ro", NULL, 0);		ma = mount_arg(ma, "ro", NULL, 0);
ma = parse_mountroot_options(ma, opts);		ma = parse_mountroot_options(ma, opts);
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines	if (ppsratecheck(&lastfail, &curfail, 1)) {
printf(" %s", h->who);		printf(" %s", h->who);
printf("\n");		printf("\n");
}		}
msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",		msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",
hz);		hz);
}		}
}		}

		static int
		vfs_mountroot_wait_if_neccessary(const char fs, const char dev)
		kibUnsubmitted Not Done Inline Actions Please come with much shorter name for the function. kib: Please come with much shorter name for the function.
		{
		int delay, timeout;

		/*
		* In case of ZFS and NFS we don't have a way to wait for
		* specific device.
		*/
		if (strcmp(fs, "zfs") == 0 \|\| strstr(fs, "nfs") != NULL \|\|
		dev[0] == '\0') {
		vfs_mountroot_wait();
		return (0);
		}

		/*
		* Otherwise, no point in waiting if the device is already there.
		* Note that we must wait for GEOM to finish reconfiguring itself,
		* eg for geom_part(4) to finish tasting.
		*/
		DROP_GIANT();
		g_waitidle();
		kibUnsubmitted Not Done Inline Actions I think this is not needed, and probably even dangerous, for the nfs case. I have no better suggestion than ugly strstr("nfs") hack, but it is still much better than preventing nfs mount due to the issues with the local storage subsystem. kib: I think this is not needed, and probably even dangerous, for the nfs case. I have no better…
		traszAuthorUnsubmitted Not Done Inline Actions For the non-NFS case it's definitely needed, because without it, partitions don't get created before we check for the device presence, and we end up doing the full wait in all cases, defying the purpose of this patch. For the NFS case, this code is not reached - just like for ZFS, we call vfs_mountroot_wait() and return few lines earlier. trasz: For the non-NFS case it's definitely needed, because without it, partitions don't get created…
		PICKUP_GIANT();
		if (parse_mount_dev_present(dev))
		return (0);

		/*
		* No luck. Let's wait. This code looks weird, but it's that way
		* to behave exactly as it used to work before.
		*/
		vfs_mountroot_wait();
		printf("mountroot: waiting for device %s...\n", dev);
		delay = hz / 10;
		timeout = root_mount_timeout * hz;
		do {
		pause("rmdev", delay);
		timeout -= delay;
		} while (timeout > 0 && !parse_mount_dev_present(dev));

		if (timeout <= 0)
		return (ENODEV);

		kibUnsubmitted Not Done Inline Actions This blank line is not needed. kib: This blank line is not needed.
		return (0);
		}

void		void
vfs_mountroot(void)		vfs_mountroot(void)
{		{
struct mount *mp;		struct mount *mp;
struct sbuf *sb;		struct sbuf *sb;
struct thread *td;		struct thread *td;
time_t timebase;		time_t timebase;
int error;		int error;

td = curthread;		td = curthread;

vfs_mountroot_wait();

sb = sbuf_new_auto();		sb = sbuf_new_auto();
vfs_mountroot_conf0(sb);		vfs_mountroot_conf0(sb);
sbuf_finish(sb);		sbuf_finish(sb);

error = vfs_mountroot_devfs(td, &mp);		error = vfs_mountroot_devfs(td, &mp);
while (!error) {		while (!error) {
error = vfs_mountroot_parse(sb, mp);		error = vfs_mountroot_parse(sb, mp);
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

View Options

sys/cddl/contrib/opensolaris/uts/common/zmod/crc32.h

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
*		*
* The environment variable vfs.root.mountfrom.options is a comma delimited		* The environment variable vfs.root.mountfrom.options is a comma delimited
* set of string mount options. These mount options must be parseable		* set of string mount options. These mount options must be parseable
* by nmount() in the kernel.		* by nmount() in the kernel.
*/		*/

static int parse_mount(char **);		static int parse_mount(char **);
static struct mntarg parse_mountroot_options(struct mntarg , const char *);		static struct mntarg parse_mountroot_options(struct mntarg , const char *);
		static int vfs_mountroot_wait_if_neccessary(const char fs, const char dev);

/*		/*
* The vnode of the system's root (/ in the filesystem, without chroot		* The vnode of the system's root (/ in the filesystem, without chroot
* active.)		* active.)
*/		*/
struct vnode *rootvnode;		struct vnode *rootvnode;

/*		/*
▲ Show 20 Lines • Show All 579 Lines • ▼ Show 20 Lines	parse_mount_dev_present(const char *dev)
struct nameidata nd;		struct nameidata nd;
int error;		int error;

NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);		NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);
error = namei(&nd);		error = namei(&nd);
if (!error)		if (!error)
vput(nd.ni_vp);		vput(nd.ni_vp);
NDFREE(&nd, NDF_ONLY_PNBUF);		NDFREE(&nd, NDF_ONLY_PNBUF);
		if (error != 0)
		printf("%s: %s not present, error %d\n", __func__, dev, error);
		marcelUnsubmitted Done Inline Actions This looks like it's more for debugging than for an end user. Maybe put this under boot verbose? The reason is that it's not an error until it's an error, meaning that if we're going to wait for the device when it's not there yet, then printing errors is confusing. Putting it under boot verbose is a nice way for people to get insight into why a boot may be stalled... marcel: This looks like it's more for debugging than for an end user. Maybe put this under boot verbose?
return (error != 0) ? 0 : 1;		return (error != 0) ? 0 : 1;
}		}
		traszAuthorUnsubmitted Not Done Inline Actions Actually, it was a debugging printf that snuck in. Removed. trasz: Actually, it was a debugging printf that snuck in. Removed.

#define ERRMSGL 255		#define ERRMSGL 255
static int		static int
parse_mount(char **conf)		parse_mount(char **conf)
{		{
char *errmsg;		char *errmsg;
struct mntarg *ma;		struct mntarg *ma;
char dev, fs, opts, tok;		char dev, fs, opts, tok;
int delay, error, timeout;		int error;

error = parse_token(conf, &tok);		error = parse_token(conf, &tok);
if (error)		if (error)
return (error);		return (error);
fs = tok;		fs = tok;
error = parse_skipto(&tok, ':');		error = parse_skipto(&tok, ':');
if (error) {		if (error) {
free(fs, M_TEMP);		free(fs, M_TEMP);
Show All 20 Lines	parse_mount(char **conf)
errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);		errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);

if (vfs_byname(fs) == NULL) {		if (vfs_byname(fs) == NULL) {
strlcpy(errmsg, "unknown file system", ERRMSGL);		strlcpy(errmsg, "unknown file system", ERRMSGL);
error = ENOENT;		error = ENOENT;
goto out;		goto out;
}		}

if (strcmp(fs, "zfs") != 0 && strstr(fs, "nfs") == NULL &&		error = vfs_mountroot_wait_if_neccessary(fs, dev);
dev[0] != '\0' && !parse_mount_dev_present(dev)) {		if (error != 0)
printf("mountroot: waiting for device %s ...\n", dev);
delay = hz / 10;
timeout = root_mount_timeout * hz;
do {
pause("rmdev", delay);
timeout -= delay;
} while (timeout > 0 && !parse_mount_dev_present(dev));
if (timeout <= 0) {
error = ENODEV;
goto out;		goto out;
}
}

ma = NULL;		ma = NULL;
ma = mount_arg(ma, "fstype", fs, -1);		ma = mount_arg(ma, "fstype", fs, -1);
ma = mount_arg(ma, "fspath", "/", -1);		ma = mount_arg(ma, "fspath", "/", -1);
ma = mount_arg(ma, "from", dev, -1);		ma = mount_arg(ma, "from", dev, -1);
ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);		ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);
ma = mount_arg(ma, "ro", NULL, 0);		ma = mount_arg(ma, "ro", NULL, 0);
ma = parse_mountroot_options(ma, opts);		ma = parse_mountroot_options(ma, opts);
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines	if (ppsratecheck(&lastfail, &curfail, 1)) {
printf(" %s", h->who);		printf(" %s", h->who);
printf("\n");		printf("\n");
}		}
msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",		msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",
hz);		hz);
}		}
}		}

		static int
		vfs_mountroot_wait_if_neccessary(const char fs, const char dev)
		kibUnsubmitted Not Done Inline Actions Please come with much shorter name for the function. kib: Please come with much shorter name for the function.
		{
		int delay, timeout;

		/*
		* In case of ZFS and NFS we don't have a way to wait for
		* specific device.
		*/
		if (strcmp(fs, "zfs") == 0 \|\| strstr(fs, "nfs") != NULL \|\|
		dev[0] == '\0') {
		vfs_mountroot_wait();
		return (0);
		}

		/*
		* Otherwise, no point in waiting if the device is already there.
		* Note that we must wait for GEOM to finish reconfiguring itself,
		* eg for geom_part(4) to finish tasting.
		*/
		DROP_GIANT();
		g_waitidle();
		kibUnsubmitted Not Done Inline Actions I think this is not needed, and probably even dangerous, for the nfs case. I have no better suggestion than ugly strstr("nfs") hack, but it is still much better than preventing nfs mount due to the issues with the local storage subsystem. kib: I think this is not needed, and probably even dangerous, for the nfs case. I have no better…
		traszAuthorUnsubmitted Not Done Inline Actions For the non-NFS case it's definitely needed, because without it, partitions don't get created before we check for the device presence, and we end up doing the full wait in all cases, defying the purpose of this patch. For the NFS case, this code is not reached - just like for ZFS, we call vfs_mountroot_wait() and return few lines earlier. trasz: For the non-NFS case it's definitely needed, because without it, partitions don't get created…
		PICKUP_GIANT();
		if (parse_mount_dev_present(dev))
		return (0);

		/*
		* No luck. Let's wait. This code looks weird, but it's that way
		* to behave exactly as it used to work before.
		*/
		vfs_mountroot_wait();
		printf("mountroot: waiting for device %s...\n", dev);
		delay = hz / 10;
		timeout = root_mount_timeout * hz;
		do {
		pause("rmdev", delay);
		timeout -= delay;
		} while (timeout > 0 && !parse_mount_dev_present(dev));

		if (timeout <= 0)
		return (ENODEV);

		kibUnsubmitted Not Done Inline Actions This blank line is not needed. kib: This blank line is not needed.
		return (0);
		}

void		void
vfs_mountroot(void)		vfs_mountroot(void)
{		{
struct mount *mp;		struct mount *mp;
struct sbuf *sb;		struct sbuf *sb;
struct thread *td;		struct thread *td;
time_t timebase;		time_t timebase;
int error;		int error;

td = curthread;		td = curthread;

vfs_mountroot_wait();

sb = sbuf_new_auto();		sb = sbuf_new_auto();
vfs_mountroot_conf0(sb);		vfs_mountroot_conf0(sb);
sbuf_finish(sb);		sbuf_finish(sb);

error = vfs_mountroot_devfs(td, &mp);		error = vfs_mountroot_devfs(td, &mp);
while (!error) {		while (!error) {
error = vfs_mountroot_parse(sb, mp);		error = vfs_mountroot_parse(sb, mp);
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

View Options

sys/cddl/contrib/opensolaris/uts/common/zmod/deflate.h

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
*		*
* The environment variable vfs.root.mountfrom.options is a comma delimited		* The environment variable vfs.root.mountfrom.options is a comma delimited
* set of string mount options. These mount options must be parseable		* set of string mount options. These mount options must be parseable
* by nmount() in the kernel.		* by nmount() in the kernel.
*/		*/

static int parse_mount(char **);		static int parse_mount(char **);
static struct mntarg parse_mountroot_options(struct mntarg , const char *);		static struct mntarg parse_mountroot_options(struct mntarg , const char *);
		static int vfs_mountroot_wait_if_neccessary(const char fs, const char dev);

/*		/*
* The vnode of the system's root (/ in the filesystem, without chroot		* The vnode of the system's root (/ in the filesystem, without chroot
* active.)		* active.)
*/		*/
struct vnode *rootvnode;		struct vnode *rootvnode;

/*		/*
▲ Show 20 Lines • Show All 579 Lines • ▼ Show 20 Lines	parse_mount_dev_present(const char *dev)
struct nameidata nd;		struct nameidata nd;
int error;		int error;

NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);		NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);
error = namei(&nd);		error = namei(&nd);
if (!error)		if (!error)
vput(nd.ni_vp);		vput(nd.ni_vp);
NDFREE(&nd, NDF_ONLY_PNBUF);		NDFREE(&nd, NDF_ONLY_PNBUF);
		if (error != 0)
		printf("%s: %s not present, error %d\n", __func__, dev, error);
		marcelUnsubmitted Done Inline Actions This looks like it's more for debugging than for an end user. Maybe put this under boot verbose? The reason is that it's not an error until it's an error, meaning that if we're going to wait for the device when it's not there yet, then printing errors is confusing. Putting it under boot verbose is a nice way for people to get insight into why a boot may be stalled... marcel: This looks like it's more for debugging than for an end user. Maybe put this under boot verbose?
return (error != 0) ? 0 : 1;		return (error != 0) ? 0 : 1;
}		}
		traszAuthorUnsubmitted Not Done Inline Actions Actually, it was a debugging printf that snuck in. Removed. trasz: Actually, it was a debugging printf that snuck in. Removed.

#define ERRMSGL 255		#define ERRMSGL 255
static int		static int
parse_mount(char **conf)		parse_mount(char **conf)
{		{
char *errmsg;		char *errmsg;
struct mntarg *ma;		struct mntarg *ma;
char dev, fs, opts, tok;		char dev, fs, opts, tok;
int delay, error, timeout;		int error;

error = parse_token(conf, &tok);		error = parse_token(conf, &tok);
if (error)		if (error)
return (error);		return (error);
fs = tok;		fs = tok;
error = parse_skipto(&tok, ':');		error = parse_skipto(&tok, ':');
if (error) {		if (error) {
free(fs, M_TEMP);		free(fs, M_TEMP);
Show All 20 Lines	parse_mount(char **conf)
errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);		errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);

if (vfs_byname(fs) == NULL) {		if (vfs_byname(fs) == NULL) {
strlcpy(errmsg, "unknown file system", ERRMSGL);		strlcpy(errmsg, "unknown file system", ERRMSGL);
error = ENOENT;		error = ENOENT;
goto out;		goto out;
}		}

if (strcmp(fs, "zfs") != 0 && strstr(fs, "nfs") == NULL &&		error = vfs_mountroot_wait_if_neccessary(fs, dev);
dev[0] != '\0' && !parse_mount_dev_present(dev)) {		if (error != 0)
printf("mountroot: waiting for device %s ...\n", dev);
delay = hz / 10;
timeout = root_mount_timeout * hz;
do {
pause("rmdev", delay);
timeout -= delay;
} while (timeout > 0 && !parse_mount_dev_present(dev));
if (timeout <= 0) {
error = ENODEV;
goto out;		goto out;
}
}

ma = NULL;		ma = NULL;
ma = mount_arg(ma, "fstype", fs, -1);		ma = mount_arg(ma, "fstype", fs, -1);
ma = mount_arg(ma, "fspath", "/", -1);		ma = mount_arg(ma, "fspath", "/", -1);
ma = mount_arg(ma, "from", dev, -1);		ma = mount_arg(ma, "from", dev, -1);
ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);		ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);
ma = mount_arg(ma, "ro", NULL, 0);		ma = mount_arg(ma, "ro", NULL, 0);
ma = parse_mountroot_options(ma, opts);		ma = parse_mountroot_options(ma, opts);
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines	if (ppsratecheck(&lastfail, &curfail, 1)) {
printf(" %s", h->who);		printf(" %s", h->who);
printf("\n");		printf("\n");
}		}
msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",		msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",
hz);		hz);
}		}
}		}

		static int
		vfs_mountroot_wait_if_neccessary(const char fs, const char dev)
		kibUnsubmitted Not Done Inline Actions Please come with much shorter name for the function. kib: Please come with much shorter name for the function.
		{
		int delay, timeout;

		/*
		* In case of ZFS and NFS we don't have a way to wait for
		* specific device.
		*/
		if (strcmp(fs, "zfs") == 0 \|\| strstr(fs, "nfs") != NULL \|\|
		dev[0] == '\0') {
		vfs_mountroot_wait();
		return (0);
		}

		/*
		* Otherwise, no point in waiting if the device is already there.
		* Note that we must wait for GEOM to finish reconfiguring itself,
		* eg for geom_part(4) to finish tasting.
		*/
		DROP_GIANT();
		g_waitidle();
		kibUnsubmitted Not Done Inline Actions I think this is not needed, and probably even dangerous, for the nfs case. I have no better suggestion than ugly strstr("nfs") hack, but it is still much better than preventing nfs mount due to the issues with the local storage subsystem. kib: I think this is not needed, and probably even dangerous, for the nfs case. I have no better…
		traszAuthorUnsubmitted Not Done Inline Actions For the non-NFS case it's definitely needed, because without it, partitions don't get created before we check for the device presence, and we end up doing the full wait in all cases, defying the purpose of this patch. For the NFS case, this code is not reached - just like for ZFS, we call vfs_mountroot_wait() and return few lines earlier. trasz: For the non-NFS case it's definitely needed, because without it, partitions don't get created…
		PICKUP_GIANT();
		if (parse_mount_dev_present(dev))
		return (0);

		/*
		* No luck. Let's wait. This code looks weird, but it's that way
		* to behave exactly as it used to work before.
		*/
		vfs_mountroot_wait();
		printf("mountroot: waiting for device %s...\n", dev);
		delay = hz / 10;
		timeout = root_mount_timeout * hz;
		do {
		pause("rmdev", delay);
		timeout -= delay;
		} while (timeout > 0 && !parse_mount_dev_present(dev));

		if (timeout <= 0)
		return (ENODEV);

		kibUnsubmitted Not Done Inline Actions This blank line is not needed. kib: This blank line is not needed.
		return (0);
		}

void		void
vfs_mountroot(void)		vfs_mountroot(void)
{		{
struct mount *mp;		struct mount *mp;
struct sbuf *sb;		struct sbuf *sb;
struct thread *td;		struct thread *td;
time_t timebase;		time_t timebase;
int error;		int error;

td = curthread;		td = curthread;

vfs_mountroot_wait();

sb = sbuf_new_auto();		sb = sbuf_new_auto();
vfs_mountroot_conf0(sb);		vfs_mountroot_conf0(sb);
sbuf_finish(sb);		sbuf_finish(sb);

error = vfs_mountroot_devfs(td, &mp);		error = vfs_mountroot_devfs(td, &mp);
while (!error) {		while (!error) {
error = vfs_mountroot_parse(sb, mp);		error = vfs_mountroot_parse(sb, mp);
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

View Options

sys/cddl/contrib/opensolaris/uts/common/zmod/deflate.c

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
*		*
* The environment variable vfs.root.mountfrom.options is a comma delimited		* The environment variable vfs.root.mountfrom.options is a comma delimited
* set of string mount options. These mount options must be parseable		* set of string mount options. These mount options must be parseable
* by nmount() in the kernel.		* by nmount() in the kernel.
*/		*/

static int parse_mount(char **);		static int parse_mount(char **);
static struct mntarg parse_mountroot_options(struct mntarg , const char *);		static struct mntarg parse_mountroot_options(struct mntarg , const char *);
		static int vfs_mountroot_wait_if_neccessary(const char fs, const char dev);

/*		/*
* The vnode of the system's root (/ in the filesystem, without chroot		* The vnode of the system's root (/ in the filesystem, without chroot
* active.)		* active.)
*/		*/
struct vnode *rootvnode;		struct vnode *rootvnode;

/*		/*
▲ Show 20 Lines • Show All 579 Lines • ▼ Show 20 Lines	parse_mount_dev_present(const char *dev)
struct nameidata nd;		struct nameidata nd;
int error;		int error;

NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);		NDINIT(&nd, LOOKUP, FOLLOW \| LOCKLEAF, UIO_SYSSPACE, dev, curthread);
error = namei(&nd);		error = namei(&nd);
if (!error)		if (!error)
vput(nd.ni_vp);		vput(nd.ni_vp);
NDFREE(&nd, NDF_ONLY_PNBUF);		NDFREE(&nd, NDF_ONLY_PNBUF);
		if (error != 0)
		printf("%s: %s not present, error %d\n", __func__, dev, error);
		marcelUnsubmitted Done Inline Actions This looks like it's more for debugging than for an end user. Maybe put this under boot verbose? The reason is that it's not an error until it's an error, meaning that if we're going to wait for the device when it's not there yet, then printing errors is confusing. Putting it under boot verbose is a nice way for people to get insight into why a boot may be stalled... marcel: This looks like it's more for debugging than for an end user. Maybe put this under boot verbose?
return (error != 0) ? 0 : 1;		return (error != 0) ? 0 : 1;
}		}
		traszAuthorUnsubmitted Not Done Inline Actions Actually, it was a debugging printf that snuck in. Removed. trasz: Actually, it was a debugging printf that snuck in. Removed.

#define ERRMSGL 255		#define ERRMSGL 255
static int		static int
parse_mount(char **conf)		parse_mount(char **conf)
{		{
char *errmsg;		char *errmsg;
struct mntarg *ma;		struct mntarg *ma;
char dev, fs, opts, tok;		char dev, fs, opts, tok;
int delay, error, timeout;		int error;

error = parse_token(conf, &tok);		error = parse_token(conf, &tok);
if (error)		if (error)
return (error);		return (error);
fs = tok;		fs = tok;
error = parse_skipto(&tok, ':');		error = parse_skipto(&tok, ':');
if (error) {		if (error) {
free(fs, M_TEMP);		free(fs, M_TEMP);
Show All 20 Lines	parse_mount(char **conf)
errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);		errmsg = malloc(ERRMSGL, M_TEMP, M_WAITOK \| M_ZERO);

if (vfs_byname(fs) == NULL) {		if (vfs_byname(fs) == NULL) {
strlcpy(errmsg, "unknown file system", ERRMSGL);		strlcpy(errmsg, "unknown file system", ERRMSGL);
error = ENOENT;		error = ENOENT;
goto out;		goto out;
}		}

if (strcmp(fs, "zfs") != 0 && strstr(fs, "nfs") == NULL &&		error = vfs_mountroot_wait_if_neccessary(fs, dev);
dev[0] != '\0' && !parse_mount_dev_present(dev)) {		if (error != 0)
printf("mountroot: waiting for device %s ...\n", dev);
delay = hz / 10;
timeout = root_mount_timeout * hz;
do {
pause("rmdev", delay);
timeout -= delay;
} while (timeout > 0 && !parse_mount_dev_present(dev));
if (timeout <= 0) {
error = ENODEV;
goto out;		goto out;
}
}

ma = NULL;		ma = NULL;
ma = mount_arg(ma, "fstype", fs, -1);		ma = mount_arg(ma, "fstype", fs, -1);
ma = mount_arg(ma, "fspath", "/", -1);		ma = mount_arg(ma, "fspath", "/", -1);
ma = mount_arg(ma, "from", dev, -1);		ma = mount_arg(ma, "from", dev, -1);
ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);		ma = mount_arg(ma, "errmsg", errmsg, ERRMSGL);
ma = mount_arg(ma, "ro", NULL, 0);		ma = mount_arg(ma, "ro", NULL, 0);
ma = parse_mountroot_options(ma, opts);		ma = parse_mountroot_options(ma, opts);
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines	if (ppsratecheck(&lastfail, &curfail, 1)) {
printf(" %s", h->who);		printf(" %s", h->who);
printf("\n");		printf("\n");
}		}
msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",		msleep(&root_holds, &root_holds_mtx, PZERO \| PDROP, "roothold",
hz);		hz);
}		}
}		}

		static int
		vfs_mountroot_wait_if_neccessary(const char fs, const char dev)
		kibUnsubmitted Not Done Inline Actions Please come with much shorter name for the function. kib: Please come with much shorter name for the function.
		{
		int delay, timeout;

		/*
		* In case of ZFS and NFS we don't have a way to wait for
		* specific device.
		*/
		if (strcmp(fs, "zfs") == 0 \|\| strstr(fs, "nfs") != NULL \|\|
		dev[0] == '\0') {
		vfs_mountroot_wait();
		return (0);
		}

		/*
		* Otherwise, no point in waiting if the device is already there.
		* Note that we must wait for GEOM to finish reconfiguring itself,
		* eg for geom_part(4) to finish tasting.
		*/
		DROP_GIANT();
		g_waitidle();
		kibUnsubmitted Not Done Inline Actions I think this is not needed, and probably even dangerous, for the nfs case. I have no better suggestion than ugly strstr("nfs") hack, but it is still much better than preventing nfs mount due to the issues with the local storage subsystem. kib: I think this is not needed, and probably even dangerous, for the nfs case. I have no better…
		traszAuthorUnsubmitted Not Done Inline Actions For the non-NFS case it's definitely needed, because without it, partitions don't get created before we check for the device presence, and we end up doing the full wait in all cases, defying the purpose of this patch. For the NFS case, this code is not reached - just like for ZFS, we call vfs_mountroot_wait() and return few lines earlier. trasz: For the non-NFS case it's definitely needed, because without it, partitions don't get created…
		PICKUP_GIANT();
		if (parse_mount_dev_present(dev))
		return (0);

		/*
		* No luck. Let's wait. This code looks weird, but it's that way
		* to behave exactly as it used to work before.
		*/
		vfs_mountroot_wait();
		printf("mountroot: waiting for device %s...\n", dev);
		delay = hz / 10;
		timeout = root_mount_timeout * hz;
		do {
		pause("rmdev", delay);
		timeout -= delay;
		} while (timeout > 0 && !parse_mount_dev_present(dev));

		if (timeout <= 0)
		return (ENODEV);

		kibUnsubmitted Not Done Inline Actions This blank line is not needed. kib: This blank line is not needed.
		return (0);
		}

void		void
vfs_mountroot(void)		vfs_mountroot(void)
{		{
struct mount *mp;		struct mount *mp;
struct sbuf *sb;		struct sbuf *sb;
struct thread *td;		struct thread *td;
time_t timebase;		time_t timebase;
int error;		int error;

td = curthread;		td = curthread;

vfs_mountroot_wait();

sb = sbuf_new_auto();		sb = sbuf_new_auto();
vfs_mountroot_conf0(sb);		vfs_mountroot_conf0(sb);
sbuf_finish(sb);		sbuf_finish(sb);

error = vfs_mountroot_devfs(td, &mp);		error = vfs_mountroot_devfs(td, &mp);
while (!error) {		while (!error) {
error = vfs_mountroot_parse(sb, mp);		error = vfs_mountroot_parse(sb, mp);
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines