pfs_instr.h

Go to the documentation of this file.

/* Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; version 2 of the License.

  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 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,
  51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */

#ifndef PFS_INSTR_H
#define PFS_INSTR_H

struct PFS_mutex_class;
struct PFS_rwlock_class;
struct PFS_cond_class;
struct PFS_file_class;
struct PFS_table_share;
struct PFS_thread_class;
struct PFS_socket_class;

#ifdef __WIN__
#include <winsock2.h>
#else
#include <arpa/inet.h>
#endif
#include "my_global.h"
#include "my_compiler.h"
#include "pfs_lock.h"
#include "pfs_stat.h"
#include "pfs_instr_class.h"
#include "pfs_events_waits.h"
#include "pfs_events_stages.h"
#include "pfs_events_statements.h"
#include "pfs_server.h"
#include "lf.h"
#include "pfs_con_slice.h"

struct PFS_thread;
struct PFS_host;
struct PFS_user;
struct PFS_account;

struct PFS_instr
{
  pfs_lock m_lock;
  bool m_enabled;
  bool m_timed;
};

struct PFS_ALIGNED PFS_mutex : public PFS_instr
{
  const void *m_identity;
  PFS_mutex_class *m_class;
  PFS_mutex_stat m_mutex_stat;
  PFS_thread *m_owner;
  ulonglong m_last_locked;
};

struct PFS_ALIGNED PFS_rwlock : public PFS_instr
{
  const void *m_identity;
  PFS_rwlock_class *m_class;
  PFS_rwlock_stat m_rwlock_stat;
  PFS_thread *m_writer;
  uint m_readers;
  ulonglong m_last_written;
  ulonglong m_last_read;
};

struct PFS_ALIGNED PFS_cond : public PFS_instr
{
  const void *m_identity;
  PFS_cond_class *m_class;
  PFS_single_stat m_wait_stat;
  PFS_cond_stat m_cond_stat;
};

struct PFS_ALIGNED PFS_file : public PFS_instr
{
  uint32 get_version()
  { return m_lock.get_version(); }

  const void *m_identity;
  char m_filename[FN_REFLEN];
  uint m_filename_length;
  PFS_file_class *m_class;
  PFS_file_stat m_file_stat;
};

struct PFS_ALIGNED PFS_table
{
  bool m_io_enabled;
  bool m_lock_enabled;
  bool m_io_timed;
  bool m_lock_timed;

  bool m_has_io_stats;

  bool m_has_lock_stats;

public:
  void aggregate(void)
  {
    if (m_has_io_stats && m_has_lock_stats)
    {
      safe_aggregate(& m_table_stat, m_share);
      m_has_io_stats= false;
      m_has_lock_stats= false;
    }
    else if (m_has_io_stats)
    {
      safe_aggregate_io(& m_table_stat, m_share);
      m_has_io_stats= false;
    }
    else if (m_has_lock_stats)
    {
      safe_aggregate_lock(& m_table_stat, m_share);
      m_has_lock_stats= false;
    }
  }

  void sanitized_aggregate(void);

  void sanitized_aggregate_io(void);

  void sanitized_aggregate_lock(void);

  pfs_lock m_lock;
  PFS_thread *m_thread_owner;
  PFS_table_share *m_share;
  const void *m_identity;
  PFS_table_stat m_table_stat;

private:
  static void safe_aggregate(PFS_table_stat *stat,
                             PFS_table_share *safe_share);
  static void safe_aggregate_io(PFS_table_stat *stat,
                                PFS_table_share *safe_share);
  static void safe_aggregate_lock(PFS_table_stat *stat,
                                  PFS_table_share *safe_share);
};

struct PFS_ALIGNED PFS_socket : public PFS_instr
{
  uint32 get_version()
  { return m_lock.get_version(); }

  const void *m_identity;
  PFS_thread *m_thread_owner;
  uint m_fd;
  struct sockaddr_storage  m_sock_addr;
  socklen_t m_addr_len;
  bool m_idle;
  PFS_socket_class *m_class;
  PFS_socket_stat m_socket_stat;
};

