path: root/meta/recipes-devtools/unfs-server/unfs-server-2.2beta47/006-reiserfs.patch

# Patch origin: nfs-server source RPM from openSUSE 10.3

--- nfs-server/Makefile.in
+++ nfs-server/Makefile.in	2002/11/08 13:59:16
@@ -100,7 +100,7 @@
 		  utimes.c mkdir.c rename.c getopt.c getopt_long.c \
 		  alloca.c mountlist.c xmalloc.c \
 		  xstrdup.c strdup.c strstr.c nfsmounted.c faccess.c \
-		  haccess.c daemon.c signals.c
+		  haccess.c daemon.c signals.c teahash3.c
 XDRFILES	= mount.x nfs_prot.x
 GENFILES	= mount.h mount_xdr.c mount_svc.c nfs_prot.h nfs_prot_xdr.c \
 		  ugid.h ugid_xdr.c ugid_clnt.c
@@ -112,7 +112,7 @@
 MANPAGES8	= showmount
 MANPAGES	= $(MANPAGES5) $(MANPAGES8p) $(MANPAGES8)
 LIBOBJS		= version.o fsusage.o mountlist.o xmalloc.o xstrdup.o \
-		  nfsmounted.o faccess.o haccess.o daemon.o \
+		  nfsmounted.o faccess.o haccess.o daemon.o teahash3.o \
 		  signals.o @LIBOBJS@ @ALLOCA@
 OBJS		= logging.o fh.o devtab.o auth_init.o auth_clnt.o auth.o
 NFSD_OBJS	= nfsd.o rpcmisc.o nfs_dispatch.o getattr.o setattr.o \
--- nfs-server/auth.c
+++ nfs-server/auth.c	2002/11/08 13:59:16
@@ -83,6 +83,7 @@
 					0,		/* read-only */
 					0,		/* relative links */
 					0,		/* noaccess */
+					0,		/* hashed inodes */
 					1,		/* cross_mounts */
 					1,		/* allow setuid */
 					65534,		/* default uid */
@@ -100,6 +101,7 @@
 					0,		/* relative links */
 					0,		/* noaccess */
 					1,		/* cross_mounts */
+					0,		/* hashed inodes */
 					0,		/* allow setuid */
 					65534,		/* default uid */
 					65534,		/* default gid */
@@ -991,6 +993,7 @@
 	if (mp == 0) {
 		mp = (nfs_mount*) xmalloc(sizeof(nfs_mount));
 		memset(mp, 0, sizeof(*mp));
+		mp->mount_dev = 0;
 		mp->origin = cp;
 		mp->client = cp;
 		mp->path   = xstrdup(path);
@@ -1169,6 +1172,8 @@
 	default_options.nobody_gid = anon_gid;
 	anonymous_options.nobody_uid = anon_uid;
 	anonymous_options.nobody_gid = anon_gid;
+	default_options.cross_mounts = cross_mounts;
+	default_options.hashed_inodes = hashed_inodes;
 
 	memset(cached_clients, 0, sizeof(cached_clients));
 	cached_next = 0;
--- nfs-server/auth.h
+++ nfs-server/auth.h	2002/11/08 13:59:16
@@ -43,15 +43,16 @@
 
 typedef struct nfs_options {
 	ugid_mapping_t		uidmap;		/* uid/gid mapping behavior */
-	int			root_squash;
-	int			all_squash;
-	int			some_squash;	/* speed up luid() etc. */
-	int			secure_port;
-	int			read_only;
-	int			link_relative;
-	int			noaccess;
-	int			cross_mounts;
-	int			allow_setuid;
+	unsigned		root_squash : 1;
+	unsigned		all_squash : 1;
+	unsigned		some_squash : 1;	/* speed up luid() etc. */
+	unsigned		secure_port : 1;
+	unsigned		read_only : 1;
+	unsigned		link_relative : 1;
+	unsigned		noaccess : 1;
+	unsigned		cross_mounts : 1;
+	unsigned		hashed_inodes : 1;
+	unsigned		allow_setuid : 1;
 	uid_t			nobody_uid;
 	gid_t			nobody_gid;
 	char *			clnt_nisdomain;
@@ -64,6 +65,7 @@
 	int			length;
 	char *			path;
 	nfs_options		o;
+	dev_t			mount_dev;
 	/* Original NFS client */
 	struct nfs_client *	origin;
 } nfs_mount;
@@ -121,6 +123,8 @@
 extern void       auth_check_all_netmasks(void);
 extern void	  auth_sort_all_mountlists(void);
 extern void	  auth_log_all(void);
+extern int	  auth_checkdev(nfs_mount *, dev_t dev);
+extern int	  auth_checkpathdev(char *, dev_t dev);
 
 /* This function lets us set our euid/fsuid temporarily */
 extern void       auth_override_uid(uid_t);
--- nfs-server/auth_clnt.c
+++ nfs-server/auth_clnt.c	2002/11/08 13:59:16
@@ -89,6 +89,13 @@
 		return NULL;
 	}
 
+	if (!mp->o.cross_mounts && !mp->mount_dev) {
+		struct stat st;
+		if (!lstat(mp->path, &st) < 0)
+			return NULL;
+		mp->mount_dev = st.st_dev;
+	}
+
 	/* Check request originated on a privileged port. */
 	if (!allow_non_root && mp->o.secure_port
 	 && !SECURE_PORT(svc_getcaller(rqstp->rq_xprt)->sin_port)) {
@@ -350,3 +357,28 @@
 	return 1;
 }
 #endif
+
+int auth_checkpathdev(char *path, dev_t dev)
+{
+	nfs_mount *mp = auth_match_mount(nfsclient, path);
+	if (!mp)
+		return 0;
+	return auth_checkdev(mp, dev);
+}
+
+int auth_checkdev(nfs_mount *mp, dev_t dev)
+{
+	if (!mp->mount_dev)
+		return 1;
+	if (mp->mount_dev != dev) {
+		struct stat st;
+		/* Restat in case the cd switched */
+		if (efs_lstat(mp->path, &st) < 0) {
+			Dprintf(L_ERROR, "Unable to stat mount point %s\n", mp->path);
+			return 0;
+		}
+		mp->mount_dev = st.st_dev;
+	}
+	return mp->mount_dev == dev;
+}
+
--- nfs-server/auth_init.c
+++ nfs-server/auth_init.c	2002/11/08 13:59:16
@@ -320,6 +320,14 @@
 			/* knfsd compatibility, ignore */;
 		else ifkwd(4, "sync")
 			/* knfsd compatibility, ignore */;
