Page MenuHomeFreeBSD
Differential D5997

Extract "long" make target into scripts.
ClosedPublic
Actions

Authored by mat on Apr 19 2016, 1:07 PM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 17, 12:55 AM
Unknown Object (File)
Fri, Apr 11, 12:07 PM
Unknown Object (File)
Tue, Apr 1, 6:46 AM
Unknown Object (File)
Sun, Mar 23, 8:30 AM
Unknown Object (File)
Thu, Mar 20, 12:26 PM
Unknown Object (File)
Mar 15 2025, 1:06 PM
Unknown Object (File)
Mar 11 2025, 12:58 AM
Unknown Object (File)
Mar 10 2025, 10:01 PM
View All Files
Subscribers
bdrewery
sunpoet

Details

Reviewers
None
Group Reviewers
portmgr
Commits
rP415842: Extract the larger bsd.port.mk targets into separate scripts.
Summary

Extract check-vulnerable target.
Extract do-fetch, fetch-list, fetch-url-list-int and fetch-urlall-list.

Diff Detail

Repository
rP FreeBSD ports repository
Lint
No Lint Coverage
Unit
No Test Coverage
Build Status
Buildable 3628
Build 3668: arc lint + arc unit

Event Timeline

mat updated this revision to Diff 15314.Apr 19 2016, 1:07 PM
mat retitled this revision from to Extract "long" make target into scripts..
mat updated this object.
mat edited the test plan for this revision. (Show Details)
Herald added a reviewer: portmgr. · View Herald TranscriptApr 19 2016, 1:07 PM
mat updated this revision to Diff 15316.Apr 19 2016, 1:14 PM
mat edited edge metadata.

Spot a mistake.

Herald edited edge metadata. · View Herald TranscriptApr 19 2016, 1:14 PM
mat updated this revision to Diff 15317.Apr 19 2016, 1:15 PM
mat edited edge metadata.

And with the correct fix.

Herald edited edge metadata. · View Herald TranscriptApr 19 2016, 1:15 PM
mat updated this revision to Diff 15318.Apr 19 2016, 1:54 PM
mat edited edge metadata.
  • Extract makesum.
Herald edited edge metadata. · View Herald TranscriptApr 19 2016, 1:54 PM
mat updated this revision to Diff 15319.Apr 19 2016, 2:08 PM
mat edited edge metadata.
  • Extract makesum.
Herald edited edge metadata. · View Herald TranscriptApr 19 2016, 2:08 PM
mat updated this revision to Diff 15437.Apr 21 2016, 11:29 AM
mat edited edge metadata.

update the makesum.sh to validate all of it's environment.

Herald edited edge metadata. · View Herald TranscriptApr 21 2016, 11:29 AM
mat updated this revision to Diff 15438.Apr 21 2016, 12:28 PM
mat edited edge metadata.
  • Extract checksum.
  • Extract makesum.
  • Do the fetching directly when running makesum.
  • Extract check-checksum-algorithms.
Herald edited edge metadata. · View Herald TranscriptApr 21 2016, 12:28 PM
mat updated this revision to Diff 16051.May 9 2016, 2:45 PM
mat edited edge metadata.
  • Fix PATCHFILES.
  • Handle ports with no DISTFILES.
Herald edited edge metadata. · View Herald TranscriptMay 9 2016, 2:45 PM
mat updated this revision to Diff 16475.May 17 2016, 4:01 PM
mat edited edge metadata.

Rebase, include the TIMESTAMP bits in makesum.

mat updated this revision to Diff 16622.May 20 2016, 2:36 PM

rebase.

bdrewery added a subscriber: bdrewery.May 20 2016, 9:07 PM

Awesome! If an exp-run works then just do it.

bdrewery added a comment.May 20 2016, 9:08 PM

Looks like you need to update this with your debug feature.

mat added a comment.May 21 2016, 8:42 AM
In D5997#137279, @bdrewery wrote:

Awesome! If an exp-run works then just do it.

It's currently being tested in https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=208916

In D5997#137281, @bdrewery wrote:

Looks like you need to update this with your debug feature.

Yes, I added it on my local repo but did not update the review.

mat updated this revision to Diff 16723.May 23 2016, 12:52 PM

Rebase, and:

  • Fix PATCHFILES handling.
  • Add debug hooks.
mat updated this revision to Diff 16725.May 23 2016, 1:10 PM
  • Escape/unescape bits when needed.
mat updated this revision to Diff 16726.May 23 2016, 1:32 PM
  • Make RANDOMIZE_MASTER_SITES work again.
Closed by commit rP415842: Extract the larger bsd.port.mk targets into separate scripts. (authored by mat). · Explain WhyMay 25 2016, 3:58 PM
This revision was automatically updated to reflect the committed changes.
sunpoet added a subscriber: sunpoet.May 28 2016, 3:09 PM

I got error message as follows:

% make fetch-urlall-list
=> /usr/ports/distfiles/ is not writable by you; cannot fetch.
*** Error code 1

Stop.

Revision Contents
Changeset List

PathSize
Mk/
Scripts/
35 lines
89 lines
148 lines
28 lines
32 lines
603 lines

Diff 16051

View Options

Mk/Scripts/check-vulnerable.sh

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

Mk/Scripts/checksum.sh

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

Mk/Scripts/do-fetch.sh

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

Mk/Scripts/functions.sh

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

Mk/Scripts/makesum.sh

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

Mk/bsd.port.mk

Loading...