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
nfsgetdents(struct nfs_file * nfp,struct dirent * dep,unsigned size)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