Page MenuHomeFreeBSD
Differential D2408

Add ELF Tool Chain's c++filt to the build
ClosedPublic
Actions

Authored by emaste on Apr 30 2015, 3:00 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Apr 12, 2:07 PM
Unknown Object (File)
Sat, Mar 29, 3:44 PM
Unknown Object (File)
Tue, Mar 25, 5:02 AM
Unknown Object (File)
Fri, Mar 21, 8:23 PM
Unknown Object (File)
Thu, Mar 20, 3:45 AM
Unknown Object (File)
Mar 14 2025, 11:31 AM
Unknown Object (File)
Mar 13 2025, 7:56 PM
Unknown Object (File)
Mar 11 2025, 4:33 PM
View All Files
Subscribers
freebsd-toolchain-list
imp

Details

Reviewers
brooks
imp
Commits
rS282285: Add ELF Tool Chain's c++filt to the build

Diff Detail

Lint
Lint Skipped
Unit
Tests Skipped

Event Timeline

emaste updated this revision to Diff 5105.Apr 30 2015, 3:00 PM
emaste retitled this revision from to Add ELF Tool Chain's c++filt to the build.
emaste updated this object.
emaste edited the test plan for this revision. (Show Details)
emaste added a reviewer: brooks.
emaste added a subscriber: Unknown Object (MLST).
emaste added a comment.Apr 30 2015, 3:08 PM

Oh - we also need either:

diff --git a/gnu/usr.bin/cc/Makefile b/gnu/usr.bin/cc/Makefile
index abc9876..12ee7f8 100644
--- a/gnu/usr.bin/cc/Makefile
+++ b/gnu/usr.bin/cc/Makefile
@@ -12,7 +12,10 @@ SUBDIR+= cpp
 .endif
 
 .if ${MK_CXX} != "no"
-SUBDIR+= cc1plus c++ c++filt
+SUBDIR+= cc1plus c++
+.if ${MK_ELFTOOLCHAIN_TOLOLS} != "no"
+SUBDIR+= c++filt
+.endif
 .endif
 
 .if ${MK_GCOV} != "no"

or

--- a/usr.bin/Makefile
+++ b/usr.bin/Makefile
@@ -238,7 +238,9 @@ SUBDIR+=    ee
 
 .if ${MK_ELFTOOLCHAIN_TOOLS} != "no"
 _addr2line=    addr2line
+.if ${MK_GCC} != "no" && ${MK_CXX} != "no"
 _cxxfilt=      cxxfilt
+.endif
 _elfcopy=      elfcopy
 _nm=           nm
 _readelf=      readelf
brooks edited edge metadata.Apr 30 2015, 3:33 PM

s/MK_ELFTOOLCHAIN_TOLOLS/MK_ELFTOOLCHAIN_TOOLS/ required :)

emaste updated this revision to Diff 5108.Apr 30 2015, 3:39 PM
emaste edited edge metadata.
  • prefer ELF Tool Chain's c++filt
  • exclude from make delete-old
  • fix typo
emaste added inline comments.Apr 30 2015, 3:41 PM
gnu/usr.bin/cc/Makefile
16

Sigh, this is backwards.
Will update to == "no" - i.e., build GCC's c++filt in the WITHOUT_ELFTOOLCHAIN_TOOLS case.

brooks accepted this revision.Apr 30 2015, 3:43 PM
brooks edited edge metadata.

Looks good to me.

This revision is now accepted and ready to land.Apr 30 2015, 3:43 PM
imp accepted this revision.Apr 30 2015, 4:07 PM
imp added a reviewer: imp.
imp added a subscriber: imp.

I came to troll you for TOLO -> YOLO, but brooks beat me to it...

Closed by commit rS282285: Add ELF Tool Chain's c++filt to the build (authored by emaste). · Explain WhyApr 30 2015, 9:30 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathSize
gnu/
usr.bin/
cc/
5 lines
tools/
build/
mk/
2 lines
usr.bin/
2 lines
cxxfilt/
17 lines

Diff 5108

View Options

gnu/usr.bin/cc/Makefile

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 Linesparse_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 Linesparse_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

tools/build/mk/OptionalObsoleteFiles.inc

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 Linesparse_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 Linesparse_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

usr.bin/Makefile

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 Linesparse_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 Linesparse_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

usr.bin/cxxfilt/Makefile

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 Linesparse_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 Linesparse_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