Page MenuHomeFreeBSD
Differential D7529

libifconfig: First baby steps towards libification of ifconfig
ClosedPublic
Actions

Authored by marieheleneka_gmail.com on Aug 16 2016, 12:54 PM.
Tags
None
Referenced Files
F114935437: D7529.id19419.diff
Fri, Apr 18, 6:20 PM
F114927650: D7529.id19418.diff
Fri, Apr 18, 3:54 PM
Unknown Object (File)
Thu, Apr 17, 8:12 PM
Unknown Object (File)
Wed, Apr 16, 12:59 AM
Unknown Object (File)
Tue, Apr 15, 2:37 AM
Unknown Object (File)
Sat, Apr 12, 5:21 PM
Unknown Object (File)
Sat, Apr 12, 2:13 PM
Unknown Object (File)
Fri, Apr 11, 5:19 PM
View All Files
Subscribers
bcr
bdrewery
emaste
imp
kbowling

Details

Reviewers
kp
allanjude
gnn
adrian
Commits
rS304815: Add libifc, a library implementing core functionality that exists in ifconfig…
Summary

Libifconfig will implement most things ifconfig does today, and it is my intention to reduce complexity of future ifconfig maintenance and development by refactoring ifconfig to use it once the library stabilizes more. (Some work is done on this already)

This is an initial patch to get feedback on the first baby steps, and maybe get it into the tree, which would hopefully make it easier to experiment with and increase amount of feedback.

The API is not currently stable. It may change entirely at any time, but it's safe to experiment with.
See https://github.com/Savagedlight/libifconfig/tree/master/examples for basic usage examples.

The manpage is nonexistent at the moment, but between the examples and documentation in the header files you should find your way around.

Diff Detail

Repository
rS FreeBSD src repository - subversion
Lint
Lint Skipped
Unit
Tests Skipped

Event Timeline

marieheleneka_gmail.com updated this revision to Diff 19341.Aug 16 2016, 12:54 PM
marieheleneka_gmail.com retitled this revision from to libifconfig: First baby steps towards libification of ifconfig.
marieheleneka_gmail.com updated this object.
marieheleneka_gmail.com edited the test plan for this revision. (Show Details)
marieheleneka_gmail.com added reviewers: gnn, kp, allanjude, adrian.
marieheleneka_gmail.com set the repository for this revision to rS FreeBSD src repository - subversion.
Herald added subscribers: emaste, imp, bdrewery. · View Herald TranscriptAug 16 2016, 12:54 PM
marieheleneka_gmail.com updated this revision to Diff 19347.Aug 16 2016, 1:07 PM

Removed things that are not related to FreeBSD base.

gnn edited edge metadata.Aug 16 2016, 1:10 PM

A few points about how we put code into FreeBSD.

