usr/src/lib/libast/common/sfio/sfpool.c

   1 /***********************************************************************
   2 *                                                                      *
   3 *               This software is part of the ast package               *
   4 *          Copyright (c) 1985-2010 AT&T Intellectual Property          *
   5 *                      and is licensed under the                       *
   6 *                  Common Public License, Version 1.0                  *
   7 *                    by AT&T Intellectual Property                     *
   8 *                                                                      *
   9 *                A copy of the License is available at                 *
  10 *            http://www.opensource.org/licenses/cpl1.0.txt             *
  11 *         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
  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 /*      Management of pools of streams.
  25 **      If pf is not nil, f is pooled with pf and f becomes current;
  26 **      otherwise, f is isolated from its pool. flag can be one of
  27 **      0 or SF_SHARE.
  28 **
  29 **      Written by Kiem-Phong Vo.
  30 */
  31
  32 /* Note that we do not free the space for a pool once it is allocated.
  33 ** This is to prevent memory faults in calls such as sfsync(NULL) that walk the pool
  34 ** link list and during such walks may free up streams&pools. Free pools will be
  35 ** reused in newpool().
  36 */
  37 #if __STD_C
  38 static int delpool(reg Sfpool_t* p)
  39 #else
  40 static int delpool(p)
  41 reg Sfpool_t*   p;
  42 #endif
  43 {
  44         POOLMTXENTER(p);
  45
  46         if(p->s_sf && p->sf != p->array)
  47                 free((Void_t*)p->sf);
  48         p->mode = SF_AVAIL;
  49
  50         POOLMTXRETURN(p,0);
  51 }
  52
  53 #if __STD_C
  54 static Sfpool_t* newpool(reg int mode)
  55 #else
  56 static Sfpool_t* newpool(mode)
  57 reg int mode;
  58 #endif
  59 {
  60         reg Sfpool_t    *p, *last = &_Sfpool;
  61
  62         /* look to see if there is a free pool */
  63         for(last = &_Sfpool, p = last->next; p; last = p, p = p->next)
  64         {       if(p->mode == SF_AVAIL )
  65                 {       p->mode = 0;
  66                         break;
  67                 }
  68         }
  69
  70         if(!p)
  71         {       POOLMTXLOCK(last);
  72
  73                 if(!(p = (Sfpool_t*) malloc(sizeof(Sfpool_t))) )
  74                 {       POOLMTXUNLOCK(last);
  75                         return NIL(Sfpool_t*);
  76                 }
  77
  78                 (void)vtmtxopen(&p->mutex, VT_INIT); /* initialize mutex */
  79
  80                 p->mode = 0;
  81                 p->n_sf = 0;
  82                 p->next = NIL(Sfpool_t*);
  83                 last->next = p;
  84
  85                 POOLMTXUNLOCK(last);
  86         }
  87
  88         POOLMTXENTER(p);
  89
  90         p->mode = mode&SF_SHARE;
  91         p->s_sf = sizeof(p->array)/sizeof(p->array[0]);
  92         p->sf = p->array;
  93
  94         POOLMTXRETURN(p,p);
  95 }
  96
  97 /* move a stream to head */
  98 #if __STD_C
  99 static int _sfphead(Sfpool_t* p, Sfio_t* f, int n)
 100 #else
 101 static int _sfphead(p, f, n)
 102 Sfpool_t*       p;      /* the pool                     */
 103 Sfio_t*         f;      /* the stream                   */
 104 int             n;      /* current position in pool     */
 105 #endif
 106 {
 107         reg Sfio_t*     head;
 108         reg ssize_t     k, w, v;
 109         reg int         rv;
 110
 111         POOLMTXENTER(p);
 112
 113         if(n == 0)
 114                 POOLMTXRETURN(p,0);
 115
 116         head = p->sf[0];
 117         if(SFFROZEN(head) )
 118                 POOLMTXRETURN(p,-1);
 119
 120         SFLOCK(head,0);
 121         rv = -1;
 122
 123         if(!(p->mode&SF_SHARE) || (head->mode&SF_READ) || (f->mode&SF_READ) )
 124         {       if(SFSYNC(head) < 0)
 125                         goto done;
 126         }
 127         else    /* shared pool of write-streams, data can be moved among streams */
 128         {       if(SFMODE(head,1) != SF_WRITE && _sfmode(head,SF_WRITE,1) < 0)
 129                         goto done;
 130                 /**/ASSERT(f->next == f->data);
 131
 132                 v = head->next - head->data;    /* pending data         */
 133                 if((k = v - (f->endb-f->data)) <= 0)
 134                         k = 0;
 135                 else    /* try to write out amount exceeding f's capacity */
 136                 {       if((w = SFWR(head,head->data,k,head->disc)) == k)
 137                                 v -= k;
 138                         else    /* write failed, recover buffer then quit */
 139                         {       if(w > 0)
 140                                 {       v -= w;
 141                                         memcpy(head->data,(head->data+w),v);
 142                                 }
 143                                 head->next = head->data+v;
 144                                 goto done;
 145                         }
 146                 }
 147
 148                 /* move data from head to f */
 149                 if((head->data+k) != f->data )
 150                         memcpy(f->data,(head->data+k),v);
 151                 f->next = f->data+v;
 152         }
 153
 154         f->mode &= ~SF_POOL;
 155         head->mode |= SF_POOL;
 156         head->next = head->endr = head->endw = head->data; /* clear write buffer */
 157
 158         p->sf[n] = head;
 159         p->sf[0] = f;
 160         rv = 0;
 161
 162 done:
 163         head->mode &= ~SF_LOCK; /* partially unlock because it's no longer head */
 164
 165         POOLMTXRETURN(p,rv);
 166 }
 167
 168 /* delete a stream from its pool */
 169 #if __STD_C
 170 static int _sfpdelete(Sfpool_t* p, Sfio_t* f, int n)
 171 #else
 172 static int _sfpdelete(p, f, n)
 173 Sfpool_t*       p;      /* the pool             */
 174 Sfio_t*         f;      /* the stream           */
 175 int             n;      /* position in pool     */
 176 #endif
 177 {
 178         POOLMTXENTER(p);
 179
 180         p->n_sf -= 1;
 181         for(; n < p->n_sf; ++n)
 182                 p->sf[n] = p->sf[n+1];
 183
 184         f->pool = NIL(Sfpool_t*);
 185         f->mode &= ~SF_POOL;
 186
 187         if(p->n_sf == 0 || p == &_Sfpool)
 188         {       if(p != &_Sfpool)
 189                         delpool(p);
 190                 goto done;
 191         }
 192
 193         /* !_Sfpool, make sure head stream is an open stream */
 194         for(n = 0; n < p->n_sf; ++n)
 195                 if(!SFFROZEN(p->sf[n]))
 196                         break;
 197         if(n < p->n_sf && n > 0)
 198         {       f = p->sf[n];
 199                 p->sf[n] = p->sf[0];
 200                 p->sf[0] = f;
 201         }
 202
 203         /* head stream has SF_POOL off */
 204         f = p->sf[0];
 205         f->mode &= ~SF_POOL;
 206         if(!SFFROZEN(f))
 207                 _SFOPEN(f);
 208
 209         /* if only one stream left, delete pool */
 210         if(p->n_sf == 1 )
 211         {       _sfpdelete(p,f,0);
 212                 _sfsetpool(f);
 213         }
 214
 215 done:
 216         POOLMTXRETURN(p,0);
 217 }
 218
 219 #if __STD_C
 220 static int _sfpmove(reg Sfio_t* f, reg int type)
 221 #else
 222 static int _sfpmove(f,type)
 223 reg Sfio_t*     f;
 224 reg int         type;   /* <0 : deleting, 0: move-to-front, >0: inserting */
 225 #endif
 226 {
 227         reg Sfpool_t*   p;
 228         reg int         n;
 229
 230         if(type > 0)
 231                 return _sfsetpool(f);
 232         else
 233         {       if(!(p = f->pool) )
 234                         return -1;
 235                 for(n = p->n_sf-1; n >= 0; --n)
 236                         if(p->sf[n] == f)
 237                                 break;
 238                 if(n < 0)
 239                         return -1;
 240
 241                 return type == 0 ? _sfphead(p,f,n) : _sfpdelete(p,f,n);
 242         }
 243 }
 244
 245 #if __STD_C
 246 Sfio_t* sfpool(reg Sfio_t* f, reg Sfio_t* pf, reg int mode)
 247 #else
 248 Sfio_t* sfpool(f,pf,mode)
 249 reg Sfio_t*     f;
 250 reg Sfio_t*     pf;
 251 reg int         mode;
 252 #endif
 253 {
 254         int             k;
 255         Sfpool_t*       p;
 256         Sfio_t*         rv;
 257
 258         _Sfpmove = _sfpmove;
 259
 260         if(!f)  /* return head of pool of pf regardless of lock states */
 261         {       if(!pf)
 262                         return NIL(Sfio_t*);
 263                 else if(!pf->pool || pf->pool == &_Sfpool)
 264                         return pf;
 265                 else    return pf->pool->sf[0];
 266         }
 267
 268         if(f)   /* check for permissions */
 269         {       SFMTXLOCK(f);
 270                 if((f->mode&SF_RDWR) != f->mode && _sfmode(f,0,0) < 0)
 271                 {       SFMTXUNLOCK(f);
 272                         return NIL(Sfio_t*);
 273                 }
 274                 if(f->disc == _Sfudisc)
 275                         (void)sfclose((*_Sfstack)(f,NIL(Sfio_t*)));
 276         }
 277         if(pf)
 278         {       SFMTXLOCK(pf);
 279                 if((pf->mode&SF_RDWR) != pf->mode && _sfmode(pf,0,0) < 0)
 280                 {       if(f)
 281                                 SFMTXUNLOCK(f);
 282                         SFMTXUNLOCK(pf);
 283                         return NIL(Sfio_t*);
 284                 }
 285                 if(pf->disc == _Sfudisc)
 286                         (void)sfclose((*_Sfstack)(pf,NIL(Sfio_t*)));
 287         }
 288
 289         /* f already in the same pool with pf */
 290         if(f == pf || (pf && f->pool == pf->pool && f->pool != &_Sfpool) )
 291         {       if(f)
 292                         SFMTXUNLOCK(f);
 293                 if(pf)
 294                         SFMTXUNLOCK(pf);
 295                 return pf;
 296         }
 297
 298         /* lock streams before internal manipulations */
 299         rv = NIL(Sfio_t*);
 300         SFLOCK(f,0);
 301         if(pf)
 302                 SFLOCK(pf,0);
 303
 304         if(!pf) /* deleting f from its current pool */
 305         {       if((p = f->pool) != NIL(Sfpool_t*) && p != &_Sfpool)
 306                         for(k = 0; k < p->n_sf && pf == NIL(Sfio_t*); ++k)
 307                                 if(p->sf[k] != f) /* a stream != f represents the pool */
 308                                         pf = p->sf[k];
 309                 if(!pf) /* already isolated */
 310                 {       rv = f; /* just return self */
 311                         goto done;
 312                 }
 313
 314                 if(_sfpmove(f,-1) < 0 || _sfsetpool(f) < 0)
 315                         goto done; /* can't delete */
 316
 317                 if(!pf->pool || pf->pool == &_Sfpool || pf->pool->n_sf <= 0 )
 318                         rv = pf;
 319                 else    rv = pf->pool->sf[0];   /* return head of old pool */
 320                 goto done;
 321         }
 322
 323         if(pf->pool && pf->pool != &_Sfpool) /* always use current mode */
 324                 mode = pf->pool->mode;
 325
 326         if(mode&SF_SHARE) /* can only have write streams */
 327         {       if(SFMODE(f,1) != SF_WRITE && _sfmode(f,SF_WRITE,1) < 0)
 328                         goto done;
 329                 if(SFMODE(pf,1) != SF_WRITE && _sfmode(pf,SF_WRITE,1) < 0)
 330                         goto done;
 331                 if(f->next > f->data && SFSYNC(f) < 0) /* start f clean */
 332                         goto done;
 333         }
 334
 335         if(_sfpmove(f,-1) < 0)  /* isolate f from current pool */
 336                 goto done;
 337
 338         if(!(p = pf->pool) || p == &_Sfpool) /* making a new pool */
 339         {       if(!(p = newpool(mode)) )
 340                         goto done;
 341                 if(_sfpmove(pf,-1) < 0) /* isolate pf from its current pool */
 342                         goto done;
 343                 pf->pool = p;
 344                 p->sf[0] = pf;
 345                 p->n_sf += 1;
 346         }
 347
 348         f->pool = p;    /* add f to pf's pool */
 349         if(_sfsetpool(f) < 0)
 350                 goto done;
 351
 352         /**/ASSERT(p->sf[0] == pf && p->sf[p->n_sf-1] == f);
 353         SFOPEN(pf,0);
 354         SFOPEN(f,0);
 355         if(_sfpmove(f,0) < 0) /* make f head of pool */
 356                 goto done;
 357         rv = pf;
 358
 359 done:
 360         if(f)
 361         {       SFOPEN(f,0);
 362                 SFMTXUNLOCK(f);
 363         }
 364         if(pf)
 365         {       SFOPEN(pf,0);
 366                 SFMTXUNLOCK(pf);
 367         }
 368         return rv;
 369 }