/* Copyright (c) 2008, 2025, Oracle and/or its affiliates.

  This program is free software; you can redistribute it and/or modify

  it under the terms of the GNU General Public License, version 2.0,

  as published by the Free Software Foundation.

  This program is designed to work with certain software (including

  but not limited to OpenSSL) that is licensed under separate terms,

  as designated in a particular file or component or in included license

  documentation.  The authors of MySQL hereby grant you an additional

  permission to link the program and your derivative works with the

  separately licensed software that they have either included with

  the program or referenced in the documentation.

  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License, version 2.0, for more details.

  You should have received a copy of the GNU General Public License

  along with this program; if not, write to the Free Software

  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */

/**

  @file include/mysql/psi/mysql_file.h

  Instrumentation helpers for mysys file io.

  This header file provides the necessary declarations

  to use the mysys file API with the performance schema instrumentation.

  In some compilers (SunStudio), 'static inline' functions, when declared

  but not used, are not optimized away (because they are unused) by default,

  so that including a static inline function from a header file does

  create unwanted dependencies, causing unresolved symbols at link time.

  Other compilers, like gcc, optimize these dependencies by default.

  Since the instrumented APIs declared here are wrapper on top

  of mysys file io APIs, including mysql/psi/mysql_file.h assumes that

  the dependency on my_sys already exists.

*/

#ifndef MYSQL_FILE_H

#define MYSQL_FILE_H

/* For strlen() */

#include <assert.h>

#include <string.h>

/* HAVE_PSI_*_INTERFACE */

#include "my_psi_config.h"  // IWYU pragma: keep

/* For MY_STAT */

#include "my_dir.h"

#include "my_inttypes.h"

/* For my_chsize */

#include "my_sys.h"

#include "mysql/psi/psi_file.h"

#include "mysql/service_mysql_alloc.h"

#if defined(MYSQL_SERVER) || defined(PFS_DIRECT_CALL)

/* PSI_FILE_CALL() as direct call. */

#include "pfs_file_provider.h"  // IWYU pragma: keep

#endif

#ifndef PSI_FILE_CALL

#define PSI_FILE_CALL(M) psi_file_service->M

#endif

/**

  @defgroup psi_api_file File Instrumentation (API)

  @ingroup psi_api

  @{

*/

/**

  @def mysql_file_register(P1, P2, P3)

  File registration.

*/

#define mysql_file_register(P1, P2, P3) inline_mysql_file_register(P1, P2, P3)

/**

  @def mysql_file_fgets(P1, P2, F)

  Instrumented fgets.

  @c mysql_file_fgets is a replacement for @c fgets.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fgets(P1, P2, F) \

  inline_mysql_file_fgets(__FILE__, __LINE__, P1, P2, F)

#else

#define mysql_file_fgets(P1, P2, F) inline_mysql_file_fgets(P1, P2, F)

#endif

/**

  @def mysql_file_fgetc(F)

  Instrumented fgetc.

  @c mysql_file_fgetc is a replacement for @c fgetc.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fgetc(F) inline_mysql_file_fgetc(__FILE__, __LINE__, F)

#else

#define mysql_file_fgetc(F) inline_mysql_file_fgetc(F)

#endif

/**

  @def mysql_file_fputs(P1, F)

  Instrumented fputs.

  @c mysql_file_fputs is a replacement for @c fputs.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fputs(P1, F) \

  inline_mysql_file_fputs(__FILE__, __LINE__, P1, F)

#else

#define mysql_file_fputs(P1, F) inline_mysql_file_fputs(P1, F)

#endif

/**

  @def mysql_file_fputc(P1, F)

  Instrumented fputc.

  @c mysql_file_fputc is a replacement for @c fputc.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fputc(P1, F) \

  inline_mysql_file_fputc(__FILE__, __LINE__, P1, F)

#else

#define mysql_file_fputc(P1, F) inline_mysql_file_fputc(P1, F)

#endif

/**

  @def mysql_file_fprintf

  Instrumented fprintf.

  @c mysql_file_fprintf is a replacement for @c fprintf.

*/