lib/libifconfig/.gitlab-ci.yml
1 ↗(On Diff #19341)

I don't think this file is supposed to be here?

lib/libifconfig/LICENSE.txt
1 ↗(On Diff #19341)

We don't normally have a LICENSE file. Just put the appropriate license into the C and include files.

lib/libifconfig/examples/ifcreate.c
1 ↗(On Diff #19341)

Please move the examples into the examples directory in share.

kp edited edge metadata.Aug 16 2016, 1:21 PM

Very quick first pass remarks.

The source and headers should probably be moved directly into lib/libifconfig.

Bikeshed: libifconfig or libifc?

lib/libifconfig/Makefile
4 ↗(On Diff #19347)

This (and SRCS/INCS/INCSDIR) should be indented with tabs.

share/mk/bsd.libnames.mk
85

This should be indented with a tab.

bcr added a subscriber: bcr.Aug 16 2016, 1:27 PM

Typo fixes in comments.

lib/libifconfig/examples/ifcreate.c
51 ↗(On Diff #19347)

superfluous space after "do".

77 ↗(On Diff #19347)

s/accomodating/accommodating/

lib/libifconfig/examples/ifdestroy.c
51 ↗(On Diff #19347)

Superfluous space after "do".

lib/libifconfig/examples/setdescription.c
48 ↗(On Diff #19347)

Superfluous space after "do".

lib/libifconfig/examples/setmtu.c
52 ↗(On Diff #19347)

Superfluous space after "do".

kbowling added a subscriber: kbowling.Aug 16 2016, 2:43 PM
kp added inline comments.Aug 16 2016, 3:16 PM
lib/libifconfig/src/libifconfig.c
135 ↗(On Diff #19347)

This will likely be easier to read if the conditions are inverted, i.e. check for error, not success.

Something like:

if ((desc = realloc(desc, descrlen)) == NULL) {
    h->error.errtype = OTHER;
    h->error.errcode = ENOMEM;
    return (-1);
}

ifr.ifr_buffer.buffer = descr;
ifr.ifr_buffer.length = descrlen;

if (libifc_ioctlwrap(h, AF_LOCAL, SIOCGIFHESCR, &ifr) != 0)
    return (-1);

if (ifr.ifr_buffer.length > descrlen) {
    descrlen = ifr.ifr_buffer.length;
    continue;
}

...
196 ↗(On Diff #19347)

The maximum length is configured through the net.ifdescr_maxlen sysctl.
If the name is longer the ioctl() will return ENAMETOOLONG.

I don't think you need to check for this before the ioctl() call. Just handle the error.

206 ↗(On Diff #19347)

It's safe to call free(NULL). You don't need this check.
Also, I don't think it can be NULL at this point. You can trust the kernel to not remove the buffer for you.

244 ↗(On Diff #19347)

The kernel doesn't truncate, and if the name is longer than it likes you'll get an error.

lib/libifconfig/src/libifconfig_internal.c
87 ↗(On Diff #19347)

The maximum number of address families (looking at /usr/include/sys/socket.h) seems to be low enough that this shouldn't be required. AF_MAX is 42 (a pleasing number).

Just allocating a fixed array of AF_MAX will waste very little memory, simplify things, and get rid of the lookup loop in libifc_socket().

marieheleneka_gmail.com updated this revision to Diff 19357.Aug 16 2016, 3:20 PM
marieheleneka_gmail.com edited edge metadata.
marieheleneka_gmail.com marked 9 inline comments as done.

Addressed feedback

marieheleneka_gmail.com added inline comments.Aug 16 2016, 3:47 PM
lib/libifconfig/src/libifconfig.c
135 ↗(On Diff #19347)

Chop all the x-mas trees. :)

lib/libifconfig/src/libifconfig_internal.c
87 ↗(On Diff #19347)

I agree that allocating a static amount of memory (sizeof(...)*AF_MAX) should incur an insignificant amount of wasted memory, and that the reduction in code complexity is desired.

It does however not remove the need for the lookup loop, as this is required to find the proper socket and create it if it doesn't exist.

kp added inline comments.Aug 16 2016, 3:49 PM
lib/libifconfig/src/libifconfig_internal.c
87 ↗(On Diff #19347)

Yes, but if you allocate fds[AF_MAX] you can index based on address family and the lookup becomes a simple array access, rather than an iteration of the array.
(so fds[AF_INET], rather than a for loop).

marieheleneka_gmail.com updated this revision to Diff 19399.Aug 17 2016, 9:54 AM
marieheleneka_gmail.com marked 8 inline comments as done.

Addressed feedback.

Now assumes addressfamily will be a number less than AF_MAX and allocates an array of sockets with AF_MAX elements. All lookups and assignments of sockets are now done via array access.

kp added inline comments.Aug 17 2016, 9:58 AM
lib/libifconfig/libifconfig.c
82 ↗(On Diff #19399)

You may want to initialise the sockets array elements to -1, because '0' can be a valid file descriptor.

lib/libifconfig/libifconfig_internal.c
99 ↗(On Diff #19399)

So != -1 here.

106 ↗(On Diff #19399)

You could assign directly to h->sockets[addressfamily] here.

marieheleneka_gmail.com updated this revision to Diff 19404.Aug 17 2016, 11:01 AM
marieheleneka_gmail.com marked 3 inline comments as done.

Addressed comments.

Also adjusted sockets array from AF_MAX to AF_MAX+1 as AF_MAX describes the highest ID of currently available AF's, and not number of available AFs. (1-based vs 0-based counting, in other words.)

marieheleneka_gmail.com updated this revision to Diff 19418.Aug 17 2016, 3:10 PM

The only change in this revision is the library has been renamed from "libifconfig" to "libifc", to be in sync with the prefixes and what people are actually calling it. Uploading it so it will be easier to track changes between revisions here.

kp added inline comments.Aug 17 2016, 3:20 PM
share/mk/bsd.libnames.mk
85

I think you missed a rename here.

marieheleneka_gmail.com updated this revision to Diff 19419.Aug 17 2016, 3:33 PM
marieheleneka_gmail.com marked an inline comment as done.

Fixed a few missed renames.

marieheleneka_gmail.com updated this revision to Diff 19454.Aug 18 2016, 12:55 PM

Removed libifc_ioctlwrap_caddrt as it was not necessary.
'struct ifreq ifr' is now always initialized by overwriting it with 0's.
Makefile now defines WARN?=6 to fault on all warnings. (Warnings are future "gifts" we don't want)

marieheleneka_gmail.com updated this revision to Diff 19625.Aug 24 2016, 11:46 AM

Now tells lib/Makefile to build libifc, so it actually gets built with 'buildworld'
Disabled building of shared library for now, to further state this is not production ready.

marieheleneka_gmail.com updated this revision to Diff 19687.Aug 25 2016, 7:20 PM

Added missing $FreeBSD$ tags

Closed by commit rS304815: Add libifc, a library implementing core functionality that exists in ifconfig… (authored by kp). · Explain WhyAug 25 2016, 7:40 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathSize
lib/
libifc/
17 lines
109 lines
383 lines
89 lines
114 lines
share/
examples/
libifc/
7 lines
91 lines
85 lines
89 lines
92 lines
mk/
1 line
1 line

Diff 19418

View Options

lib/libifc/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

lib/libifc/libifc.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 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

lib/libifc/libifc.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
View Options

lib/libifc/libifc_internal.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 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

lib/libifc/libifc_internal.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
View Options

share/examples/libifc/Makefile

Loading...
View Options

share/examples/libifc/ifcreate.c

Loading...
View Options

share/examples/libifc/ifdestroy.c

Loading...
View Options

share/examples/libifc/setdescription.c

Loading...
View Options

share/examples/libifc/setmtu.c

Loading...
View Options

share/mk/bsd.libnames.mk

Loading...
View Options

share/mk/src.libnames.mk

Loading...