xref: /aosp_15_r20/external/stressapptest/src/disk_blocks.h (revision 424fb153c814cbcb3e8904974796228774b3229a)

// Copyright 2008 Google Inc. All Rights Reserved.

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at

//      http://www.apache.org/licenses/LICENSE-2.0

// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Interface for a thread-safe container of disk blocks

#ifndef STRESSAPPTEST_DISK_BLOCKS_H_
#define STRESSAPPTEST_DISK_BLOCKS_H_

#include <sys/types.h>
#include <pthread.h>
#include <time.h>
#include <sys/time.h>
#include <errno.h>
#include <map>
#include <vector>
#include <string>

#include "sattypes.h"

class Pattern;

// Data about a block written to disk so that it can be verified later.
// Thread-unsafe, must be used with locks on non-const methods,
// except for initialized accessor/mutator, which are thread-safe
// (and in fact, is the only method supposed to be accessed from
// someone which is not the thread-safe DiskBlockTable).
class BlockData {
 public:
  BlockData();
  ~BlockData();

  // These are reference counters used to control how many
  // threads currently have a copy of this particular block.
  void IncreaseReferenceCounter() { references_++; }
  void DecreaseReferenceCounter() { references_--; }
  int GetReferenceCounter() const { return references_; }

  // Controls whether the block was written on disk or not.
  // Once written, you cannot "un-written" then without destroying
  // this object.
  void set_initialized();
  bool initialized() const;

  // Accessor methods for some data related to blocks.
  void set_address(uint64 address) { address_ = address; }
  uint64 address() const { return address_; }
  void set_size(uint64 size) { size_ = size; }
  uint64 size() const { return size_; }
  void set_pattern(Pattern *p) { pattern_ = p; }
  Pattern *pattern() { return pattern_; }
 private:
  uint64 address_;  // Address of first sector in block
  uint64 size_;  // Size of block
  int references_;  // Reference counter
  bool initialized_;  // Flag indicating the block was written on disk
  Pattern *pattern_;
  mutable pthread_mutex_t data_mutex_;
  DISALLOW_COPY_AND_ASSIGN(BlockData);
};

// A thread-safe table used to store block data and control access
// to these blocks, letting several threads read and write blocks on
// disk.
class DiskBlockTable {
 public:
  DiskBlockTable();
  virtual ~DiskBlockTable();

  // Returns number of elements stored on table.
  uint64 Size();

  // Sets all initial parameters. Assumes all existent data is
  // invalid and, therefore, must be removed.
  void SetParameters(int sector_size, int write_block_size,
                     int64 device_sectors,
                     int64 segment_size,
                     const string& device_name);

  // During the regular execution, there will be 2 types of threads:
  // - Write thread:  gets a large number of blocks using GetUnusedBlock,
  //                  writes them on disk (if on destructive mode),
  //                  reads block content ONCE from disk and them removes
  //                  the block from queue with RemoveBlock. After a removal a
  //                  block is not available for read threads, but it is
  //                  only removed from memory if there is no reference for
  //                  this block. Note that a write thread also counts as
  //                  a reference.
  // - Read threads:  get one block at a time (if available) with
  //                  GetRandomBlock, reads its content from disk,
  //                  checking whether it is correct or not, and releases
  //                  (Using ReleaseBlock) the block to be erased by the
  //                  write threads. Since several read threads are allowed
  //                  to read the same block, a reference counter is used to
  //                  control when the block can be REALLY erased from
  //                  memory, and all memory management is made by a
  //                  DiskBlockTable instance.

  // Returns a new block in a unused address. Does not
  // grant ownership of the pointer to the caller
  // (use RemoveBlock to delete the block from memory instead).
  BlockData *GetUnusedBlock(int64 segment);

  // Removes block from structure (called by write threads). Returns
  // 1 if successful, 0 otherwise.
  int RemoveBlock(BlockData *block);

  // Gets a random block from the list. Only returns if an element
  // is available (a write thread has got this block, written it on disk,
  // and set this block as initialized). Does not grant ownership of the
  // pointer to the caller (use RemoveBlock to delete the block from
  // memory instead).
  BlockData *GetRandomBlock();

  // Releases block to be erased (called by random threads). Returns
  // 1 if successful, 0 otherwise.
  int ReleaseBlock(BlockData *block);

 protected:
  struct StorageData {
    BlockData *block;
    int pos;
  };
  typedef map<int64, StorageData*> AddrToBlockMap;
  typedef vector<int64> PosToAddrVector;

  // Inserts block in structure, used in tests and by other methods.
  void InsertOnStructure(BlockData *block);

  // Generates a random 64-bit integer.
  // Virtual method so it can be overridden by the tests.
  virtual int64 Random64();

  // Accessor methods for testing.
  const PosToAddrVector& pos_to_addr() const { return pos_to_addr_; }
  const AddrToBlockMap& addr_to_block() const { return addr_to_block_; }

  int sector_size() const { return sector_size_; }
  int write_block_size() const { return write_block_size_; }
  const string& device_name() const { return device_name_; }
  int64 device_sectors() const { return device_sectors_; }
  int64 segment_size() const { return segment_size_; }

 private:
  // Number of retries to allocate sectors.
  static const int kBlockRetry = 100;
  // Actual tables.
  PosToAddrVector pos_to_addr_;
  AddrToBlockMap addr_to_block_;

  // Configuration parameters for block selection
  int sector_size_;  // Sector size, in bytes
  int write_block_size_;  // Block size, in bytes
  string device_name_;  // Device name
  int64 device_sectors_;  // Number of sectors in device
  int64 segment_size_;  // Segment size in bytes
  uint64 size_;  // Number of elements on table
  pthread_mutex_t data_mutex_;
  pthread_cond_t data_condition_;
  pthread_mutex_t parameter_mutex_;
  DISALLOW_COPY_AND_ASSIGN(DiskBlockTable);
};

#endif  // STRESSAPPTEST_BLOCKS_H_