pfs_lock.h

Go to the documentation of this file.

/* Copyright (c) 2009, 2010, 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_LOCK_H
#define PFS_LOCK_H

#include "pfs_atomic.h"

#define PFS_LOCK_FREE 0x00

#define PFS_LOCK_DIRTY 0x01

#define PFS_LOCK_ALLOCATED 0x02

#define VERSION_MASK 0xFFFFFFFC
#define STATE_MASK   0x00000003
#define VERSION_INC  4

struct pfs_lock
{
  volatile uint32 m_version_state;

  bool is_free(void)
  {
    uint32 copy= m_version_state; /* non volatile copy, and dirty read */
    return ((copy & STATE_MASK) == PFS_LOCK_FREE);
  }

  bool is_populated(void)
  {
    uint32 copy= m_version_state; /* non volatile copy, and dirty read */
    return ((copy & STATE_MASK) == PFS_LOCK_ALLOCATED);
  }

  bool free_to_dirty(void)
  {
    uint32 copy= m_version_state; /* non volatile copy, and dirty read */
    uint32 old_val= (copy & VERSION_MASK) + PFS_LOCK_FREE;
    uint32 new_val= (copy & VERSION_MASK) + PFS_LOCK_DIRTY;

    return (PFS_atomic::cas_u32(&m_version_state, &old_val, new_val));
  }

  void allocated_to_dirty(void)
  {
    uint32 copy= PFS_atomic::load_u32(&m_version_state);
    /* Make sure the record was ALLOCATED. */
    DBUG_ASSERT((copy & STATE_MASK) == PFS_LOCK_ALLOCATED);
    /* Keep the same version, set the DIRTY state */
    uint32 new_val= (copy & VERSION_MASK) + PFS_LOCK_DIRTY;
    /* We own the record, no need to use compare and swap. */
    PFS_atomic::store_u32(&m_version_state, new_val);
  }

  void dirty_to_allocated(void)
  {
    uint32 copy= PFS_atomic::load_u32(&m_version_state);
    /* Make sure the record was DIRTY. */
    DBUG_ASSERT((copy & STATE_MASK) == PFS_LOCK_DIRTY);
    /* Increment the version, set the ALLOCATED state */
    uint32 new_val= (copy & VERSION_MASK) + VERSION_INC + PFS_LOCK_ALLOCATED;
    PFS_atomic::store_u32(&m_version_state, new_val);
  }

  void set_allocated(void)
  {
    /* Do not set the version to 0, read the previous value. */
    uint32 copy= PFS_atomic::load_u32(&m_version_state);
    /* Increment the version, set the ALLOCATED state */
    uint32 new_val= (copy & VERSION_MASK) + VERSION_INC + PFS_LOCK_ALLOCATED;
    PFS_atomic::store_u32(&m_version_state, new_val);
  }

  void dirty_to_free(void)
  {
    uint32 copy= PFS_atomic::load_u32(&m_version_state);
    /* Make sure the record was DIRTY. */
    DBUG_ASSERT((copy & STATE_MASK) == PFS_LOCK_DIRTY);
    /* Keep the same version, set the FREE state */
    uint32 new_val= (copy & VERSION_MASK) + PFS_LOCK_FREE;
    PFS_atomic::store_u32(&m_version_state, new_val);
  }

  void allocated_to_free(void)
  {
#ifndef DBUG_OFF
    extern volatile bool ready_to_exit;
#endif

    /*
      If this record is not in the ALLOCATED state and the caller is trying
      to free it, this is a bug: the caller is confused,
      and potentially damaging data owned by another thread or object.
      The correct assert to use here to guarantee data integrity is simply:
        DBUG_ASSERT(m_state == PFS_LOCK_ALLOCATED);
      Now, because of Bug#56666 (Race condition between the server main thread
      and the kill server thread), this assert actually fails during shutdown,
      and the failure is legitimate, on concurrent calls to mysql_*_destroy(),
      when destroying the instrumentation of an object ... twice.
      During shutdown this has no consequences for the performance schema,
      so the assert is relaxed with the "|| ready_to_exit" condition as a work
      around until Bug#56666 is fixed.
    */
    uint32 copy= PFS_atomic::load_u32(&m_version_state);
    /* Make sure the record was ALLOCATED. */
    DBUG_ASSERT(((copy & STATE_MASK) == PFS_LOCK_ALLOCATED) || ready_to_exit);
    /* Keep the same version, set the FREE state */
    uint32 new_val= (copy & VERSION_MASK) + PFS_LOCK_FREE;
    PFS_atomic::store_u32(&m_version_state, new_val);
  }

  void begin_optimistic_lock(struct pfs_lock *copy)
  {
    copy->m_version_state= PFS_atomic::load_u32(&m_version_state);
  }

  bool end_optimistic_lock(struct pfs_lock *copy)
  {
    /* Check there was valid data to look at. */
    if ((copy->m_version_state & STATE_MASK) != PFS_LOCK_ALLOCATED)
      return false;

    /* Check the version + state has not changed. */
    if (copy->m_version_state != PFS_atomic::load_u32(&m_version_state))
      return false;

    return true;
  }

  uint32 get_version()
  {
    return (PFS_atomic::load_u32(&m_version_state) & VERSION_MASK);
  }
};


#endif