+		else ifkwd(13, "hashed_inodes")
+			mp->o.hashed_inodes = 1;
+		else ifkwd(16, "no_hashed_inodes")
+			mp->o.hashed_inodes = 0;
+		else ifkwd(12, "cross_mounts")
+			mp->o.cross_mounts = 1;
+		else ifkwd(15, "no_cross_mounts")
+			mp->o.cross_mounts = 0;
 		else {
 			Dprintf(L_ERROR,
 				"Unknown keyword \"%.*s\" in export file\n",
--- nfs-server/exports.man
+++ nfs-server/exports.man	2002/11/08 13:59:16
@@ -208,6 +208,17 @@
 .IR no_all_squash ,
 which is the default setting.
 .TP
+.IR hashed_inodes
+Use a special scheme to generate inode numbers that may work better with
+reiserfs filesystems.
+.IR no_hashed_inodes
+which uses a direct mapping is the default.
+.TP
+.IR cross_mounts
+Do not cross mount points in exports. Turning this off with
+.IR no_cross_mounts
+avoids inode number space conflicts when there are too many files.
+.TP
 .IR map_daemon
 This option turns on dynamic uid/gid mapping. Each uid in an NFS request
 will be translated to the equivalent server uid, and each uid in an
--- nfs-server/fh.c
+++ nfs-server/fh.c	2002/11/08 14:11:31
@@ -4,8 +4,9 @@
  *
  *		Interfaces:
  *		    pseudo_inode
- *			mostly used internally, but also called from unfsd.c
- *			when reporting directory contents.
+ *			mostly used internally, for hash tables
+ *		    visible_inode
+ *			generate visible inode shown to the client in the fattr.
  *		    fh_init
  *			Initializes the queues and 'flush' timer
  *		    fh_pr
@@ -47,6 +48,8 @@
  * Note: the original code mistakenly assumes that the overall path
  *	length remains within the value given by PATH_MAX... that leads
  *	to interesting buffer overflows all over the place.
+ *
+ *	Depends that dev_t only uses 16bits.
  */
 
 #include <assert.h>
@@ -137,9 +140,9 @@
 };
 
 /* Forward declared local functions */
-static psi_t	path_psi(char *, nfsstat *, struct stat *, int);
+static psi_t	path_psi(char *, nfsstat *, struct stat *, int, int *);
 static psi_t	path_psi_m(char *, nfsstat *, struct stat *,
-					      struct stat *, int);
+					      struct stat *, int, int *);
 static int	fh_flush_fds(void);
 static char *	fh_dump(svc_fh *);
 static void	fh_insert_fdcache(fhcache *fhc);
@@ -173,19 +176,22 @@
 	fh_list_size++;
 
 	/* Insert into hash tab. */
-	hash_slot = &(fh_hashed[fhc->h.psi % HASH_TAB_SIZE]);
+	hash_slot = &(fh_hashed[pseudo_inode(fhc->h.ino,fhc->h.dev) % HASH_TAB_SIZE]);
 	fhc->hash_next = *hash_slot;
 	*hash_slot = fhc;
 }
 
 static fhcache *
-fh_lookup(psi_t psi)
+fh_lookup(ino_t ino, dev_t dev)
 {
 	register fhcache *fhc;
 
-	fhc = fh_hashed[psi % HASH_TAB_SIZE];
-	while (fhc != NULL && fhc->h.psi != psi)
+	fhc = fh_hashed[pseudo_inode(ino,dev) % HASH_TAB_SIZE];
+	while (fhc != NULL) {
+		if (fhc->h.ino == ino && fhc->h.dev == dev)
+			break;
 		fhc = fhc->hash_next;
+	}
 	return (fhc);
 }
 
@@ -193,7 +199,8 @@
 fh_insert_fdcache(fhcache *fhc)
 {
 #ifdef FHTRACE
-	Dprintf(D_FHTRACE, "insert fh %x into fdcache @%d\n", fhc->h.psi, fhc->fd);
+	Dprintf(D_FHTRACE, "insert fh %x,%x into fdcache @%d\n",
+			fhc->h.ino, fhc->h.dev, fhc->fd);
 	if (fhc->fd < 0) {
 		fh_complain("fd cache bug: bad fd", fhc);
 		return;
@@ -289,8 +296,9 @@
 #endif
 
 	Dprintf(D_FHTRACE|D_FHCACHE,
-		"fh_delete: deleting handle %x ('%s', fd=%d)\n",
-		fhc, fhc->path ? fhc->path : "<unnamed>", fhc->fd);
+		"fh_delete: deleting handle %x [%x,%x] ('%s', fd=%d)\n",
+		fhc, fhc->h.dev, fhc->h.ino, fhc->path ? fhc->path : "<unnamed>",
+			fhc->fd);
 
 	/* Remove from current posn */
 	fhc->prev->next = fhc->next;
@@ -298,7 +306,7 @@
 	fh_list_size--;
 
 	/* Remove from hash tab */
-	hash_slot = &(fh_hashed[fhc->h.psi % HASH_TAB_SIZE]);
+	hash_slot = &(fh_hashed[pseudo_inode(fhc->h.ino,fhc->h.dev) % HASH_TAB_SIZE]);
 	while (*hash_slot != NULL && *hash_slot != fhc)
 		hash_slot = &((*hash_slot)->hash_next);
 	if (*hash_slot == NULL)
@@ -528,6 +536,7 @@
 		index -= 8;
 	}
 
+#if 0
 	/* If we have an XXL inode number, spew out warning (but at most
 	 * once a second) */
 	if (inode & ~mask) {
@@ -541,14 +550,34 @@
 		}
 		inode &= mask;
 	}
-
+#endif
 	return (psi_t) (prefix | inode);
 #endif
 }
 