#define mysql_file_fprintf inline_mysql_file_fprintf

/**

  @def mysql_file_vfprintf(F, P1, P2)

  Instrumented vfprintf.

  @c mysql_file_vfprintf is a replacement for @c vfprintf.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_vfprintf(F, P1, P2) \

  inline_mysql_file_vfprintf(__FILE__, __LINE__, F, P1, P2)

#else

#define mysql_file_vfprintf(F, P1, P2) inline_mysql_file_vfprintf(F, P1, P2)

#endif

/**

  @def mysql_file_fflush(F, P1, P2)

  Instrumented fflush.

  @c mysql_file_fflush is a replacement for @c fflush.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fflush(F) inline_mysql_file_fflush(__FILE__, __LINE__, F)

#else

#define mysql_file_fflush(F) inline_mysql_file_fflush(F)

#endif

/**

  @def mysql_file_feof(F)

  Instrumented feof.

  @c mysql_file_feof is a replacement for @c feof.

*/

#define mysql_file_feof(F) inline_mysql_file_feof(F)

/**

  @def mysql_file_fstat(FN, S)

  Instrumented fstat.

  @c mysql_file_fstat is a replacement for @c my_fstat.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fstat(FN, S) \

  inline_mysql_file_fstat(__FILE__, __LINE__, FN, S)

#else

#define mysql_file_fstat(FN, S) inline_mysql_file_fstat(FN, S)

#endif

/**

  @def mysql_file_stat(K, FN, S, FL)

  Instrumented stat.

  @c mysql_file_stat is a replacement for @c my_stat.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_stat(K, FN, S, FL) \

  inline_mysql_file_stat(K, __FILE__, __LINE__, FN, S, FL)

#else

#define mysql_file_stat(K, FN, S, FL) inline_mysql_file_stat(FN, S, FL)

#endif

/**

  @def mysql_file_chsize(F, P1, P2, P3)

  Instrumented chsize.

  @c mysql_file_chsize is a replacement for @c my_chsize.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_chsize(F, P1, P2, P3) \

  inline_mysql_file_chsize(__FILE__, __LINE__, F, P1, P2, P3)

#else

#define mysql_file_chsize(F, P1, P2, P3) inline_mysql_file_chsize(F, P1, P2, P3)

#endif

/**

  @def mysql_file_fopen(K, N, F1, F2)

  Instrumented fopen.

  @c mysql_file_fopen is a replacement for @c my_fopen.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fopen(K, N, F1, F2) \

  inline_mysql_file_fopen(K, __FILE__, __LINE__, N, F1, F2)

#else

#define mysql_file_fopen(K, N, F1, F2) inline_mysql_file_fopen(N, F1, F2)

#endif

/**

  @def mysql_file_fclose(FD, FL)

  Instrumented fclose.

  @c mysql_file_fclose is a replacement for @c my_fclose.

  Without the instrumentation, this call will have the same behavior as the

  undocumented and possibly platform specific my_fclose(NULL, ...) behavior.

  With the instrumentation, mysql_fclose(NULL, ...) will safely return 0,

  which is an extension compared to my_fclose and is therefore compliant.

  mysql_fclose is on purpose *not* implementing

  @code assert(file != NULL) @endcode,

  since doing so could introduce regressions.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fclose(FD, FL) \

  inline_mysql_file_fclose(__FILE__, __LINE__, FD, FL)

#else

#define mysql_file_fclose(FD, FL) inline_mysql_file_fclose(FD, FL)

#endif

/**

  @def mysql_file_fread(FD, P1, P2, P3)

  Instrumented fread.

  @c mysql_file_fread is a replacement for @c my_fread.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fread(FD, P1, P2, P3) \

  inline_mysql_file_fread(__FILE__, __LINE__, FD, P1, P2, P3)

#else

#define mysql_file_fread(FD, P1, P2, P3) inline_mysql_file_fread(FD, P1, P2, P3)

#endif

/**

  @def mysql_file_fwrite(FD, P1, P2, P3)

  Instrumented fwrite.

  @c mysql_file_fwrite is a replacement for @c my_fwrite.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fwrite(FD, P1, P2, P3) \

  inline_mysql_file_fwrite(__FILE__, __LINE__, FD, P1, P2, P3)

#else

#define mysql_file_fwrite(FD, P1, P2, P3) \

  inline_mysql_file_fwrite(FD, P1, P2, P3)

#endif

/**

  @def mysql_file_fseek(FD, P, W)

  Instrumented fseek.

  @c mysql_file_fseek is a replacement for @c my_fseek.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_fseek(FD, P, W) \

  inline_mysql_file_fseek(__FILE__, __LINE__, FD, P, W)

#else

#define mysql_file_fseek(FD, P, W) inline_mysql_file_fseek(FD, P, W)

#endif

/**

  @def mysql_file_ftell(FD)

  Instrumented ftell.

  @c mysql_file_ftell is a replacement for @c my_ftell.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_ftell(FD) inline_mysql_file_ftell(__FILE__, __LINE__, FD)

#else

#define mysql_file_ftell(FD) inline_mysql_file_ftell(FD)

#endif

/**

  @def mysql_file_create(K, N, F1, F2, F3)

  Instrumented create.

  @c mysql_file_create is a replacement for @c my_create.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_create(K, N, F1, F2, F3) \

  inline_mysql_file_create(K, __FILE__, __LINE__, N, F1, F2, F3)

#else

#define mysql_file_create(K, N, F1, F2, F3) \

  inline_mysql_file_create(N, F1, F2, F3)

#endif

/**

  @def mysql_file_create_temp(K, T, D, P, M, U, F)

  Instrumented create_temp_file.

  @c mysql_file_create_temp is a replacement for @c create_temp_file.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_create_temp(K, T, D, P, M, U, F) \

  inline_mysql_file_create_temp(K, __FILE__, __LINE__, T, D, P, M, U, F)

#else

#define mysql_file_create_temp(K, T, D, P, M, U, F) \

  inline_mysql_file_create_temp(T, D, P, M, U, F)

#endif

/**

  @def mysql_file_open(K, N, F1, F2)

  Instrumented open.

  @c mysql_file_open is a replacement for @c my_open.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_open(K, N, F1, F2) \

  inline_mysql_file_open(K, __FILE__, __LINE__, N, F1, F2)

#else

#define mysql_file_open(K, N, F1, F2) inline_mysql_file_open(N, F1, F2)

#endif

/**

  @def mysql_file_close(FD, F)

  Instrumented close.

  @c mysql_file_close is a replacement for @c my_close.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_close(FD, F) \

  inline_mysql_file_close(__FILE__, __LINE__, FD, F)

#else

#define mysql_file_close(FD, F) inline_mysql_file_close(FD, F)

#endif

/**

  @def mysql_file_read(FD, B, S, F)

  Instrumented read.

  @c mysql_read is a replacement for @c my_read.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_read(FD, B, S, F) \

  inline_mysql_file_read(__FILE__, __LINE__, FD, B, S, F)

#else

#define mysql_file_read(FD, B, S, F) inline_mysql_file_read(FD, B, S, F)

#endif

/**

  @def mysql_file_write(FD, B, S, F)

  Instrumented write.

  @c mysql_file_write is a replacement for @c my_write.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_write(FD, B, S, F) \

  inline_mysql_file_write(__FILE__, __LINE__, FD, B, S, F)

#else

#define mysql_file_write(FD, B, S, F) inline_mysql_file_write(FD, B, S, F)

#endif

/**

  @def mysql_file_pread(FD, B, S, O, F)

  Instrumented pread.

  @c mysql_pread is a replacement for @c my_pread.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_pread(FD, B, S, O, F) \

  inline_mysql_file_pread(__FILE__, __LINE__, FD, B, S, O, F)

#else

#define mysql_file_pread(FD, B, S, O, F) inline_mysql_file_pread(FD, B, S, O, F)

#endif

/**

  @def mysql_file_pwrite(FD, B, S, O, F)

  Instrumented pwrite.

  @c mysql_file_pwrite is a replacement for @c my_pwrite.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_pwrite(FD, B, S, O, F) \

  inline_mysql_file_pwrite(__FILE__, __LINE__, FD, B, S, O, F)

#else

#define mysql_file_pwrite(FD, B, S, O, F) \

  inline_mysql_file_pwrite(FD, B, S, O, F)

#endif

/**

  @def mysql_file_seek(FD, P, W, F)

  Instrumented seek.

  @c mysql_file_seek is a replacement for @c my_seek.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_seek(FD, P, W, F) \

  inline_mysql_file_seek(__FILE__, __LINE__, FD, P, W, F)

#else

#define mysql_file_seek(FD, P, W, F) inline_mysql_file_seek(FD, P, W, F)

#endif

/**

  @def mysql_file_tell(FD, F)

  Instrumented tell.

  @c mysql_file_tell is a replacement for @c my_tell.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_tell(FD, F) inline_mysql_file_tell(__FILE__, __LINE__, FD, F)

#else

#define mysql_file_tell(FD, F) inline_mysql_file_tell(FD, F)

#endif

/**

  @def mysql_file_delete(K, P1, P2)

  Instrumented delete.

  @c mysql_file_delete is a replacement for @c my_delete.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_delete(K, P1, P2) \

  inline_mysql_file_delete(K, __FILE__, __LINE__, P1, P2)

#else

#define mysql_file_delete(K, P1, P2) inline_mysql_file_delete(P1, P2)

#endif

/**

  @def mysql_file_rename(K, P1, P2, P3)

  Instrumented rename.

  @c mysql_file_rename is a replacement for @c my_rename.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_rename(K, P1, P2, P3) \

  inline_mysql_file_rename(K, __FILE__, __LINE__, P1, P2, P3)

#else

#define mysql_file_rename(K, P1, P2, P3) inline_mysql_file_rename(P1, P2, P3)

#endif

/**

  @def mysql_file_create_with_symlink(K, P1, P2, P3, P4, P5)

  Instrumented create with symbolic link.

  @c mysql_file_create_with_symlink is a replacement

  for @c my_create_with_symlink.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_create_with_symlink(K, P1, P2, P3, P4, P5)                  \

  inline_mysql_file_create_with_symlink(K, __FILE__, __LINE__, P1, P2, P3, P4, \

                                        P5)

#else

#define mysql_file_create_with_symlink(K, P1, P2, P3, P4, P5) \

  inline_mysql_file_create_with_symlink(P1, P2, P3, P4, P5)

#endif

/**

  @def mysql_file_delete_with_symlink(K, P1, P2)

  Instrumented delete with symbolic link.

  @c mysql_file_delete_with_symlink is a replacement

  for @c my_delete_with_symlink.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_delete_with_symlink(K, P1, P2) \

  inline_mysql_file_delete_with_symlink(K, __FILE__, __LINE__, P1, P2)

#else

#define mysql_file_delete_with_symlink(K, P1, P2) \

  inline_mysql_file_delete_with_symlink(P1, P2)

#endif

/**

  @def mysql_file_rename_with_symlink(K, P1, P2, P3)

  Instrumented rename with symbolic link.

  @c mysql_file_rename_with_symlink is a replacement

  for @c my_rename_with_symlink.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_rename_with_symlink(K, P1, P2, P3) \

  inline_mysql_file_rename_with_symlink(K, __FILE__, __LINE__, P1, P2, P3)

#else

#define mysql_file_rename_with_symlink(K, P1, P2, P3) \

  inline_mysql_file_rename_with_symlink(P1, P2, P3)

#endif

/**

  @def mysql_file_sync(P1, P2)

  Instrumented file sync.

  @c mysql_file_sync is a replacement for @c my_sync.

*/

