rpms/util-linux/FC-5 util-linux-2.13-nfsmount-mountd-udp.patch, NONE, 1.1 util-linux-2.13-nfsmount-retry.patch, NONE, 1.1 util-linux-2.13-nfsmount-syslog.patch, NONE, 1.1 util-linux.spec, 1.114, 1.115

Tue May 2 12:03:41 UTC 2006

Author: steved

Update of /cvs/dist/rpms/util-linux/FC-5
In directory cvs.devel.redhat.com:/tmp/cvs-serv27816

Modified Files:
	util-linux.spec 
Added Files:
	util-linux-2.13-nfsmount-mountd-udp.patch 
	util-linux-2.13-nfsmount-retry.patch 
	util-linux-2.13-nfsmount-syslog.patch 
Log Message:
Added syslog logging to background mounts as suggested.
fix #183713 - foreground mounts are not retrying as advertised
fix #169042 - Changed nfsmount to try udp before using tcp when rpc-ing
  the remote rpc.mountd (iff -o tcp is not specified).
  This drastically increases the total number of tcp mounts
  that can happen at once (ala autofs).


util-linux-2.13-nfsmount-mountd-udp.patch:
 nfsmount.c |   22 +++++++++++++++-------
 1 files changed, 15 insertions(+), 7 deletions(-)

--- NEW FILE util-linux-2.13-nfsmount-mountd-udp.patch ---
--- util-linux-2.13-pre7/mount/nfsmount.c.udp	2006-05-02 07:12:35.000000000 -0400
+++ util-linux-2.13-pre7/mount/nfsmount.c	2006-05-02 07:15:44.000000000 -0400
@@ -132,13 +132,22 @@ void rpc_strerror()
 }
 
 /* Define the order in which to probe for UDP/TCP services */
+enum plist {
+	use_tcp = 0,
+	udp_tcp,
+	udp_only,
+};
 static const u_int *
-proto_probelist(const int use_tcp)
+proto_probelist(enum plist list)
 {
+	static const u_int probe_udp_tcp[] = { IPPROTO_UDP, IPPROTO_TCP, 0 };
 	static const u_int probe_both[] = { IPPROTO_TCP, IPPROTO_UDP, 0 };
 	static const u_int probe_udponly[] = { IPPROTO_UDP, 0 };
-	if (use_tcp)
+
+	if (list == use_tcp)
 		return probe_both;
+	if (list == udp_tcp)
+		return probe_udp_tcp;
 	return probe_udponly;
 }
 
@@ -432,7 +441,7 @@ clnt_ping(struct sockaddr_in *saddr, con
 	if (sock != -1)
 		close(sock);
 
-	if (stat != RPC_PROGVERSMISMATCH)
+	if (stat == RPC_SUCCESS)
 		return 1;
 
  out_bad:
@@ -469,8 +478,7 @@ probe_port(clnt_addr_t *server, 
 				if (clnt_ping(saddr, prog, *p_vers, *p_prot))
 					goto out_ok;
 			}
-		} else if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED)
-			break;
+		}
 		if (!prot) {
 			if (*++p_prot)
 				continue;
@@ -505,7 +513,7 @@ probe_nfsport(clnt_addr_t *nfs_server)
 	if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
 		return 1;
 	probe_vers = nfs_probelist(MAX_NFSPROT);
-	probe_prot = proto_probelist(HAVE_RELIABLE_TCP);
+	probe_prot = proto_probelist(HAVE_RELIABLE_TCP ? use_tcp : udp_only);
 	return probe_port(nfs_server, probe_vers, probe_prot);
 }
 
@@ -519,7 +527,7 @@ probe_mntport(clnt_addr_t *mnt_server)
 	if (pmap->pm_vers && pmap->pm_prot && pmap->pm_port)
 		return 1;
 	probe_vers = mnt_probelist(MAX_MNTPROT);
-	probe_prot = proto_probelist(HAVE_RELIABLE_TCP);
+	probe_prot = proto_probelist(HAVE_RELIABLE_TCP ? udp_tcp : udp_only);
 	return probe_port(mnt_server, probe_vers, probe_prot);
 }
 

util-linux-2.13-nfsmount-retry.patch:
 nfs.5       |    8 ++-
 nfs4mount.c |   37 +++++++++++---
 nfsmount.c  |  149 +++++++++++++++++++++++++++++++++++++++++-------------------
 3 files changed, 137 insertions(+), 57 deletions(-)

