]>
Commit | Line | Data |
---|---|---|
fe000966 | 1 | /* |
a8df0863 | 2 | Copyright (C) 2010 - 2021 Proxmox Server Solutions GmbH |
fe000966 DM |
3 | |
4 | This program is free software: you can redistribute it and/or modify | |
5 | it under the terms of the GNU Affero General Public License as published by | |
6 | the Free Software Foundation, either version 3 of the License, or | |
7 | (at your option) any later version. | |
8 | ||
9 | This program is distributed in the hope that it will be useful, | |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | GNU Affero General Public License for more details. | |
13 | ||
14 | You should have received a copy of the GNU Affero General Public License | |
15 | along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | ||
17 | Author: Dietmar Maurer <dietmar@proxmox.com> | |
18 | ||
19 | */ | |
20 | ||
21 | #ifndef _PVE_MEMDB_H_ | |
22 | #define _PVE_MEMDB_H_ | |
23 | ||
24 | ||
25 | #include <stdio.h> | |
26 | #include <stdlib.h> | |
27 | ||
28 | #include <glib.h> | |
29 | #include <sys/statvfs.h> | |
30 | ||
a8df0863 TL |
31 | #define MEMDB_MAX_FILE_SIZE (1024 * 1024) // 1 MiB |
32 | #define MEMDB_MAX_FSSIZE (128 * 1024 * 1024) // 128 MiB | |
33 | #define MEMDB_MAX_INODES (256 * 1024) // 256k | |
fe000966 DM |
34 | |
35 | #define MEMDB_BLOCKSIZE 4096 | |
36 | #define MEMDB_BLOCKS ((MEMDB_MAX_FSSIZE + MEMDB_BLOCKSIZE - 1)/MEMDB_BLOCKSIZE) | |
37 | ||
38 | typedef struct memdb_tree_entry memdb_tree_entry_t; | |
39 | struct memdb_tree_entry { | |
40 | guint64 parent; | |
41 | guint64 inode; | |
42 | guint64 version; | |
43 | guint32 writer; | |
44 | guint32 mtime; | |
45 | guint32 size; | |
46 | char type; /* DT_REG .. regular file, DT_DIR ... directory */ | |
47 | union { | |
48 | GHashTable *entries; | |
49 | gpointer value; | |
50 | } data; | |
2a588832 | 51 | char name[]; |
fe000966 DM |
52 | }; |
53 | ||
54 | typedef struct { | |
55 | guint64 inode; | |
56 | char digest[32]; /* SHA256 digest */ | |
57 | } memdb_index_extry_t; | |
58 | ||
59 | typedef struct { | |
60 | guint64 version; | |
61 | guint64 last_inode; | |
62 | guint32 writer; | |
63 | guint32 mtime; | |
64 | guint32 size; /* number of entries */ | |
65 | guint32 bytes; /* total bytes allocated */ | |
2a588832 | 66 | memdb_index_extry_t entries[]; |
fe000966 DM |
67 | } memdb_index_t; |
68 | ||
69 | typedef struct db_backend db_backend_t; | |
70 | ||
71 | typedef struct { | |
72 | char *path; | |
73 | guint32 ltime; | |
74 | guchar csum[32]; | |
75 | } memdb_lock_info_t; | |
76 | ||
77 | typedef struct { | |
78 | char *dbfilename; | |
79 | gboolean errors; | |
80 | memdb_tree_entry_t *root; | |
81 | GHashTable *index; /* map version ==> memdb_tree_entry */ | |
82 | GHashTable *locks; /* contains memdb_lock_info_t */ | |
89fde9ac | 83 | GMutex mutex; |
fe000966 DM |
84 | db_backend_t *bdb; |
85 | } memdb_t; | |
86 | ||
87 | memdb_t * | |
88 | memdb_open(const char *dbfilename); | |
89 | ||
90 | void | |
91 | memdb_close(memdb_t *memdb); | |
92 | ||
93 | gboolean | |
94 | memdb_checkpoint(memdb_t *memdb); | |
95 | ||
96 | gboolean | |
97 | memdb_recreate_vmlist(memdb_t *memdb); | |
98 | ||
99 | gboolean | |
100 | memdb_lock_expired( | |
101 | memdb_t *memdb, | |
102 | const char *path, | |
103 | const guchar csum[32]); | |
104 | ||
105 | void | |
106 | memdb_update_locks(memdb_t *memdb); | |
107 | ||
108 | int | |
109 | memdb_statfs( | |
110 | memdb_t *memdb, | |
111 | struct statvfs *stbuf); | |
112 | ||
113 | int | |
114 | memdb_mkdir( | |
115 | memdb_t *memdb, | |
116 | const char *path, | |
117 | guint32 writer, | |
118 | guint32 mtime); | |
119 | ||
120 | int | |
121 | memdb_mtime( | |
122 | memdb_t *memdb, | |
123 | const char *path, | |
124 | guint32 writer, | |
125 | guint32 mtime); | |
126 | ||
127 | GList * | |
128 | memdb_readdir( | |
129 | memdb_t *memdb, | |
130 | const char *path); | |
131 | ||
132 | void | |
133 | memdb_dirlist_free(GList *dirlist); | |
134 | ||
135 | void | |
136 | tree_entry_debug(memdb_tree_entry_t *te); | |
137 | ||
138 | void | |
139 | tree_entry_print(memdb_tree_entry_t *te); | |
140 | ||
141 | memdb_tree_entry_t * | |
142 | memdb_tree_entry_new(const char *name); | |
143 | ||
144 | memdb_tree_entry_t * | |
145 | memdb_tree_entry_copy( | |
146 | memdb_tree_entry_t *te, | |
147 | gboolean with_data); | |
148 | ||
149 | void | |
150 | memdb_tree_entry_free(memdb_tree_entry_t *te); | |
151 | ||
152 | int | |
153 | memdb_delete( | |
154 | memdb_t *memdb, | |
155 | const char *path, | |
156 | guint32 writer, | |
157 | guint32 mtime); | |
158 | ||
159 | int | |
160 | memdb_read( | |
161 | memdb_t *memdb, | |
162 | const char *path, | |
163 | gpointer *data_ret); | |
164 | ||
4fb4cb7a KG |
165 | int |
166 | memdb_read_nolock( | |
167 | memdb_t *memdb, | |
168 | const char *path, | |
169 | gpointer *data_ret); | |
170 | ||
fe000966 DM |
171 | int |
172 | memdb_create( | |
173 | memdb_t *memdb, | |
174 | const char *path, | |
175 | guint32 writer, | |
176 | guint32 mtime); | |
177 | ||
178 | int | |
179 | memdb_write( | |
180 | memdb_t *memdb, | |
181 | const char *path, | |
182 | guint32 writer, | |
183 | guint32 mtime, | |
184 | gconstpointer data, | |
185 | size_t count, | |
186 | off_t offset, | |
187 | gboolean truncate); | |
188 | ||
189 | memdb_tree_entry_t * | |
190 | memdb_getattr( | |
191 | memdb_t *memdb, | |
192 | const char *path); | |
193 | ||
194 | int | |
195 | memdb_rename( | |
196 | memdb_t *memdb, | |
197 | const char *from, | |
198 | const char *to, | |
199 | guint32 writer, | |
200 | guint32 mtime); | |
201 | ||
202 | void | |
203 | memdb_dump ( | |
204 | memdb_t *memdb); | |
205 | ||
206 | gboolean | |
207 | memdb_compute_checksum( | |
208 | GHashTable *index, | |
209 | memdb_tree_entry_t *root, | |
210 | guchar *csum, | |
211 | size_t csum_len); | |
212 | ||
213 | memdb_index_t * | |
214 | memdb_encode_index( | |
215 | GHashTable *index, | |
216 | memdb_tree_entry_t *root); | |
217 | ||
218 | void | |
219 | memdb_dump_index (memdb_index_t *idx); | |
220 | ||
221 | memdb_index_t * | |
222 | memdb_index_copy(memdb_index_t *idx); | |
223 | ||
224 | gboolean | |
225 | memdb_tree_entry_csum( | |
226 | memdb_tree_entry_t *te, | |
227 | guchar csum[32]); | |
228 | ||
229 | db_backend_t * | |
230 | bdb_backend_open( | |
231 | const char *filename, | |
232 | memdb_tree_entry_t *root, | |
233 | GHashTable *index); | |
234 | ||
235 | void | |
236 | bdb_backend_close(db_backend_t *bdb); | |
237 | ||
238 | int | |
239 | bdb_backend_write( | |
240 | db_backend_t *bdb, | |
241 | guint64 inode, | |
242 | guint64 parent, | |
243 | guint64 version, | |
244 | guint32 writer, | |
245 | guint32 mtime, | |
246 | guint32 size, | |
247 | char type, | |
248 | char *name, | |
249 | gpointer value, | |
250 | guint64 delete_inode); | |
251 | ||
252 | gboolean | |
253 | bdb_backend_commit_update( | |
254 | memdb_t *memdb, | |
255 | memdb_index_t *master, | |
256 | memdb_index_t *slave, | |
257 | GList *inodes); | |
258 | ||
259 | ||
260 | #endif /* _PVE_MEMDB_H_ */ |