1 | /*
|
---|
2 | * openfs.c --- open an ext2 filesystem
|
---|
3 | *
|
---|
4 | * Copyright (C) 1993, 1994, 1995, 1996 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 <stdio.h>
|
---|
13 | #include <string.h>
|
---|
14 | #if HAVE_UNISTD_H
|
---|
15 | #include <unistd.h>
|
---|
16 | #endif
|
---|
17 | #include <fcntl.h>
|
---|
18 | #include <time.h>
|
---|
19 | #if HAVE_SYS_STAT_H
|
---|
20 | #include <sys/stat.h>
|
---|
21 | #endif
|
---|
22 | #if HAVE_SYS_TYPES_H
|
---|
23 | #include <sys/types.h>
|
---|
24 | #endif
|
---|
25 |
|
---|
26 | #include "ext2_fs.h"
|
---|
27 |
|
---|
28 |
|
---|
29 | #include "ext2fs.h"
|
---|
30 | #include "e2image.h"
|
---|
31 |
|
---|
32 | blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block, dgrp_t i)
|
---|
33 | {
|
---|
34 | int bg;
|
---|
35 | int has_super = 0;
|
---|
36 | int ret_blk;
|
---|
37 |
|
---|
38 | if (!(fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) ||
|
---|
39 | (i < fs->super->s_first_meta_bg))
|
---|
40 | return (group_block + i + 1);
|
---|
41 |
|
---|
42 | bg = (fs->blocksize / sizeof (struct ext2_group_desc)) * i;
|
---|
43 | if (ext2fs_bg_has_super(fs, bg))
|
---|
44 | has_super = 1;
|
---|
45 | ret_blk = (fs->super->s_first_data_block + has_super +
|
---|
46 | (bg * fs->super->s_blocks_per_group));
|
---|
47 | /*
|
---|
48 | * If group_block is not the normal value, we're trying to use
|
---|
49 | * the backup group descriptors and superblock --- so use the
|
---|
50 | * alternate location of the second block group in the
|
---|
51 | * metablock group. Ideally we should be testing each bg
|
---|
52 | * descriptor block individually for correctness, but we don't
|
---|
53 | * have the infrastructure in place to do that.
|
---|
54 | */
|
---|
55 | if (group_block != fs->super->s_first_data_block &&
|
---|
56 | ((ret_blk + fs->super->s_blocks_per_group) <
|
---|
57 | fs->super->s_blocks_count))
|
---|
58 | ret_blk += fs->super->s_blocks_per_group;
|
---|
59 | return ret_blk;
|
---|
60 | }
|
---|
61 |
|
---|
62 | errcode_t ext2fs_open(const char *name, int flags, int superblock,
|
---|
63 | unsigned int block_size, io_manager manager,
|
---|
64 | ext2_filsys *ret_fs)
|
---|
65 | {
|
---|
66 | return ext2fs_open2(name, 0, flags, superblock, block_size,
|
---|
67 | manager, ret_fs);
|
---|
68 | }
|
---|
69 |
|
---|
70 | /*
|
---|
71 | * Note: if superblock is non-zero, block-size must also be non-zero.
|
---|
72 | * Superblock and block_size can be zero to use the default size.
|
---|
73 | *
|
---|
74 | * Valid flags for ext2fs_open()
|
---|
75 | *
|
---|
76 | * EXT2_FLAG_RW - Open the filesystem for read/write.
|
---|
77 | * EXT2_FLAG_FORCE - Open the filesystem even if some of the
|
---|
78 | * features aren't supported.
|
---|
79 | * EXT2_FLAG_JOURNAL_DEV_OK - Open an ext3 journal device
|
---|
80 | */
|
---|
81 | errcode_t ext2fs_open2(const char *name, const char *io_options,
|
---|
82 | int flags, int superblock,
|
---|
83 | unsigned int block_size, io_manager manager,
|
---|
84 | ext2_filsys *ret_fs)
|
---|
85 | {
|
---|
86 | ext2_filsys fs;
|
---|
87 | errcode_t retval;
|
---|
88 | unsigned long i;
|
---|
89 | int groups_per_block, blocks_per_group;
|
---|
90 | blk_t group_block, blk;
|
---|
91 | char *dest, *cp;
|
---|
92 | #if BB_BIG_ENDIAN
|
---|
93 | int j;
|
---|
94 | struct ext2_group_desc *gdp;
|
---|
95 | #endif
|
---|
96 |
|
---|
97 | EXT2_CHECK_MAGIC(manager, EXT2_ET_MAGIC_IO_MANAGER);
|
---|
98 |
|
---|
99 | retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs);
|
---|
100 | if (retval)
|
---|
101 | return retval;
|
---|
102 |
|
---|
103 | memset(fs, 0, sizeof(struct struct_ext2_filsys));
|
---|
104 | fs->magic = EXT2_ET_MAGIC_EXT2FS_FILSYS;
|
---|
105 | fs->flags = flags;
|
---|
106 | fs->umask = 022;
|
---|
107 | retval = ext2fs_get_mem(strlen(name)+1, &fs->device_name);
|
---|
108 | if (retval)
|
---|
109 | goto cleanup;
|
---|
110 | strcpy(fs->device_name, name);
|
---|
111 | cp = strchr(fs->device_name, '?');
|
---|
112 | if (!io_options && cp) {
|
---|
113 | *cp++ = 0;
|
---|
114 | io_options = cp;
|
---|
115 | }
|
---|
116 |
|
---|
117 | retval = manager->open(fs->device_name,
|
---|
118 | (flags & EXT2_FLAG_RW) ? IO_FLAG_RW : 0,
|
---|
119 | &fs->io);
|
---|
120 | if (retval)
|
---|
121 | goto cleanup;
|
---|
122 | if (io_options &&
|
---|
123 | (retval = io_channel_set_options(fs->io, io_options)))
|
---|
124 | goto cleanup;
|
---|
125 | fs->image_io = fs->io;
|
---|
126 | fs->io->app_data = fs;
|
---|
127 | retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &fs->super);
|
---|
128 | if (retval)
|
---|
129 | goto cleanup;
|
---|
130 | if (flags & EXT2_FLAG_IMAGE_FILE) {
|
---|
131 | retval = ext2fs_get_mem(sizeof(struct ext2_image_hdr),
|
---|
132 | &fs->image_header);
|
---|
133 | if (retval)
|
---|
134 | goto cleanup;
|
---|
135 | retval = io_channel_read_blk(fs->io, 0,
|
---|
136 | -(int)sizeof(struct ext2_image_hdr),
|
---|
137 | fs->image_header);
|
---|
138 | if (retval)
|
---|
139 | goto cleanup;
|
---|
140 | if (fs->image_header->magic_number != EXT2_ET_MAGIC_E2IMAGE)
|
---|
141 | return EXT2_ET_MAGIC_E2IMAGE;
|
---|
142 | superblock = 1;
|
---|
143 | block_size = fs->image_header->fs_blocksize;
|
---|
144 | }
|
---|
145 |
|
---|
146 | /*
|
---|
147 | * If the user specifies a specific block # for the
|
---|
148 | * superblock, then he/she must also specify the block size!
|
---|
149 | * Otherwise, read the master superblock located at offset
|
---|
150 | * SUPERBLOCK_OFFSET from the start of the partition.
|
---|
151 | *
|
---|
152 | * Note: we only save a backup copy of the superblock if we
|
---|
153 | * are reading the superblock from the primary superblock location.
|
---|
154 | */
|
---|
155 | if (superblock) {
|
---|
156 | if (!block_size) {
|
---|
157 | retval = EXT2_ET_INVALID_ARGUMENT;
|
---|
158 | goto cleanup;
|
---|
159 | }
|
---|
160 | io_channel_set_blksize(fs->io, block_size);
|
---|
161 | group_block = superblock;
|
---|
162 | fs->orig_super = 0;
|
---|
163 | } else {
|
---|
164 | io_channel_set_blksize(fs->io, SUPERBLOCK_OFFSET);
|
---|
165 | superblock = 1;
|
---|
166 | group_block = 0;
|
---|
167 | retval = ext2fs_get_mem(SUPERBLOCK_SIZE, &fs->orig_super);
|
---|
168 | if (retval)
|
---|
169 | goto cleanup;
|
---|
170 | }
|
---|
171 | retval = io_channel_read_blk(fs->io, superblock, -SUPERBLOCK_SIZE,
|
---|
172 | fs->super);
|
---|
173 | if (retval)
|
---|
174 | goto cleanup;
|
---|
175 | if (fs->orig_super)
|
---|
176 | memcpy(fs->orig_super, fs->super, SUPERBLOCK_SIZE);
|
---|
177 |
|
---|
178 | #if BB_BIG_ENDIAN
|
---|
179 | if ((fs->super->s_magic == ext2fs_swab16(EXT2_SUPER_MAGIC)) ||
|
---|
180 | (fs->flags & EXT2_FLAG_SWAP_BYTES)) {
|
---|
181 | fs->flags |= EXT2_FLAG_SWAP_BYTES;
|
---|
182 |
|
---|
183 | ext2fs_swap_super(fs->super);
|
---|
184 | }
|
---|
185 | #endif
|
---|
186 |
|
---|
187 | if (fs->super->s_magic != EXT2_SUPER_MAGIC) {
|
---|
188 | retval = EXT2_ET_BAD_MAGIC;
|
---|
189 | goto cleanup;
|
---|
190 | }
|
---|
191 | if (fs->super->s_rev_level > EXT2_LIB_CURRENT_REV) {
|
---|
192 | retval = EXT2_ET_REV_TOO_HIGH;
|
---|
193 | goto cleanup;
|
---|
194 | }
|
---|
195 |
|
---|
196 | /*
|
---|
197 | * Check for feature set incompatibility
|
---|
198 | */
|
---|
199 | if (!(flags & EXT2_FLAG_FORCE)) {
|
---|
200 | if (fs->super->s_feature_incompat &
|
---|
201 | ~EXT2_LIB_FEATURE_INCOMPAT_SUPP) {
|
---|
202 | retval = EXT2_ET_UNSUPP_FEATURE;
|
---|
203 | goto cleanup;
|
---|
204 | }
|
---|
205 | if ((flags & EXT2_FLAG_RW) &&
|
---|
206 | (fs->super->s_feature_ro_compat &
|
---|
207 | ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP)) {
|
---|
208 | retval = EXT2_ET_RO_UNSUPP_FEATURE;
|
---|
209 | goto cleanup;
|
---|
210 | }
|
---|
211 | if (!(flags & EXT2_FLAG_JOURNAL_DEV_OK) &&
|
---|
212 | (fs->super->s_feature_incompat &
|
---|
213 | EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
|
---|
214 | retval = EXT2_ET_UNSUPP_FEATURE;
|
---|
215 | goto cleanup;
|
---|
216 | }
|
---|
217 | }
|
---|
218 |
|
---|
219 | fs->blocksize = EXT2_BLOCK_SIZE(fs->super);
|
---|
220 | if (fs->blocksize == 0) {
|
---|
221 | retval = EXT2_ET_CORRUPT_SUPERBLOCK;
|
---|
222 | goto cleanup;
|
---|
223 | }
|
---|
224 | fs->fragsize = EXT2_FRAG_SIZE(fs->super);
|
---|
225 | fs->inode_blocks_per_group = ((fs->super->s_inodes_per_group *
|
---|
226 | EXT2_INODE_SIZE(fs->super) +
|
---|
227 | EXT2_BLOCK_SIZE(fs->super) - 1) /
|
---|
228 | EXT2_BLOCK_SIZE(fs->super));
|
---|
229 | if (block_size) {
|
---|
230 | if (block_size != fs->blocksize) {
|
---|
231 | retval = EXT2_ET_UNEXPECTED_BLOCK_SIZE;
|
---|
232 | goto cleanup;
|
---|
233 | }
|
---|
234 | }
|
---|
235 | /*
|
---|
236 | * Set the blocksize to the filesystem's blocksize.
|
---|
237 | */
|
---|
238 | io_channel_set_blksize(fs->io, fs->blocksize);
|
---|
239 |
|
---|
240 | /*
|
---|
241 | * If this is an external journal device, don't try to read
|
---|
242 | * the group descriptors, because they're not there.
|
---|
243 | */
|
---|
244 | if (fs->super->s_feature_incompat &
|
---|
245 | EXT3_FEATURE_INCOMPAT_JOURNAL_DEV) {
|
---|
246 | fs->group_desc_count = 0;
|
---|
247 | *ret_fs = fs;
|
---|
248 | return 0;
|
---|
249 | }
|
---|
250 |
|
---|
251 | /*
|
---|
252 | * Read group descriptors
|
---|
253 | */
|
---|
254 | blocks_per_group = EXT2_BLOCKS_PER_GROUP(fs->super);
|
---|
255 | if (blocks_per_group == 0 ||
|
---|
256 | blocks_per_group > EXT2_MAX_BLOCKS_PER_GROUP(fs->super) ||
|
---|
257 | fs->inode_blocks_per_group > EXT2_MAX_INODES_PER_GROUP(fs->super)) {
|
---|
258 | retval = EXT2_ET_CORRUPT_SUPERBLOCK;
|
---|
259 | goto cleanup;
|
---|
260 | }
|
---|
261 | fs->group_desc_count = (fs->super->s_blocks_count -
|
---|
262 | fs->super->s_first_data_block +
|
---|
263 | blocks_per_group - 1) / blocks_per_group;
|
---|
264 | fs->desc_blocks = (fs->group_desc_count +
|
---|
265 | EXT2_DESC_PER_BLOCK(fs->super) - 1)
|
---|
266 | / EXT2_DESC_PER_BLOCK(fs->super);
|
---|
267 | retval = ext2fs_get_mem(fs->desc_blocks * fs->blocksize,
|
---|
268 | &fs->group_desc);
|
---|
269 | if (retval)
|
---|
270 | goto cleanup;
|
---|
271 | if (!group_block)
|
---|
272 | group_block = fs->super->s_first_data_block;
|
---|
273 | dest = (char *) fs->group_desc;
|
---|
274 | groups_per_block = fs->blocksize / sizeof(struct ext2_group_desc);
|
---|
275 | for (i=0 ; i < fs->desc_blocks; i++) {
|
---|
276 | blk = ext2fs_descriptor_block_loc(fs, group_block, i);
|
---|
277 | retval = io_channel_read_blk(fs->io, blk, 1, dest);
|
---|
278 | if (retval)
|
---|
279 | goto cleanup;
|
---|
280 | #if BB_BIG_ENDIAN
|
---|
281 | if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
|
---|
282 | gdp = (struct ext2_group_desc *) dest;
|
---|
283 | for (j=0; j < groups_per_block; j++)
|
---|
284 | ext2fs_swap_group_desc(gdp++);
|
---|
285 | }
|
---|
286 | #endif
|
---|
287 | dest += fs->blocksize;
|
---|
288 | }
|
---|
289 |
|
---|
290 | *ret_fs = fs;
|
---|
291 | return 0;
|
---|
292 | cleanup:
|
---|
293 | ext2fs_free(fs);
|
---|
294 | return retval;
|
---|
295 | }
|
---|
296 |
|
---|
297 | /*
|
---|
298 | * Set/get the filesystem data I/O channel.
|
---|
299 | *
|
---|
300 | * These functions are only valid if EXT2_FLAG_IMAGE_FILE is true.
|
---|
301 | */
|
---|
302 | errcode_t ext2fs_get_data_io(ext2_filsys fs, io_channel *old_io)
|
---|
303 | {
|
---|
304 | if ((fs->flags & EXT2_FLAG_IMAGE_FILE) == 0)
|
---|
305 | return EXT2_ET_NOT_IMAGE_FILE;
|
---|
306 | if (old_io) {
|
---|
307 | *old_io = (fs->image_io == fs->io) ? 0 : fs->io;
|
---|
308 | }
|
---|
309 | return 0;
|
---|
310 | }
|
---|
311 |
|
---|
312 | errcode_t ext2fs_set_data_io(ext2_filsys fs, io_channel new_io)
|
---|
313 | {
|
---|
314 | if ((fs->flags & EXT2_FLAG_IMAGE_FILE) == 0)
|
---|
315 | return EXT2_ET_NOT_IMAGE_FILE;
|
---|
316 | fs->io = new_io ? new_io : fs->image_io;
|
---|
317 | return 0;
|
---|
318 | }
|
---|
319 |
|
---|
320 | errcode_t ext2fs_rewrite_to_io(ext2_filsys fs, io_channel new_io)
|
---|
321 | {
|
---|
322 | if ((fs->flags & EXT2_FLAG_IMAGE_FILE) == 0)
|
---|
323 | return EXT2_ET_NOT_IMAGE_FILE;
|
---|
324 | fs->io = fs->image_io = new_io;
|
---|
325 | fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_RW |
|
---|
326 | EXT2_FLAG_BB_DIRTY | EXT2_FLAG_IB_DIRTY;
|
---|
327 | fs->flags &= ~EXT2_FLAG_IMAGE_FILE;
|
---|
328 | return 0;
|
---|
329 | }
|
---|