#ifdef HAVE_PSI_FILE_INTERFACE

#define mysql_file_sync(P1, P2) \

  inline_mysql_file_sync(__FILE__, __LINE__, P1, P2)

#else

#define mysql_file_sync(P1, P2) inline_mysql_file_sync(P1, P2)

#endif

/**

  An instrumented FILE structure.

  @c MYSQL_FILE is a drop-in replacement for @c FILE.

  @sa mysql_file_open

*/

struct MYSQL_FILE {

  /** The real file. */

  FILE *m_file;

  /**

    The instrumentation hook.

    Note that this hook is not conditionally defined,

    for binary compatibility of the @c MYSQL_FILE interface.

  */

  struct PSI_file *m_psi;

};

static inline void inline_mysql_file_register(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *category, PSI_file_info *info, int count

#else

    const char *category [[maybe_unused]], void *info [[maybe_unused]],

    int count [[maybe_unused]]

#endif

) {

#ifdef HAVE_PSI_FILE_INTERFACE

  PSI_FILE_CALL(register_file)(category, info, count);

#endif

}

Unexecuted instantiation: charset.cc:inline_mysql_file_register(char const*, PSI_file_info_v1*, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_register(char const*, PSI_file_info_v1*, int)

static inline char *inline_mysql_file_fgets(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    char *str, int size, MYSQL_FILE *file) {

  char *result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_READ);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, (size_t)size, src_file, src_line);

    result = fgets(str, size, file->m_file);

    PSI_FILE_CALL(end_file_wait)(locker, result ? strlen(result) : 0);

    return result;

  }

