probe_file/da_io_stdc.c

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Jaewon Lim <jaewon81.lim@samsung.com>
   9  * Woojin Jung <woojin2.jung@samsung.com>
  10  * Juyoung Kim <j0.kim@samsung.com>
  11  * Anastasia Lyupa <a.lyupa@samsung.com>
  12  *
  13  * This library is free software; you can redistribute it and/or modify it under
  14  * the terms of the GNU Lesser General Public License as published by the
  15  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  16  * any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  20  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  21  * License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  25  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  26  *
  27  * Contributors:
  28  * - S-Core Co., Ltd
  29  * - Samsung RnD Institute Russia
  30  *
  31  */
  32
  33 #include <stdio.h>
  34 #include <stdarg.h>
  35 #include <string.h>
  36 #include <stdlib.h>
  37 #include <dlfcn.h>
  38 #include <errno.h>
  39 #include "daprobe.h"
  40 #include "probeinfo.h"
  41 #include "dautil.h"
  42 #include "dahelper.h"
  43 #include "da_io.h"
  44
  45 #include "binproto.h"
  46
  47 static enum DaOptions _sopt = OPT_FILE;
  48
  49 FILE* fopen(const char* filename, const char* mode)
  50 {
  51         static FILE* (*fopenp)(const char* filename, const char* mode);
  52         FILE* fret;
  53
  54         BEFORE_ORIGINAL_FILE_NOFILTER(fopen, LIBC);
  55         _filepath = (char*)filename;
  56
  57         fret = fopenp(filename, mode);
  58
  59         AFTER_PACK_ORIGINAL_FILEP(API_ID_fopen,
  60                                   fret, 0, fret, FD_API_OPEN, "ss", filename, mode);
  61
  62         return fret;
  63 }
  64
  65 FILE* freopen(const char * filename, const char * mode, FILE * stream)
  66 {
  67         static FILE* (*freopenp)(const char * filename, const char * mode, FILE * stream);
  68         FILE* fret;
  69
  70         BEFORE_ORIGINAL_FILE_NOFILTER(freopen, LIBC);
  71         _filepath = (char*)filename;
  72
  73         fret = freopenp(filename, mode, stream);
  74
  75         AFTER_PACK_ORIGINAL_FILEP(API_ID_freopen,
  76                                   fret, 0, fret, FD_API_OPEN, "ssp", filename, mode, stream);
  77
  78         return fret;
  79 }
  80
  81 FILE* fdopen(int fildes, const char *mode)
  82 {
  83         static FILE* (*fdopenp)(int fildes, const char *mode);
  84         FILE* fret;
  85
  86         BEFORE_ORIGINAL_FILE_NOFILTER(fdopen, LIBC);
  87
  88         fret = fdopenp(fildes, mode);
  89
  90         AFTER_PACK_ORIGINAL_FILEP(API_ID_fdopen,
  91                                   fret, 0, fret, FD_API_OPEN, "ds", fildes, mode);
  92
  93         return fret;
  94 }
  95
  96 int fflush(FILE* stream)
  97 {
  98         static int (*fflushp)(FILE* stream);
  99
 100         BEFORE_ORIGINAL_FILE(fflush, LIBC);
 101         ret = fflushp(stream);
 102         AFTER_PACK_ORIGINAL_FILEP(API_ID_fflush,
 103                                   ret, 0, stream, FD_API_OTHER, "p", stream);
 104         return ret;
 105 }
 106
 107 int fclose(FILE* stream)
 108 {
 109         static int (*fclosep)(FILE* stream);
 110         DECLARE_VARIABLE_FD;
 111
 112         GET_REAL_FUNC(fclose, LIBC);
 113
 114         bfiltering = false;
 115         PRE_PROBEBLOCK_BEGIN();
 116         GET_FD_FROM_FILEP(stream);
 117         if(_fd != -1) {
 118                 _fstatret = fstat(_fd, &_statbuf);
 119         }
 120         PRE_PROBEBLOCK_END();
 121
 122         ret = fclosep(stream);
 123
 124         POST_PACK_PROBEBLOCK_BEGIN();
 125         PREPARE_LOCAL_BUF();
 126         PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
 127                           API_ID_fclose,
 128                           "p", stream);
 129         PACK_COMMON_END(ret, newerrno, blockresult);
 130         POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, FD_API_CLOSE);
 131         POST_PACK_PROBEBLOCK_END();
 132
 133         return ret;
 134 }
 135
 136 int remove(const char* filename)
 137 {
 138         static int (*removep)(const char* filename);
 139
 140         BEFORE_ORIGINAL_FILE(remove, LIBC);
 141         _filepath = (char*)filename;
 142         ret = removep(filename);
 143         AFTER_PACK_ORIGINAL_NOFD(API_ID_remove,
 144                                  ret, 0, FD_API_DIRECTORY, "s", filename);
 145         return ret;
 146 }
 147
 148 int rename(const char* oldname, const char* newname)
 149 {
 150         static int (*renamep)(const char* oldname, const char* newname);
 151
 152         BEFORE_ORIGINAL_FILE(rename, LIBC);
 153         _filepath = (char*)newname;
 154         ret = renamep(oldname, newname);
 155         AFTER_PACK_ORIGINAL_NOFD(API_ID_rename,
 156                                  ret, 0, FD_API_DIRECTORY, "ss", oldname, newname);
 157         return ret;
 158 }
 159
 160 FILE * tmpfile ( void )
 161 {
 162         static FILE* (*tmpfilep) ( void );
 163         FILE* fret;
 164
 165         BEFORE_ORIGINAL_FILE_NOFILTER(tmpfile, LIBC);
 166         _filepath = "<temp file>";
 167         fret = tmpfilep();
 168         AFTER_PACK_ORIGINAL_FILEP(API_ID_tmpfile,
 169                                   fret, 0, fret, FD_API_OPEN, "s", "");
 170         return fret;
 171 }
 172
 173 int fgetpos(FILE* stream, fpos_t* position)
 174 {
 175         static int (*fgetposp)(FILE* stream, fpos_t* position);
 176
 177         BEFORE_ORIGINAL_FILE(fgetpos, LIBC);
 178         ret = fgetposp(stream, position);
 179         AFTER_PACK_ORIGINAL_FILEP(API_ID_fgetpos,
 180                                   ret, 0, stream, FD_API_OTHER, "pp", stream, position);
 181         return ret;
 182 }
 183
 184 int fseek(FILE* stream, long int offset, int origin)
 185 {
 186         static int (*fseekp)(FILE* stream, long int offset, int origin);
 187
 188         BEFORE_ORIGINAL_FILE(fseek, LIBC);
 189         ret = fseekp(stream, offset, origin);
 190         AFTER_PACK_ORIGINAL_FILEP(API_ID_fseek,
 191                                   ret, (unsigned int)offset, stream, FD_API_OTHER,
 192                                   "pxd", stream, offset, origin);
 193         return ret;
 194 }
 195
 196 int fsetpos(FILE* stream, const fpos_t* pos)
 197 {
 198         static int (*fsetposp)(FILE* stream, const fpos_t* pos);
 199
 200         BEFORE_ORIGINAL_FILE(fsetpos, LIBC);
 201         ret = fsetposp(stream, pos);
 202         AFTER_PACK_ORIGINAL_FILEP(API_ID_fsetpos,
 203                                   ret, 0, stream, FD_API_OTHER, "pp", stream, pos);
 204         return ret;
 205 }
 206
 207 long int ftell(FILE* stream)
 208 {
 209         static long int (*ftellp)(FILE* stream);
 210         long int lret;
 211
 212         BEFORE_ORIGINAL_FILE(ftell, LIBC);
 213
 214         lret = ftellp(stream);
 215
 216         AFTER_PACK_ORIGINAL_FILEP(API_ID_ftell,
 217                                   lret, 0, stream, FD_API_OTHER, "p", stream);
 218
 219         return lret;
 220 }
 221
 222 void rewind(FILE* stream)
 223 {
 224         static void (*rewindp)(FILE* stream);
 225
 226         BEFORE_ORIGINAL_FILE(rewind, LIBC);
 227
 228         rewindp(stream);
 229
 230         AFTER_PACK_ORIGINAL_FILEP(API_ID_rewind,
 231                                   0, 0, stream, FD_API_OTHER, "p", stream);
 232 }
 233
 234 void clearerr(FILE* stream)
 235 {
 236         static void (*clearerrp)(FILE* stream);
 237
 238         BEFORE_ORIGINAL_FILE(clearerr, LIBC);
 239
 240         clearerrp(stream);
 241
 242         AFTER_PACK_ORIGINAL_FILEP(API_ID_clearerr,
 243                                   0, 0, stream, FD_API_OTHER, "p", stream);
 244 }
 245
 246 int feof(FILE* stream)
 247 {
 248         static int (*feofp)(FILE* stream);
 249
 250         BEFORE_ORIGINAL_FILE(feof, LIBC);
 251         ret = feofp(stream);
 252         AFTER_PACK_ORIGINAL_FILEP(API_ID_feof,
 253                                   ret, 0, stream, FD_API_OTHER, "p", stream);
 254         return ret;
 255 }
 256
 257 int ferror(FILE* stream)
 258 {
 259         static int (*ferrorp)(FILE* stream);
 260
 261         BEFORE_ORIGINAL_FILE(ferror, LIBC);
 262         ret = ferrorp(stream);
 263         AFTER_PACK_ORIGINAL_FILEP(API_ID_ferror,
 264                                   ret, 0, stream, FD_API_OTHER, "p", stream);
 265         return ret;
 266 }
 267
 268 int fileno(FILE* stream)
 269 {
 270         static int (*filenop)(FILE* stream);
 271
 272         BEFORE_ORIGINAL_FILE(fileno, LIBC);
 273         ret = filenop(stream);
 274         AFTER_PACK_ORIGINAL_FILEP(API_ID_fileno,
 275                                   ret, 0, stream, FD_API_OTHER, "p", stream);
 276         return ret;
 277 }
 278
 279 void perror(const char* string)
 280 {
 281         static void (*perrorp)(const char* string);
 282
 283         BEFORE_ORIGINAL_FILE(perror, LIBC);
 284
 285         perrorp(string);
 286
 287         AFTER_PACK_ORIGINAL_NOFD(API_ID_perror,
 288                                  0, 0, FD_API_OTHER, "s", string);
 289 }
 290
 291 // *******************************************************************
 292 // File read / write APIs
 293 // *******************************************************************
 294
 295 int vfprintf(FILE* stream, const char* format, va_list arg)
 296 {
 297         static int (*vfprintfp)(FILE* stream, const char* format, va_list arg);
 298
 299         BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
 300         FILE_API_START_BLOCK(API_ID_vfprintf, FD_API_WRITE_START);
 301         ret = vfprintfp(stream, format, arg);
 302         AFTER_PACK_ORIGINAL_FILEP(API_ID_vfprintf,
 303                                   ret, ret, stream, FD_API_WRITE_END, "ps", stream, format);
 304         return ret;
 305 }
 306
 307 int vfscanf(FILE* stream, const char* format, va_list arg)
 308 {
 309         static int (*vfscanfp)(FILE* stream, const char* format, va_list arg);
 310
 311         BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
 312         FILE_API_START_BLOCK(API_ID_vfscanf, FD_API_READ_START);
 313         ret = vfscanfp(stream, format, arg);
 314         AFTER_PACK_ORIGINAL_FILEP(API_ID_vfscanf,
 315                                   ret, ret, stream, FD_API_READ_END, "ps", stream, format);
 316         return ret;
 317 }
 318
 319 int fgetc(FILE* stream)
 320 {
 321         static int (*fgetcp)(FILE* stream);
 322
 323         BEFORE_ORIGINAL_FILE(fgetc, LIBC);
 324         FILE_API_START_BLOCK(API_ID_fgetc, FD_API_READ_START);
 325         ret = fgetcp(stream);
 326         AFTER_PACK_ORIGINAL_FILEP(API_ID_fgetc,
 327                                   ret, (ret == EOF ? 0 : 1), stream, FD_API_READ_END, "p", stream);
 328         return ret;
 329 }
 330
 331 #if 0   // why is this commented?
 332 char* fgets(char* str, int size, FILE* stream)
 333 {
 334         static char* (*fgetsp)(char* str, int num, FILE* stream);
 335         char* cret;
 336
 337         BEFORE_ORIGINAL_FILE(fgets, LIBC);
 338
 339         FILE_API_START_BLOCK(API_ID_fgets, FD_API_READ_START);
 340
 341         cret = fgetsp(str, size, stream);
 342
 343         AFTER_PACK_ORIGINAL_FILEP(API_ID_fgets, cret, (ret == NULL ? 0 : strlen(cret)),
 344                         stream, FD_API_READ_END, "sdp", str, size, stream);
 345
 346         return cret;
 347 }
 348 #endif
 349
 350 int fputc(int character, FILE* stream)
 351 {
 352         static int (*fputcp)(int character, FILE* stream);
 353
 354         BEFORE_ORIGINAL_FILE(fputc, LIBC);
 355         FILE_API_START_BLOCK(API_ID_fputc, FD_API_WRITE_START);
 356         ret = fputcp(character, stream);
 357         AFTER_PACK_ORIGINAL_FILEP(API_ID_fputc,
 358                                   ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE_END,
 359                                   "dp", character, stream);
 360         return ret;
 361 }
 362
 363 int fputs(const char* str, FILE* stream)
 364 {
 365         static int (*fputsp)(const char* str, FILE* stream);
 366
 367         BEFORE_ORIGINAL_FILE(fputs, LIBC);
 368         FILE_API_START_BLOCK(API_ID_fputs, FD_API_WRITE_START);
 369         ret = fputsp(str, stream);
 370         AFTER_PACK_ORIGINAL_FILEP(API_ID_fputs,
 371                                   ret, ret, stream, FD_API_WRITE_END, "sp", str, stream);
 372         return ret;
 373 }
 374
 375 int getc(FILE* stream)
 376 {
 377         static int (*getcp)(FILE* stream);
 378
 379         BEFORE_ORIGINAL_FILE(getc, LIBC);
 380         FILE_API_START_BLOCK(API_ID_getc, FD_API_READ_START);
 381         ret = getcp(stream);
 382         AFTER_PACK_ORIGINAL_FILEP(API_ID_getc,
 383                                   ret, (ret == EOF ? 0 : 1), stream, FD_API_READ_END, "p", stream);
 384         return ret;
 385 }
 386
 387 int putc(int character, FILE* stream)
 388 {
 389         static int (*putcp)(int character, FILE* stream);
 390
 391         BEFORE_ORIGINAL_FILE(putc, LIBC);
 392         FILE_API_START_BLOCK(API_ID_putc, FD_API_WRITE_START);
 393         ret = putcp(character, stream);
 394         AFTER_PACK_ORIGINAL_FILEP(API_ID_putc,
 395                                   ret, (ret == EOF ? 0 : 1), stream, FD_API_WRITE_END,
 396                                   "dp", character, stream);
 397         return ret;
 398 }
 399
 400 int ungetc(int character, FILE* stream)
 401 {
 402         static int (*ungetcp)(int character, FILE* stream);
 403
 404         BEFORE_ORIGINAL_FILE(ungetc, LIBC);
 405         ret = ungetcp(character, stream);
 406         AFTER_PACK_ORIGINAL_FILEP(API_ID_ungetc,
 407                                   ret, 0, stream, FD_API_OTHER, "dp", character, stream);
 408         return ret;
 409 }
 410
 411 size_t fread(void* ptr, size_t size, size_t count, FILE* stream)
 412 {
 413         static size_t (*freadp)(void* ptr, size_t size, size_t count, FILE* stream);
 414         size_t tret;
 415
 416         BEFORE_ORIGINAL_FILE(fread, LIBC);
 417
 418         FILE_API_START_BLOCK(API_ID_fread, FD_API_READ_START);
 419
 420         tret = freadp(ptr, size, count, stream);
 421
 422         AFTER_PACK_ORIGINAL_FILEP(API_ID_fread,
 423                                   tret, 0, stream, FD_API_READ_END,
 424                                   "pxxp", ptr, size, count, stream);
 425
 426         return tret;
 427 }
 428
 429 size_t fwrite(const void* ptr, size_t size, size_t count, FILE* stream)
 430 {
 431         static size_t (*fwritep)(const void* ptr, size_t size, size_t count, FILE* stream);
 432         size_t tret;
 433
 434         BEFORE_ORIGINAL_FILE(fwrite, LIBC);
 435
 436         FILE_API_START_BLOCK(API_ID_fwrite, FD_API_WRITE_START);
 437
 438         tret = fwritep(ptr, size, count, stream);
 439
 440         AFTER_PACK_ORIGINAL_FILEP(API_ID_fwrite,
 441                                   tret, 0, stream, FD_API_WRITE_END,
 442                                   "pxxp", ptr, size, count, stream);
 443
 444         return tret;
 445 }
 446
 447 // *********************************************************
 448 // variable parameter function
 449 // *********************************************************
 450 int fprintf(FILE* stream, const char* format, ...)
 451 {
 452         static int (*vfprintfp)(FILE* stream, const char* format, ...);
 453
 454         BEFORE_ORIGINAL_FILE(vfprintf, LIBC);
 455
 456         FILE_API_START_BLOCK(API_ID_fprintf, FD_API_WRITE_START);
 457
 458         va_list arg;
 459         va_start(arg, format);
 460         ret = vfprintfp(stream, format, arg);
 461
 462         AFTER_PACK_ORIGINAL_FILEP(API_ID_fprintf,
 463                                   ret, ret, stream, FD_API_WRITE_END, "ps", stream, format);
 464         va_end(arg);
 465
 466         return ret;
 467 }
 468
 469 int fscanf(FILE* stream, const char* format, ...)
 470 {
 471         static int (*vfscanfp)(FILE* stream, const char* format, ...);
 472
 473         BEFORE_ORIGINAL_FILE(vfscanf, LIBC);
 474
 475         FILE_API_START_BLOCK(API_ID_fscanf, FD_API_READ_START);
 476
 477         va_list arg;
 478         va_start(arg, format);
 479         ret = vfscanfp(stream, format, arg);
 480
 481         AFTER_PACK_ORIGINAL_FILEP(API_ID_fscanf,
 482                                   ret, ret, stream, FD_API_READ_END, "ps", stream, format);
 483         va_end(arg);
 484
 485         return ret;
 486 }
 487
 488 #if !defined(DA_DEBUG_LOG) && !defined(PRINT_STDOUT)
 489 int printf(const char* format, ...)
 490 {
 491         static int (*vprintfp)(const char* format, ...);
 492
 493         BEFORE_ORIGINAL_FILE(vprintf, LIBC);
 494
 495         FILE_API_START_BLOCK(API_ID_printf, FD_API_WRITE_START);
 496
 497         va_list arg;
 498         va_start(arg, format);
 499         ret = vprintfp(format, arg);
 500
 501         AFTER_PACK_ORIGINAL_NOFD(API_ID_printf,
 502                                  ret, ret, FD_API_WRITE_END, "s", format);
 503         va_end(arg);
 504
 505         return ret;
 506 }
 507 #endif
 508
 509 int scanf(const char* format, ...)
 510 {
 511         static int (*vscanfp)(const char* format, ...);
 512
 513         BEFORE_ORIGINAL_FILE(vscanf, LIBC);
 514
 515         FILE_API_START_BLOCK(API_ID_scanf, FD_API_READ_START);
 516
 517         va_list arg;
 518         va_start(arg, format);
 519         ret = vscanfp(format, arg);
 520
 521         AFTER_PACK_ORIGINAL_NOFD(API_ID_scanf,
 522                                  ret, ret, FD_API_READ_END, "s", format);
 523         va_end(arg);
 524
 525         return ret;
 526 }
 527
 528 int getchar()
 529 {
 530         static int (*getcharp)();
 531
 532         BEFORE_ORIGINAL_FILE(getchar, LIBC);
 533         FILE_API_START_BLOCK(API_ID_getchar, FD_API_READ_START);
 534         ret = getcharp();
 535         AFTER_PACK_ORIGINAL_NOFD(API_ID_getchar,
 536                                  ret, (ret == EOF ? 0 : 1), FD_API_READ_END, "s", "");
 537         return ret;
 538 }
 539
 540 int putchar(int c)
 541 {
 542         static int (*putcharp)(int c);
 543
 544         BEFORE_ORIGINAL_FILE(putchar, LIBC);
 545         FILE_API_START_BLOCK(API_ID_putchar, FD_API_WRITE_START);
 546         ret = putcharp(c);
 547         AFTER_PACK_ORIGINAL_NOFD(API_ID_putchar,
 548                                  ret, (ret == EOF ? 0 : 1), FD_API_WRITE_END, "d", c);
 549         return ret;
 550 }
 551
 552 char* gets(char* str)
 553 {
 554         static char* (*getsp)(char* str);
 555         char* cret;
 556
 557         BEFORE_ORIGINAL_FILE(gets, LIBC);
 558
 559         FILE_API_START_BLOCK(API_ID_gets, FD_API_READ_START);
 560
 561         cret = getsp(str);
 562
 563         AFTER_PACK_ORIGINAL_NOFD(API_ID_gets,
 564                                  cret, strlen(cret), FD_API_READ_END, "s", str);
 565
 566         return cret;
 567 }
 568
 569 #if !defined(DA_DEBUG_LOG) && !defined(PRINT_STDOUT)
 570 int puts(const char* str)
 571 {
 572         static int (*putsp)(const char* str);
 573
 574         BEFORE_ORIGINAL_FILE(puts, LIBC);
 575         FILE_API_START_BLOCK(API_ID_puts, FD_API_WRITE_START);
 576         ret = putsp(str);
 577         AFTER_PACK_ORIGINAL_NOFD(API_ID_puts,
 578                                  ret, ret, FD_API_WRITE_END, "s", str);
 579         return ret;
 580 }
 581 #endif
 582
 583 char* tmpnam(char* str)
 584 {
 585         static char* (*tmpnamp)(char* str);
 586         char* cret;
 587
 588         BEFORE_ORIGINAL_FILE(tmpnam, LIBC);
 589
 590         cret = tmpnamp(str);
 591
 592         AFTER_PACK_ORIGINAL_NOFD(API_ID_tmpnam,
 593                                  cret, 0, FD_API_OTHER, "s", str);
 594
 595         return cret;
 596 }
 597
 598 void setbuf(FILE* stream, char* buf)
 599 {
 600         static void (*setbufp)(FILE* stream, char* buf);
 601
 602         BEFORE_ORIGINAL_FILE(setbuf, LIBC);
 603
 604         setbufp(stream, buf);
 605
 606         AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuf,
 607                                   0, 0, stream, FD_API_OTHER, "pp", stream, buf);
 608 }
 609
 610 void setbuffer(FILE* stream, char* buf, size_t size)
 611 {
 612         static void (*setbufferp)(FILE* stream, char* buf, size_t size);
 613
 614         BEFORE_ORIGINAL_FILE(setbuffer, LIBC);
 615
 616         setbufferp(stream, buf, size);
 617
 618         AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuffer,
 619                                   0, size, stream, FD_API_OTHER,
 620                                   "ppx", stream, buf, size);
 621 }
 622
 623 void setlinebuf(FILE* stream)
 624 {
 625         static int (*setlinebufp)(FILE* stream);
 626
 627         BEFORE_ORIGINAL_FILE(setlinebuf, LIBC);
 628
 629         setlinebufp(stream);
 630
 631         AFTER_PACK_ORIGINAL_FILEP(API_ID_setlinebuf,
 632                                   0, 0, stream, FD_API_OTHER, "p", stream);
 633 }
 634
 635 int setvbuf(FILE* stream, char* buf, int mode, size_t size)
 636 {
 637         static int (*setvbufp)(FILE* stream, char* buf, int mode, size_t size);
 638
 639         BEFORE_ORIGINAL_FILE(setvbuf, LIBC);
 640         ret = setvbufp(stream,buf,mode,size);
 641         AFTER_PACK_ORIGINAL_FILEP(API_ID_setvbuf,
 642                                   ret, size, stream, FD_API_OTHER,
 643                                   "ppdx", stream, buf, mode, size);
 644         return ret;
 645 }
 646