OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.18.0/] [newlib/] [libc/] [posix/] [telldir.c] - Blame information for rev 207

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 207 jeremybenn
#ifndef HAVE_OPENDIR
2
 
3
/*
4
 * Copyright (c) 1983 Regents of the University of California.
5
 * All rights reserved.
6
 *
7
 * Redistribution and use in source and binary forms, with or without
8
 * modification, are permitted provided that the following conditions
9
 * are met:
10
 * 1. Redistributions of source code must retain the above copyright
11
 *    notice, this list of conditions and the following disclaimer.
12
 * 2. Redistributions in binary form must reproduce the above copyright
13
 *    notice, this list of conditions and the following disclaimer in the
14
 *    documentation and/or other materials provided with the distribution.
15
 * 3. All advertising materials mentioning features or use of this software
16
 *    must display the following acknowledgement:
17
 *      This product includes software developed by the University of
18
 *      California, Berkeley and its contributors.
19
 * 4. Neither the name of the University nor the names of its contributors
20
 *    may be used to endorse or promote products derived from this software
21
 *    without specific prior written permission.
22
 *
23
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33
 * SUCH DAMAGE.
34
 */
35
 
36
#if defined(LIBC_SCCS) && !defined(lint)
37
static char sccsid[] = "@(#)telldir.c   5.9 (Berkeley) 2/23/91";
38
#endif /* LIBC_SCCS and not lint */
39
 
40
#include <sys/param.h>
41
#include <dirent.h>
42
#include <stdlib.h>
43
#include <unistd.h>
44
#include <sys/lock.h>
45
 
46
/*
47
 * The option SINGLEUSE may be defined to say that a telldir
48
 * cookie may be used only once before it is freed. This option
49
 * is used to avoid having memory usage grow without bound.
50
 */
51
#define SINGLEUSE
52
 
53
/*
54
 * One of these structures is malloced to describe the current directory
55
 * position each time telldir is called. It records the current magic
56
 * cookie returned by getdirentries and the offset within the buffer
57
 * associated with that return value.
58
 */
59
struct ddloc {
60
        struct  ddloc *loc_next;/* next structure in list */
61
        long    loc_index;      /* key associated with structure */
62
        long    loc_seek;       /* magic cookie returned by getdirentries */
63
        long    loc_loc;        /* offset of entry in buffer */
64
        DIR    *loc_dirp;       /* DIR pointer */
65
};
66
 
67
#define NDIRHASH        32      /* Num of hash lists, must be a power of 2 */
68
#define LOCHASH(i)      ((i)&(NDIRHASH-1))
69
 
70
static long     dd_loccnt;      /* Index of entry for sequential readdir's */
71
static struct   ddloc *dd_hash[NDIRHASH];   /* Hash list heads for ddlocs */
72
__LOCK_INIT(static, dd_hash_lock);
73
 
74
/*
75
 * return a pointer into a directory
76
 */
77
 
78
#if !defined(_ELIX_LEVEL) || (_ELIX_LEVEL >= 2)
79
 
80
long
81
_DEFUN(telldir, (dirp),
82
       DIR *dirp)
83
{
84
        register int index;
85
        register struct ddloc *lp;
86
 
87
        if ((lp = (struct ddloc *)malloc(sizeof(struct ddloc))) == NULL)
88
                return (-1);
89
 
90
#ifdef HAVE_DD_LOCK
91
        __lock_acquire_recursive(dirp->dd_lock);
92
        __lock_acquire(dd_hash_lock);
93
#endif
94
        index = dd_loccnt++;
95
        lp->loc_index = index;
96
        lp->loc_seek = dirp->dd_seek;
97
        lp->loc_loc = dirp->dd_loc;
98
        lp->loc_dirp = dirp;
99
        lp->loc_next = dd_hash[LOCHASH(index)];
100
        dd_hash[LOCHASH(index)] = lp;
101
#ifdef HAVE_DD_LOCK
102
        __lock_release(dd_hash_lock);
103
        __lock_release_recursive(dirp->dd_lock);
104
#endif
105
        return (index);
106
}
107
 
108
#endif /* !_ELIX_LEVEL || _ELIX_LEVEL >= 2 */
109
 
110
/*
111
 * seek to an entry in a directory.
112
 * Only values returned by "telldir" should be passed to seekdir.
113
 */
114
void
115
_DEFUN(_seekdir, (dirp, loc),
116
        register DIR *dirp _AND
117
        long loc)
118
{
119
        register struct ddloc *lp;
120
        register struct ddloc **prevlp;
121
        struct dirent *dp;
122
        extern long lseek();
123
 
124
#ifdef HAVE_DD_LOCK
125
        __lock_acquire(dd_hash_lock);
126
#endif
127
        prevlp = &dd_hash[LOCHASH(loc)];
128
        lp = *prevlp;
129
        while (lp != NULL) {
130
                if (lp->loc_index == loc)
131
                        break;
132
                prevlp = &lp->loc_next;
133
                lp = lp->loc_next;
134
        }
135
        if (lp == NULL) {
136
#ifdef HAVE_DD_LOCK
137
                __lock_release(dd_hash_lock);
138
#endif
139
                return;
140
        }
141
        if (lp->loc_loc == dirp->dd_loc && lp->loc_seek == dirp->dd_seek)
142
                goto found;
143
        (void) lseek(dirp->dd_fd, lp->loc_seek, 0);
144
        dirp->dd_seek = lp->loc_seek;
145
        dirp->dd_loc = 0;
146
        while (dirp->dd_loc < lp->loc_loc) {
147
                dp = readdir(dirp);
148
                if (dp == NULL)
149
                        break;
150
        }
151
found:
152
#ifdef SINGLEUSE
153
        *prevlp = lp->loc_next;
154
        free((caddr_t)lp);
155
#endif
156
#ifdef HAVE_DD_LOCK
157
        __lock_release(dd_hash_lock);
158
#endif
159
}
160
 
161
/* clean out any hash entries from a closed directory */
162
void
163
_DEFUN(_cleanupdir, (dirp),
164
        register DIR *dirp)
165
{
166
        int i;
167
 
168
#ifdef HAVE_DD_LOCK
169
        __lock_acquire(dd_hash_lock);
170
#endif
171
        for (i = 0; i < NDIRHASH; ++i) {
172
                register struct ddloc *lp;
173
                register struct ddloc *prevlp;
174
                lp = dd_hash[i];
175
                while (lp != NULL && lp->loc_dirp == dirp) {
176
                        dd_hash[i] = lp->loc_next;
177
                        prevlp = lp;
178
                        free((caddr_t)lp);
179
                        lp = prevlp->loc_next;
180
                }
181
                prevlp = lp;
182
                while (lp != NULL) {
183
                        lp = lp->loc_next;
184
                        if (lp != NULL && lp->loc_dirp == dirp) {
185
                                prevlp->loc_next = lp->loc_next;
186
                                free((caddr_t)lp);
187
                                lp = prevlp;
188
                        }
189
                        else
190
                                prevlp = lp;
191
                }
192
        }
193
#ifdef HAVE_DD_LOCK
194
        __lock_release(dd_hash_lock);
195
#endif
196
 
197
}
198
#endif /* ! HAVE_OPENDIR */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.