#endif

  result = fgets(str, size, file->m_file);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fgets(char const*, unsigned int, char*, int, MYSQL_FILE*)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fgets(char const*, unsigned int, char*, int, MYSQL_FILE*)

static inline int inline_mysql_file_fgetc(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    MYSQL_FILE *file) {

  int result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_READ);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, (size_t)1, src_file, src_line);

    result = fgetc(file->m_file);

    PSI_FILE_CALL(end_file_wait)(locker, (size_t)1);

    return result;

  }

#endif

  result = fgetc(file->m_file);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fgetc(char const*, unsigned int, MYSQL_FILE*)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fgetc(char const*, unsigned int, MYSQL_FILE*)

static inline int inline_mysql_file_fputs(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    const char *str, MYSQL_FILE *file) {

  int result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  size_t bytes;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_WRITE);

  if (likely(locker != nullptr)) {

    bytes = str ? strlen(str) : 0;

    PSI_FILE_CALL(start_file_wait)(locker, bytes, src_file, src_line);

    result = fputs(str, file->m_file);

    PSI_FILE_CALL(end_file_wait)(locker, bytes);

    return result;

  }

#endif

  result = fputs(str, file->m_file);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fputs(char const*, unsigned int, char const*, MYSQL_FILE*)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fputs(char const*, unsigned int, char const*, MYSQL_FILE*)

