usr/src/stand/lib/fs/nfs/getdents.c

   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 }