Page MenuHomeFreeBSD
Differential D13986

Remove extra copy of bootinfo.c. It's a bit rotted copy of the one in efi/loader.
ClosedPublic
Actions

Authored by imp on Jan 19 2018, 4:57 PM.
Tags
None
Referenced Files
Unknown Object (File)
Sat, Apr 12, 2:38 AM
Unknown Object (File)
Thu, Apr 10, 12:40 PM
Unknown Object (File)
Fri, Mar 28, 3:01 PM
Unknown Object (File)
Mar 18 2025, 1:17 AM
Unknown Object (File)
Mar 17 2025, 4:13 AM
Unknown Object (File)
Jan 22 2025, 6:01 AM
Unknown Object (File)
Dec 21 2024, 6:00 AM
Unknown Object (File)
Dec 7 2024, 5:44 PM
View All 36 Files
Subscribers
bcran
dab

Details

Reviewers
emaste
Commits
rGcec2b3064525: Remove extra copy of bootinfo.c. It's a bit rotted copy of the one in
Summary

This appears to be a duplicate copy that was hacked, but has since bit rotted. We should kill it and if there's anything here that actually works, we should move it into the one in loader/bootinfo.c.

And then we should merge it with all the other metadata stuff. Too many cut and paste copies of that code!

Diff Detail

Lint
No Lint Coverage
Unit
No Test Coverage
Build Status
Buildable 14482
Build 14624: arc lint + arc unit

Revision Contents
Changeset List

PathSize
stand/
efi/
loader/
arch/
i386/

Diff 38210

View Options

stand/efi/loader/arch/i386/bootinfo.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 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