static inline int inline_mysql_file_fputc(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    char c, MYSQL_FILE *file) {

  int result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_WRITE);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, (size_t)1, src_file, src_line);

    result = fputc(c, file->m_file);

    PSI_FILE_CALL(end_file_wait)(locker, (size_t)1);

    return result;

  }

#endif

  result = fputc(c, file->m_file);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fputc(char const*, unsigned int, char, MYSQL_FILE*)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fputc(char const*, unsigned int, char, MYSQL_FILE*)

static inline int inline_mysql_file_fprintf(MYSQL_FILE *file,

                                            const char *format, ...)

    MY_ATTRIBUTE((format(printf, 2, 3)));

static inline int inline_mysql_file_fprintf(MYSQL_FILE *file,

                                            const char *format, ...) {

  /*

    TODO: figure out how to pass src_file and src_line from the caller.

  */

  int result;

  va_list args;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_WRITE);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, (size_t)0, __FILE__, __LINE__);

    va_start(args, format);

    result = vfprintf(file->m_file, format, args);

    va_end(args);

    PSI_FILE_CALL(end_file_wait)(locker, (size_t)result);

    return result;

  }

#endif

  va_start(args, format);

  result = vfprintf(file->m_file, format, args);

  va_end(args);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fprintf(MYSQL_FILE*, char const*, ...)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fprintf(MYSQL_FILE*, char const*, ...)

