sfpool.c revision 3e14f97f673e8a630f076077de35afdd43dc1587
3853N/A/***********************************************************************
3853N/A* *
3853N/A* This software is part of the ast package *
3853N/A* Copyright (c) 1985-2010 AT&T Intellectual Property *
3853N/A* and is licensed under the *
3853N/A* Common Public License, Version 1.0 *
3853N/A* by AT&T Intellectual Property *
3853N/A* *
3853N/A* A copy of the License is available at *
3853N/A* http://www.opensource.org/licenses/cpl1.0.txt *
3853N/A* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) *
3853N/A* *
3853N/A* Information and Software Systems Research *
3853N/A* AT&T Research *
3853N/A* Florham Park NJ *
3853N/A* *
3853N/A* Glenn Fowler <gsf@research.att.com> *
3853N/A* David Korn <dgk@research.att.com> *
3853N/A* Phong Vo <kpv@research.att.com> *
3853N/A* *
3853N/A***********************************************************************/
3853N/A#include "sfhdr.h"
3853N/A
3853N/A/* Management of pools of streams.
4676N/A** If pf is not nil, f is pooled with pf and f becomes current;
3853N/A** otherwise, f is isolated from its pool. flag can be one of
3853N/A** 0 or SF_SHARE.
3853N/A**
3853N/A** Written by Kiem-Phong Vo.
3853N/A*/
3853N/A
3853N/A/* Note that we do not free the space for a pool once it is allocated.
3853N/A** This is to prevent memory faults in calls such as sfsync(NULL) that walk the pool
3853N/A** link list and during such walks may free up streams&pools. Free pools will be
3853N/A** reused in newpool().
3853N/A*/
3853N/A#if __STD_C
3853N/Astatic int delpool(reg Sfpool_t* p)
3853N/A#else
3853N/Astatic int delpool(p)
3853N/Areg Sfpool_t* p;
3853N/A#endif
3853N/A{
3853N/A POOLMTXENTER(p);
3853N/A
3853N/A if(p->s_sf && p->sf != p->array)
3853N/A free((Void_t*)p->sf);
3853N/A p->mode = SF_AVAIL;
3853N/A
3853N/A POOLMTXRETURN(p,0);
3853N/A}
3853N/A
3853N/A#if __STD_C
3853N/Astatic Sfpool_t* newpool(reg int mode)
3853N/A#else
3853N/Astatic Sfpool_t* newpool(mode)
3853N/Areg int mode;
3853N/A#endif
3853N/A{
3853N/A reg Sfpool_t *p, *last = &_Sfpool;
3853N/A
3853N/A /* look to see if there is a free pool */
3853N/A for(last = &_Sfpool, p = last->next; p; last = p, p = p->next)
3853N/A { if(p->mode == SF_AVAIL )
3853N/A { p->mode = 0;
3853N/A break;
3853N/A }
3853N/A }
3853N/A
3853N/A if(!p)
3853N/A { POOLMTXLOCK(last);
3853N/A
3853N/A if(!(p = (Sfpool_t*) malloc(sizeof(Sfpool_t))) )
3853N/A { POOLMTXUNLOCK(last);
3853N/A return NIL(Sfpool_t*);
3853N/A }
3853N/A
3853N/A (void)vtmtxopen(&p->mutex, VT_INIT); /* initialize mutex */
3853N/A
3853N/A p->mode = 0;
3853N/A p->n_sf = 0;
3853N/A p->next = NIL(Sfpool_t*);
3853N/A last->next = p;
3853N/A
3853N/A POOLMTXUNLOCK(last);
3853N/A }
3853N/A
3853N/A POOLMTXENTER(p);
3853N/A
3853N/A p->mode = mode&SF_SHARE;
3853N/A p->s_sf = sizeof(p->array)/sizeof(p->array[0]);
3853N/A p->sf = p->array;
3853N/A
3853N/A POOLMTXRETURN(p,p);
3853N/A}
3853N/A
3853N/A/* move a stream to head */
3853N/A#if __STD_C
3853N/Astatic int _sfphead(Sfpool_t* p, Sfio_t* f, int n)
3853N/A#else
3853N/Astatic int _sfphead(p, f, n)
3853N/ASfpool_t* p; /* the pool */
3853N/ASfio_t* f; /* the stream */
3853N/Aint n; /* current position in pool */
3853N/A#endif
3853N/A{
3853N/A reg Sfio_t* head;
3853N/A reg ssize_t k, w, v;
3853N/A reg int rv;
3853N/A
3853N/A POOLMTXENTER(p);
3853N/A
3853N/A if(n == 0)
3853N/A POOLMTXRETURN(p,0);
3853N/A
3853N/A head = p->sf[0];
3853N/A if(SFFROZEN(head) )
3853N/A POOLMTXRETURN(p,-1);
3853N/A
3853N/A SFLOCK(head,0);
3853N/A rv = -1;
3853N/A
3853N/A if(!(p->mode&SF_SHARE) || (head->mode&SF_READ) || (f->mode&SF_READ) )
3853N/A { if(SFSYNC(head) < 0)
3853N/A goto done;
3853N/A }
3853N/A else /* shared pool of write-streams, data can be moved among streams */
3853N/A { if(SFMODE(head,1) != SF_WRITE && _sfmode(head,SF_WRITE,1) < 0)
3853N/A goto done;
3853N/A /**/ASSERT(f->next == f->data);
3853N/A
3853N/A v = head->next - head->data; /* pending data */
3853N/A if((k = v - (f->endb-f->data)) <= 0)
3853N/A k = 0;
3853N/A else /* try to write out amount exceeding f's capacity */
3853N/A { if((w = SFWR(head,head->data,k,head->disc)) == k)
3853N/A v -= k;
3853N/A else /* write failed, recover buffer then quit */
3853N/A { if(w > 0)
3853N/A { v -= w;
3853N/A memcpy(head->data,(head->data+w),v);
3853N/A }
3853N/A head->next = head->data+v;
3853N/A goto done;
3853N/A }
3853N/A }
3853N/A
3853N/A /* move data from head to f */
3853N/A if((head->data+k) != f->data )
3853N/A memcpy(f->data,(head->data+k),v);
3853N/A f->next = f->data+v;
3853N/A }
3853N/A
3853N/A f->mode &= ~SF_POOL;
3853N/A head->mode |= SF_POOL;
3853N/A head->next = head->endr = head->endw = head->data; /* clear write buffer */
3853N/A
3853N/A p->sf[n] = head;
3853N/A p->sf[0] = f;
3853N/A rv = 0;
3853N/A
3853N/Adone:
3853N/A head->mode &= ~SF_LOCK; /* partially unlock because it's no longer head */
3853N/A
3853N/A POOLMTXRETURN(p,rv);
3853N/A}
3853N/A
3853N/A/* delete a stream from its pool */
3853N/A#if __STD_C
3853N/Astatic int _sfpdelete(Sfpool_t* p, Sfio_t* f, int n)
4676N/A#else
3853N/Astatic int _sfpdelete(p, f, n)
3853N/ASfpool_t* p; /* the pool */
3853N/ASfio_t* f; /* the stream */
3853N/Aint n; /* position in pool */
3853N/A#endif
3853N/A{
3853N/A POOLMTXENTER(p);
3853N/A
3853N/A p->n_sf -= 1;
3853N/A for(; n < p->n_sf; ++n)
3853N/A p->sf[n] = p->sf[n+1];
3853N/A
3853N/A f->pool = NIL(Sfpool_t*);
3853N/A f->mode &= ~SF_POOL;
if(p->n_sf == 0 || p == &_Sfpool)
{ if(p != &_Sfpool)
delpool(p);
goto done;
}
/* !_Sfpool, make sure head stream is an open stream */
for(n = 0; n < p->n_sf; ++n)
if(!SFFROZEN(p->sf[n]))
break;
if(n < p->n_sf && n > 0)
{ f = p->sf[n];
p->sf[n] = p->sf[0];
p->sf[0] = f;
}
/* head stream has SF_POOL off */
f = p->sf[0];
f->mode &= ~SF_POOL;
if(!SFFROZEN(f))
_SFOPEN(f);
/* if only one stream left, delete pool */
if(p->n_sf == 1 )
{ _sfpdelete(p,f,0);
_sfsetpool(f);
}
done:
POOLMTXRETURN(p,0);
}
#if __STD_C
static int _sfpmove(reg Sfio_t* f, reg int type)
#else
static int _sfpmove(f,type)
reg Sfio_t* f;
reg int type; /* <0 : deleting, 0: move-to-front, >0: inserting */
#endif
{
reg Sfpool_t* p;
reg int n;
if(type > 0)
return _sfsetpool(f);
else
{ if(!(p = f->pool) )
return -1;
for(n = p->n_sf-1; n >= 0; --n)
if(p->sf[n] == f)
break;
if(n < 0)
return -1;
return type == 0 ? _sfphead(p,f,n) : _sfpdelete(p,f,n);
}
}
#if __STD_C
Sfio_t* sfpool(reg Sfio_t* f, reg Sfio_t* pf, reg int mode)
#else
Sfio_t* sfpool(f,pf,mode)
reg Sfio_t* f;
reg Sfio_t* pf;
reg int mode;
#endif
{
int k;
Sfpool_t* p;
Sfio_t* rv;
_Sfpmove = _sfpmove;
if(!f) /* return head of pool of pf regardless of lock states */
{ if(!pf)
return NIL(Sfio_t*);
else if(!pf->pool || pf->pool == &_Sfpool)
return pf;
else return pf->pool->sf[0];
}
if(f) /* check for permissions */
{ SFMTXLOCK(f);
if((f->mode&SF_RDWR) != f->mode && _sfmode(f,0,0) < 0)
{ SFMTXUNLOCK(f);
return NIL(Sfio_t*);
}
if(f->disc == _Sfudisc)
(void)sfclose((*_Sfstack)(f,NIL(Sfio_t*)));
}
if(pf)
{ SFMTXLOCK(pf);
if((pf->mode&SF_RDWR) != pf->mode && _sfmode(pf,0,0) < 0)
{ if(f)
SFMTXUNLOCK(f);
SFMTXUNLOCK(pf);
return NIL(Sfio_t*);
}
if(pf->disc == _Sfudisc)
(void)sfclose((*_Sfstack)(pf,NIL(Sfio_t*)));
}
/* f already in the same pool with pf */
if(f == pf || (pf && f->pool == pf->pool && f->pool != &_Sfpool) )
{ if(f)
SFMTXUNLOCK(f);
if(pf)
SFMTXUNLOCK(pf);
return pf;
}
/* lock streams before internal manipulations */
rv = NIL(Sfio_t*);
SFLOCK(f,0);
if(pf)
SFLOCK(pf,0);
if(!pf) /* deleting f from its current pool */
{ if((p = f->pool) != NIL(Sfpool_t*) && p != &_Sfpool)
for(k = 0; k < p->n_sf && pf == NIL(Sfio_t*); ++k)
if(p->sf[k] != f) /* a stream != f represents the pool */
pf = p->sf[k];
if(!pf) /* already isolated */
{ rv = f; /* just return self */
goto done;
}
if(_sfpmove(f,-1) < 0 || _sfsetpool(f) < 0)
goto done; /* can't delete */
if(!pf->pool || pf->pool == &_Sfpool || pf->pool->n_sf <= 0 )
rv = pf;
else rv = pf->pool->sf[0]; /* return head of old pool */
goto done;
}
if(pf->pool && pf->pool != &_Sfpool) /* always use current mode */
mode = pf->pool->mode;
if(mode&SF_SHARE) /* can only have write streams */
{ if(SFMODE(f,1) != SF_WRITE && _sfmode(f,SF_WRITE,1) < 0)
goto done;
if(SFMODE(pf,1) != SF_WRITE && _sfmode(pf,SF_WRITE,1) < 0)
goto done;
if(f->next > f->data && SFSYNC(f) < 0) /* start f clean */
goto done;
}
if(_sfpmove(f,-1) < 0) /* isolate f from current pool */
goto done;
if(!(p = pf->pool) || p == &_Sfpool) /* making a new pool */
{ if(!(p = newpool(mode)) )
goto done;
if(_sfpmove(pf,-1) < 0) /* isolate pf from its current pool */
goto done;
pf->pool = p;
p->sf[0] = pf;
p->n_sf += 1;
}
f->pool = p; /* add f to pf's pool */
if(_sfsetpool(f) < 0)
goto done;
/**/ASSERT(p->sf[0] == pf && p->sf[p->n_sf-1] == f);
SFOPEN(pf,0);
SFOPEN(f,0);
if(_sfpmove(f,0) < 0) /* make f head of pool */
goto done;
rv = pf;
done:
if(f)
{ SFOPEN(f,0);
SFMTXUNLOCK(f);
}
if(pf)
{ SFOPEN(pf,0);
SFMTXUNLOCK(pf);
}
return rv;
}