xref: /titanic_44/usr/src/stand/lib/fs/nfs/getdents.c (revision 8eea8e29cc4374d1ee24c25a07f45af132db3499)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  *
26  *  Stuff relating to directory reading ...
27  */
28 
29 #pragma ident	"%Z%%M%	%I%	%E% SMI"
30 
31 #include <rpc/types.h>
32 #include <rpc/auth.h>
33 #include <rpc/xdr.h>
34 #include "clnt.h"
35 #include <rpc/rpc_msg.h>
36 #include <sys/t_lock.h>
37 #include "nfs_inet.h"
38 #include <rpc/rpc.h>
39 #include "brpc.h"
40 #include <rpcsvc/nfs_prot.h>
41 #include <sys/types.h>
42 #include <sys/stat.h>
43 #include <sys/bootvfs.h>
44 #include <sys/sysmacros.h>
45 #include "socket_inet.h"
46 #include <sys/salib.h>
47 #include <sys/bootdebug.h>
48 
49 #define	MAXDENTS 16
50 #define	MINSIZ 20
51 
52 /*
53  * Boot needs to be cleaned up to use either dirent32 or dirent64,
54  * in the meantime use dirent_t and always round to 8 bytes
55  */
56 #define	BDIRENT_RECLEN(namelen) \
57 	((offsetof(dirent_t, d_name[0]) + 1 + (namelen) + 7) & ~ 7)
58 
59 #define	dprintf	if (boothowto & RB_DEBUG) printf
60 
61 /*
62  *  Get directory entries:
63  *
64  *	Uses the nfs "READDIR" operation to read directory entries
65  *	into a local buffer.  These are then translated into file
66  *	system independent "dirent" structs and returned in the
67  *	caller's buffer.  Returns the number of entries converted
68  *	(-1 if there's an error).
69  *
70  *	Although the xdr functions can allocate memory, we have
71  *	a limited heap so we allocate our own space,
72  *	assuming the worst case of 256 byte names.
73  *	This is a space hog in our local buffer, so we want
74  *	the number of buffers to be small. To make sure we don't
75  *	get more names than we can handle, we tell the rpc
76  *	routine that we only have space for MAXDENT names if
77  *	they are all the minimum size. This keeps the return
78  *	packet unfragmented, but may result in lots of reads
79  *	to process a large directory. Since this is standalone
80  *	we don't worry about speed. With MAXDENTs at 16, the
81  *	local buffer is 4k.
82  */
83 
84 int
85 nfsgetdents(struct nfs_file *nfp, struct dirent *dep, unsigned size)
86 {
87 	entry *ep;
88 	readdirargs rda;
89 	readdirres  res;
90 	enum clnt_stat status;
91 	struct {
92 		entry etlist[MAXDENTS];
93 		char names[MAXDENTS][NFS_MAXNAMLEN+1];
94 	} rdbuf;
95 	uint32_t offset;
96 	int j, cnt = 0;
97 	struct timeval zero_timeout = {0, 0};	/* default */
98 
99 	bzero((caddr_t)&res, sizeof (res));
100 	bzero((caddr_t)&rda, sizeof (rda));
101 	bzero((caddr_t)rdbuf.etlist, sizeof (rdbuf.etlist));
102 	bcopy((caddr_t)&nfp->fh.fh2, (caddr_t)&rda.dir, NFS_FHSIZE);
103 	bcopy((caddr_t)nfp->cookie.cookie2, (caddr_t)rda.cookie,
104 						sizeof (nfscookie));
105 
106 	while (!res.readdirres_u.reply.eof) {
107 		/*
108 		 *  Keep issuing nfs calls until EOF is reached on
109 		 *  the directory or the user buffer is filled.
110 		 */
111 
112 		for (j = 0; j < MAXDENTS; j++) {
113 			/*
114 			 *  Link our buffers together for the benefit of
115 			 *  XDR.  We do this each time we issue the rpc call
116 			 *  JIC the xdr decode
117 			 *  routines screw up the linkage!
118 			 */
119 
120 			rdbuf.etlist[j].name = rdbuf.names[(MAXDENTS-1) - j];
121 			rdbuf.etlist[j].nextentry =
122 				(j < (MAXDENTS-1)) ? &rdbuf.etlist[j+1] : 0;
123 		}
124 
125 		res.readdirres_u.reply.entries = rdbuf.etlist;
126 		/*
127 		 * Cannot give the whole buffer unless every name is
128 		 * 256 bytes! Assume the worst case of all 1 byte names.
129 		 * This results in MINSIZ bytes/name in the xdr stream.
130 		 */
131 		rda.count = sizeof (res) + MAXDENTS*MINSIZ;
132 		bzero((caddr_t)rdbuf.names, sizeof (rdbuf.names));
133 
134 		status = CLNT_CALL(root_CLIENT, NFSPROC_READDIR,
135 		    xdr_readdirargs, (caddr_t)&rda,
136 		    xdr_readdirres, (caddr_t)&res, zero_timeout);
137 
138 		if (status != RPC_SUCCESS) {
139 			dprintf("nfs_getdents: RPC error\n");
140 			return (-1);
141 		}
142 		if (res.status != NFS_OK) {
143 			/*
144 			 *  The most common failure here would be trying to
145 			 *  issue a getdents call on a non-directory!
146 			 */
147 
148 			nfs_error(res.status);
149 			return (-1);
150 		}
151 
152 		for (ep = rdbuf.etlist; ep; ep = ep->nextentry) {
153 			/*
154 			 *  Step thru all entries returned by NFS, converting
155 			 *  to the cannonical form and copying out to the
156 			 *  user's buffer.
157 			 */
158 
159 			int n;
160 
161 			/*
162 			 * catch the case user called at EOF
163 			 */
164 			if ((n = strlen(ep->name)) == 0)
165 				return (cnt);
166 
167 			n = BDIRENT_RECLEN(n);
168 
169 			if (n > size)
170 				return (cnt);
171 			size -= n;
172 
173 			(void) strcpy(dep->d_name, ep->name);
174 			dep->d_ino = ep->fileid;
175 			bcopy(ep->cookie, &offset, sizeof (nfscookie));
176 			dep->d_off = offset;
177 			dep->d_reclen = (ushort_t)n;
178 
179 			dep = (struct dirent *)((char *)dep + n);
180 			bcopy(ep->cookie, rda.cookie, sizeof (nfscookie));
181 			bcopy(ep->cookie, nfp->cookie.cookie2,
182 							sizeof (nfscookie));
183 			cnt++;
184 		}
185 	}
186 
187 	return (cnt);
188 }
189