static inline int inline_mysql_file_vfprintf(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    MYSQL_FILE *file, const char *format, va_list args)

#ifdef HAVE_PSI_FILE_INTERFACE

    MY_ATTRIBUTE((format(printf, 4, 0)));

#else

    MY_ATTRIBUTE((format(printf, 2, 0)));

#endif

static inline int inline_mysql_file_vfprintf(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    MYSQL_FILE *file, const char *format, va_list args) {

  int result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_WRITE);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, (size_t)0, src_file, src_line);

    result = vfprintf(file->m_file, format, args);

    PSI_FILE_CALL(end_file_wait)(locker, (size_t)result);

    return result;

  }

#endif

  result = vfprintf(file->m_file, format, args);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_vfprintf(char const*, unsigned int, MYSQL_FILE*, char const*, __va_list_tag*)

Unexecuted instantiation: my_init.cc:inline_mysql_file_vfprintf(char const*, unsigned int, MYSQL_FILE*, char const*, __va_list_tag*)

static inline int inline_mysql_file_fflush(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    MYSQL_FILE *file) {

  int result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_FLUSH);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, (size_t)0, src_file, src_line);

    result = fflush(file->m_file);

    PSI_FILE_CALL(end_file_wait)(locker, (size_t)0);

    return result;

  }

#endif

  result = fflush(file->m_file);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fflush(char const*, unsigned int, MYSQL_FILE*)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fflush(char const*, unsigned int, MYSQL_FILE*)

static inline int inline_mysql_file_feof(MYSQL_FILE *file) {

  /* Not instrumented, there is no wait involved */

  return feof(file->m_file);

}

Unexecuted instantiation: charset.cc:inline_mysql_file_feof(MYSQL_FILE*)

Unexecuted instantiation: my_init.cc:inline_mysql_file_feof(MYSQL_FILE*)

static inline int inline_mysql_file_fstat(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    int filenr, MY_STAT *stat_area) {

  int result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, filenr,

                                                            PSI_FILE_FSTAT);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, (size_t)0, src_file, src_line);

    result = my_fstat(filenr, stat_area);

    PSI_FILE_CALL(end_file_wait)(locker, (size_t)0);

    return result;

  }

#endif

  result = my_fstat(filenr, stat_area);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fstat(char const*, unsigned int, int, stat*)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fstat(char const*, unsigned int, int, stat*)

static inline MY_STAT *inline_mysql_file_stat(

#ifdef HAVE_PSI_FILE_INTERFACE

    PSI_file_key key, const char *src_file, uint src_line,

#endif

    const char *path, MY_STAT *stat_area, myf flags) {

  MY_STAT *result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker = nullptr;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_name_locker)(

      &state, key, PSI_FILE_STAT, path, &locker);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);

    result = my_stat(path, stat_area, flags);

    PSI_FILE_CALL(end_file_open_wait)(locker, result);

    return result;

  }

#endif

  result = my_stat(path, stat_area, flags);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_stat(unsigned int, char const*, unsigned int, char const*, stat*, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_stat(unsigned int, char const*, unsigned int, char const*, stat*, int)

static inline int inline_mysql_file_chsize(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    File file, my_off_t newlength, int filler, myf flags) {

  int result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file,

                                                            PSI_FILE_CHSIZE);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)

    (locker, (size_t)newlength, src_file, src_line);

    result = my_chsize(file, newlength, filler, flags);

    PSI_FILE_CALL(end_file_wait)(locker, (size_t)newlength);

    return result;

  }

