1/***********************************************************************
2*                                                                      *
3*               This software is part of the ast package               *
4*          Copyright (c) 1985-2011 AT&T Intellectual Property          *
5*                      and is licensed under the                       *
6*                 Eclipse Public License, Version 1.0                  *
7*                    by AT&T Intellectual Property                     *
8*                                                                      *
9*                A copy of the License is available at                 *
10*          http://www.eclipse.org/org/documents/epl-v10.html           *
11*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
12*                                                                      *
13*              Information and Software Systems Research               *
14*                            AT&T Research                             *
15*                           Florham Park NJ                            *
16*                                                                      *
17*                 Glenn Fowler <gsf@research.att.com>                  *
18*                  David Korn <dgk@research.att.com>                   *
19*                   Phong Vo <kpv@research.att.com>                    *
20*                                                                      *
21***********************************************************************/
22#include	"sfhdr.h"
23
24/*	Internal function to do a hard read.
25**	This knows about discipline and memory mapping, peek read.
26**
27**	Written by Kiem-Phong Vo.
28*/
29
30/* synchronize unseekable write streams */
31#if __STD_C
32static void _sfwrsync(void)
33#else
34static void _sfwrsync()
35#endif
36{	reg Sfpool_t*	p;
37	reg Sfio_t*	f;
38	reg int		n;
39
40	/* sync all pool heads */
41	for(p = _Sfpool.next; p; p = p->next)
42	{	if(p->n_sf <= 0)
43			continue;
44		f = p->sf[0];
45		if(!SFFROZEN(f) && f->next > f->data &&
46		   (f->mode&SF_WRITE) && f->extent < 0 )
47			(void)_sfflsbuf(f,-1);
48	}
49
50	/* and all the ones in the discrete pool */
51	for(n = 0; n < _Sfpool.n_sf; ++n)
52	{	f = _Sfpool.sf[n];
53
54		if(!SFFROZEN(f) && f->next > f->data &&
55		   (f->mode&SF_WRITE) && f->extent < 0 )
56			(void)_sfflsbuf(f,-1);
57	}
58}
59
60#if __STD_C
61ssize_t sfrd(Sfio_t* f, Void_t* buf, size_t n, Sfdisc_t* disc)
62#else
63ssize_t sfrd(f,buf,n,disc)
64Sfio_t*		f;
65Void_t*		buf;
66size_t		n;
67Sfdisc_t*	disc;
68#endif
69{
70	Sfoff_t		r;
71	reg Sfdisc_t*	dc;
72	reg int		local, rcrv, dosync, oerrno;
73	SFMTXDECL(f);
74
75	SFMTXENTER(f,-1);
76
77	GETLOCAL(f,local);
78	if((rcrv = f->mode & (SF_RC|SF_RV)) )
79		f->mode &= ~(SF_RC|SF_RV);
80	f->bits &= ~SF_JUSTSEEK;
81
82	if(f->mode&SF_PKRD)
83		SFMTXRETURN(f, -1);
84
85	if(!local && !(f->bits&SF_DCDOWN)) /* an external user's call */
86	{	if(f->mode != SF_READ && _sfmode(f,SF_READ,0) < 0)
87			SFMTXRETURN(f, -1);
88		if(f->next < f->endb)
89		{	if(SFSYNC(f) < 0)
90				SFMTXRETURN(f, -1);
91			if((f->mode&(SF_SYNCED|SF_READ)) == (SF_SYNCED|SF_READ) )
92			{	f->endb = f->next = f->endr = f->data;
93				f->mode &= ~SF_SYNCED;
94			}
95#ifdef MAP_TYPE
96			if((f->bits&SF_MMAP) && f->data)
97			{	SFMUNMAP(f, f->data, f->endb-f->data);
98				f->data = NIL(uchar*);
99			}
100#endif
101			f->next = f->endb = f->endr = f->endw = f->data;
102		}
103	}
104
105	for(dosync = 0;;)
106	{	/* stream locked by sfsetfd() */
107		if(!(f->flags&SF_STRING) && f->file < 0)
108			SFMTXRETURN(f, 0);
109
110		f->flags &= ~(SF_EOF|SF_ERROR);
111
112		dc = disc;
113		if(f->flags&SF_STRING)
114		{	if((r = (f->data+f->extent) - f->next) < 0)
115				r = 0;
116			if(r <= 0)
117				goto do_except;
118			SFMTXRETURN(f, (ssize_t)r);
119		}
120
121		/* warn that a read is about to happen */
122		SFDISC(f,dc,readf);
123		if(dc && dc->exceptf && (f->flags&SF_IOCHECK) )
124		{	reg int	rv;
125			if(local)
126				SETLOCAL(f);
127			if((rv = _sfexcept(f,SF_READ,n,dc)) > 0)
128				n = rv;
129			else if(rv < 0)
130			{	f->flags |= SF_ERROR;
131				SFMTXRETURN(f, (ssize_t)rv);
132			}
133		}
134
135#ifdef MAP_TYPE
136		if(f->bits&SF_MMAP)
137		{	reg ssize_t	a, round;
138			sfstat_t	st;
139
140			/* determine if we have to copy data to buffer */
141			if((uchar*)buf >= f->data && (uchar*)buf <= f->endb)
142			{	n += f->endb - f->next;
143				buf = NIL(char*);
144			}
145
146			/* actual seek location */
147			if((f->flags&(SF_SHARE|SF_PUBLIC)) == (SF_SHARE|SF_PUBLIC) &&
148			   (r = SFSK(f,(Sfoff_t)0,SEEK_CUR,dc)) != f->here)
149				f->here = r;
150			else	f->here -= f->endb-f->next;
151
152			/* before mapping, make sure we have data to map */
153			if((f->flags&SF_SHARE) || (size_t)(r = f->extent-f->here) < n)
154			{	if((r = sysfstatf(f->file,&st)) < 0)
155					goto do_except;
156				if((r = (f->extent = st.st_size) - f->here) <= 0 )
157				{	r = 0;	/* eof */
158					goto do_except;
159				}
160			}
161
162			/* make sure current position is page aligned */
163			if((a = (size_t)(f->here%_Sfpage)) != 0)
164			{	f->here -= a;
165				r += a;
166			}
167
168			/* map minimal requirement */
169			if(r > (round = (1 + (n+a)/f->size)*f->size) )
170				r = round;
171
172			if(f->data)
173				SFMUNMAP(f, f->data, f->endb-f->data);
174
175			for(;;)
176			{	f->data = (uchar*) sysmmapf((caddr_t)0, (size_t)r,
177							(PROT_READ|PROT_WRITE),
178							MAP_PRIVATE,
179							f->file, (sfoff_t)f->here);
180				if(f->data && (caddr_t)f->data != (caddr_t)(-1))
181					break;
182				else
183				{	f->data = NIL(uchar*);
184					if((r >>= 1) < (_Sfpage*SF_NMAP) ||
185					   (errno != EAGAIN && errno != ENOMEM) )
186						break;
187				}
188			}
189
190			if(f->data)
191			{	if(f->bits&SF_SEQUENTIAL)
192					SFMMSEQON(f,f->data,r);
193				f->next = f->data+a;
194				f->endr = f->endb = f->data+r;
195				f->endw = f->data;
196				f->here += r;
197
198				/* make known our seek location */
199				(void)SFSK(f,f->here,SEEK_SET,dc);
200
201				if(buf)
202				{	if(n > (size_t)(r-a))
203						n = (ssize_t)(r-a);
204					memcpy(buf,f->next,n);
205					f->next += n;
206				}
207				else	n = f->endb - f->next;
208
209				SFMTXRETURN(f, n);
210			}
211			else
212			{	r = -1;
213				f->here += a;
214
215				/* reset seek pointer to its physical location */
216				(void)SFSK(f,f->here,SEEK_SET,dc);
217
218				/* make a buffer */
219				(void)SFSETBUF(f,(Void_t*)f->tiny,(size_t)SF_UNBOUND);
220
221				if(!buf)
222				{	buf = (Void_t*)f->data;
223					n = f->size;
224				}
225			}
226		}
227#endif
228
229		/* sync unseekable write streams to prevent deadlock */
230		if(!dosync && f->extent < 0)
231		{	dosync = 1;
232			_sfwrsync();
233		}
234
235		/* make sure file pointer is right */
236		if(f->extent >= 0 && (f->flags&SF_SHARE) )
237		{	if(!(f->flags&SF_PUBLIC) )
238				f->here = SFSK(f,f->here,SEEK_SET,dc);
239			else	f->here = SFSK(f,(Sfoff_t)0,SEEK_CUR,dc);
240		}
241
242		oerrno = errno;
243		errno = 0;
244
245		if(dc && dc->readf)
246		{	int	share = f->flags&SF_SHARE;
247
248			if(rcrv) /* pass on rcrv for possible continuations */
249				f->mode |= rcrv;
250				/* tell readf that no peeking necessary */
251			else	f->flags &= ~SF_SHARE;
252
253			SFDCRD(f,buf,n,dc,r);
254
255			/* reset flags */
256			if(rcrv)
257				f->mode &= ~rcrv;
258			else	f->flags |= share;
259		}
260		else if(SFISNULL(f))
261			r = 0;
262		else if(f->extent < 0 && (f->flags&SF_SHARE) && rcrv)
263		{	/* try peek read */
264			r = sfpkrd(f->file, (char*)buf, n,
265				    (rcrv&SF_RC) ? (int)f->getr : -1,
266				    -1L, (rcrv&SF_RV) ? 1 : 0);
267			if(r > 0)
268			{	if(rcrv&SF_RV)
269					f->mode |= SF_PKRD;
270				else	f->mode |= SF_RC;
271			}
272		}
273		else	r = sysreadf(f->file,buf,n);
274
275		if(errno == 0 )
276			errno = oerrno;
277
278		if(r > 0 )
279		{	if(!(f->bits&SF_DCDOWN) )	/* not a continuation call */
280			{	if(!(f->mode&SF_PKRD) )
281				{	f->here += r;
282					if(f->extent >= 0 && f->extent < f->here)
283						f->extent = f->here;
284				}
285				if((uchar*)buf >= f->data &&
286				   (uchar*)buf < f->data+f->size)
287					f->endb = f->endr = ((uchar*)buf) + r;
288			}
289
290			SFMTXRETURN(f, (ssize_t)r);
291		}
292
293	do_except:
294		if(local)
295			SETLOCAL(f);
296		switch(_sfexcept(f,SF_READ,(ssize_t)r,dc))
297		{
298		case SF_ECONT :
299			goto do_continue;
300		case SF_EDONE :
301			n = local ? 0 : (ssize_t)r;
302			SFMTXRETURN(f,n);
303		case SF_EDISC :
304			if(!local && !(f->flags&SF_STRING))
305				goto do_continue;
306			/* else fall thru */
307		case SF_ESTACK :
308			SFMTXRETURN(f, -1);
309		}
310
311	do_continue:
312		for(dc = f->disc; dc; dc = dc->disc)
313			if(dc == disc)
314				break;
315		disc = dc;
316	}
317}
318