1/* SPDX-License-Identifier: GPL-2.0-only */
  2/*
  3 * Copyright (C) 2011 Red Hat, Inc.
  4 *
  5 * This file is released under the GPL.
  6 */
  7
  8#ifndef _LINUX_DM_SPACE_MAP_H
  9#define _LINUX_DM_SPACE_MAP_H
 10
 11#include "dm-block-manager.h"
 12
 13typedef void (*dm_sm_threshold_fn)(void *context);
 14
 15/*
 16 * struct dm_space_map keeps a record of how many times each block in a device
 17 * is referenced.  It needs to be fixed on disk as part of the transaction.
 18 */
 19struct dm_space_map {
 20	void (*destroy)(struct dm_space_map *sm);
 21
 22	/*
 23	 * You must commit before allocating the newly added space.
 24	 */
 25	int (*extend)(struct dm_space_map *sm, dm_block_t extra_blocks);
 26
 27	/*
 28	 * Extensions do not appear in this count until after commit has
 29	 * been called.
 30	 */
 31	int (*get_nr_blocks)(struct dm_space_map *sm, dm_block_t *count);
 32
 33	/*
 34	 * Space maps must never allocate a block from the previous
 35	 * transaction, in case we need to rollback.  This complicates the
 36	 * semantics of get_nr_free(), it should return the number of blocks
 37	 * that are available for allocation _now_.  For instance you may
 38	 * have blocks with a zero reference count that will not be
 39	 * available for allocation until after the next commit.
 40	 */
 41	int (*get_nr_free)(struct dm_space_map *sm, dm_block_t *count);
 42
 43	int (*get_count)(struct dm_space_map *sm, dm_block_t b, uint32_t *result);
 44	int (*count_is_more_than_one)(struct dm_space_map *sm, dm_block_t b,
 45				      int *result);
 46	int (*set_count)(struct dm_space_map *sm, dm_block_t b, uint32_t count);
 47
 48	int (*commit)(struct dm_space_map *sm);
 49
 50	int (*inc_blocks)(struct dm_space_map *sm, dm_block_t b, dm_block_t e);
 51	int (*dec_blocks)(struct dm_space_map *sm, dm_block_t b, dm_block_t e);
 52
 53	/*
 54	 * new_block will increment the returned block.
 55	 */
 56	int (*new_block)(struct dm_space_map *sm, dm_block_t *b);
 57
 58	/*
 59	 * The root contains all the information needed to fix the space map.
 60	 * Generally this info is small, so squirrel it away in a disk block
 61	 * along with other info.
 62	 */
 63	int (*root_size)(struct dm_space_map *sm, size_t *result);
 64	int (*copy_root)(struct dm_space_map *sm, void *copy_to_here_le, size_t len);
 65
 66	/*
 67	 * You can register one threshold callback which is edge-triggered
 68	 * when the free space in the space map drops below the threshold.
 69	 */
 70	int (*register_threshold_callback)(struct dm_space_map *sm,
 71					   dm_block_t threshold,
 72					   dm_sm_threshold_fn fn,
 73					   void *context);
 74};
 75
 76/*----------------------------------------------------------------*/
 77
 78static inline void dm_sm_destroy(struct dm_space_map *sm)
 79{
 80	if (sm)
 81		sm->destroy(sm);
 82}
 83
 84static inline int dm_sm_extend(struct dm_space_map *sm, dm_block_t extra_blocks)
 85{
 86	return sm->extend(sm, extra_blocks);
 87}
 88
 89static inline int dm_sm_get_nr_blocks(struct dm_space_map *sm, dm_block_t *count)
 90{
 91	return sm->get_nr_blocks(sm, count);
 92}
 93
 94static inline int dm_sm_get_nr_free(struct dm_space_map *sm, dm_block_t *count)
 95{
 96	return sm->get_nr_free(sm, count);
 97}
 98
 99static inline int dm_sm_get_count(struct dm_space_map *sm, dm_block_t b,
100				  uint32_t *result)
101{
102	return sm->get_count(sm, b, result);
103}
104
105static inline int dm_sm_count_is_more_than_one(struct dm_space_map *sm,
106					       dm_block_t b, int *result)
107{
108	return sm->count_is_more_than_one(sm, b, result);
109}
110
111static inline int dm_sm_set_count(struct dm_space_map *sm, dm_block_t b,
112				  uint32_t count)
113{
114	return sm->set_count(sm, b, count);
115}
116
117static inline int dm_sm_commit(struct dm_space_map *sm)
118{
119	return sm->commit(sm);
120}
121
122static inline int dm_sm_inc_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e)
123{
124	return sm->inc_blocks(sm, b, e);
125}
126
127static inline int dm_sm_inc_block(struct dm_space_map *sm, dm_block_t b)
128{
129	return dm_sm_inc_blocks(sm, b, b + 1);
130}
131
132static inline int dm_sm_dec_blocks(struct dm_space_map *sm, dm_block_t b, dm_block_t e)
133{
134	return sm->dec_blocks(sm, b, e);
135}
136
137static inline int dm_sm_dec_block(struct dm_space_map *sm, dm_block_t b)
138{
139	return dm_sm_dec_blocks(sm, b, b + 1);
140}
141
142static inline int dm_sm_new_block(struct dm_space_map *sm, dm_block_t *b)
143{
144	return sm->new_block(sm, b);
145}
146
147static inline int dm_sm_root_size(struct dm_space_map *sm, size_t *result)
148{
149	return sm->root_size(sm, result);
150}
151
152static inline int dm_sm_copy_root(struct dm_space_map *sm, void *copy_to_here_le, size_t len)
153{
154	return sm->copy_root(sm, copy_to_here_le, len);
155}
156
157static inline int dm_sm_register_threshold_callback(struct dm_space_map *sm,
158						    dm_block_t threshold,
159						    dm_sm_threshold_fn fn,
160						    void *context)
161{
162	if (sm->register_threshold_callback)
163		return sm->register_threshold_callback(sm, threshold, fn, context);
164
165	return -EINVAL;
166}
167
168
169#endif	/* _LINUX_DM_SPACE_MAP_H */