#endif

  result = my_chsize(file, newlength, filler, flags);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_chsize(char const*, unsigned int, int, unsigned long long, int, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_chsize(char const*, unsigned int, int, unsigned long long, int, int)

static inline MYSQL_FILE *inline_mysql_file_fopen(

#ifdef HAVE_PSI_FILE_INTERFACE

    PSI_file_key key, const char *src_file, uint src_line,

#endif

    const char *filename, int flags, myf myFlags) {

  MYSQL_FILE *that;

  that = (MYSQL_FILE *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(MYSQL_FILE),

                                 MYF(MY_WME));

  if (likely(that != nullptr)) {

#ifdef HAVE_PSI_FILE_INTERFACE

    struct PSI_file_locker *locker;

    PSI_file_locker_state state;

    locker = PSI_FILE_CALL(get_thread_file_name_locker)(

        &state, key, PSI_FILE_STREAM_OPEN, filename, that);

    if (likely(locker != nullptr)) {

      PSI_FILE_CALL(start_file_open_wait)

      (locker, src_file, src_line);

      that->m_file = my_fopen(filename, flags, myFlags);

      that->m_psi = PSI_FILE_CALL(end_file_open_wait)(locker, that->m_file);

      if (unlikely(that->m_file == nullptr)) {

        my_free(that);

        return nullptr;

      }

      return that;

    }

#endif

    that->m_psi = nullptr;

    that->m_file = my_fopen(filename, flags, myFlags);

    if (unlikely(that->m_file == nullptr)) {

      my_free(that);

      return nullptr;

    }

  }

  return that;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fopen(unsigned int, char const*, unsigned int, char const*, int, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fopen(unsigned int, char const*, unsigned int, char const*, int, int)

static inline int inline_mysql_file_fclose(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    MYSQL_FILE *file, myf flags) {

  int result = 0;

  if (likely(file != nullptr)) {

#ifdef HAVE_PSI_FILE_INTERFACE

    struct PSI_file_locker *locker;

    PSI_file_locker_state state;

    locker = PSI_FILE_CALL(get_thread_file_stream_locker)(

        &state, file->m_psi, PSI_FILE_STREAM_CLOSE);

    if (likely(locker != nullptr)) {

      PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);

      result = my_fclose(file->m_file, flags);

      PSI_FILE_CALL(end_file_close_wait)(locker, result);

      my_free(file);

      return result;

    }

#endif

    result = my_fclose(file->m_file, flags);

    my_free(file);

  }

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fclose(char const*, unsigned int, MYSQL_FILE*, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fclose(char const*, unsigned int, MYSQL_FILE*, int)

static inline size_t inline_mysql_file_fread(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    MYSQL_FILE *file, uchar *buffer, size_t count, myf flags) {

  size_t result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  size_t bytes_read;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_READ);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);

    result = my_fread(file->m_file, buffer, count, flags);

    if (flags & (MY_NABP | MY_FNABP)) {

      bytes_read = (result == 0) ? count : 0;

    } else {

      bytes_read = (result != MY_FILE_ERROR) ? result : 0;

    }

    PSI_FILE_CALL(end_file_wait)(locker, bytes_read);

    return result;

  }

#endif

  result = my_fread(file->m_file, buffer, count, flags);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fread(char const*, unsigned int, MYSQL_FILE*, unsigned char*, unsigned long, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fread(char const*, unsigned int, MYSQL_FILE*, unsigned char*, unsigned long, int)

static inline size_t inline_mysql_file_fwrite(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    MYSQL_FILE *file, const uchar *buffer, size_t count, myf flags) {

  size_t result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  size_t bytes_written;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_WRITE);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);

    result = my_fwrite(file->m_file, buffer, count, flags);

    if (flags & (MY_NABP | MY_FNABP)) {

      bytes_written = (result == 0) ? count : 0;

    } else {

      bytes_written = (result != MY_FILE_ERROR) ? result : 0;

    }

    PSI_FILE_CALL(end_file_wait)(locker, bytes_written);

    return result;

  }

#endif

  result = my_fwrite(file->m_file, buffer, count, flags);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fwrite(char const*, unsigned int, MYSQL_FILE*, unsigned char const*, unsigned long, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fwrite(char const*, unsigned int, MYSQL_FILE*, unsigned char const*, unsigned long, int)

static inline my_off_t inline_mysql_file_fseek(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    MYSQL_FILE *file, my_off_t pos, int whence) {

  my_off_t result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_SEEK);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, (size_t)0, src_file, src_line);

    result = my_fseek(file->m_file, pos, whence);

    PSI_FILE_CALL(end_file_wait)(locker, (size_t)0);

    return result;

  }