+/* Inode as handed out by attr calls. */
+psi_t
+visible_inode(ino_t ino, dev_t dev, nfs_mount *mount)
+{
+	if (!mount->o.cross_mounts)
+		return ino;
+
+	if (mount->o.hashed_inodes) {
+		extern __u32 teahash3(/*u32 k[2], *//*u8*/const char *msg, int len);
+
+		struct {
+			ino_t ino;
+			dev_t dev;
+		} tup = { ino,dev };
+		return teahash3((char *) &tup, sizeof tup);
+	}
+
+	return pseudo_inode(ino, dev);
+}
+
 #if 1
 static char *
-fh_buildpath(svc_fh *h)
+fh_buildpath(svc_fh *h, dev_t basedev)
 {
 	char		pathbuf[PATH_MAX + NAME_MAX + 1], *path;
 	long		cookie_stack[HP_LEN + 1];
@@ -565,13 +594,17 @@
 
 	if (efs_stat("/", &sbuf) < 0)
 		return (NULL);
-	psi = pseudo_inode(sbuf.st_ino, sbuf.st_dev);
 	if (h->hash_path[0] == 0) {
-		if (psi != h->psi)
-			return (NULL);
-		return xstrdup("/");
+		if (sbuf.st_ino == h->ino && sbuf.st_dev == h->dev)
+			;
+		else
+			return NULL;
+		strcpy(pathbuf,"/");
+		path = xstrdup(pathbuf);
+		return (path);
 	}
 
+	psi = pseudo_inode(sbuf.st_ino, sbuf.st_dev);
 	if (hash_psi(psi) != h->hash_path[1])
 		return (NULL);
 
@@ -599,11 +632,18 @@
 
 				psi = pseudo_inode(dp->d_ino, sbuf.st_dev);
 				if (i == h->hash_path[0] + 1) {
-					if (psi != h->psi)
+					if (sbuf.st_dev != h->dev || dp->d_ino != h->ino)
 						continue;
 					/* GOT IT */
 					strcpy(pathbuf + pathlen, dp->d_name);
-					path = xstrdup(pathbuf);
+					if (!basedev || sbuf.st_dev == basedev ||
+						auth_checkpathdev(pathbuf, sbuf.st_dev)) {
+						path = xstrdup(pathbuf);
+					} else {
+						dprintf(L_ERROR,  "fh_buildpath: basedev %x != dev %x for %s\n",
+								(unsigned)basedev,(unsigned)sbuf.st_dev,pathbuf);
+						path = NULL;
+					}
 					efs_closedir(dir);
 					auth_override_uid(auth_uid);
 					return (path);
@@ -754,16 +794,16 @@
 #endif
 
 static psi_t
-path_psi(char *path, nfsstat *status, struct stat *sbp, int svalid)
+path_psi(char *path, nfsstat *status, struct stat *sbp, int svalid, int *mp)
 {
 	struct stat smounted;
 
-	return path_psi_m(path, status, sbp, &smounted, svalid);
+	return path_psi_m(path, status, sbp, &smounted, svalid, mp);
 }
 
 static psi_t
 path_psi_m(char *path, nfsstat *status,
-		struct stat *sbp, struct stat *mbp, int svalid)
+		struct stat *sbp, struct stat *mbp, int svalid, int *mp)
 {
 	struct stat sbuf, ddbuf;
 
@@ -815,6 +855,8 @@
 			DIR *dirp;
 			struct dirent *dp;
 
+			if (mp) *mp = 1;
+
 			errno = 0;
 			dirp = efs_opendir(dname);
 			fname[-1] = '/';	/* Restore path */
@@ -860,9 +902,70 @@
 }
 
 fhcache *
-fh_find(svc_fh *h, int mode)
+fh_newfh(svc_fh *h, int mode, dev_t basedev)
+{
+	fhcache *fhc, *flush;
+
+	ex_state = active;
+	for (flush = fh_tail.prev; fh_list_size > FH_CACHE_LIMIT; flush = fhc) {
+		/* Don't flush current head. */
+		if (flush == &fh_head)
+			break;
+		fhc = flush->prev;
+		fh_delete(flush);
+	}
+	fhc = (fhcache *) xmalloc(sizeof *fhc);
+	if (mode == FHFIND_FCREATE) {
+		/* File will be created */
+		fhc->path = NULL;
+	} else {
+		/* File must exist. Attempt to construct from hash_path */
+		char *path;
+
+		if ((path = fh_buildpath(h, basedev)) == NULL) {
+#ifdef FHTRACE
+			Dprintf(D_FHTRACE, "fh_find: stale fh (hash path)\n");
+			Dprintf(D_FHTRACE, "\tdata: %s\n", fh_dump(h));
+#endif
+			free(fhc);
+			ex_state = inactive;
+			return NULL;
+		}
+		fhc->path = path;
+	}
+	fhc->flags = 0;
+	if (fhc->path && efs_lstat(fhc->path, &fhc->attrs) >= 0) {
+		if (re_export && nfsmounted(fhc->path, &fhc->attrs))
+			fhc->flags |= FHC_NFSMOUNTED;
+		fhc->flags |= FHC_ATTRVALID;
+	}
+	fhc->fd = -1;
+	fhc->last_used = curtime;
+	fhc->h = *h;
+	fhc->last_clnt = NULL;
+	fhc->last_mount = NULL;
+	fhc->last_uid = (uid_t)-1;
+	fhc->fd_next = fhc->fd_prev = NULL;
+	fh_inserthead(fhc);
+	Dprintf(D_FHCACHE,
+		"fh_find: created new handle %x (path `%s' ino:%x dev:%x)\n",
+		fhc, fhc->path ? fhc->path : "<unnamed>", fhc->h.ino, fhc->h.dev);
+	ex_state = inactive;
+	if (fh_list_size > FH_CACHE_LIMIT)
+		flush_cache(0);
+#ifdef FHTRACE
+	if (fhc->h.hash_path[0] == 0xFF) {
+		Dprintf(L_ERROR, "newly created fh instantly flushed?!");
+		return NULL;
+	}
+#endif
+	return (fhc);
+}
+
+fhcache *
+fh_find(svc_fh *h, int mode, dev_t basedev)
 {
-	register fhcache *fhc, *flush;
+	register fhcache *fhc;
 	int		 check;
 
 	check = (mode & FHFIND_CHECK);
@@ -877,12 +980,12 @@
 
 	ex_state = active;
 	time(&curtime);
-	while ((fhc = fh_lookup(h->psi)) != NULL) {
+	while ((fhc = fh_lookup(h->ino,h->dev)) != NULL) {
 		struct stat	sbuf, *s = NULL;
 		nfsstat		dummy;
 
-		Dprintf(D_FHCACHE, "fh_find: psi=%lx... found '%s', fd=%d\n",
-			(unsigned long) h->psi,
+		Dprintf(D_FHCACHE, "fh_find: (%u,%u)... found '%s', fd=%d\n",
+			h->ino, h->dev,
 			fhc->path ? fhc->path : "<unnamed>",
 			fhc->fd);
 
@@ -905,6 +1008,7 @@
 				Dprintf(D_FHTRACE,
 					"fh_find: stale fh: lstat: %m\n");
 			} else {
+				int mp = 0;
 				/* If device/ino don't match, fhc->path may
 				 * be a mount point (hence lstat() returns
 				 * a different inode number than the readdir()
@@ -915,19 +1019,26 @@
 
 				/* Get the dev/ino of the underlying
 				 * mount point. */
-				path_psi(fhc->path, &dummy, s, 1);
-				if (fh_attrmatch(fhc, s))
-					goto fh_return;
+				if (path_psi(fhc->path, &dummy, s, 1, &mp) &&
+					fh_attrmatch(fhc, s)) {
+					if (!mp)
+						Dprintf(D_FHTRACE,"fh_find: should be mount point %x,%x\n",
+								h->dev,h->ino);
+					
+				}
 
-				Dprintf(D_FHTRACE, "fh_find: stale fh: %lx",
-					(unsigned long) h->psi);
+				Dprintf(D_FHTRACE, "fh_find: stale fh: "
+					"dev/ino %x/%lx ino:%x dev:%x",
+					s->st_dev, s->st_ino,
+					(unsigned)h->ino, (unsigned)h->dev);
 			}
 
 		fh_discard:
 #ifdef FHTRACE
 			Dprintf(D_FHTRACE, "\tdata: %s\n", fh_dump(h));
 #endif
-			Dprintf(D_FHCACHE, "fh_find: delete cached handle\n");
+			Dprintf(D_FHCACHE, "fh_find: delete cached handle %x,%x <%x>\n",
+					fhc->h.dev,fhc->h.ino,fhc->path ? fhc->path : "no path");
 			fh_delete(fhc);
 			break;
 		}
@@ -947,88 +1058,13 @@
 		return (fhc);
 	}
 
-	Dprintf(D_FHCACHE, "fh_find: psi=%lx... not found\n",
-			(unsigned long) h->psi);
-
-	if (mode == FHFIND_FCACHED) {
-		ex_state = inactive;
-		return NULL;
-	}
-
-	for (flush = fh_tail.prev; fh_list_size > FH_CACHE_LIMIT; flush = fhc) {
-		/* Don't flush current head. */
-		if (flush == &fh_head)
-			break;
-		fhc = flush->prev;
-		fh_delete(flush);
-	}
-
-	fhc = (fhcache *) xmalloc(sizeof *fhc);
-	if (mode == FHFIND_FCREATE) {
-		/* File will be created */
-		fhc->path = NULL;
-	} else {
-		/* File must exist. Attempt to construct from hash_path */
-		char *path;
-
-		if ((path = fh_buildpath(h)) == NULL) {
-#ifdef FHTRACE
-			Dprintf(D_FHTRACE, "fh_find: stale fh (hash path)\n");
-			Dprintf(D_FHTRACE, "\tdata: %s\n", fh_dump(h));
-#endif
-			free(fhc);
-			ex_state = inactive;
-			return NULL;
-		}
-		fhc->path = path;
-	}
-
-	fhc->flags = 0;
-	if (fhc->path && efs_lstat(fhc->path, &fhc->attrs) >= 0) {
-		if (nfsmounted(fhc->path, &fhc->attrs)) {
-			fhc->flags |= FHC_NFSMOUNTED;
-#if 0
-			/* We must allow the client to send us the
-			 * file handle for the NFS mount point itself,
-			 * but not for entries within an NFS mount.
-			 * XXX: needs fixing.
-			 */
-			if (!re_export) {
-				Dprintf(D_FHTRACE,
-					"Attempt to use %s (non-exportable)\n",
-					fhc->path);
-				free(fhc);
-				ex_state = inactive;
-				return NULL;
-			}
-#endif
-		}
-		fhc->flags |= FHC_ATTRVALID;
-		fhc->dev   = fhc->attrs.st_dev;
-		fhc->ino   = fhc->attrs.st_ino;
-		fhc->type  = fhc->attrs.st_mode & S_IFMT;
-	}
-	fhc->fd = -1;
-	fhc->last_used = curtime;
-	fhc->h = *h;
-	fhc->last_clnt = NULL;
-	fhc->last_mount = NULL;
-	fhc->last_uid = (uid_t)-1;
-	fhc->fd_next = fhc->fd_prev = NULL;
-	fh_inserthead(fhc);
-	Dprintf(D_FHCACHE,
-		"fh_find: created new handle %x (path `%s' psi %08x)\n",
-		fhc, fhc->path ? fhc->path : "<unnamed>", fhc->h.psi);
 	ex_state = inactive;
-	if (fh_list_size > FH_CACHE_LIMIT)
-		flush_cache(0);
-#ifdef FHTRACE
-	if (fhc->h.hash_path[0] == 0xFF) {
-		Dprintf(L_ERROR, "newly created fh instantly flushed?!");
+
+	Dprintf(D_FHCACHE, "fh_find: (%u,%u) ... not found\n",
+		h->ino, h->dev);
+	if (mode == FHFIND_FCACHED)
 		return NULL;
-	}
-#endif
-	return (fhc);
+	return fh_newfh(h, mode, basedev);
 }
 
 /*
@@ -1040,7 +1076,7 @@
 {
 	fhcache *h;
 
-	if ((h = fh_find((svc_fh *) fh, FHFIND_FCACHED)) == NULL)
+	if ((h = fh_find((svc_fh *) fh, FHFIND_FCACHED, 0)) == NULL)
 		return fh_dump((svc_fh *) fh);
 	return (h->path);
 }
@@ -1050,10 +1086,10 @@
 {
 	static char	buf[65];
 	char		*sp;
-	int		i, n = fh->hash_path[0];
+	int		i, n = fh->hash_path[0], l;
 
-	sprintf(buf, "%08x %02x ", fh->psi, fh->hash_path[0]);
-	for (i = 1, sp = buf + 12; i <= n && i < HP_LEN; i++, sp += 2)
+	l = sprintf(buf, "%08x %04x %02x ", fh->ino, fh->dev, fh->hash_path[0]);
+	for (i = 1, sp = buf + l; i <= n && i < HP_LEN; i++, sp += 2)
 		sprintf(sp, "%02x", fh->hash_path[i]);
 	return buf;
 }
@@ -1082,7 +1118,7 @@
 
 	memset(&key, 0, sizeof(key));
 	status = NFS_OK;
-	if ((psi = path_psi("/", &status, &stb, 0)) == 0)
+	if ((psi = path_psi("/", &status, &stb, 0, NULL)) == 0)
 		return ((int) status);
 
 	s = path;
@@ -1091,7 +1127,7 @@
 			return ((int) NFSERR_NAMETOOLONG);
 		key.hash_path[key.hash_path[0]] = hash_psi(psi);
 		*s = '\0';
-		if ((psi = path_psi(path, &status, &stb, 0)) == 0)
+		if ((psi = path_psi(path, &status, &stb, 0, NULL)) == 0)
 			return ((int) status);
 		*s = '/';
 	}
@@ -1099,11 +1135,12 @@
 		if (++(key.hash_path[0]) >= HP_LEN)
 			return ((int) NFSERR_NAMETOOLONG);
 		key.hash_path[key.hash_path[0]] = hash_psi(psi);
-		if ((psi = path_psi(path, &status, &stb, 0)) == 0)
+		if ((psi = path_psi(path, &status, &stb, 0, NULL)) == 0)
 			return ((int) status);
 	}
-	key.psi = psi;
-	h = fh_find(&key, FHFIND_FCREATE);
+	key.dev = stb.st_dev;
+	key.ino = stb.st_ino;
+	h = fh_find(&key, FHFIND_FCREATE, 0);
 
 #ifdef FHTRACE
 	if (!h)
@@ -1123,6 +1160,7 @@
 	return ((int) status);
 }
 
+#if 0
 char *
 fh_path(nfs_fh *fh, nfsstat *status)
 {
@@ -1135,6 +1173,7 @@
 	*status = NFS_OK;
 	return (h->path);
 }
+#endif
 
 nfs_fh *
 fh_handle(fhcache *h)
@@ -1349,7 +1388,7 @@
 	if (sbp == NULL)
 		sbp = &sbuf;
 
-	if ((dirh = fh_find((svc_fh *) &dopa->dir, FHFIND_FEXISTS)) == NULL)
+	if ((dirh = fh_find((svc_fh *) &dopa->dir, FHFIND_FEXISTS, 0)) == NULL)
 		return NFSERR_STALE;
 
 	/*
@@ -1419,8 +1458,22 @@
 
 	*new_fh = dopa->dir;
 	key = (svc_fh *) new_fh;
-	if ((key->psi = path_psi_m(pathbuf, &ret, sbp, &smount, 0)) == 0)
+
+	if (path_psi_m(pathbuf, &ret, sbp, &smount, 0, NULL) == 0)
 		return (ret);
+	key->ino = sbp->st_ino;
+	key->dev = sbp->st_dev;
+
+	if (sbp->st_dev != dirh->h.dev) {
+		nfs_mount *mp = dirh->last_mount;
+		if (!mp)
+			Dprintf(L_ERROR, "no last mount in fh_compose for %s\n", pathbuf);
+		else if (auth_checkdev(mp, sbp->st_dev) == 0) {
+			Dprintf(L_ERROR, "access to no cross path below mountpoint (<%s>, %x<->%x)\n",
+					pathbuf, mp->mount_dev, sbp->st_dev);
+			return NFSERR_STALE;
+		}
+	}
 
 	if (is_dd) {
 		/* Don't cd .. from root, or mysterious ailments will
@@ -1430,11 +1483,12 @@
 	} else {
 		if (++(key->hash_path[0]) >= HP_LEN)
 			return NFSERR_NAMETOOLONG;
-		key->hash_path[key->hash_path[0]] = hash_psi(dirh->h.psi);
+		key->hash_path[key->hash_path[0]] = hash_psi(pseudo_inode(dirh->h.ino,
+			dirh->h.dev));
 	}
 	/* FIXME: when crossing a mount point, we'll find the real
 	 * dev/ino in sbp and can store it in h... */
-	h = fh_find(key, FHFIND_FCREATE);
+	h = fh_find(key, FHFIND_FCREATE, 0);
 
 #ifdef FHTRACE
 	if (h == NULL)
@@ -1456,7 +1510,7 @@
 		/* We must have cached an old file under the same inode # */
 		Dprintf(D_FHTRACE, "Disposing of fh with bad path.\n");
 		fh_delete(h);
-		h = fh_find(key, FHFIND_FCREATE);
+		h = fh_find(key, FHFIND_FCREATE, dirh->last_mount ? dirh->last_mount->mount_dev : 0);
 #ifdef FHTRACE
 		if (!h) return NFSERR_STALE;
 #endif
@@ -1511,12 +1565,14 @@
 	return (NFS_OK);
 }
 