#define WAIT_STACK_LOGICAL_SIZE 5

#define WAIT_STACK_BOTTOM 1

#define WAIT_STACK_SIZE (WAIT_STACK_BOTTOM + WAIT_STACK_LOGICAL_SIZE)

extern uint statement_stack_max;

#define PFS_MAX_ALLOC_RETRY 1000

#define PFS_MAX_SCAN_PASS 2

struct PFS_scan
{
public:
  void init(uint random, uint max_size);

  bool has_pass() const
  { return (m_pass < m_pass_max); }

  void next_pass()
  { m_pass++; }
  
  uint first() const
  { return m_first[m_pass]; }

  uint last() const
  { return m_last[m_pass]; }

private:
  uint m_pass;
  uint m_pass_max;
  uint m_first[PFS_MAX_SCAN_PASS];
  uint m_last[PFS_MAX_SCAN_PASS];
};


struct PFS_ALIGNED PFS_thread : PFS_connection_slice
{
  static PFS_thread* get_current_thread(void);

  bool m_enabled;
  PFS_events_waits *m_events_waits_current;
  ulonglong m_event_id;
  pfs_lock m_lock;
  LF_PINS *m_filename_hash_pins;
  LF_PINS *m_table_share_hash_pins;
  LF_PINS *m_setup_actor_hash_pins;
  LF_PINS *m_setup_object_hash_pins;
  LF_PINS *m_host_hash_pins;
  LF_PINS *m_user_hash_pins;
  LF_PINS *m_account_hash_pins;
  LF_PINS *m_digest_hash_pins;
  ulonglong m_thread_internal_id;
  ulonglong m_parent_thread_internal_id;
  ulong m_processlist_id;
  PFS_thread_class *m_class;
  PFS_events_waits m_events_waits_stack[WAIT_STACK_SIZE];
  bool m_waits_history_full;
  uint m_waits_history_index;
  PFS_events_waits *m_waits_history;

  bool m_stages_history_full;
  uint m_stages_history_index;
  PFS_events_stages *m_stages_history;

  bool m_statements_history_full;
  uint m_statements_history_index;
  PFS_events_statements *m_statements_history;

  pfs_lock m_session_lock;
  char m_username[USERNAME_LENGTH];
  uint m_username_length;
  char m_hostname[HOSTNAME_LENGTH];
  uint m_hostname_length;
  char m_dbname[NAME_LEN];
  uint m_dbname_length;
  int m_command;
  time_t m_start_time;
  pfs_lock m_stmt_lock;
  PFS_stage_key m_stage;
  char m_processlist_info[COL_INFO_SIZE];
  uint m_processlist_info_length;

  PFS_events_stages m_stage_current;

  uint m_events_statements_count;
  PFS_events_statements *m_statement_stack;

  PFS_host *m_host;
  PFS_user *m_user;
  PFS_account *m_account;

  void reset_session_connect_attrs();

  char *m_session_connect_attrs;
  uint m_session_connect_attrs_length;
  const CHARSET_INFO *m_session_connect_attrs_cs;
};

extern PFS_stage_stat *global_instr_class_stages_array;
extern PFS_statement_stat *global_instr_class_statements_array;

PFS_mutex *sanitize_mutex(PFS_mutex *unsafe);
PFS_rwlock *sanitize_rwlock(PFS_rwlock *unsafe);
PFS_cond *sanitize_cond(PFS_cond *unsafe);
PFS_thread *sanitize_thread(PFS_thread *unsafe);
PFS_file *sanitize_file(PFS_file *unsafe);
PFS_socket *sanitize_socket(PFS_socket *unsafe);

int init_instruments(const PFS_global_param *param);
void cleanup_instruments();
int init_file_hash();
void cleanup_file_hash();
PFS_mutex* create_mutex(PFS_mutex_class *mutex_class, const void *identity);
void destroy_mutex(PFS_mutex *pfs);
PFS_rwlock* create_rwlock(PFS_rwlock_class *klass, const void *identity);
void destroy_rwlock(PFS_rwlock *pfs);
PFS_cond* create_cond(PFS_cond_class *klass, const void *identity);
void destroy_cond(PFS_cond *pfs);