#endif

  result = my_fseek(file->m_file, pos, whence);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_fseek(char const*, unsigned int, MYSQL_FILE*, unsigned long long, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_fseek(char const*, unsigned int, MYSQL_FILE*, unsigned long long, int)

static inline my_off_t inline_mysql_file_ftell(

#ifdef HAVE_PSI_FILE_INTERFACE

    const char *src_file, uint src_line,

#endif

    MYSQL_FILE *file) {

  my_off_t result;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_stream_locker)(&state, file->m_psi,

                                                        PSI_FILE_TELL);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_wait)(locker, (size_t)0, src_file, src_line);

    result = my_ftell(file->m_file);

    PSI_FILE_CALL(end_file_wait)(locker, (size_t)0);

    return result;

  }

#endif

  result = my_ftell(file->m_file);

  return result;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_ftell(char const*, unsigned int, MYSQL_FILE*)

Unexecuted instantiation: my_init.cc:inline_mysql_file_ftell(char const*, unsigned int, MYSQL_FILE*)

static inline File inline_mysql_file_create(

#ifdef HAVE_PSI_FILE_INTERFACE

    PSI_file_key key, const char *src_file, uint src_line,

#endif

    const char *filename, int create_flags, int access_flags, myf myFlags) {

  File file;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker = nullptr;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_name_locker)(

      &state, key, PSI_FILE_CREATE, filename, &locker);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);

    file = my_create(filename, create_flags, access_flags, myFlags);

    PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);

    return file;

  }

#endif

  file = my_create(filename, create_flags, access_flags, myFlags);

  return file;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_create(unsigned int, char const*, unsigned int, char const*, int, int, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_create(unsigned int, char const*, unsigned int, char const*, int, int, int)

static inline File inline_mysql_file_create_temp(

#ifdef HAVE_PSI_FILE_INTERFACE

    PSI_file_key key, const char *src_file, uint src_line,

#endif

    char *to, const char *dir, const char *pfx, int mode,

    UnlinkOrKeepFile unlink_or_keep, myf myFlags) {

  File file;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker = nullptr;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_name_locker)(

      &state, key, PSI_FILE_CREATE, nullptr, &locker);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);

    /* The file name is generated by create_temp_file(). */

    file = create_temp_file(to, dir, pfx, mode, unlink_or_keep, myFlags);

    PSI_FILE_CALL(end_temp_file_open_wait_and_bind_to_descriptor)

    (locker, file, (const char *)to);

    return file;

  }

#endif

  file = create_temp_file(to, dir, pfx, mode, unlink_or_keep, myFlags);

  return file;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_create_temp(unsigned int, char const*, unsigned int, char*, char const*, char const*, int, UnlinkOrKeepFile, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_create_temp(unsigned int, char const*, unsigned int, char*, char const*, char const*, int, UnlinkOrKeepFile, int)

static inline File inline_mysql_file_open(

#ifdef HAVE_PSI_FILE_INTERFACE

    PSI_file_key key, const char *src_file, uint src_line,

#endif

    const char *filename, int flags, myf myFlags) {

  File file;

#ifdef HAVE_PSI_FILE_INTERFACE

  struct PSI_file_locker *locker = nullptr;

  PSI_file_locker_state state;

  locker = PSI_FILE_CALL(get_thread_file_name_locker)(

      &state, key, PSI_FILE_OPEN, filename, &locker);

  if (likely(locker != nullptr)) {

    PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);

    file = my_open(filename, flags, myFlags);

    PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);

    return file;

  }

#endif

  file = my_open(filename, flags, myFlags);

  return file;

}

Unexecuted instantiation: charset.cc:inline_mysql_file_open(unsigned int, char const*, unsigned int, char const*, int, int)

Unexecuted instantiation: my_init.cc:inline_mysql_file_open(unsigned int, char const*, unsigned int, char const*, int, int)