+#if 0
 psi_t
 fh_psi(nfs_fh *fh)
 {
 	svc_fh *h = (svc_fh *) fh;
 	return (h->psi);
 }
+#endif
 
 void
 fh_remove(char *path)
@@ -1524,12 +1580,13 @@
 	psi_t	psi;
 	nfsstat status;
 	fhcache *fhc;
+	struct stat st;
 
-	psi = path_psi(path, &status, NULL, 0);
+	psi = path_psi(path, &status, &st, 0, NULL);
 	if (psi == 0)
 		return;
 	ex_state = active;
-	fhc = fh_lookup(psi);
+	fhc = fh_lookup(st.st_ino,st.st_dev);
 	if (fhc != NULL)
 		fh_delete(fhc);
 
@@ -1634,6 +1691,11 @@
 fh_init(void)
 {
 	static int	initialized = 0;
+
+	if (sizeof(svc_fh) > 32) {
+		fprintf(stderr, "filehandle wrong size %d\n", sizeof(svc_fh));
+		exit(10);
+	}
 
 	if (initialized)
 		return;
--- nfs-server/fh.h
+++ nfs-server/fh.h	2002/11/08 13:59:16
@@ -20,6 +20,7 @@
 #define	FHC_XONLY_PATH		001	/* NOT USED ANYMORE */
 #define	FHC_ATTRVALID		002
 #define FHC_NFSMOUNTED		004
+#define FHC_CROSS		010
 
 /* Modes for fh_find */
 #define FHFIND_FEXISTS	0	/* file must exist */
@@ -65,11 +66,12 @@
  *
  * hash_path[hash_path[0]+1] ... hash_path[HP_LEN-1] == 0
  */
-#define	HP_LEN		(NFS_FHSIZE - sizeof(psi_t))
+#define        HP_LEN          (NFS_FHSIZE-sizeof(u_int32_t)-sizeof(u_int16_t))
 typedef struct {
-	psi_t		psi;
+	u_int32_t	ino;
+	u_int16_t	dev;
 	__u8		hash_path[HP_LEN];
-} svc_fh;
+} svc_fh __attribute__((packed));
 
 typedef enum { inactive, active } mutex;
 
