usr/src/lib/libast/common/sfio/sfseek.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 /*      Set the IO pointer to a specific location in the stream
  25 **
  26 **      Written by Kiem-Phong Vo.
  27 */
  28
  29 #if __STD_C
  30 static void newpos(Sfio_t* f, Sfoff_t p)
  31 #else
  32 static void newpos(f, p)
  33 Sfio_t* f;
  34 Sfoff_t p;
  35 #endif
  36 {
  37 #ifdef MAP_TYPE
  38         if((f->bits&SF_MMAP) && f->data)
  39         {       SFMUNMAP(f, f->data, f->endb-f->data);
  40                 f->data = NIL(uchar*);
  41         }
  42 #endif
  43         f->next = f->endr = f->endw = f->data;
  44         f->endb = (f->mode&SF_WRITE) ? f->data+f->size : f->data;
  45         if((f->here = p) < 0)
  46         {       f->extent = -1;
  47                 f->here = 0;
  48         }
  49 }
  50
  51 #if __STD_C
  52 Sfoff_t sfseek(Sfio_t* f, Sfoff_t p, int type)
  53 #else
  54 Sfoff_t sfseek(f,p,type)
  55 Sfio_t* f;      /* seek to a new location in this stream */
  56 Sfoff_t p;      /* place to seek to */
  57 int     type;   /* 0: from org, 1: from here, 2: from end */
  58 #endif
  59 {
  60         Sfoff_t r, s;
  61         int     mode, local, hardseek, mustsync;
  62         SFMTXDECL(f);
  63
  64         SFMTXENTER(f, (Sfoff_t)(-1));
  65
  66         GETLOCAL(f,local);
  67
  68         hardseek = (type|f->flags)&(SF_SHARE|SF_PUBLIC);
  69
  70         if(hardseek && f->mode == (SF_READ|SF_SYNCED) )
  71         {       newpos(f,f->here);
  72                 f->mode = SF_READ;
  73         }
  74
  75         /* set and initialize the stream to a definite mode */
  76         if((int)SFMODE(f,local) != (mode = f->mode&SF_RDWR))
  77         {       int     flags = f->flags;
  78
  79                 if(hardseek&SF_PUBLIC) /* seek ptr must follow file descriptor */
  80                         f->flags |= SF_SHARE|SF_PUBLIC;
  81                 mode = _sfmode(f,mode,local);
  82                 if(hardseek&SF_PUBLIC)
  83                         f->flags = flags;
  84
  85                 if(mode < 0)
  86                         SFMTXRETURN(f, (Sfoff_t)(-1));
  87         }
  88
  89         mustsync = (type&SF_SHARE) && !(type&SF_PUBLIC) &&
  90                    (f->mode&SF_READ) && !(f->flags&SF_STRING);
  91
  92         /* Xopen-compliant */
  93         if((type &= (SEEK_SET|SEEK_CUR|SEEK_END)) != SEEK_SET &&
  94            type != SEEK_CUR && type != SEEK_END )
  95         {       errno = EINVAL;
  96                 SFMTXRETURN(f, (Sfoff_t)(-1));
  97         }
  98
  99         if(f->extent < 0)
 100         {       /* let system call set errno */
 101                 (void)SFSK(f,(Sfoff_t)0,SEEK_CUR,f->disc);
 102                 SFMTXRETURN(f, (Sfoff_t)(-1));
 103         }
 104
 105         /* throw away ungetc data */
 106         if(f->disc == _Sfudisc)
 107                 (void)sfclose((*_Sfstack)(f,NIL(Sfio_t*)));
 108
 109         /* lock the stream for internal manipulations */
 110         SFLOCK(f,local);
 111
 112         /* clear error and eof bits */
 113         f->flags &= ~(SF_EOF|SF_ERROR);
 114
 115         while(f->flags&SF_STRING)
 116         {       SFSTRSIZE(f);
 117
 118                 if(type == SEEK_CUR)
 119                         r = p + (f->next - f->data);
 120                 else if(type == SEEK_END)
 121                         r = p + f->extent;
 122                 else    r = p;
 123
 124                 if(r >= 0 && r <= f->size)
 125                 {       p = r;
 126                         f->next = f->data+p;
 127                         f->here = p;
 128                         if(p > f->extent)
 129                                 memclear((char*)(f->data+f->extent),(int)(p-f->extent));
 130                         goto done;
 131                 }
 132
 133                 /* check exception handler, note that this may pop stream */
 134                 if(SFSK(f,r,SEEK_SET,f->disc) != r)
 135                 {       p = -1;
 136                         goto done;
 137                 }
 138                 else if(!(f->flags&SF_STRING))
 139                 {       p = r;
 140                         goto done;
 141                 }
 142         }
 143
 144         if(f->mode&SF_WRITE)
 145         {       /* see if we can avoid flushing buffer */
 146                 if(!hardseek && type < SEEK_END && !(f->flags&SF_APPENDWR) )
 147                 {       s = f->here + (f->next - f->data);
 148                         r = p + (type == SEEK_SET ? 0 : s);
 149                         if(r == s)
 150                         {       p = r;
 151                                 goto done;
 152                         }
 153                 }
 154
 155                 if(f->next > f->data && SFSYNC(f) < 0)
 156                 {       p = -1;
 157                         goto done;
 158                 }
 159         }
 160
 161         if(type == SEEK_END || (f->mode&SF_WRITE) )
 162         {       if((hardseek&SF_PUBLIC) || type == SEEK_END)
 163                         p = SFSK(f, p, type, f->disc);
 164                 else
 165                 {       r = p + (type == SEEK_CUR ? f->here : 0);
 166                         p = (hardseek || r != f->here) ? SFSK(f,r,SEEK_SET,f->disc) : r;
 167                 }
 168                 if(p >= 0)
 169                         newpos(f,p);
 170
 171                 goto done;
 172         }
 173
 174         /* if get here, must be a read stream */
 175         s = f->here - (f->endb - f->next);
 176         r = p + (type == SEEK_CUR ? s : 0);
 177         if(r <= f->here && r >= (f->here - (f->endb-f->data)) )
 178         {       if((hardseek || (type == SEEK_CUR && p == 0)) )
 179                 {       if((s = SFSK(f, (Sfoff_t)0, SEEK_CUR, f->disc)) == f->here ||
 180                            (s >= 0 && !(hardseek&SF_PUBLIC) &&
 181                             (s = SFSK(f, f->here, SEEK_SET, f->disc)) == f->here) )
 182                                 goto near_done;
 183                         else if(s < 0)
 184                         {       p = -1;
 185                                 goto done;
 186                         }
 187                         else
 188                         {       newpos(f,s);
 189                                 hardseek = 0;
 190                         }
 191                 }
 192                 else
 193                 { near_done:
 194                         f->next = f->endb - (f->here - r);
 195                         p = r;
 196                         goto done;
 197                 }
 198         }
 199
 200         /* desired position */
 201         if((p += type == SEEK_CUR ? s : 0) < 0)
 202                 goto done;
 203
 204 #ifdef MAP_TYPE
 205         if(f->bits&SF_MMAP)
 206         {       /* if mmap is not great, stop mmaping if moving around too much */
 207 #if _mmap_worthy < 2
 208                 if((f->next - f->data) < ((f->endb - f->data)/4) )
 209                 {       SFSETBUF(f,(Void_t*)f->tiny,(size_t)SF_UNBOUND);
 210                         hardseek = 1; /* this forces a hard seek below */
 211                 }
 212                 else
 213 #endif
 214                 {       /* for mmap, f->here can be virtual except for hardseek */
 215                         newpos(f,p);
 216                         if(!hardseek)
 217                                 goto done;
 218                 }
 219         }
 220 #endif
 221
 222         if(f->endb > f->next)
 223         {       /* reduce wastage in future buffer fillings */
 224                 f->iosz = (f->next - f->data) + (f->endb - f->next)/2;
 225                 f->iosz = ((f->iosz + f->blksz-1)/f->blksz)*f->blksz;
 226         }
 227         if(f->iosz >= f->size)
 228                 f->iosz = 0;
 229
 230         /* buffer is now considered empty */
 231         f->next = f->endr = f->endb = f->data;
 232
 233         /* small backseeks often come in bunches, so seek back as far as possible */
 234         if(p < f->lpos && f->size > f->blksz && (p + f->blksz) > s)
 235         {       if((r = s - f->size) < 0)
 236                         r = 0;
 237         }
 238         /* try to align buffer to block boundary to enhance I/O speed */
 239         else if(f->blksz > 0 && f->size >= 2*f->blksz)
 240                 r = p - (p%f->blksz);
 241         else
 242         {       r = p;
 243
 244                 /* seeking around and wasting data, be conservative */
 245                 if(f->iosz > 0 && (p > f->lpos || p < f->lpos-f->size) )
 246                         f->bits |= SF_JUSTSEEK;
 247         }
 248
 249         if((hardseek || r != f->here) && (f->here = SFSK(f,r,SEEK_SET,f->disc)) != r)
 250         {       if(r < p) /* now try to just get to p */
 251                         f->here = SFSK(f,p,SEEK_SET,f->disc);
 252                 if(f->here != p)
 253                         p = -1;
 254                 goto done;
 255         }
 256
 257         if(r < p) /* read to cover p */
 258         {       (void)SFRD(f, f->data, f->size, f->disc);
 259                 if(p <= f->here && p >= (f->here - (f->endb - f->data)) )
 260                         f->next = f->endb - (size_t)(f->here-p);
 261                 else /* recover from read failure by just seeking to p */
 262                 {       f->next = f->endb = f->data;
 263                         if((f->here = SFSK(f,p,SEEK_SET,f->disc)) != p)
 264                                 p = -1;
 265                 }
 266         }
 267
 268 done :
 269         if(f->here < 0) /* hasn't been the best of time */
 270         {       f->extent = -1;
 271                 f->here = 0;
 272         }
 273
 274         f->lpos = p;
 275
 276         SFOPEN(f,local);
 277
 278         if(mustsync)
 279                 sfsync(f);
 280         SFMTXRETURN(f, p);
 281 }