lib/fastbuf.h

   1 /*
   2  *      UCW Library -- Fast Buffered I/O
   3  *
   4  *      (c) 1997--2004 Martin Mares <mj@ucw.cz>
   5  *      (c) 2004 Robert Spalek <robert@ucw.cz>
   6  *
   7  *      This software may be freely distributed and used according to the terms
   8  *      of the GNU Lesser General Public License.
   9  */
  10
  11 #ifndef _UCW_FASTBUF_H
  12 #define _UCW_FASTBUF_H
  13
  14 #ifndef EOF
  15 #include <stdio.h>
  16 #endif
  17
  18 #include <string.h>
  19 #include <alloca.h>
  20
  21 #include "lib/unaligned.h"
  22
  23 /*
  24  *  Generic buffered I/O. You supply hooks to be called for low-level operations
  25  *  (swapping of buffers, seeking and closing), we do the rest.
  26  *
  27  *  Buffer layout when reading:
  28  *
  29  *  +----------------+---------------------------+
  30  *  | read data      | free space                |
  31  *  +----------------+---------------------------+
  32  *  ^        ^        ^                           ^
  33  *  buffer   bptr     bstop                       bufend
  34  *
  35  *  After the last character is read, bptr == bstop and buffer refill
  36  *  is deferred to the next read attempt. This gives us an easy way
  37  *  how to implement bungetc().
  38  *
  39  *  When writing:
  40  *
  41  *  +--------+--------------+--------------------+
  42  *  | unused | written data | free space         |
  43  *  +--------+--------------+--------------------+
  44  *  ^         ^              ^                    ^
  45  *  buffer    bstop          bptr                 bufend
  46  *
  47  *  Dirty tricks:
  48  *
  49  *    - You can mix reads and writes on the same stream, but you must
  50  *      call bflush() in between and remember that the file position
  51  *      points after the flushed buffer which is not necessarily the same
  52  *      as after the data you've read.
  53  *    - The spout/refill hooks can change not only bptr and bstop, but also
  54  *      the location of the buffer; fb-mem.c takes advantage of it.
  55  *    - In some cases, the user of the bdirect interface can be allowed to modify
  56  *      the data in the buffer to avoid unnecessary copying. If the back-end
  57  *      allows such modifications, it can set can_overwrite_buffer accordingly:
  58  *              *  0 if no modification is allowed,
  59  *              *  1 if the user can modify the buffer on the condition that
  60  *                   the modifications will be undone before calling the next
  61  *                   fastbuf operation
  62  *              *  2 if the user is allowed to overwrite the data in the buffer
  63  *                   if bdirect_read_commit_modified() is called afterwards.
  64  *                   In this case, the back-end must be prepared for trimming
  65  *                   of the buffer which is done by the commit function.
  66  */
  67
  68 struct fastbuf {
  69   byte is_fastbuf[0];                   /* Dummy field for checking of type casts */
  70   byte *bptr, *bstop;                   /* Access pointers */
  71   byte *buffer, *bufend;                /* Start and end of the buffer */
  72   byte *name;                           /* File name for error messages */
  73   sh_off_t pos;                         /* Position of bstop in the file */
  74   int (*refill)(struct fastbuf *);      /* Get a buffer with new data */
  75   void (*spout)(struct fastbuf *);      /* Write buffer data to the file */
  76   void (*seek)(struct fastbuf *, sh_off_t, int);  /* Slow path for bseek(), buffer already flushed */
  77   void (*close)(struct fastbuf *);      /* Close the stream */
  78   int (*config)(struct fastbuf *, uns, int);    /* Configure the stream */
  79   int can_overwrite_buffer;             /* Can the buffer be altered? (see discussion above) 0=never, 1=temporarily, 2=permanently */
  80 };
  81
  82 /* FastIO on standard files (specify buffer size 0 to enable mmaping) */
  83
  84 struct fastbuf *bopen(byte *name, uns mode, uns buflen);
  85 struct fastbuf *bopen_try(byte *name, uns mode, uns buflen);
  86 struct fastbuf *bopen_tmp(uns buflen);
  87 struct fastbuf *bfdopen(int fd, uns buflen);
  88 struct fastbuf *bfdopen_shared(int fd, uns buflen);
  89 void bfilesync(struct fastbuf *b);
  90
  91 #define TEMP_FILE_NAME_LEN 256
  92 void temp_file_name(byte *name);
  93
  94 /* FastIO on in-memory streams */
  95
  96 struct fastbuf *fbmem_create(unsigned blocksize);       /* Create stream and return its writing fastbuf */
  97 struct fastbuf *fbmem_clone_read(struct fastbuf *);     /* Create reading fastbuf */
  98
  99 /* FastIO on memory mapped files */
 100
 101 struct fastbuf *bopen_mm(byte *name, uns mode);
 102
 103 /* FastIO on files opened with O_DIRECT (see fb-direct.c for description) */
 104
 105 struct asio_queue;
 106 struct fastbuf *fbdir_open(byte *name, uns mode, struct asio_queue *io_queue);
 107 struct fastbuf *fbdir_open_try(byte *name, uns mode, struct asio_queue *io_queue);
 108 struct fastbuf *fbdir_open_fd(int fd, struct asio_queue *io_queue);
 109 struct fastbuf *fbdir_open_tmp(struct asio_queue *io_queue);
 110
 111 /* FastI on file descriptors with limit */
 112
 113 struct fastbuf *bopen_limited_fd(int fd, uns bufsize, uns limit);
 114
 115 /* FastIO on static buffers */
 116
 117 void fbbuf_init_read(struct fastbuf *f, byte *buffer, uns size, uns can_overwrite);
 118 void fbbuf_init_write(struct fastbuf *f, byte *buffer, uns size);
 119 static inline uns
 120 fbbuf_count_written(struct fastbuf *f)
 121 {
 122   return f->bptr - f->bstop;
 123 }
 124
 125 /* FastIO on recyclable growing buffers */
 126
 127 struct fastbuf *fbgrow_create(unsigned basic_size);
 128 void fbgrow_reset(struct fastbuf *b);                   /* Reset stream and prepare for writing */
 129 void fbgrow_rewind(struct fastbuf *b);                  /* Prepare for reading */
 130
 131 /* FastO with atomic writes for multi-threaded programs */
 132
 133 struct fb_atomic {
 134   struct fastbuf fb;
 135   struct fb_atomic_file *af;
 136   byte *expected_max_bptr;
 137   uns slack_size;
 138 };
 139 #define FB_ATOMIC(f) ((struct fb_atomic *)(f)->is_fastbuf)
 140
 141 struct fastbuf *fbatomic_open(byte *name, struct fastbuf *master, uns bufsize, int record_len);
 142 void fbatomic_internal_write(struct fastbuf *b);
 143
 144 static inline void
 145 fbatomic_commit(struct fastbuf *b)
 146 {
 147   if (b->bptr >= ((struct fb_atomic *)b)->expected_max_bptr)
 148     fbatomic_internal_write(b);
 149 }
 150
 151 /* Configuring stream parameters */
 152
 153 int bconfig(struct fastbuf *f, uns type, int data);
 154
 155 #define BCONFIG_IS_TEMP_FILE 0
 156
 157 /* Universal functions working on all fastbuf's */
 158
 159 void bclose(struct fastbuf *f);
 160 void bflush(struct fastbuf *f);
 161 void bseek(struct fastbuf *f, sh_off_t pos, int whence);
 162 void bsetpos(struct fastbuf *f, sh_off_t pos);
 163 void brewind(struct fastbuf *f);
 164 sh_off_t bfilesize(struct fastbuf *f);
 165
 166 static inline sh_off_t btell(struct fastbuf *f)
 167 {
 168   return f->pos + (f->bptr - f->bstop);
 169 }
 170
 171 int bgetc_slow(struct fastbuf *f);
 172 static inline int bgetc(struct fastbuf *f)
 173 {
 174   return (f->bptr < f->bstop) ? (int) *f->bptr++ : bgetc_slow(f);
 175 }
 176
 177 int bpeekc_slow(struct fastbuf *f);
 178 static inline int bpeekc(struct fastbuf *f)
 179 {
 180   return (f->bptr < f->bstop) ? (int) *f->bptr : bpeekc_slow(f);
 181 }
 182
 183 static inline void bungetc(struct fastbuf *f)
 184 {
 185   f->bptr--;
 186 }
 187
 188 void bputc_slow(struct fastbuf *f, uns c);
 189 static inline void bputc(struct fastbuf *f, uns c)
 190 {
 191   if (f->bptr < f->bufend)
 192     *f->bptr++ = c;
 193   else
 194     bputc_slow(f, c);
 195 }
 196
 197 static inline uns
 198 bavailr(struct fastbuf *f)
 199 {
 200   return f->bstop - f->bptr;
 201 }
 202
 203 static inline uns
 204 bavailw(struct fastbuf *f)
 205 {
 206   return f->bufend - f->bptr;
 207 }
 208
 209 int bgetw_slow(struct fastbuf *f);
 210 static inline int bgetw(struct fastbuf *f)
 211 {
 212   int w;
 213   if (bavailr(f) >= 2)
 214     {
 215       w = GET_U16(f->bptr);
 216       f->bptr += 2;
 217       return w;
 218     }
 219   else
 220     return bgetw_slow(f);
 221 }
 222
 223 u32 bgetl_slow(struct fastbuf *f);
 224 static inline u32 bgetl(struct fastbuf *f)
 225 {
 226   u32 l;
 227   if (bavailr(f) >= 4)
 228     {
 229       l = GET_U32(f->bptr);
 230       f->bptr += 4;
 231       return l;
 232     }
 233   else
 234     return bgetl_slow(f);
 235 }
 236
 237 u64 bgetq_slow(struct fastbuf *f);
 238 static inline u64 bgetq(struct fastbuf *f)
 239 {
 240   u64 l;
 241   if (bavailr(f) >= 8)
 242     {
 243       l = GET_U64(f->bptr);
 244       f->bptr += 8;
 245       return l;
 246     }
 247   else
 248     return bgetq_slow(f);
 249 }
 250
 251 u64 bget5_slow(struct fastbuf *f);
 252 static inline u64 bget5(struct fastbuf *f)
 253 {
 254   u64 l;
 255   if (bavailr(f) >= 5)
 256     {
 257       l = GET_U40(f->bptr);
 258       f->bptr += 5;
 259       return l;
 260     }
 261   else
 262     return bget5_slow(f);
 263 }
 264
 265 void bputw_slow(struct fastbuf *f, uns w);
 266 static inline void bputw(struct fastbuf *f, uns w)
 267 {
 268   if (bavailw(f) >= 2)
 269     {
 270       PUT_U16(f->bptr, w);
 271       f->bptr += 2;
 272     }
 273   else
 274     bputw_slow(f, w);
 275 }
 276
 277 void bputl_slow(struct fastbuf *f, u32 l);
 278 static inline void bputl(struct fastbuf *f, u32 l)
 279 {
 280   if (bavailw(f) >= 4)
 281     {
 282       PUT_U32(f->bptr, l);
 283       f->bptr += 4;
 284     }
 285   else
 286     bputl_slow(f, l);
 287 }
 288
 289 void bputq_slow(struct fastbuf *f, u64 l);
 290 static inline void bputq(struct fastbuf *f, u64 l)
 291 {
 292   if (bavailw(f) >= 8)
 293     {
 294       PUT_U64(f->bptr, l);
 295       f->bptr += 8;
 296     }
 297   else
 298     bputq_slow(f, l);
 299 }
 300
 301 void bput5_slow(struct fastbuf *f, u64 l);
 302 static inline void bput5(struct fastbuf *f, u64 l)
 303 {
 304   if (bavailw(f) >= 5)
 305     {
 306       PUT_U40(f->bptr, l);
 307       f->bptr += 5;
 308     }
 309   else
 310     bput5_slow(f, l);
 311 }
 312
 313 uns bread_slow(struct fastbuf *f, void *b, uns l, uns check);
 314 static inline uns bread(struct fastbuf *f, void *b, uns l)
 315 {
 316   if (bavailr(f) >= l)
 317     {
 318       memcpy(b, f->bptr, l);
 319       f->bptr += l;
 320       return l;
 321     }
 322   else
 323     return bread_slow(f, b, l, 0);
 324 }
 325
 326 static inline uns breadb(struct fastbuf *f, void *b, uns l)
 327 {
 328   if (bavailr(f) >= l)
 329     {
 330       memcpy(b, f->bptr, l);
 331       f->bptr += l;
 332       return l;
 333     }
 334   else
 335     return bread_slow(f, b, l, 1);
 336 }
 337
 338 void bwrite_slow(struct fastbuf *f, void *b, uns l);
 339 static inline void bwrite(struct fastbuf *f, void *b, uns l)
 340 {
 341   if (bavailw(f) >= l)
 342     {
 343       memcpy(f->bptr, b, l);
 344       f->bptr += l;
 345     }
 346   else
 347     bwrite_slow(f, b, l);
 348 }
 349
 350 byte *bgets(struct fastbuf *f, byte *b, uns l); /* Non-std */
 351 int bgets_nodie(struct fastbuf *f, byte *b, uns l);
 352 byte *bgets0(struct fastbuf *f, byte *b, uns l);
 353
 354 struct mempool;
 355 struct bb_t;
 356 uns bgets_bb(struct fastbuf *f, struct bb_t *b, uns limit);
 357 byte *bgets_mp(struct fastbuf *f, struct mempool *mp);
 358
 359 struct bgets_stk_struct {
 360   struct fastbuf *f;
 361   byte *old_buf, *cur_buf, *src;
 362   uns old_len, cur_len, src_len;
 363 };
 364 void bgets_stk_init(struct bgets_stk_struct *s);
 365 void bgets_stk_step(struct bgets_stk_struct *s);
 366 #define bgets_stk(fb) ({ struct bgets_stk_struct _s; _s.f = (fb); for (bgets_stk_init(&_s); _s.cur_len; _s.cur_buf = alloca(_s.cur_len), bgets_stk_step(&_s)); _s.cur_buf; })
 367
 368 static inline void
 369 bputs(struct fastbuf *f, byte *b)
 370 {
 371   bwrite(f, b, strlen(b));
 372 }
 373
 374 static inline void
 375 bputs0(struct fastbuf *f, byte *b)
 376 {
 377   bwrite(f, b, strlen(b)+1);
 378 }
 379
 380 static inline void
 381 bputsn(struct fastbuf *f, byte *b)
 382 {
 383   bputs(f, b);
 384   bputc(f, '\n');
 385 }
 386
 387 void bbcopy_slow(struct fastbuf *f, struct fastbuf *t, uns l);
 388 static inline void
 389 bbcopy(struct fastbuf *f, struct fastbuf *t, uns l)
 390 {
 391   if (bavailr(f) >= l && bavailw(t) >= l)
 392     {
 393       memcpy(t->bptr, f->bptr, l);
 394       t->bptr += l;
 395       f->bptr += l;
 396     }
 397   else
 398     bbcopy_slow(f, t, l);
 399 }
 400
 401 int bskip_slow(struct fastbuf *f, uns len);
 402 static inline int bskip(struct fastbuf *f, uns len)
 403 {
 404   if (bavailr(f) >= len)
 405     {
 406       f->bptr += len;
 407       return 1;
 408     }
 409   else
 410     return bskip_slow(f, len);
 411 }
 412
 413 /* I/O on addr_int_t */
 414
 415 #ifdef CPU_64BIT_POINTERS
 416 #define bputa(x,p) bputq(x,p)
 417 #define bgeta(x) bgetq(x)
 418 #else
 419 #define bputa(x,p) bputl(x,p)
 420 #define bgeta(x) bgetl(x)
 421 #endif
 422
 423 /* Direct I/O on buffers */
 424
 425 static inline uns
 426 bdirect_read_prepare(struct fastbuf *f, byte **buf)
 427 {
 428   if (f->bptr == f->bstop && !f->refill(f))
 429     {
 430       *buf = NULL;  // This is not needed, but it helps to get rid of spurious warnings
 431       return 0;
 432     }
 433   *buf = f->bptr;
 434   return bavailr(f);
 435 }
 436
 437 static inline void
 438 bdirect_read_commit(struct fastbuf *f, byte *pos)
 439 {
 440   f->bptr = pos;
 441 }
 442
 443 static inline void
 444 bdirect_read_commit_modified(struct fastbuf *f, byte *pos)
 445 {
 446   f->bptr = pos;
 447   f->buffer = pos;      /* Avoid seeking backwards in the buffer */
 448 }
 449
 450 static inline uns
 451 bdirect_write_prepare(struct fastbuf *f, byte **buf)
 452 {
 453   if (f->bptr == f->bufend)
 454     f->spout(f);
 455   *buf = f->bptr;
 456   return bavailw(f);
 457 }
 458
 459 static inline void
 460 bdirect_write_commit(struct fastbuf *f, byte *pos)
 461 {
 462   f->bptr = pos;
 463 }
 464
 465 /* Formatted output */
 466
 467 int bprintf(struct fastbuf *b, char *msg, ...) FORMAT_CHECK(printf,2,3);
 468 int vbprintf(struct fastbuf *b, char *msg, va_list args);
 469
 470 #endif