@@ -100,6 +102,7 @@
 
 	/* These are fixed during the lifetime of this object */
 	svc_fh			h;
+	psi_t			psi;
 	dev_t			dev;
 	ino_t			ino;
 	mode_t			type;	/* st_mode & S_IFMT */
@@ -122,10 +125,11 @@
 /* Global function prototypes. */
 extern nfsstat	nfs_errno(void);
 extern psi_t	pseudo_inode(ino_t inode, dev_t dev);
+extern psi_t	visible_inode(ino_t inode, dev_t dev, nfs_mount *);
 extern void	fh_init(void);
 extern char	*fh_pr(nfs_fh *fh);
 extern int	fh_create(nfs_fh *fh, char *path);
-extern fhcache	*fh_find(svc_fh *h, int create);
+extern fhcache	*fh_find(svc_fh *h, int create, dev_t basedev);
 extern char	*fh_path(nfs_fh *fh, nfsstat *status);
 extern int	path_open(char *path, int omode, int perm);
 extern int	fh_fd(fhcache *fhc, nfsstat *status, int omode);
@@ -139,6 +143,7 @@
 extern void	fh_flush(int force);
 extern RETSIGTYPE flush_cache(int sig);
 extern int	nfsmounted(const char *path, struct stat *sbp);
+extern fhcache *fh_newfh(svc_fh *fh, int mode, dev_t basedev);
 
 #ifdef ENABLE_DEVTAB
 extern unsigned int	devtab_index(dev_t);