--- NEW FILE util-linux-2.13-nfsmount-retry.patch ---
--- util-linux-2.13-pre6/mount/nfsmount.c.retry	2006-05-01 13:05:16.000000000 -0400
+++ util-linux-2.13-pre6/mount/nfsmount.c	2006-05-01 13:19:01.000000000 -0400
@@ -125,9 +125,30 @@ void rpc_strerror()
 		if ((ptr = index(estr, ':')))
 			estr = ++ptr;
 
-		fprintf(stderr, "RPC Error: %d (%s )\n", cf_stat, estr);
 		if (cf_stat == RPC_SYSTEMERROR)
-			fprintf(stderr, "System Error: %d (%s)\n", cf_errno, strerror(cf_errno));
+			fprintf(stderr, "System Error: %s", strerror(cf_errno));
+		else
+			fprintf(stderr, "RPC Error:%s", estr);
+	}
+}
+void mount_errors(char *, int, int);
+void mount_errors(char *server, int will_retry, int bg)
+{
+	fprintf(stderr, "mount: mount to NFS server '%s' failed: ", server);
+	if (rpc_createerr.cf_stat == RPC_TIMEDOUT) {
+		if (will_retry)
+			fprintf(stderr, "timed out (retrying).\n");
+		else
+			fprintf(stderr, "timed out (giving up).\n");
+	} else {
+		rpc_strerror();
+		if (bg) {
+			if (will_retry)
+				fprintf(stderr, " (retrying).\n");
+			else
+				fprintf(stderr, " (giving up).\n");
+		} else
+			fprintf(stderr, ".\n");
 	}
 }
 