PFS_thread* create_thread(PFS_thread_class *klass, const void *identity,
                          ulonglong processlist_id);

void destroy_thread(PFS_thread *pfs);

PFS_file* find_or_create_file(PFS_thread *thread, PFS_file_class *klass,
                              const char *filename, uint len, bool create);

void release_file(PFS_file *pfs);
void destroy_file(PFS_thread *thread, PFS_file *pfs);
PFS_table* create_table(PFS_table_share *share, PFS_thread *opening_thread,
                        const void *identity);
void destroy_table(PFS_table *pfs);

PFS_socket* create_socket(PFS_socket_class *socket_class,
                          const my_socket *fd,
                          const struct sockaddr *addr,
                          socklen_t addr_len);
void destroy_socket(PFS_socket *pfs);

/* For iterators and show status. */

extern ulong mutex_max;
extern ulong mutex_lost;
extern ulong rwlock_max;
extern ulong rwlock_lost;
extern ulong cond_max;
extern ulong cond_lost;
extern ulong thread_max;
extern ulong thread_lost;
extern ulong file_max;
extern ulong file_lost;
extern long file_handle_max;
extern ulong file_handle_lost;
extern ulong table_max;
extern ulong table_lost;
extern ulong socket_max;
extern ulong socket_lost;
extern ulong events_waits_history_per_thread;
extern ulong events_stages_history_per_thread;
extern ulong events_statements_history_per_thread;
extern ulong locker_lost;
extern ulong statement_lost;
extern ulong session_connect_attrs_lost;
extern ulong session_connect_attrs_size_per_thread;

/* Exposing the data directly, for iterators. */

extern PFS_mutex *mutex_array;
extern PFS_rwlock *rwlock_array;
extern PFS_cond *cond_array;
extern PFS_thread *thread_array;
extern PFS_file *file_array;
extern PFS_file **file_handle_array;
extern PFS_table *table_array;
extern PFS_socket *socket_array;

void reset_events_waits_by_instance();
void reset_file_instance_io();
void reset_socket_instance_io();

void aggregate_all_event_names(PFS_single_stat *from_array,
                               PFS_single_stat *to_array);
void aggregate_all_event_names(PFS_single_stat *from_array,
                               PFS_single_stat *to_array_1,
                               PFS_single_stat *to_array_2);

void aggregate_all_stages(PFS_stage_stat *from_array,
                          PFS_stage_stat *to_array);
void aggregate_all_stages(PFS_stage_stat *from_array,
                          PFS_stage_stat *to_array_1,
                          PFS_stage_stat *to_array_2);

void aggregate_all_statements(PFS_statement_stat *from_array,
                              PFS_statement_stat *to_array);
void aggregate_all_statements(PFS_statement_stat *from_array,
                              PFS_statement_stat *to_array_1,
                              PFS_statement_stat *to_array_2);

void aggregate_thread(PFS_thread *thread,
                      PFS_account *safe_account,
                      PFS_user *safe_user,
                      PFS_host *safe_host);
void aggregate_thread_waits(PFS_thread *thread,
                            PFS_account *safe_account,
                            PFS_user *safe_user,
                            PFS_host *safe_host);
void aggregate_thread_stages(PFS_thread *thread,
                             PFS_account *safe_account,
                             PFS_user *safe_user,
                             PFS_host *safe_host);
void aggregate_thread_statements(PFS_thread *thread,
                                 PFS_account *safe_account,
                                 PFS_user *safe_user,
                                 PFS_host *safe_host);
void clear_thread_account(PFS_thread *thread);
void set_thread_account(PFS_thread *thread);

void update_mutex_derived_flags();
void update_rwlock_derived_flags();
void update_cond_derived_flags();
void update_file_derived_flags();
void update_table_derived_flags();
void update_socket_derived_flags();
void update_instruments_derived_flags();

extern LF_HASH filename_hash;

#endif