--- nfs-server/getattr.c
+++ nfs-server/getattr.c	2002/11/08 13:59:16
@@ -43,7 +43,7 @@
 {
 	fhcache *fhc;
 
-	if ((fhc = fh_find((svc_fh*)fh, FHFIND_FEXISTS)) == NULL) {
+	if ((fhc = fh_find((svc_fh*)fh, FHFIND_FEXISTS, 0)) == NULL) {
 		Dprintf(D_CALL, "getattr: failed! No such file.\n");
 		return (NFSERR_STALE);
 	}
@@ -103,18 +103,8 @@
 #else
 	attr->blocks = st_blocks(s);
 #endif
-#if 0
-	if (nfsmount->o.cross_mounts) {
-		attr->fsid = 1;
-		attr->fileid = fh_psi((nfs_fh *)&(fhc->h));
-	} else {
-		attr->fsid = s->st_dev;
-		attr->fileid = covered_ino(fhc->path);
-	}
-#else
-	attr->fsid   = 1;
-	attr->fileid = fh_psi((nfs_fh *)&(fhc->h));
-#endif
+	attr->fsid   = 1; // XXX
+	attr->fileid = visible_inode(fhc->h.ino, fhc->h.dev, nfsmount);
 
 	/* This may be needed by some Suns... testing */
 #define MINTIME	(24 * 2600)
--- nfs-server/mountd.c
+++ nfs-server/mountd.c	2002/11/08 13:59:16
@@ -36,6 +36,8 @@
 #include "signals.h"
 #include <rpc/pmap_clnt.h>
 
+int cross_mounts = 1;
+int hashed_inodes; /* dummy */
 
 static void	usage(FILE *, int);
 static void	terminate(void);
@@ -58,9 +60,9 @@
       {	"no-spoof-trace",	0,			0,	't' },
       { "version",		0,			0,	'v' },
       { "fail-safe",		optional_argument,	0,	'z' },
+      { "no-cross-mounts",	0,			0,	'x' },
       { "no-tcp",		0,			0,	OPT_NOTCP },
       {	"loopback-only",	0,			0,	OPT_LOOPBACK },
-
       { NULL,			0,			0,	0 }
 };
 static const char *	shortopts = "Fd:f:hnpP:rtvz::";
@@ -80,6 +82,7 @@
 int		need_reinit = 0;
 int		need_flush = 0;
 extern char	version[];
+nfs_client *nfsclient; /* dummy */
 
 /*
  * NULL
@@ -319,6 +322,9 @@
 	opterr = 0;
 	while ((c = getopt_long(argc, argv, shortopts, longopts, NULL)) != EOF)
 		switch (c) {
+		case 'x':
+			cross_mounts = 0;
+			break;
 		case 'F':
 			foreground = 1;
 			break;
@@ -444,7 +450,7 @@
 				program_name);
 	fprintf(fp, "       [--debug kind] [--help] [--allow-non-root]\n");
 	fprintf(fp, "       [--promiscuous] [--version] [--port portnum]\n");
-	fprintf(fp, "       [--exports-file=file]\n");
+	fprintf(fp, "       [--exports-file=file] [--no-cross-mounts]\n");
 	exit(n);
 }
 
--- nfs-server/nfsd.c
+++ nfs-server/nfsd.c	2002/11/08 14:20:57
@@ -72,7 +72,7 @@
       { "no-tcp",		0,			0,	OPT_NOTCP },
       { "udp-only",		0,			0,	OPT_NOTCP },
       {	"loopback-only",	0,			0,	OPT_LOOPBACK },
-
+      { "hashed-inodes",	0,			0,	'I' },
       { NULL,		0,	0, 0 }
 };
 static const char *	shortopts = "a:d:Ff:hlnP:prR:tvz::";
@@ -91,6 +91,7 @@
 int			need_flush = 0;		/* flush fh cache */
 int			read_only = 0;		/* Global ro forced */
 int			cross_mounts = 1;	/* Transparently cross mnts */
+int			hashed_inodes = 0;
 int			log_transfers = 0;	/* Log transfers */
 static svc_fh		public_fh;		/* Public NFSv2 FH */
 
@@ -122,12 +123,17 @@
 {
 	static int	total = 0, cached = 0;
 	fhcache		*fhc;
+	int		newfh = 0;
 
-	/* Try to map FH. If not cached, reconstruct path with root priv */
-	fhc = fh_find((svc_fh *)fh, FHFIND_FEXISTS|FHFIND_CHECK);
-	if (fhc == NULL) {
-		*statp = NFSERR_STALE;
-		return NULL;
+	/* Try to map FH. */
+	fhc = fh_find((svc_fh *)fh, FHFIND_FCACHED|FHFIND_CHECK, 0);
+	if (!fhc) {
+		fhc = fh_newfh((svc_fh*)fh, FHFIND_FEXISTS|FHFIND_CHECK, 0);
+		if (!fhc) {
+			*statp = NFSERR_STALE;
+			return NULL;
+		}
+		newfh = 1;
 	}
 
 	/* Try to retrieve last client who accessed this fh */
@@ -163,6 +169,16 @@
 			100 * (double) cached / total);
 	 */
 
+	/* Trust the crossmount check of the parent directory for creates */
+	if (newfh &&
+		(fhc->flags & FHC_ATTRVALID) &&
+		auth_checkdev(nfsmount, fhc->attrs.st_dev) == 0) {
+		Dprintf(L_ERROR, "auth_fh: fh crossed mount %s: %x<->%x\n",
+				fhc->path ? fhc->path : "???", nfsmount->mount_dev, fhc->attrs.st_dev);
+		*statp = NFSERR_STALE; /* or ACCES? */
+		return NULL;
+	}
+
 	if (nfsmount->o.noaccess &&
 	    ((flags & CHK_NOACCESS) || strcmp(nfsmount->path, fhc->path))) {
 		struct in_addr	addr = svc_getcaller(rqstp->rq_xprt)->sin_addr;
@@ -195,6 +211,7 @@
 	fhcache		*fhc;
 	nfsstat		status;
 	char		*path = buf, *sp;
+	struct stat	st;
 
 	/* Authenticate directory file handle */
 	if ((fhc = auth_fh(rqstp, &dopa->dir, &status, flags)) == NULL)
@@ -219,6 +236,9 @@
 	if ((nfsmount = auth_path(nfsclient, rqstp, path)) == NULL)
 		return NFSERR_ACCES;
 
+	if (efs_lstat(path, &st) >= 0 && !auth_checkdev(nfsmount, st.st_dev))
+		return NFSERR_ACCES;
+
 	/* XXX: really need to call it again here?
 	 * Already invoked in auth_fh */
 	if (!auth_user(nfsmount, rqstp))
@@ -318,7 +338,8 @@
 	int		ispublic = 0;
 
 	/* First check whether this is the public FH */
-	if (((svc_fh *) fh)->psi == 0 && !memcmp(fh, &public_fh, FHSIZE)) {
+	if (((svc_fh *) fh)->dev == 0 && ((svc_fh*)fh)->ino == 0 &&
+		!memcmp(fh, &public_fh, FHSIZE)) {
 		if (public_root_path == NULL)
 			return NFSERR_ACCES;
 		memcpy(&argp->dir, &public_root, NFS_FHSIZE);
@@ -333,6 +354,7 @@
 	if (!(fhc = auth_fh(rqstp, fh, &status, CHK_READ)))
 		return status;
 
+	/* FIXME: does too many stats */
 	status = fh_compose(argp, &dp->file, &sbuf, -1, -1, ispublic);
 	if (status != NFS_OK)
 		return status;
@@ -896,6 +918,9 @@
 	errno = 0;
 	if (efs_lstat(h->path, &sbuf) < 0 || !(S_ISDIR(sbuf.st_mode)))
 		return (NFSERR_NOTDIR);
+	if (!auth_checkdev(h->last_mount, sbuf.st_dev))
+		dotsonly = 1;
+
 	if ((dirp = efs_opendir(h->path)) == NULL)
 		return ((errno ? nfs_errno() : NFSERR_NAMETOOLONG));
 
@@ -923,7 +948,7 @@
 		}
 
 		e = *ep = (entry *) xmalloc(sizeof(entry));
-		e->fileid = pseudo_inode(dp->d_ino, sbuf.st_dev);
+		e->fileid = visible_inode(dp->d_ino, sbuf.st_dev, h->last_mount);
 		e->name = xmalloc(NLENGTH(dp) + 1);
 		strcpy(e->name, dp->d_name);
 		dloc = htonl(efs_telldir(dirp));
@@ -1033,6 +1058,9 @@
 		case 'x':
 			cross_mounts = 0;
 			break;
+		case 'I':
+			hashed_inodes = 1;
+			break;
 		case 'z':
 			if (optarg)
 				failsafe_level = atoi(optarg);
@@ -1189,7 +1217,7 @@
 "       [--debug kind] [--exports-file=file] [--port port]\n"
 "       [--allow-non-root] [--promiscuous] [--version] [--foreground]\n"
 "       [--re-export] [--log-transfers] [--public-root path]\n"
-"       [--no-spoof-trace] [--help]\n"
+"       [--no-spoof-trace] [--no-cross-mounts] [--hashed-inodes] [--help]\n"
 						, program_name);
 	exit(n);
 }
--- nfs-server/nfsd.h
+++ nfs-server/nfsd.h	2002/11/08 13:59:16
@@ -51,6 +51,7 @@
 extern int			need_reinit;
 extern int			need_flush;
 extern time_t			nfs_dispatch_time;
+extern int cross_mounts, hashed_inodes;
 
 /* Include the other module definitions. */
 #include "auth.h"
--- nfs-server/setattr.c
+++ nfs-server/setattr.c	2002/11/08 13:59:16
@@ -17,6 +17,7 @@
 
 #define IGNORE_TIME	((unsigned int) -1)
 
+#if 0
 /*
  * Set file attributes based on file handle
  */
@@ -33,6 +34,7 @@
 	}
 	return setattr(path, attr, s, rqstp, flags);
 }