@@ -289,6 +310,8 @@ get_socket(struct sockaddr_in *saddr, u_
 
 	type = (p_prot == IPPROTO_UDP ? SOCK_DGRAM : SOCK_STREAM);
 	if ((so = socket (AF_INET, type, p_prot)) < 0) {
+		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+		rpc_createerr.cf_error.re_errno = errno;
 		if (verbose) {
 			fprintf(stderr, 
 				"mount: Unable to create %s socket: errno %d (%s)\n",
@@ -302,6 +325,8 @@ get_socket(struct sockaddr_in *saddr, u_
 	laddr.sin_addr.s_addr = htonl(INADDR_ANY);
 	if (resvp) {
 		if (bindresvport(so, &laddr) < 0) {
+			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+			rpc_createerr.cf_error.re_errno = errno;
 			if (verbose) {
 				fprintf(stderr, 
 					"mount: Unable to bindresvport %s socket: errno %d (%s)\n",
@@ -314,6 +339,8 @@ get_socket(struct sockaddr_in *saddr, u_
 	} else {
 		cc = bind(so, (struct sockaddr *)&laddr, namelen);
 		if (cc < 0) {
+			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+			rpc_createerr.cf_error.re_errno = errno;
 			if (verbose) {
 				fprintf(stderr, 
 					"mount: Unable to bind to %s socket: errno %d (%s)\n",
@@ -327,6 +354,8 @@ get_socket(struct sockaddr_in *saddr, u_
 	if (type == SOCK_STREAM) {
 		cc = connect(so, (struct sockaddr *)saddr, namelen);
 		if (cc < 0) {
+			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
+			rpc_createerr.cf_error.re_errno = errno;
 			if (verbose) {
 				fprintf(stderr, 
 					"mount: Unable to connect to %s:%d, errno %d (%s)\n",
@@ -410,8 +439,16 @@ clnt_ping(struct sockaddr_in *saddr, con
 	int sock, stat;
 	static char clnt_res;
 
-	rpc_createerr.cf_stat = stat = 0;
+	rpc_createerr.cf_stat = stat = errno = 0;
 	sock = get_socket(saddr, prot, FALSE);
+	if (sock == RPC_ANYSOCK && errno == ETIMEDOUT) {
+		/*
+		 * TCP timeout. Bubble up the error to see 
+		 * how it should be handled.
+		 */
+		rpc_createerr.cf_stat = RPC_TIMEDOUT;
+		goto out_bad;
+	}
 
 	switch(prot) {
 	case IPPROTO_UDP:
@@ -475,10 +512,21 @@ probe_port(clnt_addr_t *server, 
 		if (p_port) {
 			if (!port || port == p_port) {
 				saddr->sin_port = htons(p_port);
+				if (verbose) {
+					fprintf(stderr, 
+						"mount: trying %s prog %ld vers %ld prot %s port %d\n", 
+						inet_ntoa(saddr->sin_addr), prog, *p_vers,
+						*p_prot == IPPROTO_UDP ? "udp" : "tcp", p_port);
+				}
 				if (clnt_ping(saddr, prog, *p_vers, *p_prot))
 					goto out_ok;
+				if (rpc_createerr.cf_stat == RPC_TIMEDOUT)
+					goto out_bad;
 			}
 		}
+		if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED) 
+			goto out_bad;
+
 		if (!prot) {
 			if (*++p_prot)
 				continue;
@@ -491,7 +539,9 @@ probe_port(clnt_addr_t *server, 
 		if (vers || !*++p_vers)
 			break;
 	}
+out_bad:
 	return 0;
+
  out_ok:
 	if (!vers)
 		pmap->pm_vers = *p_vers;
@@ -556,8 +606,13 @@ probe_bothports(clnt_addr_t *mnt_server,
 				return 1;
 			memcpy(mnt_pmap, &save_mnt, sizeof(*mnt_pmap));
 		}
-		if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED)
+		switch (rpc_createerr.cf_stat) {
+		case RPC_PROGVERSMISMATCH:
+		case RPC_PROGNOTREGISTERED:
 			break;
+		default:
+			goto out_bad;
+		}
 		memcpy(nfs_pmap, &save_nfs, sizeof(*nfs_pmap));
 	}
  out_bad:
@@ -569,11 +624,11 @@ probe_bothports(clnt_addr_t *mnt_server,
 }
 
 static CLIENT *
-mnt_openclnt(clnt_addr_t *mnt_server, int *msock, const int report_errs)
+mnt_openclnt(clnt_addr_t *mnt_server, int *msock)
 {
 	struct sockaddr_in *mnt_saddr = &mnt_server->saddr;
 	struct pmap *mnt_pmap = &mnt_server->pmap;
-	CLIENT *clnt;
+	CLIENT *clnt = NULL;
 
 	/* contact the mount daemon via TCP */
 	mnt_saddr->sin_port = htons((u_short)mnt_pmap->pm_port);
@@ -592,18 +647,12 @@ mnt_openclnt(clnt_addr_t *mnt_server, in
 				      msock,
 				      MNT_SENDBUFSIZE, MNT_RECVBUFSIZE);
 		break;
-	default:
-		goto out_bad;
 	}
-	if (!clnt)
-		goto report_err;
-	/* try to mount hostname:dirname */
-	clnt->cl_auth = authunix_create_default();
-	return clnt;
- report_err:
-	if (report_errs)
-		clnt_pcreateerror("mount");
- out_bad:
+	if (clnt) {
+		/* try to mount hostname:dirname */
+		clnt->cl_auth = authunix_create_default();
+		return clnt;
+	}
 	return NULL;
 }
 
@@ -635,33 +684,16 @@ nfs2_mount(CLIENT *clnt, mnt2arg_t *mnt2
 
 static int
 nfs_call_mount(clnt_addr_t *mnt_server, clnt_addr_t *nfs_server,
-	       mntarg_t *mntarg, mntres_t *mntres, const int report_errs)
+	       mntarg_t *mntarg, mntres_t *mntres)
 {
 	CLIENT *clnt;
 	enum clnt_stat stat;
 	int msock;
 
-	if (!probe_bothports(mnt_server, nfs_server)) {
-		if (report_errs) {
-			fprintf(stderr, "mount to NFS server '%s' failed", 
-				*nfs_server->hostname);
-			if (rpc_createerr.cf_stat != RPC_PROGNOTREGISTERED) {
-				fprintf(stderr, ": server is down.\n");
-			} else  if (nfs_server->pmap.pm_prot) {
-				fprintf(stderr, ": possible invalid protocol.\n");
-			} else if (nfs_server->pmap.pm_port) {
-				fprintf(stderr, ": possible invalid port.\n");
-			} else {
-				fprintf(stderr, ".\n");
-			}
-			if (verbose) {
-				rpc_strerror();
-			}
-		}
+	if (!probe_bothports(mnt_server, nfs_server))
 		goto out_bad;
-	}
 
-	clnt = mnt_openclnt(mnt_server, &msock, report_errs);
+	clnt = mnt_openclnt(mnt_server, &msock);
 	if (!clnt)
 		goto out_bad;
 	/* make pointers in xdr_mountres3 NULL so
@@ -679,8 +711,10 @@ nfs_call_mount(clnt_addr_t *mnt_server, 
 	default:
 		goto out_bad;
 	}
-	if (stat != RPC_SUCCESS && report_errs)
-		clnt_perror(clnt, "mount");
+	if (stat != RPC_SUCCESS) {
+		clnt_geterr(clnt, &rpc_createerr.cf_error);
+		rpc_createerr.cf_stat = stat;
+	}
 	mnt_closeclnt(clnt, msock);
 	if (stat == RPC_SUCCESS)
 		return 1;
@@ -976,6 +1010,7 @@ nfsmount(const char *spec, const char *n
 	char new_opts[1024], cbuf[1024];
 	static struct nfs_mount_data data;
 	int val;
+	static int doonce = 0;
 
 	clnt_addr_t mnt_server = { &mounthost, };
 	clnt_addr_t nfs_server = { &hostname, };
@@ -1070,7 +1105,10 @@ nfsmount(const char *spec, const char *n
 		goto fail;
 	if (!nfsmnt_check_compat(nfs_pmap, mnt_pmap))
 		goto fail;
-
+	
+	if (retry == 10000 && !bg)
+		retry = 2; /* reset for fg mounts */
+	
 
 #ifdef NFS_MOUNT_DEBUG
 	printf("rsize = %d, wsize = %d, timeo = %d, retrans = %d\n",
@@ -1160,17 +1198,32 @@ nfsmount(const char *spec, const char *n
 				sleep(30);
 
 			stat = nfs_call_mount(&mnt_server, &nfs_server,
-					      &dirname, &mntres,
-					      !running_bg && prevt == 0);
+					      &dirname, &mntres);
 			if (stat)
 				break;
 			memcpy(nfs_pmap, &save_nfs, sizeof(*nfs_pmap));
 			memcpy(mnt_pmap, &save_mnt, sizeof(*mnt_pmap));
 			prevt = t;
 		}
-
-		if (!bg)
+		if (!bg) {
+			switch(rpc_createerr.cf_stat){
+			case RPC_TIMEDOUT:
+				break;
+			case RPC_SYSTEMERROR:
+				if (errno == ETIMEDOUT)
+					break;
+			default:
+				mount_errors(*nfs_server.hostname, 0, bg);
 		        goto fail;
+			}
+			t = time(NULL);
+			if (t >= timeout) {
+				mount_errors(*nfs_server.hostname, 0, bg);
+				goto fail;
+			}
+			mount_errors(*nfs_server.hostname, 1, bg);
+			continue;
+		}
 		if (!running_bg) {
 			prev_bg_host = xstrdup(hostname);
 			if (retry > 0)
@@ -1178,8 +1231,12 @@ nfsmount(const char *spec, const char *n
 			goto fail;
 		}
 		t = time(NULL);
-		if (t >= timeout)
+		if (t >= timeout) {
+			mount_errors(*nfs_server.hostname, 0, bg);
 			goto fail;
+		}
+		if (doonce++ < 1)
+			mount_errors(*nfs_server.hostname, 1, bg);
 	}
 
 	if (nfs_pmap->pm_vers == 2) {
@@ -1342,7 +1399,7 @@ nfs_call_umount(clnt_addr_t *mnt_server,
 	enum clnt_stat res = 0;
 	int msock;
 
-	clnt = mnt_openclnt(mnt_server, &msock, 1);
+	clnt = mnt_openclnt(mnt_server, &msock);
 	if (!clnt)
 		goto out_bad;
 	switch (mnt_server->pmap.pm_vers) {
--- util-linux-2.13-pre6/mount/nfs4mount.c.retry	2006-05-01 13:05:14.000000000 -0400
+++ util-linux-2.13-pre6/mount/nfs4mount.c	2006-05-01 13:08:10.000000000 -0400
@@ -77,7 +77,7 @@ char *GSSDLCK = DEFAULT_DIR "/rpcgssd";
 #endif
 
 extern int clnt_ping(struct sockaddr_in *, const u_long, const u_long, const u_int);
-extern void rpc_strerror();
+extern void mount_errors(char *, int, int);
 
 struct {
 	char    *flavour;
@@ -211,6 +211,7 @@ int nfs4mount(const char *spec, const ch
 	int nocto, noac;
 	int retry;
 	int retval;
+	time_t timeout, t;
 
 	retval = EX_FAIL;
 	if (strlen(spec) >= sizeof(hostdir)) {
@@ -413,12 +414,33 @@ int nfs4mount(const char *spec, const ch
 	printf("proto = %s\n", (data.proto == IPPROTO_TCP) ? "tcp" : "udp");
 #endif
 
+	timeout = time(NULL) + 60 * retry;
 	data.version = NFS4_MOUNT_VERSION;
-
-	clnt_ping(&server_addr, NFS_PROGRAM, 4, data.proto);
-	if (rpc_createerr.cf_stat) {
-		fprintf(stderr, "mount to NFS server '%s' failed.\n", data.hostname.data);
-		goto fail;
+	for (;;) {
+		if (verbose) {
+			fprintf(stderr, 
+				"mount: pinging: prog %d vers %d prot %s port %d\n", 
+				NFS_PROGRAM, 4, data.proto == IPPROTO_UDP ? "udp" : "tcp", 
+				ntohs(server_addr.sin_port));
+		}
+		clnt_ping(&server_addr, NFS_PROGRAM, 4, data.proto);
+		switch(rpc_createerr.cf_stat){
+		case RPC_TIMEDOUT:
+			break;
+		case RPC_SYSTEMERROR:
+			if (errno == ETIMEDOUT)
+				break;
+		default:
+			mount_errors(hostname, 0, bg);
+			goto fail;
+		}
+		t = time(NULL);
+		if (t >= timeout) {
+			mount_errors(hostname, 0, bg);
+			goto fail;
+		}
+		mount_errors(hostname, 1, bg);
+		continue;
 	}
 
 	*mount_opts = (char *) &data;
@@ -426,8 +448,5 @@ int nfs4mount(const char *spec, const ch
 	return 0;
 
 fail:
-	if (verbose) {
-		rpc_strerror();
-	}
 	return retval;
 }
--- util-linux-2.13-pre6/mount/nfs.5.retry	2006-05-01 13:05:16.000000000 -0400
+++ util-linux-2.13-pre6/mount/nfs.5	2006-05-01 13:08:10.000000000 -0400
@@ -134,7 +134,9 @@ There is no default value.
 .I retry=n
 The number of minutes to retry an NFS mount operation
 in the foreground or background before giving up.
-The default value is 10000 minutes, which is roughly one week.
+The default value for forground mounts is 2 minutes.  
+The default value for background mounts is 10000 minutes, 
+which is roughly one week.
 .TP 1.5i
 .I namlen=n
 When an NFS server does not support version two of the
@@ -355,7 +357,9 @@ There is no default value.
 .I retry=n
 The number of minutes to retry an NFS mount operation
 in the foreground or background before giving up.
-The default value is 10000 minutes, which is roughly one week.
+The default value for forground mounts is 2 minutes.  
+The default value for background mounts is 10000 minutes, 
+which is roughly one week.
 .TP 1.5i
 .I port=n
 The numeric value of the port to connect to the NFS server on.

util-linux-2.13-nfsmount-syslog.patch:
 nfsmount.c |   56 +++++++++++++++++++++++++++++++++++++++-----------------
 1 files changed, 39 insertions(+), 17 deletions(-)

--- NEW FILE util-linux-2.13-nfsmount-syslog.patch ---
--- util-linux-2.13-pre6/mount/nfsmount.c.syslog	2006-05-02 05:56:58.000000000 -0400
+++ util-linux-2.13-pre6/mount/nfsmount.c	2006-05-02 06:52:08.000000000 -0400
@@ -50,6 +50,7 @@
 #include <arpa/inet.h>
 #include <mntent.h>
 #include <paths.h>
+#include <syslog.h>
 
 #include "sundries.h"
 #include "nfsmount.h"
@@ -113,43 +114,64 @@ static int nfs_call_umount(clnt_addr_t *
 
 int clnt_ping(struct sockaddr_in *, const u_long, const u_long, const u_int);
 
+static char errbuf[BUFSIZ];
+static char *erreob = &errbuf[BUFSIZ];
+
 /* Convert RPC errors into strings */
-void rpc_strerror(void);
-void rpc_strerror()
+int rpc_strerror(int);
+int rpc_strerror(int spos)
 {
 	int cf_stat = rpc_createerr.cf_stat; 
-	int cf_errno = rpc_createerr.cf_error.re_errno;
+	int pos=0, cf_errno = rpc_createerr.cf_error.re_errno;
 	char *ptr, *estr = clnt_sperrno(cf_stat);
+	char *tmp;
 
 	if (estr) {
 		if ((ptr = index(estr, ':')))
 			estr = ++ptr;
 
+		tmp = &errbuf[spos];
 		if (cf_stat == RPC_SYSTEMERROR)
-			fprintf(stderr, "System Error: %s", strerror(cf_errno));
+			pos = snprintf(tmp, (erreob - tmp), 
+				"System Error: %s", strerror(cf_errno));
 		else
-			fprintf(stderr, "RPC Error:%s", estr);
+			pos = snprintf(tmp, (erreob - tmp), "RPC Error:%s", estr);
 	}
+	return (pos);
 }
 void mount_errors(char *, int, int);
 void mount_errors(char *server, int will_retry, int bg)
 {
-	fprintf(stderr, "mount: mount to NFS server '%s' failed: ", server);
+	int pos = 0;
+	char *tmp;
+	static int onlyonce = 0;
+
+	tmp = &errbuf[pos];
+	if (bg) 
+		pos = snprintf(tmp, (erreob - tmp), 
+			"mount to NFS server '%s' failed: ", server);
+	else
+		pos = snprintf(tmp, (erreob - tmp), 
+			"mount: mount to NFS server '%s' failed: ", server);
+
+	tmp = &errbuf[pos];
 	if (rpc_createerr.cf_stat == RPC_TIMEDOUT) {
-		if (will_retry)
-			fprintf(stderr, "timed out (retrying).\n");
-		else
-			fprintf(stderr, "timed out (giving up).\n");
+		pos = snprintf(tmp, (erreob - tmp), "timed out %s", 
+			will_retry ? "(retrying)" : "(giving up)");
 	} else {
-		rpc_strerror();
+		pos += rpc_strerror(pos);
+		tmp = &errbuf[pos];
 		if (bg) {
-			if (will_retry)
-				fprintf(stderr, " (retrying).\n");
-			else
-				fprintf(stderr, " (giving up).\n");
-		} else
-			fprintf(stderr, ".\n");
+			pos = snprintf(tmp, (erreob - tmp), " %s",
+				will_retry ? "(retrying)" : "(giving up)");
+		}
 	}
+	if (bg) {
+		if (onlyonce++ < 1)
+			openlog("mount", LOG_CONS|LOG_PID, LOG_AUTH);
+		syslog(LOG_ERR, "%s.", errbuf);
+	} else
+		fprintf(stderr, "%s.\n", errbuf);
 }
 
 /* Define the order in which to probe for UDP/TCP services */


Index: util-linux.spec
===================================================================
RCS file: /cvs/dist/rpms/util-linux/FC-5/util-linux.spec,v
retrieving revision 1.114
retrieving revision 1.115
diff -u -r1.114 -r1.115
--- util-linux.spec	31 Mar 2006 09:07:46 -0000	1.114
+++ util-linux.spec	2 May 2006 12:03:27 -0000	1.115
@@ -25,7 +25,7 @@
 Summary: A collection of basic system utilities.
 Name: util-linux
 Version: 2.13
-Release: 0.20.2
+Release: 0.20.3
 License: distributable
 Group: System Environment/Base
 
@@ -192,6 +192,14 @@
 Patch233: util-linux-2.13-mount-man-bugs.patch
 # Keep gcc happy
 Patch234: util-linux-2.13-hexdump-gcc.patch
+# 169042 - Changed nfsmount to try udp before using tcp when rpc-ing
+#          the remote rpc.mountd (iff -o tcp is not specified).
+Patch235: util-linux-2.13-nfsmount-mountd-udp.patch
+# 183713 - foreground nfs mount timeout options to get hard mount semantic
+Patch236: util-linux-2.13-nfsmount-retry.patch
+# Adds syslog logging to background mounts
+Patch237: util-linux-2.13-nfsmount-syslog.patch
+
 
 # When adding patches, please make sure that it is easy to find out what bug # the 
 # patch fixes.
@@ -277,6 +285,9 @@
 %patch232 -p1
 %patch233 -p1
 %patch234 -p1
+%patch235 -p1
+%patch236 -p1
+%patch237 -p1
 
 %build
 unset LINGUAS || :
@@ -661,6 +672,15 @@
 /sbin/losetup
 
 %changelog
+* Tue May  2 2006 Steve Dickson <steved at redhat.com> 2.13-0.20.3
+- Added syslog logging to background mounts as suggested
+  by a customer.
+- fix #183713 - foreground mounts are not retrying as advertised
+- fix #169042 - Changed nfsmount to try udp before using tcp when rpc-ing
+  the remote rpc.mountd (iff -o tcp is not specified).
+  This drastically increases the total number of tcp mounts
+  that can happen at once (ala autofs).
+
 * Fri Mar 31 2006 Karel Zak <kzak at redhat.com> 2.13-0.20.2
 - fix memset() usage (and prevent gcc warning)
 


