diff --git a/nfs-utils-1.1.2-mount-cleanup.patch b/nfs-utils-1.1.2-mount-cleanup.patch new file mode 100644 index 0000000..58a826d --- /dev/null +++ b/nfs-utils-1.1.2-mount-cleanup.patch @@ -0,0 +1,458 @@ +commit c641800eb0fcaa819199e58e5c4c8d1c2a9dab5d +Author: Chuck Lever +Date: Fri Jun 6 15:06:21 2008 -0400 + + Clean up: instead of passing so many arguments to all the helpers, have + nfsmount_string build a data structure that contains all the arguments, and + pass a pointer to that instead. + + Signed-off-by: Chuck Lever + Signed-off-by: Steve Dickson + +diff --git a/utils/mount/stropts.c b/utils/mount/stropts.c +index ad5bdee..3564f15 100644 +--- a/utils/mount/stropts.c ++++ b/utils/mount/stropts.c +@@ -77,12 +77,26 @@ extern int nfs_mount_data_version; + extern char *progname; + extern int verbose; + +-static int parse_devname(const char *spec, char **hostname) ++struct nfsmount_info { ++ const char *spec, /* server:/path */ ++ *node, /* mounted-on dir */ ++ *type; /* "nfs" or "nfs4" */ ++ char *hostname; /* server's hostname */ ++ ++ struct mount_options *options; /* parsed mount options */ ++ char **extra_opts; /* string for /etc/mtab */ ++ ++ int flags, /* MS_ flags */ ++ fake, /* actually do the mount? */ ++ child; /* forked bg child? */ ++}; ++ ++static int nfs_parse_devname(struct nfsmount_info *mi) + { + int ret = 0; + char *dev, *pathname, *s; + +- dev = xstrdup(spec); ++ dev = xstrdup(mi->spec); + + if (!(pathname = strchr(dev, ':'))) { + nfs_error(_("%s: remote share not in 'host:dir' format"), +@@ -113,11 +127,12 @@ static int parse_devname(const char *spec, char **hostname) + nfs_error(_("%s: ignoring hostnames that follow the first one"), + progname); + } +- *hostname = xstrdup(dev); +- if (strlen(*hostname) > NFS_MAXHOSTNAME) { ++ mi->hostname = xstrdup(dev); ++ if (strlen(mi->hostname) > NFS_MAXHOSTNAME) { + nfs_error(_("%s: server hostname is too long"), + progname); +- free(*hostname); ++ free(mi->hostname); ++ mi->hostname = NULL; + goto out; + } + +@@ -273,28 +288,30 @@ static int verify_lock_option(struct mount_options *options) + } + + /* +- * Set up mandatory mount options. ++ * Set up mandatory NFS mount options. + * + * Returns 1 if successful; otherwise zero. + */ +-static int validate_options(const char *type, +- struct sockaddr_in *saddr, +- struct mount_options *options, +- int fake) ++static int nfs_validate_options(struct nfsmount_info *mi) + { +- if (!append_addr_option(saddr, options)) ++ struct sockaddr_in saddr; ++ ++ if (!fill_ipv4_sockaddr(mi->hostname, &saddr)) + return 0; + +- if (strncmp(type, "nfs4", 4) == 0) { +- if (!append_clientaddr_option(saddr, options)) ++ if (strncmp(mi->type, "nfs4", 4) == 0) { ++ if (!append_clientaddr_option(&saddr, mi->options)) + return 0; + } else { +- if (!fix_mounthost_option(options)) ++ if (!fix_mounthost_option(mi->options)) + return 0; +- if (!fake && !verify_lock_option(options)) ++ if (!mi->fake && !verify_lock_option(mi->options)) + return 0; + } + ++ if (!append_addr_option(&saddr, mi->options)) ++ return 0; ++ + return 1; + } + +@@ -443,6 +460,27 @@ err: + } + + /* ++ * Do the mount(2) system call. ++ * ++ * Returns 1 if successful, otherwise zero. ++ * "errno" is set to reflect the individual error. ++ */ ++static int nfs_sys_mount(const struct nfsmount_info *mi, const char *type, ++ const char *options) ++{ ++ int result; ++ ++ result = mount(mi->spec, mi->node, type, ++ mi->flags & ~(MS_USER|MS_USERS), options); ++ if (verbose && result) { ++ int save = errno; ++ nfs_error(_("%s: mount(2): %s"), progname, strerror(save)); ++ errno = save; ++ } ++ return !result; ++} ++ ++/* + * Retry an NFS mount that failed because the requested service isn't + * available on the server. + * +@@ -453,12 +491,11 @@ err: + * 'extra_opts' are updated to reflect the mount options that worked. + * If the retry fails, 'options' and 'extra_opts' are left unchanged. + */ +-static int retry_nfsmount(const char *spec, const char *node, +- int flags, struct mount_options *options, +- int fake, char **extra_opts) ++static int nfs_retry_nfs23mount(struct nfsmount_info *mi) + { + struct mount_options *retry_options; + char *retry_str = NULL; ++ char **extra_opts = mi->extra_opts; + + retry_options = rewrite_mount_options(*extra_opts); + if (!retry_options) { +@@ -476,17 +513,16 @@ static int retry_nfsmount(const char *spec, const char *node, + printf(_("%s: text-based options (retry): '%s'\n"), + progname, retry_str); + +- if (!mount(spec, node, "nfs", +- flags & ~(MS_USER|MS_USERS), retry_str)) { +- free(*extra_opts); +- *extra_opts = retry_str; +- po_replace(options, retry_options); +- return 1; ++ if (!nfs_sys_mount(mi, "nfs", retry_str)) { ++ po_destroy(retry_options); ++ free(retry_str); ++ return 0; + } + +- po_destroy(retry_options); +- free(retry_str); +- return 0; ++ free(*extra_opts); ++ *extra_opts = retry_str; ++ po_replace(mi->options, retry_options); ++ return 1; + } + + /* +@@ -502,11 +538,11 @@ static int retry_nfsmount(const char *spec, const char *node, + * 'extra_opts' are updated to reflect the mount options that worked. + * If the retry fails, 'options' and 'extra_opts' are left unchanged. + */ +-static int try_nfs23mount(const char *spec, const char *node, +- int flags, struct mount_options *options, +- int fake, char **extra_opts) ++static int nfs_try_nfs23mount(struct nfsmount_info *mi) + { +- if (po_join(options, extra_opts) == PO_FAILED) { ++ char **extra_opts = mi->extra_opts; ++ ++ if (po_join(mi->options, extra_opts) == PO_FAILED) { + errno = EIO; + return 0; + } +@@ -515,11 +551,10 @@ static int try_nfs23mount(const char *spec, const char *node, + printf(_("%s: text-based options: '%s'\n"), + progname, *extra_opts); + +- if (fake) ++ if (mi->fake) + return 1; + +- if (!mount(spec, node, "nfs", +- flags & ~(MS_USER|MS_USERS), *extra_opts)) ++ if (nfs_sys_mount(mi, "nfs", *extra_opts)) + return 1; + + /* +@@ -529,7 +564,7 @@ static int try_nfs23mount(const char *spec, const char *node, + if (errno != EOPNOTSUPP && errno != EPROTONOSUPPORT) + return 0; + +- return retry_nfsmount(spec, node, flags, options, fake, extra_opts); ++ return nfs_retry_nfs23mount(mi); + } + + /* +@@ -538,11 +573,11 @@ static int try_nfs23mount(const char *spec, const char *node, + * Returns 1 if successful. Otherwise, returns zero. + * "errno" is set to reflect the individual error. + */ +-static int try_nfs4mount(const char *spec, const char *node, +- int flags, struct mount_options *options, +- int fake, char **extra_opts) ++static int nfs_try_nfs4mount(struct nfsmount_info *mi) + { +- if (po_join(options, extra_opts) == PO_FAILED) { ++ char **extra_opts = mi->extra_opts; ++ ++ if (po_join(mi->options, extra_opts) == PO_FAILED) { + errno = EIO; + return 0; + } +@@ -551,31 +586,24 @@ static int try_nfs4mount(const char *spec, const char *node, + printf(_("%s: text-based options: '%s'\n"), + progname, *extra_opts); + +- if (fake) ++ if (mi->fake) + return 1; + +- if (!mount(spec, node, "nfs4", +- flags & ~(MS_USER|MS_USERS), *extra_opts)) +- return 1; +- return 0; ++ return nfs_sys_mount(mi, "nfs4", *extra_opts); + } + + /* +- * Try the mount(2) system call. ++ * Perform either an NFSv2/3 mount, or an NFSv4 mount system call. + * + * Returns 1 if successful. Otherwise, returns zero. + * "errno" is set to reflect the individual error. + */ +-static int try_mount(const char *spec, const char *node, const char *type, +- int flags, struct mount_options *options, int fake, +- char **extra_opts) ++static int nfs_try_mount(struct nfsmount_info *mi) + { +- if (strncmp(type, "nfs4", 4) == 0) +- return try_nfs4mount(spec, node, flags, +- options, fake, extra_opts); ++ if (strncmp(mi->type, "nfs4", 4) == 0) ++ return nfs_try_nfs4mount(mi); + else +- return try_nfs23mount(spec, node, flags, +- options, fake, extra_opts); ++ return nfs_try_nfs23mount(mi); + } + + /* +@@ -585,22 +613,19 @@ static int try_mount(const char *spec, const char *node, const char *type, + * + * Returns a valid mount command exit code. + */ +-static int nfsmount_fg(const char *spec, const char *node, +- const char *type, int flags, +- struct mount_options *options, int fake, +- char **extra_opts) ++static int nfsmount_fg(struct nfsmount_info *mi) + { + unsigned int secs = 1; + time_t timeout; + +- timeout = nfs_parse_retry_option(options, NFS_DEF_FG_TIMEOUT_MINUTES); ++ timeout = nfs_parse_retry_option(mi->options, ++ NFS_DEF_FG_TIMEOUT_MINUTES); + if (verbose) + printf(_("%s: timeout set for %s"), + progname, ctime(&timeout)); + + for (;;) { +- if (try_mount(spec, node, type, flags, +- options, fake, extra_opts)) ++ if (nfs_try_mount(mi)) + return EX_SUCCESS; + + if (is_permanent_error(errno)) +@@ -620,7 +645,7 @@ static int nfsmount_fg(const char *spec, const char *node, + } + }; + +- mount_error(spec, node, errno); ++ mount_error(mi->spec, mi->node, errno); + return EX_FAIL; + } + +@@ -631,21 +656,17 @@ static int nfsmount_fg(const char *spec, const char *node, + * + * EX_BG should cause the caller to fork and invoke nfsmount_child. + */ +-static int nfsmount_parent(const char *spec, const char *node, +- const char *type, char *hostname, int flags, +- struct mount_options *options, +- int fake, char **extra_opts) ++static int nfsmount_parent(struct nfsmount_info *mi) + { +- if (try_mount(spec, node, type, flags, options, +- fake, extra_opts)) ++ if (nfs_try_mount(mi)) + return EX_SUCCESS; + + if (is_permanent_error(errno)) { +- mount_error(spec, node, errno); ++ mount_error(mi->spec, mi->node, errno); + return EX_FAIL; + } + +- sys_mount_errors(hostname, errno, 1, 1); ++ sys_mount_errors(mi->hostname, errno, 1, 1); + return EX_BG; + } + +@@ -657,15 +678,13 @@ static int nfsmount_parent(const char *spec, const char *node, + * error return, though, so we use sys_mount_errors to log the + * failure. + */ +-static int nfsmount_child(const char *spec, const char *node, +- const char *type, char *hostname, int flags, +- struct mount_options *options, +- int fake, char **extra_opts) ++static int nfsmount_child(struct nfsmount_info *mi) + { + unsigned int secs = 1; + time_t timeout; + +- timeout = nfs_parse_retry_option(options, NFS_DEF_BG_TIMEOUT_MINUTES); ++ timeout = nfs_parse_retry_option(mi->options, ++ NFS_DEF_BG_TIMEOUT_MINUTES); + + for (;;) { + if (sleep(secs)) +@@ -674,8 +693,7 @@ static int nfsmount_child(const char *spec, const char *node, + if (secs > 120) + secs = 120; + +- if (try_mount(spec, node, type, flags, options, +- fake, extra_opts)) ++ if (nfs_try_mount(mi)) + return EX_SUCCESS; + + if (is_permanent_error(errno)) +@@ -684,10 +702,10 @@ static int nfsmount_child(const char *spec, const char *node, + if (time(NULL) > timeout) + break; + +- sys_mount_errors(hostname, errno, 1, 1); ++ sys_mount_errors(mi->hostname, errno, 1, 1); + }; + +- sys_mount_errors(hostname, errno, 1, 0); ++ sys_mount_errors(mi->hostname, errno, 1, 0); + return EX_FAIL; + } + +@@ -696,17 +714,28 @@ static int nfsmount_child(const char *spec, const char *node, + * + * Returns a valid mount command exit code. + */ +-static int nfsmount_bg(const char *spec, const char *node, +- const char *type, char *hostname, int flags, +- struct mount_options *options, +- int fake, int child, char **extra_opts) ++static int nfsmount_bg(struct nfsmount_info *mi) + { +- if (!child) +- return nfsmount_parent(spec, node, type, hostname, flags, +- options, fake, extra_opts); ++ if (!mi->child) ++ return nfsmount_parent(mi); ++ else ++ return nfsmount_child(mi); ++} ++ ++/* ++ * Process mount options and try a mount system call. ++ * ++ * Returns a valid mount command exit code. ++ */ ++static int nfsmount_start(struct nfsmount_info *mi) ++{ ++ if (!nfs_validate_options(mi)) ++ return EX_FAIL; ++ ++ if (po_rightmost(mi->options, "bg", "fg") == PO_KEY1_RIGHTMOST) ++ return nfsmount_bg(mi); + else +- return nfsmount_child(spec, node, type, hostname, flags, +- options, fake, extra_opts); ++ return nfsmount_fg(mi); + } + + /** +@@ -723,35 +752,27 @@ static int nfsmount_bg(const char *spec, const char *node, + int nfsmount_string(const char *spec, const char *node, const char *type, + int flags, char **extra_opts, int fake, int child) + { +- struct mount_options *options = NULL; +- struct sockaddr_in saddr; +- char *hostname; ++ struct nfsmount_info mi = { ++ .spec = spec, ++ .node = node, ++ .type = type, ++ .extra_opts = extra_opts, ++ .flags = flags, ++ .fake = fake, ++ .child = child, ++ }; + int retval = EX_FAIL; + +- if (!parse_devname(spec, &hostname)) ++ if (!nfs_parse_devname(&mi)) + return retval; +- if (!fill_ipv4_sockaddr(hostname, &saddr)) +- goto fail; + +- options = po_split(*extra_opts); +- if (!options) { ++ mi.options = po_split(*extra_opts); ++ if (mi.options) { ++ retval = nfsmount_start(&mi); ++ po_destroy(mi.options); ++ } else + nfs_error(_("%s: internal option parsing error"), progname); +- goto fail; +- } + +- if (!validate_options(type, &saddr, options, fake)) +- goto out; +- +- if (po_rightmost(options, "bg", "fg") == PO_KEY1_RIGHTMOST) +- retval = nfsmount_bg(spec, node, type, hostname, flags, +- options, fake, child, extra_opts); +- else +- retval = nfsmount_fg(spec, node, type, flags, options, +- fake, extra_opts); +- +-out: +- po_destroy(options); +-fail: +- free(hostname); ++ free(mi.hostname); + return retval; + } diff --git a/nfs-utils-1.1.2-mount-error-reporting.patch b/nfs-utils-1.1.2-mount-error-reporting.patch new file mode 100644 index 0000000..eaf6d3e --- /dev/null +++ b/nfs-utils-1.1.2-mount-error-reporting.patch @@ -0,0 +1,66 @@ +commit 52dff26c60c07cf1b4fbf8fbd3a1eab7ba90405f +Author: Chuck Lever +Date: Fri Jun 6 15:07:24 2008 -0400 + + Fix error reporting when probe_bothports() fails while rewriting mount + options. + + Signed-off-by: Chuck Lever + Signed-off-by: Steve Dickson + +diff --git a/utils/mount/error.c b/utils/mount/error.c +index 23a91ff..147e919 100644 +--- a/utils/mount/error.c ++++ b/utils/mount/error.c +@@ -227,6 +227,9 @@ void mount_error(const char *spec, const char *mount_point, int error) + nfs_error(_("%s: mount point %s does not exist"), + progname, mount_point); + break; ++ case ESPIPE: ++ rpc_mount_errors((char *)spec, 0, 0); ++ break; + case EIO: + case EFAULT: + nfs_error(_("%s: internal error"), progname); +diff --git a/utils/mount/stropts.c b/utils/mount/stropts.c +index 3564f15..967fd69 100644 +--- a/utils/mount/stropts.c ++++ b/utils/mount/stropts.c +@@ -356,6 +356,8 @@ static struct mount_options *rewrite_mount_options(char *str) + clnt_addr_t nfs_server = { }; + int p; + ++ errno = EIO; ++ + options = po_split(str); + if (!options) + return NULL; +@@ -426,7 +428,7 @@ static struct mount_options *rewrite_mount_options(char *str) + po_remove_all(options, "udp"); + + if (!probe_bothports(&mnt_server, &nfs_server)) { +- rpc_mount_errors("rpcbind", 0, 0); ++ errno = ESPIPE; + goto err; + } + +@@ -452,6 +454,7 @@ static struct mount_options *rewrite_mount_options(char *str) + + } + ++ errno = 0; + return options; + + err: +@@ -498,10 +501,8 @@ static int nfs_retry_nfs23mount(struct nfsmount_info *mi) + char **extra_opts = mi->extra_opts; + + retry_options = rewrite_mount_options(*extra_opts); +- if (!retry_options) { +- errno = EIO; ++ if (!retry_options) + return 0; +- } + + if (po_join(retry_options, &retry_str) == PO_FAILED) { + po_destroy(retry_options); diff --git a/nfs-utils-1.1.2-mount-retry.patch b/nfs-utils-1.1.2-mount-retry.patch index 81c00fb..5db50c3 100644 --- a/nfs-utils-1.1.2-mount-retry.patch +++ b/nfs-utils-1.1.2-mount-retry.patch @@ -1,73 +1,106 @@ -commit 5f7cc524008a7dc548a71f4c7b0d39759371a37a -Author: Jeff Layton -Date: Wed May 7 10:27:53 2008 -0400 +commit d7a1070383bcf40d32c7f10e535ba443209dedef +Author: Chuck Lever +Date: Fri Jun 6 15:02:18 2008 -0400 - Currently nfs4mount() sets the retry value to 10000 on both fg and bg - mounts. It should be 2 for fg and 10000 for bg. nfsmount() sets it - properly, but there is a potential corner case. If someone explicitly - sets retry=10000 on a fg mount, then it will be reset to 2. + Steinar Gunderson reports: - Fix this by having retry default to -1 for both flavors, and then reset if - needed after the mount options have been parsed. + "It seems retry= is now additive with the text-based mount interface. In + particular, "mount -o retry=0" still gives a two-minute timeout." - Signed-off-by: Jeff Layton + Correct the bug and make retry= option parsing more robust. If parsing + the retry option fails, the option is ignored and a default timeout is + used. + + Note that currently the kernel parser ignores the "retry=" option if the + value is a number. If the value contains other characters, the kernel will + choke. A subsequent patch to the kernel will allow any characters as the + value of the retry option (excepting of course ","). + + Signed-off-by: Chuck Lever Signed-off-by: Steve Dickson -diff --git a/utils/mount/nfs4mount.c b/utils/mount/nfs4mount.c -index 311e5a0..af70551 100644 ---- a/utils/mount/nfs4mount.c -+++ b/utils/mount/nfs4mount.c -@@ -238,7 +238,7 @@ int nfs4mount(const char *spec, const char *node, int flags, - nocto = 0; - noac = 0; - unshared = 0; -- retry = 10000; /* 10000 minutes ~ 1 week */ -+ retry = -1; +diff --git a/utils/mount/stropts.c b/utils/mount/stropts.c +index b2b56be..ad5bdee 100644 +--- a/utils/mount/stropts.c ++++ b/utils/mount/stropts.c +@@ -65,6 +65,14 @@ + #define NFS_MAXPATHNAME (1024) + #endif - /* - * NFSv4 specifies that the default port should be 2049 -@@ -332,6 +332,14 @@ int nfs4mount(const char *spec, const char *node, int flags, - } - } ++#ifndef NFS_DEF_FG_TIMEOUT_MINUTES ++#define NFS_DEF_FG_TIMEOUT_MINUTES (2u) ++#endif ++ ++#ifndef NFS_DEF_BG_TIMEOUT_MINUTES ++#define NFS_DEF_BG_TIMEOUT_MINUTES (10000u) ++#endif ++ + extern int nfs_mount_data_version; + extern char *progname; + extern int verbose; +@@ -141,6 +149,32 @@ static int fill_ipv4_sockaddr(const char *hostname, struct sockaddr_in *addr) + } -+ /* if retry is still -1, then it wasn't set via an option */ -+ if (retry == -1) { -+ if (bg) -+ retry = 10000; /* 10000 mins == ~1 week */ -+ else -+ retry = 2; /* 2 min default on fg mounts */ + /* ++ * Obtain a retry timeout value based on the value of the "retry=" option. ++ * ++ * Returns a time_t timeout timestamp, in seconds. ++ */ ++static time_t nfs_parse_retry_option(struct mount_options *options, ++ unsigned int timeout_minutes) ++{ ++ char *retry_option, *endptr; ++ ++ retry_option = po_get(options, "retry"); ++ if (retry_option) { ++ long tmp; ++ ++ errno = 0; ++ tmp = strtol(retry_option, &endptr, 10); ++ if (errno == 0 && endptr != retry_option && tmp >= 0) ++ timeout_minutes = tmp; ++ else if (verbose) ++ nfs_error(_("%s: invalid retry timeout was specified; " ++ "using default timeout"), progname); + } + - data.flags = (soft ? NFS4_MOUNT_SOFT : 0) - | (intr ? NFS4_MOUNT_INTR : 0) - | (nocto ? NFS4_MOUNT_NOCTO : 0) -diff --git a/utils/mount/nfsmount.c b/utils/mount/nfsmount.c -index 6c0c365..a9dd917 100644 ---- a/utils/mount/nfsmount.c -+++ b/utils/mount/nfsmount.c -@@ -571,7 +571,7 @@ nfsmount(const char *spec, const char *node, int flags, - #endif ++ return time(NULL) + (time_t)(timeout_minutes * 60); ++} ++ ++/* + * Append the 'addr=' option to the options string to pass a resolved + * server address to the kernel. After a successful mount, this address + * is also added to /etc/mtab for use when unmounting. +@@ -557,14 +591,9 @@ static int nfsmount_fg(const char *spec, const char *node, + char **extra_opts) + { + unsigned int secs = 1; +- time_t timeout = time(NULL); +- char *retry; +- +- timeout += 60 * 2; /* default: 2 minutes */ +- retry = po_get(options, "retry"); +- if (retry) +- timeout += 60 * atoi(retry); ++ time_t timeout; - bg = 0; -- retry = 10000; /* 10000 minutes ~ 1 week */ -+ retry = -1; ++ timeout = nfs_parse_retry_option(options, NFS_DEF_FG_TIMEOUT_MINUTES); + if (verbose) + printf(_("%s: timeout set for %s"), + progname, ctime(&timeout)); +@@ -634,13 +663,9 @@ static int nfsmount_child(const char *spec, const char *node, + int fake, char **extra_opts) + { + unsigned int secs = 1; +- time_t timeout = time(NULL); +- char *retry; ++ time_t timeout; - memset(mnt_pmap, 0, sizeof(*mnt_pmap)); - mnt_pmap->pm_prog = MOUNTPROG; -@@ -585,9 +585,13 @@ nfsmount(const char *spec, const char *node, int flags, - goto fail; - if (!nfsmnt_check_compat(nfs_pmap, mnt_pmap)) - goto fail; -- -- if (retry == 10000 && !bg) -- retry = 2; /* reset for fg mounts */ -+ -+ if (retry == -1) { -+ if (bg) -+ retry = 10000; /* 10000 mins == ~1 week*/ -+ else -+ retry = 2; /* 2 min default on fg mounts */ -+ } +- timeout += 60 * 10000; /* default: 10,000 minutes */ +- retry = po_get(options, "retry"); +- if (retry) +- timeout += 60 * atoi(retry); ++ timeout = nfs_parse_retry_option(options, NFS_DEF_BG_TIMEOUT_MINUTES); - #ifdef NFS_MOUNT_DEBUG - printf(_("rsize = %d, wsize = %d, timeo = %d, retrans = %d\n"), + for (;;) { + if (sleep(secs)) diff --git a/nfs-utils-1.1.2-mount-statd-chk.patch b/nfs-utils-1.1.2-mount-statd-chk.patch new file mode 100644 index 0000000..4baf2e0 --- /dev/null +++ b/nfs-utils-1.1.2-mount-statd-chk.patch @@ -0,0 +1,71 @@ +commit 331c2ca949d5b4b4d18d0aca90afb8ae9475bcd6 +Author: Neil Brown +Date: Fri Jun 6 14:59:21 2008 -0400 + + Make the text-based mount path check whether statd is running if the "lock" + option is in effect. This echoes similar logic in the legacy mount path. + + Signed-off-by: Neil Brown + Signed-off-by: Chuck Lever + Signed-off-by: Steve Dickson + +diff --git a/utils/mount/stropts.c b/utils/mount/stropts.c +index cdd610e..b2b56be 100644 +--- a/utils/mount/stropts.c ++++ b/utils/mount/stropts.c +@@ -219,13 +219,34 @@ static int fix_mounthost_option(struct mount_options *options) + } + + /* ++ * Returns zero if the "lock" option is in effect, but statd ++ * can't be started. Otherwise, returns 1. ++ */ ++static int verify_lock_option(struct mount_options *options) ++{ ++ if (po_rightmost(options, "nolock", "lock") == PO_KEY1_RIGHTMOST) ++ return 1; ++ ++ if (!start_statd()) { ++ nfs_error(_("%s: rpc.statd is not running but is " ++ "required for remote locking."), progname); ++ nfs_error(_("%s: Either use '-o nolock' to keep " ++ "locks local, or start statd."), progname); ++ return 0; ++ } ++ ++ return 1; ++} ++ ++/* + * Set up mandatory mount options. + * + * Returns 1 if successful; otherwise zero. + */ +-static int set_mandatory_options(const char *type, +- struct sockaddr_in *saddr, +- struct mount_options *options) ++static int validate_options(const char *type, ++ struct sockaddr_in *saddr, ++ struct mount_options *options, ++ int fake) + { + if (!append_addr_option(saddr, options)) + return 0; +@@ -236,6 +257,8 @@ static int set_mandatory_options(const char *type, + } else { + if (!fix_mounthost_option(options)) + return 0; ++ if (!fake && !verify_lock_option(options)) ++ return 0; + } + + return 1; +@@ -691,7 +714,7 @@ int nfsmount_string(const char *spec, const char *node, const char *type, + goto fail; + } + +- if (!set_mandatory_options(type, &saddr, options)) ++ if (!validate_options(type, &saddr, options, fake)) + goto out; + + if (po_rightmost(options, "bg", "fg") == PO_KEY1_RIGHTMOST) diff --git a/nfs-utils-1.1.2-nfsstat-m-arg.patch b/nfs-utils-1.1.2-nfsstat-m-arg.patch new file mode 100644 index 0000000..da41fc3 --- /dev/null +++ b/nfs-utils-1.1.2-nfsstat-m-arg.patch @@ -0,0 +1,26 @@ +commit d03090be4f440d70328988e9f792f3bd0ebd956b +Author: Neil Brown +Date: Fri Jun 6 15:17:55 2008 -0400 + + nfsstat -m lists all current nfs mounts, with the mount options. + It does this by reading /proc/mounts and looking for mounts of type + "nfs". It really should check for "nfs4" as well. + + For simplicity, just check the first 3 characters of the type. + + Signed-off-by: NeilBrown + Signed-off-by: Steve Dickson + +diff --git a/utils/nfsstat/nfsstat.c b/utils/nfsstat/nfsstat.c +index aa6c961..d2cca8d 100644 +--- a/utils/nfsstat/nfsstat.c ++++ b/utils/nfsstat/nfsstat.c +@@ -716,7 +716,7 @@ mounts(const char *name) + if (!(type = strtok(NULL, " \t"))) + continue; + +- if (strcmp(type, "nfs")) { ++ if (strcmp(type, "nfs") && strcmp(type,"nfs4")) { + continue; + } + diff --git a/nfs-utils-1.1.2-warnings.patch b/nfs-utils-1.1.2-warnings.patch new file mode 100644 index 0000000..16e1e0f --- /dev/null +++ b/nfs-utils-1.1.2-warnings.patch @@ -0,0 +1,47 @@ +commit fd54675db0806e81c17ee7e7eec0abfcd33f1f23 +Author: Steve Dickson +Date: Fri Jun 6 14:44:48 2008 -0400 + + Cleaned up warnings in rmtab.c and xlog.c + + Signed-off-by: Steve Dickson + +diff --git a/support/export/rmtab.c b/support/export/rmtab.c +index 8f392a7..0ce3682 100644 +--- a/support/export/rmtab.c ++++ b/support/export/rmtab.c +@@ -23,7 +23,7 @@ int + rmtab_read(void) + { + struct rmtabent *rep; +- nfs_export *exp; ++ nfs_export *exp = NULL; + + setrmtabent("r"); + while ((rep = getrmtabent(1, NULL)) != NULL) { +@@ -31,10 +31,10 @@ rmtab_read(void) + int htype; + + htype = client_gettype(rep->r_client); +- if (htype == MCL_FQDN || htype == MCL_SUBNETWORK ++ if (htype == MCL_FQDN || (htype == MCL_SUBNETWORK + && (hp = gethostbyname (rep->r_client)) + && (hp = hostent_dup (hp), +- exp = export_allowed (hp, rep->r_path))) { ++ (exp = export_allowed (hp, rep->r_path))))) { + /* see if the entry already exists, otherwise this was an instantiated + * wild card, and we must add it + */ +diff --git a/support/nfs/xlog.c b/support/nfs/xlog.c +index 6820346..5ac9ba0 100644 +--- a/support/nfs/xlog.c ++++ b/support/nfs/xlog.c +@@ -133,7 +133,7 @@ xlog_enabled(int fac) + void + xlog_backend(int kind, const char *fmt, va_list args) + { +- va_list args2; ++ va_list args2 = NULL; + + if (!(kind & (L_ALL)) && !(logging && (kind & logmask))) + return; diff --git a/nfs-utils.spec b/nfs-utils.spec index a3a5235..49e3226 100644 --- a/nfs-utils.spec +++ b/nfs-utils.spec @@ -2,7 +2,7 @@ Summary: NFS utilities and supporting clients and daemons for the kernel NFS ser Name: nfs-utils URL: http://sourceforge.net/projects/nfs Version: 1.1.2 -Release: 5%{?dist} +Release: 6%{?dist} Epoch: 1 # group all 32bit related archs @@ -42,6 +42,13 @@ Patch107: nfs-utils-1.1.2-gssd-getverbose.patch Patch108: nfs-utils-1.1.2-gssd-creds.patch Patch109: nfs-utils-1.1.2-mount-chk-setuid.patch Patch110: nfs-utils-1.1.2-exportfs-man-typo.patch +Patch111: nfs-utils-1.1.2-warnings.patch +Patch112: nfs-utils-1.1.2-mount-statd-chk.patch +Patch113: nfs-utils-1.1.2-mount-cleanup.patch +Patch114: nfs-utils-1.1.2-mount-error-reporting.patch +Patch115: nfs-utils-1.1.2-nfsstat-m-arg.patch + + %if %{enablefscache} Patch90: nfs-utils-1.1.0-mount-fsc.patch @@ -112,6 +119,11 @@ This package also contains the mount.nfs and umount.nfs program. %patch108 -p1 %patch109 -p1 %patch110 -p1 +%patch111 -p1 +%patch112 -p1 +%patch113 -p1 +%patch114 -p1 +%patch115 -p1 %if %{enablefscache} %patch90 -p1 @@ -279,6 +291,10 @@ fi %attr(4755,root,root) /sbin/umount.nfs4 %changelog +* Fri Jun 6 2008 Steve Dickson 1.1.2-6 +- Added 5 (111 thru 115) upstream patches that fixed + things mostly in the text mounting code. + * Thu May 8 2008 Steve Dickson 1.1.2-5 - Added 10 (101 thru 110) upstream patches that fixed things mostly in the mount and gssd code.