1 /* 2 * Copyright (c) 1983, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD: src/lib/libc/gen/telldir.c,v 1.4.12.1 2001/03/05 09:39:59 obrien Exp $ 30 * 31 * @(#)telldir.c 8.1 (Berkeley) 6/4/93 32 */ 33 34 #include "namespace.h" 35 #include <sys/param.h> 36 #include <dirent.h> 37 #include <pthread.h> 38 #include <stdlib.h> 39 #include <unistd.h> 40 #include "un-namespace.h" 41 42 #include "libc_private.h" 43 #include "gen_private.h" 44 45 /* 46 * One of these structures is malloced to describe the current directory 47 * position each time telldir is called. It records the current magic 48 * cookie returned by getdirentries and the offset within the buffer 49 * associated with that return value. 50 */ 51 struct ddloc { 52 struct ddloc *loc_next;/* next structure in list */ 53 long loc_index; /* key associated with structure */ 54 off_t loc_seek; /* magic cookie returned by getdirentries */ 55 long loc_loc; /* offset of entry in buffer */ 56 const DIR* loc_dirp; /* directory which used this entry */ 57 }; 58 59 #define NDIRHASH 32 /* Num of hash lists, must be a power of 2 */ 60 #define LOCHASH(i) ((i)&(NDIRHASH-1)) 61 62 static long dd_loccnt; /* Index of entry for sequential readdir's */ 63 static struct ddloc *dd_hash[NDIRHASH]; /* Hash list heads for ddlocs */ 64 static pthread_mutex_t dd_hash_lock; 65 66 /* 67 * return a pointer into a directory 68 */ 69 long 70 telldir(DIR *dirp) 71 { 72 long index; 73 struct ddloc *lp; 74 75 if (__isthreaded) { 76 _pthread_mutex_lock(&dirp->dd_lock); 77 _pthread_mutex_lock(&dd_hash_lock); 78 } 79 80 /* 81 * Reduce memory use by reusing a ddloc that might already exist 82 * for this position. 83 */ 84 for (lp = dd_hash[LOCHASH(dirp->dd_lastseek)]; lp; lp = lp->loc_next) { 85 if (lp->loc_dirp == dirp && lp->loc_seek == dirp->dd_seek && 86 lp->loc_loc == dirp->dd_loc) { 87 index = lp->loc_index; 88 goto done; 89 } 90 } 91 92 if ((lp = (struct ddloc *)malloc(sizeof(struct ddloc))) == NULL) { 93 index = -1; 94 goto done; 95 } 96 index = dd_loccnt++; 97 lp->loc_index = index; 98 lp->loc_seek = dirp->dd_seek; 99 lp->loc_loc = dirp->dd_loc; 100 lp->loc_dirp = dirp; 101 102 lp->loc_next = dd_hash[LOCHASH(index)]; 103 dd_hash[LOCHASH(index)] = lp; 104 105 done: 106 if (__isthreaded) { 107 _pthread_mutex_unlock(&dd_hash_lock); 108 _pthread_mutex_unlock(&dirp->dd_lock); 109 } 110 return (index); 111 } 112 113 /* 114 * seek to an entry in a directory. 115 * Only values returned by "telldir" should be passed to seekdir. 116 */ 117 void 118 _seekdir(DIR *dirp, long loc) 119 { 120 struct ddloc *lp; 121 struct dirent *dp; 122 123 if (__isthreaded) 124 _pthread_mutex_lock(&dd_hash_lock); 125 for (lp = dd_hash[LOCHASH(loc)]; lp; lp = lp->loc_next) { 126 if (lp->loc_dirp == dirp && lp->loc_index == loc) 127 break; 128 } 129 if (__isthreaded) 130 _pthread_mutex_unlock(&dd_hash_lock); 131 if (lp == NULL) 132 return; 133 if (lp->loc_loc == dirp->dd_loc && lp->loc_seek == dirp->dd_seek) 134 return; 135 lseek(dirp->dd_fd, lp->loc_seek, SEEK_SET); 136 dirp->dd_seek = lp->loc_seek; 137 dirp->dd_loc = 0; 138 dirp->dd_lastseek = loc; 139 140 /* 141 * Scan the buffer until we find dd_loc. If the directory 142 * changed between the tell and seek it is possible to 143 * load a new buffer or for dd_loc to not match directly. 144 */ 145 while (dirp->dd_loc < lp->loc_loc && dirp->dd_seek == lp->loc_seek) { 146 dp = _readdir_unlocked(dirp, 0); 147 if (dp == NULL) 148 break; 149 } 150 } 151 152 /* 153 * Reclaim memory for telldir cookies which weren't used. 154 */ 155 void 156 _reclaim_telldir(DIR *dirp) 157 { 158 struct ddloc *lp; 159 struct ddloc **prevlp; 160 int i; 161 162 if (__isthreaded) 163 _pthread_mutex_lock(&dd_hash_lock); 164 for (i = 0; i < NDIRHASH; i++) { 165 prevlp = &dd_hash[i]; 166 lp = *prevlp; 167 while (lp != NULL) { 168 if (lp->loc_dirp == dirp) { 169 *prevlp = lp->loc_next; 170 free((caddr_t)lp); 171 lp = *prevlp; 172 continue; 173 } 174 prevlp = &lp->loc_next; 175 lp = lp->loc_next; 176 } 177 } 178 if (__isthreaded) 179 _pthread_mutex_unlock(&dd_hash_lock); 180 } 181