+#endif
 
 /*
  * Set file attributes given the path. The flags argument
--- nfs-server/teahash3.c
+++ nfs-server/teahash3.c	2002/11/08 13:59:16
@@ -0,0 +1,168 @@
+/* Taken from the reiserfs source code and hacked slightly by AK.
+ * This is GPLed.  */ 
+/*
+ * Keyed 32-bit hash function using TEA in a Davis-Meyer function
+ *   H0 = Key
+ *   Hi = E Mi(Hi-1) + Hi-1
+ *
+ * (see Applied Cryptography, 2nd edition, p448).
+ *
+ * Jeremy Fitzhardinge <jeremy@zip.com.au> 1998
+ * 
+ * Jeremy has agreed to the contents of reiserfs/README. -Hans
+ */
+
+#include <assert.h>
+
+#if 0 
+/* OK for Intel */
+typedef unsigned long u32;
+typedef const unsigned char u8;
+#else
+#include <inttypes.h>
+typedef uint32_t u32;
+typedef uint8_t u8;
+#endif
+
+
+#define DELTA 0x9E3779B9
+#define FULLROUNDS 10		/* 32 is overkill, 16 is strong crypto */
+#define PARTROUNDS 6		/* 6 gets complete mixing */
+
+/* a, b, c, d - data; h0, h1 - accumulated hash */
+#define TEACORE(rounds)							\
+	do {								\
+		u32 sum = 0;						\
+		int n = rounds;						\
+		u32 b0, b1;						\
+									\
+		b0 = h0;						\
+		b1 = h1;						\
+									\
+		do							\
+		{							\
+			sum += DELTA;					\
+			b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b);	\
+			b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d);	\
+		} while(--n);						\
+									\
+		h0 += b0;						\
+		h1 += b1;						\
+	} while(0)
+
+u32 teahash3(/*u32 k[2], *//*u8*/const char *msg, int len)
+{
+	u32 k[] = { 0x9464a485, 0x542e1a94, 0x3e846bff, 0xb75bcfc3}; 
+
+	u32 h0 = k[0], h1 = k[1];
+	u32 a, b, c, d;
+	u32 pad;
+	int i;
+ 
+	assert(len >= 0 && len < 256);
+
+	pad = (u32)len | ((u32)len << 8);
+	pad |= pad << 16;
+
+	while(len >= 16)
+	{
+		a = (u32)msg[ 0]      |
+		    (u32)msg[ 1] << 8 |
+		    (u32)msg[ 2] << 16|
+		    (u32)msg[ 3] << 24;
+		b = (u32)msg[ 4]      |
+		    (u32)msg[ 5] << 8 |
+		    (u32)msg[ 6] << 16|
+		    (u32)msg[ 7] << 24;
+		c = (u32)msg[ 8]      |
+		    (u32)msg[ 9] << 8 |
+		    (u32)msg[10] << 16|
+		    (u32)msg[11] << 24;
+		d = (u32)msg[12]      |
+		    (u32)msg[13] << 8 |
+		    (u32)msg[14] << 16|
+		    (u32)msg[15] << 24;
+		
+		TEACORE(PARTROUNDS);
+
+		len -= 16;
+		msg += 16;
+	}
+
+	if (len >= 12)
+	{
+		assert(len < 16);
+
+		a = (u32)msg[ 0]      |
+		    (u32)msg[ 1] << 8 |
+		    (u32)msg[ 2] << 16|
+		    (u32)msg[ 3] << 24;
+		b = (u32)msg[ 4]      |
+		    (u32)msg[ 5] << 8 |
+		    (u32)msg[ 6] << 16|
+		    (u32)msg[ 7] << 24;
+		c = (u32)msg[ 8]      |
+		    (u32)msg[ 9] << 8 |
+		    (u32)msg[10] << 16|
+		    (u32)msg[11] << 24;
+
+		d = pad;
+		for(i = 12; i < len; i++)
+		{
+			d <<= 8;
+			d |= msg[i];
+		}
+	}
+	else if (len >= 8)
+	{
+		assert(len < 12);
+
+		a = (u32)msg[ 0]      |
+		    (u32)msg[ 1] << 8 |
+		    (u32)msg[ 2] << 16|
+		    (u32)msg[ 3] << 24;
+		b = (u32)msg[ 4]      |
+		    (u32)msg[ 5] << 8 |
+		    (u32)msg[ 6] << 16|
+		    (u32)msg[ 7] << 24;
+
+		c = d = pad;
+		for(i = 8; i < len; i++)
+		{
+			c <<= 8;
+			c |= msg[i];
+		}
+	}
+	else if (len >= 4)
+	{
+		assert(len < 8);
+
+		a = (u32)msg[ 0]      |
+		    (u32)msg[ 1] << 8 |
+		    (u32)msg[ 2] << 16|
+		    (u32)msg[ 3] << 24;
+
+		b = c = d = pad;
+		for(i = 4; i < len; i++)
+		{
+			b <<= 8;
+			b |= msg[i];
+		}
+	}
+	else
+	{
+		assert(len < 4);
+
+		a = b = c = d = pad;
+		for(i = 0; i < len; i++)
+		{
+			a <<= 8;
+			a |= msg[i];
+		}
+	}
+
+	TEACORE(FULLROUNDS);
+
+/*	return 0;*/
+	return h0^h1;
+}
--- nfs-server/ugid_map.c
+++ nfs-server/ugid_map.c	2002/11/08 13:59:16
@@ -276,8 +276,10 @@
 	if ((gid == 0 && mountp->o.root_squash) || mountp->o.all_squash)
 		retgid = mountp->o.nobody_gid;
 
+#if 0
 	Dprintf(D_UGID, "lgid(%s, %d) = %d\n",
 			inet_ntoa(mountp->client->clnt_addr), gid, retgid);
+#endif
 	return retgid;
 }