rtems-rfs-block.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-2-Clause */
 
/*
 *  COPYRIGHT (c) 2010 Chris Johns <chrisj@rtems.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
 
#if !defined (_RTEMS_RFS_BLOCK_H_)
#define _RTEMS_RFS_BLOCK_H_
 
#include <rtems/rfs/rtems-rfs-block-pos.h>
#include <rtems/rfs/rtems-rfs-buffer.h>
#include <rtems/rfs/rtems-rfs-data.h>
#include <rtems/rfs/rtems-rfs-file-system.h>
 
#define rtems_rfs_block_get_number(_h, _b) \
  ((rtems_rfs_block_no) \
   (rtems_rfs_read_u32 (rtems_rfs_buffer_data (_h) + \
                        ((_b) * sizeof (rtems_rfs_block_no)))))
 
#define rtems_rfs_block_set_number(_h, _b, _n) \
  do { \
    rtems_rfs_write_u32 (rtems_rfs_buffer_data (_h) + \
                         ((_b) * sizeof (rtems_rfs_block_no)), (_n)); \
    rtems_rfs_buffer_mark_dirty (_h); \
  } while (0)
 
typedef struct rtems_rfs_block_map_s
{
  bool dirty;
 
  rtems_rfs_inode_handle* inode;
 
  rtems_rfs_block_size size;
 
  rtems_rfs_block_pos bpos;
 
  rtems_rfs_block_no last_map_block;
 
  rtems_rfs_block_no last_data_block;
 
  uint32_t blocks[RTEMS_RFS_INODE_BLOCKS];
 
  rtems_rfs_buffer_handle singly_buffer;
 
  rtems_rfs_buffer_handle doubly_buffer;
 
} rtems_rfs_block_map;
 
#define rtems_rfs_block_map_is_dirty(_m) ((_m)->dirty)
 
#define rtems_rfs_block_map_count(_m) ((_m)->size.count)
 
#define rtems_rfs_block_map_size(_m) (&((_m)->size))
 
#define rtems_rfs_block_map_size_offset(_m) ((_m)->size.offset)
 
#define rtems_rfs_block_map_last(_m) \
  rtems_rfs_block_pos_last_block (&(_m)->bpos, &(_m)->size)
 
#define rtems_rfs_block_map_past_end(_m, _p) \
  rtems_rfs_block_pos_past_end (_p, &(_m)->size)
 
#define rtems_rfs_block_map_pos(_f, _m) \
  rtems_rfs_block_get_pos (_f, &(_m)->bpos)
 
#define rtems_rfs_block_map_block(_m) ((_m)->bpos.bno)
 
#define rtems_rfs_block_map_block_offset(_m) ((_m)->bpos.boff)
 
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
                                     rtems_rfs_block_off  offset)
{
  map->size.offset = offset;
  map->dirty = true;
}
 
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map*  map,
                              rtems_rfs_block_size* size)
{
  rtems_rfs_block_copy_size (&map->size, size);
  map->dirty = true;
}
int rtems_rfs_block_map_open (rtems_rfs_file_system*  fs,
                              rtems_rfs_inode_handle* inode,
                              rtems_rfs_block_map*    map);
 
int rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
                               rtems_rfs_block_map*   map);
 
int rtems_rfs_block_map_find (rtems_rfs_file_system*  fs,
                              rtems_rfs_block_map*    map,
                              rtems_rfs_block_pos*    bpos,
                              rtems_rfs_buffer_block* block);
 
int rtems_rfs_block_map_seek (rtems_rfs_file_system*  fs,
                              rtems_rfs_block_map*    map,
                              rtems_rfs_pos_rel       offset,
                              rtems_rfs_buffer_block* block);
 
int rtems_rfs_block_map_next_block (rtems_rfs_file_system*  fs,
                                    rtems_rfs_block_map*    map,
                                    rtems_rfs_buffer_block* block);
 
int rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
                              rtems_rfs_block_map*   map,
                              size_t                 blocks,
                              rtems_rfs_block_no*    new_block);
 
int rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
                                rtems_rfs_block_map*   map,
                                size_t                 blocks);
 
int rtems_rfs_block_map_free_all (rtems_rfs_file_system* fs,
                                  rtems_rfs_block_map*   map);
 
#endif