1 /*
2 * irel_ma.c
3 *
4 * Copyright (C) 1996, 1997 Theodore Ts'o.
5 *
6 * %Begin-Header%
7 * This file may be redistributed under the terms of the GNU Public
8 * License.
9 * %End-Header%
10 */
11
12 #include <fcntl.h>
13 #include <stdio.h>
14 #include <string.h>
15 #if HAVE_UNISTD_H
16 #include <unistd.h>
17 #endif
18 #if HAVE_ERRNO_H
19 #include <errno.h>
20 #endif
21
22 #include "ext2_fs.h"
23 #include "ext2fs.h"
24 #include "irel.h"
25
26 static errcode_t ima_put(ext2_irel irel, ext2_ino_t old,
27 struct ext2_inode_relocate_entry *ent);
28 static errcode_t ima_get(ext2_irel irel, ext2_ino_t old,
29 struct ext2_inode_relocate_entry *ent);
30 static errcode_t ima_get_by_orig(ext2_irel irel, ext2_ino_t orig, ext2_ino_t *old,
31 struct ext2_inode_relocate_entry *ent);
32 static errcode_t ima_start_iter(ext2_irel irel);
33 static errcode_t ima_next(ext2_irel irel, ext2_ino_t *old,
34 struct ext2_inode_relocate_entry *ent);
35 static errcode_t ima_add_ref(ext2_irel irel, ext2_ino_t ino,
36 struct ext2_inode_reference *ref);
37 static errcode_t ima_start_iter_ref(ext2_irel irel, ext2_ino_t ino);
38 static errcode_t ima_next_ref(ext2_irel irel, struct ext2_inode_reference *ref);
39 static errcode_t ima_move(ext2_irel irel, ext2_ino_t old, ext2_ino_t new);
40 static errcode_t ima_delete(ext2_irel irel, ext2_ino_t old);
41 static errcode_t ima_free(ext2_irel irel);
42
43 /*
44 * This data structure stores the array of inode references; there is
45 * a structure for each inode.
46 */
47 struct inode_reference_entry {
48 __u16 num;
49 struct ext2_inode_reference *refs;
50 };
51
52 struct irel_ma {
53 __u32 magic;
54 ext2_ino_t max_inode;
55 ext2_ino_t ref_current;
56 int ref_iter;
57 ext2_ino_t *orig_map;
58 struct ext2_inode_relocate_entry *entries;
59 struct inode_reference_entry *ref_entries;
60 };
61
ext2fs_irel_memarray_create(char * name,ext2_ino_t max_inode,ext2_irel * new_irel)62 errcode_t ext2fs_irel_memarray_create(char *name, ext2_ino_t max_inode,
63 ext2_irel *new_irel)
64 {
65 ext2_irel irel = 0;
66 errcode_t retval;
67 struct irel_ma *ma = 0;
68 size_t size;
69
70 *new_irel = 0;
71
72 /*
73 * Allocate memory structures
74 */
75 retval = ext2fs_get_mem(sizeof(struct ext2_inode_relocation_table),
76 &irel);
77 if (retval)
78 goto errout;
79 memset(irel, 0, sizeof(struct ext2_inode_relocation_table));
80
81 retval = ext2fs_get_mem(strlen(name)+1, &irel->name);
82 if (retval)
83 goto errout;
84 strcpy(irel->name, name);
85
86 retval = ext2fs_get_mem(sizeof(struct irel_ma), &ma);
87 if (retval)
88 goto errout;
89 memset(ma, 0, sizeof(struct irel_ma));
90 irel->priv_data = ma;
91
92 size = (size_t) (sizeof(ext2_ino_t) * (max_inode+1));
93 retval = ext2fs_get_array(max_inode+1, sizeof(ext2_ino_t),
94 &ma->orig_map);
95 if (retval)
96 goto errout;
97 memset(ma->orig_map, 0, size);
98
99 size = (size_t) (sizeof(struct ext2_inode_relocate_entry) *
100 (max_inode+1));
101 retval = ext2fs_get_array((max_inode+1,
102 sizeof(struct ext2_inode_relocate_entry), &ma->entries);
103 if (retval)
104 goto errout;
105 memset(ma->entries, 0, size);
106
107 size = (size_t) (sizeof(struct inode_reference_entry) *
108 (max_inode+1));
109 retval = ext2fs_get_mem(max_inode+1,
110 sizeof(struct inode_reference_entry), &ma->ref_entries);
111 if (retval)
112 goto errout;
113 memset(ma->ref_entries, 0, size);
114 ma->max_inode = max_inode;
115
116 /*
117 * Fill in the irel data structure
118 */
119 irel->put = ima_put;
120 irel->get = ima_get;
121 irel->get_by_orig = ima_get_by_orig;
122 irel->start_iter = ima_start_iter;
123 irel->next = ima_next;
124 irel->add_ref = ima_add_ref;
125 irel->start_iter_ref = ima_start_iter_ref;
126 irel->next_ref = ima_next_ref;
127 irel->move = ima_move;
128 irel->delete = ima_delete;
129 irel->free = ima_free;
130
131 *new_irel = irel;
132 return 0;
133
134 errout:
135 ima_free(irel);
136 return retval;
137 }
138
139 static errcode_t ima_put(ext2_irel irel, ext2_ino_t old,
140 struct ext2_inode_relocate_entry *ent)
141 {
142 struct inode_reference_entry *ref_ent;
143 struct irel_ma *ma;
144 errcode_t retval;
145 size_t size, old_size;
146
147 ma = irel->priv_data;
148 if (old > ma->max_inode)
149 return EXT2_ET_INVALID_ARGUMENT;
150
151 /*
152 * Force the orig field to the correct value; the application
153 * program shouldn't be messing with this field.
154 */
155 if (ma->entries[(unsigned) old].new == 0)
156 ent->orig = old;
157 else
158 ent->orig = ma->entries[(unsigned) old].orig;
159
160 /*
161 * If max_refs has changed, reallocate the refs array
162 */
163 ref_ent = ma->ref_entries + (unsigned) old;
164 if (ref_ent->refs && ent->max_refs !=
165 ma->entries[(unsigned) old].max_refs) {
166 size = (sizeof(struct ext2_inode_reference) * ent->max_refs);
167 old_size = (sizeof(struct ext2_inode_reference) *
168 ma->entries[(unsigned) old].max_refs);
169 retval = ext2fs_resize_mem(old_size, size, &ref_ent->refs);
170 if (retval)
171 return retval;
172 }
173
174 ma->entries[(unsigned) old] = *ent;
175 ma->orig_map[(unsigned) ent->orig] = old;
176 return 0;
177 }
178
179 static errcode_t ima_get(ext2_irel irel, ext2_ino_t old,
180 struct ext2_inode_relocate_entry *ent)
181 {
182 struct irel_ma *ma;
183
184 ma = irel->priv_data;
185 if (old > ma->max_inode)
186 return EXT2_ET_INVALID_ARGUMENT;
187 if (ma->entries[(unsigned) old].new == 0)
188 return ENOENT;
189 *ent = ma->entries[(unsigned) old];
190 return 0;
191 }
192
193 static errcode_t ima_get_by_orig(ext2_irel irel, ext2_ino_t orig, ext2_ino_t *old,
194 struct ext2_inode_relocate_entry *ent)
195 {
196 struct irel_ma *ma;
197 ext2_ino_t ino;
198
199 ma = irel->priv_data;
200 if (orig > ma->max_inode)
201 return EXT2_ET_INVALID_ARGUMENT;
202 ino = ma->orig_map[(unsigned) orig];
203 if (ino == 0)
204 return ENOENT;
205 *old = ino;
206 *ent = ma->entries[(unsigned) ino];
207 return 0;
208 }
209
210 static errcode_t ima_start_iter(ext2_irel irel)
211 {
212 irel->current = 0;
213 return 0;
214 }
215
216 static errcode_t ima_next(ext2_irel irel, ext2_ino_t *old,
217 struct ext2_inode_relocate_entry *ent)
218 {
219 struct irel_ma *ma;
220
221 ma = irel->priv_data;
222 while (++irel->current < ma->max_inode) {
223 if (ma->entries[(unsigned) irel->current].new == 0)
224 continue;
225 *old = irel->current;
226 *ent = ma->entries[(unsigned) irel->current];
227 return 0;
228 }
229 *old = 0;
230 return 0;
231 }
232
233 static errcode_t ima_add_ref(ext2_irel irel, ext2_ino_t ino,
234 struct ext2_inode_reference *ref)
235 {
236 struct irel_ma *ma;
237 size_t size;
238 struct inode_reference_entry *ref_ent;
239 struct ext2_inode_relocate_entry *ent;
240 errcode_t retval;
241
242 ma = irel->priv_data;
243 if (ino > ma->max_inode)
244 return EXT2_ET_INVALID_ARGUMENT;
245
246 ref_ent = ma->ref_entries + (unsigned) ino;
247 ent = ma->entries + (unsigned) ino;
248
249 /*
250 * If the inode reference array doesn't exist, create it.
251 */
252 if (ref_ent->refs == 0) {
253 size = (size_t) ((sizeof(struct ext2_inode_reference) *
254 ent->max_refs));
255 retval = ext2fs_get_array(ent->max_refs,
256 sizeof(struct ext2_inode_reference), &ref_ent->refs);
257 if (retval)
258 return retval;
259 memset(ref_ent->refs, 0, size);
260 ref_ent->num = 0;
261 }
262
263 if (ref_ent->num >= ent->max_refs)
264 return EXT2_ET_TOO_MANY_REFS;
265
266 ref_ent->refs[(unsigned) ref_ent->num++] = *ref;
267 return 0;
268 }
269
270 static errcode_t ima_start_iter_ref(ext2_irel irel, ext2_ino_t ino)
271 {
272 struct irel_ma *ma;
273
274 ma = irel->priv_data;
275 if (ino > ma->max_inode)
276 return EXT2_ET_INVALID_ARGUMENT;
277 if (ma->entries[(unsigned) ino].new == 0)
278 return ENOENT;
279 ma->ref_current = ino;
280 ma->ref_iter = 0;
281 return 0;
282 }
283
284 static errcode_t ima_next_ref(ext2_irel irel,
285 struct ext2_inode_reference *ref)
286 {
287 struct irel_ma *ma;
288 struct inode_reference_entry *ref_ent;
289
290 ma = irel->priv_data;
291
292 ref_ent = ma->ref_entries + ma->ref_current;
293
294 if ((ref_ent->refs == NULL) ||
295 (ma->ref_iter >= ref_ent->num)) {
296 ref->block = 0;
297 ref->offset = 0;
298 return 0;
299 }
300 *ref = ref_ent->refs[ma->ref_iter++];
301 return 0;
302 }
303
304
305 static errcode_t ima_move(ext2_irel irel, ext2_ino_t old, ext2_ino_t new)
306 {
307 struct irel_ma *ma;
308
309 ma = irel->priv_data;
310 if ((old > ma->max_inode) || (new > ma->max_inode))
311 return EXT2_ET_INVALID_ARGUMENT;
312 if (ma->entries[(unsigned) old].new == 0)
313 return ENOENT;
314
315 ma->entries[(unsigned) new] = ma->entries[(unsigned) old];
316 if (ma->ref_entries[(unsigned) new].refs)
317 ext2fs_free_mem(&ma->ref_entries[(unsigned) new].refs);
318 ma->ref_entries[(unsigned) new] = ma->ref_entries[(unsigned) old];
319
320 ma->entries[(unsigned) old].new = 0;
321 ma->ref_entries[(unsigned) old].num = 0;
322 ma->ref_entries[(unsigned) old].refs = 0;
323
324 ma->orig_map[ma->entries[new].orig] = new;
325 return 0;
326 }
327
328 static errcode_t ima_delete(ext2_irel irel, ext2_ino_t old)
329 {
330 struct irel_ma *ma;
331
332 ma = irel->priv_data;
333 if (old > ma->max_inode)
334 return EXT2_ET_INVALID_ARGUMENT;
335 if (ma->entries[(unsigned) old].new == 0)
336 return ENOENT;
337
338 ma->entries[old].new = 0;
339 if (ma->ref_entries[(unsigned) old].refs)
340 ext2fs_free_mem(&ma->ref_entries[(unsigned) old].refs);
341 ma->orig_map[ma->entries[(unsigned) old].orig] = 0;
342
343 ma->ref_entries[(unsigned) old].num = 0;
344 ma->ref_entries[(unsigned) old].refs = 0;
345 return 0;
346 }
347
348 static errcode_t ima_free(ext2_irel irel)
349 {
350 struct irel_ma *ma;
351 ext2_ino_t ino;
352
353 if (!irel)
354 return 0;
355
356 ma = irel->priv_data;
357
358 if (ma) {
359 if (ma->orig_map)
360 ext2fs_free_mem(&ma->orig_map);
361 if (ma->entries)
362 ext2fs_free_mem(&ma->entries);
363 if (ma->ref_entries) {
364 for (ino = 0; ino <= ma->max_inode; ino++) {
365 if (ma->ref_entries[(unsigned) ino].refs)
366 ext2fs_free_mem(&ma->ref_entries[(unsigned) ino].refs);
367 }
368 ext2fs_free_mem(&ma->ref_entries);
369 }
370 ext2fs_free_mem(&ma);
371 }
372 if (irel->name)
373 ext2fs_free_mem(&irel->name);
374 ext2fs_free_mem(&irel);
375 return 0;
376 }
377