/*
* inode.c --- utility routines to read and write inodes
- *
+ *
* Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
*
* %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
+ * This file may be redistributed under the terms of the GNU Library
+ * General Public License, version 2.
* %End-Header%
*/
+#include "config.h"
#include <stdio.h>
#include <string.h>
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
-#include <stdlib.h>
+#if HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#include <time.h>
#if HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#include <sys/types.h>
#endif
-#include <linux/ext2_fs.h>
-
+#include "ext2_fs.h"
#include "ext2fsP.h"
+#include "e2image.h"
struct ext2_struct_inode_scan {
errcode_t magic;
ext2_filsys fs;
- ino_t current_inode;
- blk_t current_block;
+ ext2_ino_t current_inode;
+ blk64_t current_block;
dgrp_t current_group;
- ino_t inodes_left;
+ ext2_ino_t inodes_left;
blk_t blocks_left;
dgrp_t groups_left;
blk_t inode_buffer_blocks;
errcode_t (*done_group)(ext2_filsys fs,
ext2_inode_scan scan,
dgrp_t group,
- void * private);
+ void * priv_data);
void * done_group_data;
int bad_block_ptr;
int scan_flags;
int reserved[6];
};
-static errcode_t create_icache(ext2_filsys fs)
+/*
+ * This routine flushes the icache, if it exists.
+ */
+errcode_t ext2fs_flush_icache(ext2_filsys fs)
{
int i;
-
+
+ if (!fs->icache)
+ return 0;
+
+ for (i=0; i < fs->icache->cache_size; i++)
+ fs->icache->cache[i].ino = 0;
+
+ fs->icache->buffer_blk = 0;
+ return 0;
+}
+
+static errcode_t create_icache(ext2_filsys fs)
+{
+ errcode_t retval;
+
if (fs->icache)
return 0;
- fs->icache = malloc(sizeof(struct ext2_inode_cache));
+ retval = ext2fs_get_mem(sizeof(struct ext2_inode_cache), &fs->icache);
+ if (retval)
+ return retval;
+
memset(fs->icache, 0, sizeof(struct ext2_inode_cache));
- fs->icache->buffer = malloc(fs->blocksize);
- if (!fs->icache->buffer) {
- free(fs->icache);
- return EXT2_NO_MEMORY;
+ retval = ext2fs_get_mem(fs->blocksize, &fs->icache->buffer);
+ if (retval) {
+ ext2fs_free_mem(&fs->icache);
+ return retval;
}
fs->icache->buffer_blk = 0;
fs->icache->cache_last = -1;
fs->icache->cache_size = 4;
fs->icache->refcount = 1;
- fs->icache->cache = malloc(sizeof(struct ext2_inode_cache_ent)
- * fs->icache->cache_size);
- if (!fs->icache->cache) {
- free(fs->icache->buffer);
- free(fs->icache);
- return EXT2_NO_MEMORY;
+ retval = ext2fs_get_array(fs->icache->cache_size,
+ sizeof(struct ext2_inode_cache_ent),
+ &fs->icache->cache);
+ if (retval) {
+ ext2fs_free_mem(&fs->icache->buffer);
+ ext2fs_free_mem(&fs->icache);
+ return retval;
}
- for (i=0; i < fs->icache->cache_size; i++)
- fs->icache->cache[i].ino = 0;
+ ext2fs_flush_icache(fs);
return 0;
}
{
ext2_inode_scan scan;
errcode_t retval;
- errcode_t (*save_get_blocks)(ext2_filsys f, ino_t ino, blk_t *blocks);
+ errcode_t (*save_get_blocks)(ext2_filsys f, ext2_ino_t ino, blk_t *blocks);
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
fs->get_blocks = 0;
retval = ext2fs_read_bb_inode(fs, &fs->badblocks);
if (retval && fs->badblocks) {
- badblocks_list_free(fs->badblocks);
+ ext2fs_badblocks_list_free(fs->badblocks);
fs->badblocks = 0;
}
fs->get_blocks = save_get_blocks;
}
- scan = (ext2_inode_scan) malloc(sizeof(struct ext2_struct_inode_scan));
- if (!scan)
- return EXT2_NO_MEMORY;
+ retval = ext2fs_get_mem(sizeof(struct ext2_struct_inode_scan), &scan);
+ if (retval)
+ return retval;
memset(scan, 0, sizeof(struct ext2_struct_inode_scan));
scan->magic = EXT2_ET_MAGIC_INODE_SCAN;
scan->fs = fs;
scan->inode_size = EXT2_INODE_SIZE(fs->super);
scan->bytes_left = 0;
- scan->current_group = -1;
+ scan->current_group = 0;
+ scan->groups_left = fs->group_desc_count - 1;
scan->inode_buffer_blocks = buffer_blocks ? buffer_blocks : 8;
- scan->groups_left = fs->group_desc_count;
- scan->inode_buffer = malloc((size_t) (scan->inode_buffer_blocks *
- fs->blocksize));
+ scan->current_block = ext2fs_inode_table_loc(scan->fs,
+ scan->current_group);
+ scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super);
+ scan->blocks_left = scan->fs->inode_blocks_per_group;
+ if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
+ EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
+ __u32 unused = ext2fs_bg_itable_unused(fs, scan->current_group);
+ if (scan->inodes_left > unused)
+ scan->inodes_left -= unused;
+ else
+ scan->inodes_left = 0;
+ scan->blocks_left =
+ (scan->inodes_left +
+ (fs->blocksize / scan->inode_size - 1)) *
+ scan->inode_size / fs->blocksize;
+ }
+ retval = io_channel_alloc_buf(fs->io, scan->inode_buffer_blocks,
+ &scan->inode_buffer);
scan->done_group = 0;
scan->done_group_data = 0;
scan->bad_block_ptr = 0;
- if (!scan->inode_buffer) {
- free(scan);
- return EXT2_NO_MEMORY;
+ if (retval) {
+ ext2fs_free_mem(&scan);
+ return retval;
}
- scan->temp_buffer = malloc(scan->inode_size);
- if (!scan->temp_buffer) {
- free(scan->inode_buffer);
- free(scan);
- return EXT2_NO_MEMORY;
+ retval = ext2fs_get_mem(scan->inode_size, &scan->temp_buffer);
+ if (retval) {
+ ext2fs_free_mem(&scan->inode_buffer);
+ ext2fs_free_mem(&scan);
+ return retval;
}
if (scan->fs->badblocks && scan->fs->badblocks->num)
scan->scan_flags |= EXT2_SF_CHK_BADBLOCKS;
+ if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
+ EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
+ scan->scan_flags |= EXT2_SF_DO_LAZY;
*ret_scan = scan;
return 0;
}
{
if (!scan || (scan->magic != EXT2_ET_MAGIC_INODE_SCAN))
return;
-
- free(scan->inode_buffer);
+
+ ext2fs_free_mem(&scan->inode_buffer);
scan->inode_buffer = NULL;
- free(scan->temp_buffer);
+ ext2fs_free_mem(&scan->temp_buffer);
scan->temp_buffer = NULL;
- free(scan);
+ ext2fs_free_mem(&scan);
return;
}
errcode_t (*done_group)(ext2_filsys fs,
ext2_inode_scan scan,
dgrp_t group,
- void * private),
+ void * priv_data),
void *done_group_data)
{
if (!scan || (scan->magic != EXT2_ET_MAGIC_INODE_SCAN))
return;
-
+
scan->done_group = done_group;
scan->done_group_data = done_group_data;
}
*/
static errcode_t get_next_blockgroup(ext2_inode_scan scan)
{
+ ext2_filsys fs = scan->fs;
+
scan->current_group++;
scan->groups_left--;
-
- scan->current_block = scan->fs->
- group_desc[scan->current_group].bg_inode_table;
+
+ scan->current_block = ext2fs_inode_table_loc(scan->fs,
+ scan->current_group);
+ scan->current_inode = scan->current_group *
+ EXT2_INODES_PER_GROUP(fs->super);
scan->bytes_left = 0;
- scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super);
- scan->blocks_left = scan->fs->inode_blocks_per_group;
+ scan->inodes_left = EXT2_INODES_PER_GROUP(fs->super);
+ scan->blocks_left = fs->inode_blocks_per_group;
+ if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
+ EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
+ __u32 unused = ext2fs_bg_itable_unused(fs, scan->current_group);
+ if (scan->inodes_left > unused)
+ scan->inodes_left -= unused;
+ else
+ scan->inodes_left = 0;
+ scan->blocks_left =
+ (scan->inodes_left +
+ (fs->blocksize / scan->inode_size - 1)) *
+ scan->inode_size / fs->blocksize;
+ }
+
return 0;
}
{
scan->current_group = group - 1;
scan->groups_left = scan->fs->group_desc_count - group;
- scan->current_inode = group * EXT2_INODES_PER_GROUP(scan->fs->super);
return get_next_blockgroup(scan);
}
* increasing order.
*/
static errcode_t check_for_inode_bad_blocks(ext2_inode_scan scan,
- blk_t *num_blocks)
+ blk64_t *num_blocks)
{
- blk_t blk = scan->current_block;
+ blk64_t blk = scan->current_block;
badblocks_list bb = scan->fs->badblocks;
/*
*/
static errcode_t get_next_blocks(ext2_inode_scan scan)
{
- blk_t num_blocks;
+ blk64_t num_blocks;
errcode_t retval;
/*
if (retval)
return retval;
}
-
+
if ((scan->scan_flags & EXT2_SF_BAD_INODE_BLK) ||
(scan->current_block == 0)) {
memset(scan->inode_buffer, 0,
(size_t) num_blocks * scan->fs->blocksize);
} else {
- retval = io_channel_read_blk(scan->fs->io,
+ retval = io_channel_read_blk64(scan->fs->io,
scan->current_block,
(int) num_blocks,
scan->inode_buffer);
return 0;
}
-errcode_t ext2fs_get_next_inode(ext2_inode_scan scan, ino_t *ino,
- struct ext2_inode *inode)
+#if 0
+/*
+ * Returns 1 if the entire inode_buffer has a non-zero size and
+ * contains all zeros. (Not just deleted inodes, since that means
+ * that part of the inode table was used at one point; we want all
+ * zeros, which means that the inode table is pristine.)
+ */
+static inline int is_empty_scan(ext2_inode_scan scan)
+{
+ int i;
+
+ if (scan->bytes_left == 0)
+ return 0;
+
+ for (i=0; i < scan->bytes_left; i++)
+ if (scan->ptr[i])
+ return 0;
+ return 1;
+}
+#endif
+
+errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
+ struct ext2_inode *inode, int bufsize)
{
errcode_t retval;
int extra_bytes = 0;
-
+
EXT2_CHECK_MAGIC(scan, EXT2_ET_MAGIC_INODE_SCAN);
/*
* Do we need to start reading a new block group?
*/
if (scan->inodes_left <= 0) {
- retry:
+ force_new_group:
if (scan->done_group) {
retval = (scan->done_group)
(scan->fs, scan, scan->current_group,
retval = get_next_blockgroup(scan);
if (retval)
return retval;
- if (scan->current_block == 0) {
- if (scan->scan_flags & EXT2_SF_SKIP_MISSING_ITABLE) {
- goto retry;
- } else
- return EXT2_ET_MISSING_INODE_TABLE;
- }
+ }
+ /*
+ * These checks are done outside the above if statement so
+ * they can be done for block group #0.
+ */
+ if ((scan->scan_flags & EXT2_SF_DO_LAZY) &&
+ (ext2fs_bg_flags_test(scan->fs, scan->current_group, EXT2_BG_INODE_UNINIT)
+ ))
+ goto force_new_group;
+ if (scan->inodes_left == 0)
+ goto force_new_group;
+ if (scan->current_block == 0) {
+ if (scan->scan_flags & EXT2_SF_SKIP_MISSING_ITABLE) {
+ goto force_new_group;
+ } else
+ return EXT2_ET_MISSING_INODE_TABLE;
}
+
/*
* Have we run out of space in the inode buffer? If so, we
* need to read in more blocks.
retval = get_next_blocks(scan);
if (retval)
return retval;
+#if 0
+ /*
+ * XXX test Need check for used inode somehow.
+ * (Note: this is hard.)
+ */
+ if (is_empty_scan(scan))
+ goto force_new_group;
+#endif
}
retval = 0;
scan->ptr += scan->inode_size - extra_bytes;
scan->bytes_left -= scan->inode_size - extra_bytes;
- if ((scan->fs->flags & EXT2_FLAG_SWAP_BYTES) ||
- (scan->fs->flags & EXT2_FLAG_SWAP_BYTES_READ))
- ext2fs_swap_inode(scan->fs, inode,
- (struct ext2_inode *) scan->temp_buffer, 0);
- else
- *inode = *((struct ext2_inode *) scan->temp_buffer);
+#ifdef WORDS_BIGENDIAN
+ memset(inode, 0, bufsize);
+ ext2fs_swap_inode_full(scan->fs,
+ (struct ext2_inode_large *) inode,
+ (struct ext2_inode_large *) scan->temp_buffer,
+ 0, bufsize);
+#else
+ memcpy(inode, scan->temp_buffer, bufsize);
+#endif
if (scan->scan_flags & EXT2_SF_BAD_EXTRA_BYTES)
retval = EXT2_ET_BAD_BLOCK_IN_INODE_TABLE;
scan->scan_flags &= ~EXT2_SF_BAD_EXTRA_BYTES;
} else {
- if ((scan->fs->flags & EXT2_FLAG_SWAP_BYTES) ||
- (scan->fs->flags & EXT2_FLAG_SWAP_BYTES_READ))
- ext2fs_swap_inode(scan->fs, inode,
- (struct ext2_inode *) scan->ptr, 0);
- else
- *inode = *((struct ext2_inode *) scan->ptr);
+#ifdef WORDS_BIGENDIAN
+ memset(inode, 0, bufsize);
+ ext2fs_swap_inode_full(scan->fs,
+ (struct ext2_inode_large *) inode,
+ (struct ext2_inode_large *) scan->ptr,
+ 0, bufsize);
+#else
+ memcpy(inode, scan->ptr, bufsize);
+#endif
scan->ptr += scan->inode_size;
scan->bytes_left -= scan->inode_size;
if (scan->scan_flags & EXT2_SF_BAD_INODE_BLK)
return retval;
}
+errcode_t ext2fs_get_next_inode(ext2_inode_scan scan, ext2_ino_t *ino,
+ struct ext2_inode *inode)
+{
+ return ext2fs_get_next_inode_full(scan, ino, inode,
+ sizeof(struct ext2_inode));
+}
+
/*
* Functions to read and write a single inode.
*/
-errcode_t ext2fs_read_inode (ext2_filsys fs, ino_t ino,
- struct ext2_inode * inode)
+errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
+ struct ext2_inode * inode, int bufsize)
{
- unsigned long group, block, block_nr, offset;
+ blk64_t block_nr;
+ unsigned long group, block, offset;
char *ptr;
errcode_t retval;
- int clen, length, i;
+ int clen, i, inodes_per_block, length;
+ io_channel io;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
/* Check to see if user has an override function */
- if (fs->read_inode) {
+ if (fs->read_inode &&
+ ((bufsize == sizeof(struct ext2_inode)) ||
+ (EXT2_INODE_SIZE(fs->super) == sizeof(struct ext2_inode)))) {
retval = (fs->read_inode)(fs, ino, inode);
if (retval != EXT2_ET_CALLBACK_NOTHANDLED)
return retval;
}
+ if ((ino == 0) || (ino > fs->super->s_inodes_count))
+ return EXT2_ET_BAD_INODE_NUM;
/* Create inode cache if not present */
if (!fs->icache) {
retval = create_icache(fs);
return retval;
}
/* Check to see if it's in the inode cache */
- for (i=0; i < fs->icache->cache_size; i++) {
- if (fs->icache->cache[i].ino == ino) {
- *inode = fs->icache->cache[i].inode;
- return 0;
+ if (bufsize == sizeof(struct ext2_inode)) {
+ /* only old good inode can be retrieved from the cache */
+ for (i=0; i < fs->icache->cache_size; i++) {
+ if (fs->icache->cache[i].ino == ino) {
+ *inode = fs->icache->cache[i].inode;
+ return 0;
+ }
}
}
- if (ino > fs->super->s_inodes_count)
- return EXT2_ET_BAD_INODE_NUM;
- group = (ino - 1) / EXT2_INODES_PER_GROUP(fs->super);
- offset = ((ino - 1) % EXT2_INODES_PER_GROUP(fs->super)) *
- EXT2_INODE_SIZE(fs->super);
- block = offset >> EXT2_BLOCK_SIZE_BITS(fs->super);
- if (!fs->group_desc[(unsigned)group].bg_inode_table)
- return EXT2_ET_MISSING_INODE_TABLE;
- block_nr = fs->group_desc[(unsigned)group].bg_inode_table + block;
- if (block_nr != fs->icache->buffer_blk) {
- retval = io_channel_read_blk(fs->io, block_nr, 1,
- fs->icache->buffer);
- if (retval)
- return retval;
- fs->icache->buffer_blk = block_nr;
+ if (fs->flags & EXT2_FLAG_IMAGE_FILE) {
+ inodes_per_block = fs->blocksize / EXT2_INODE_SIZE(fs->super);
+ block_nr = fs->image_header->offset_inode / fs->blocksize;
+ block_nr += (ino - 1) / inodes_per_block;
+ offset = ((ino - 1) % inodes_per_block) *
+ EXT2_INODE_SIZE(fs->super);
+ io = fs->image_io;
+ } else {
+ group = (ino - 1) / EXT2_INODES_PER_GROUP(fs->super);
+ if (group > fs->group_desc_count)
+ return EXT2_ET_BAD_INODE_NUM;
+ offset = ((ino - 1) % EXT2_INODES_PER_GROUP(fs->super)) *
+ EXT2_INODE_SIZE(fs->super);
+ block = offset >> EXT2_BLOCK_SIZE_BITS(fs->super);
+ if (!ext2fs_inode_table_loc(fs, (unsigned) group))
+ return EXT2_ET_MISSING_INODE_TABLE;
+ block_nr = ext2fs_inode_table_loc(fs, group) +
+ block;
+ io = fs->io;
}
offset &= (EXT2_BLOCK_SIZE(fs->super) - 1);
- ptr = ((char *) fs->icache->buffer) + (unsigned) offset;
- memset(inode, 0, sizeof(struct ext2_inode));
length = EXT2_INODE_SIZE(fs->super);
- if (length > sizeof(struct ext2_inode))
- length = sizeof(struct ext2_inode);
-
- if ((offset + length) > EXT2_BLOCK_SIZE(fs->super)) {
- clen = (int) (EXT2_BLOCK_SIZE(fs->super) - offset);
- memcpy((char *) inode, ptr, clen);
- length -= clen;
-
- retval = io_channel_read_blk(fs->io, block_nr+1, 1,
- fs->icache->buffer);
- if (retval) {
- fs->icache->buffer_blk = 0;
- return retval;
+ if (bufsize < length)
+ length = bufsize;
+
+ ptr = (char *) inode;
+ while (length) {
+ clen = length;
+ if ((offset + length) > fs->blocksize)
+ clen = fs->blocksize - offset;
+
+ if (block_nr != fs->icache->buffer_blk) {
+ retval = io_channel_read_blk64(io, block_nr, 1,
+ fs->icache->buffer);
+ if (retval)
+ return retval;
+ fs->icache->buffer_blk = block_nr;
}
- fs->icache->buffer_blk = block_nr+1;
-
- memcpy(((char *) inode) + clen,
- fs->icache->buffer, length);
- } else
- memcpy((char *) inode, ptr, length);
-
- if ((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
- (fs->flags & EXT2_FLAG_SWAP_BYTES_READ))
- ext2fs_swap_inode(fs, inode, inode, 0);
+
+ memcpy(ptr, ((char *) fs->icache->buffer) + (unsigned) offset,
+ clen);
+
+ offset = 0;
+ length -= clen;
+ ptr += clen;
+ block_nr++;
+ }
+
+#ifdef WORDS_BIGENDIAN
+ ext2fs_swap_inode_full(fs, (struct ext2_inode_large *) inode,
+ (struct ext2_inode_large *) inode,
+ 0, bufsize);
+#endif
/* Update the inode cache */
fs->icache->cache_last = (fs->icache->cache_last + 1) %
fs->icache->cache_size;
fs->icache->cache[fs->icache->cache_last].ino = ino;
fs->icache->cache[fs->icache->cache_last].inode = *inode;
-
+
return 0;
}
-errcode_t ext2fs_write_inode(ext2_filsys fs, ino_t ino,
- struct ext2_inode * inode)
+errcode_t ext2fs_read_inode(ext2_filsys fs, ext2_ino_t ino,
+ struct ext2_inode * inode)
{
- unsigned long group, block, block_nr, offset;
- errcode_t retval;
- struct ext2_inode temp_inode;
+ return ext2fs_read_inode_full(fs, ino, inode,
+ sizeof(struct ext2_inode));
+}
+
+errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
+ struct ext2_inode * inode, int bufsize)
+{
+ blk64_t block_nr;
+ unsigned long group, block, offset;
+ errcode_t retval = 0;
+ struct ext2_inode_large temp_inode, *w_inode;
char *ptr;
- int clen, length, i;
+ int clen, i, length;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
if (retval)
return retval;
}
-
+
if (!(fs->flags & EXT2_FLAG_RW))
return EXT2_ET_RO_FILSYS;
- if (ino > fs->super->s_inodes_count)
+ if ((ino == 0) || (ino > fs->super->s_inodes_count))
return EXT2_ET_BAD_INODE_NUM;
- if ((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
- (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE))
- ext2fs_swap_inode(fs, &temp_inode, inode, 1);
- else
- memcpy(&temp_inode, inode, sizeof(struct ext2_inode));
-
+ length = bufsize;
+ if (length < EXT2_INODE_SIZE(fs->super))
+ length = EXT2_INODE_SIZE(fs->super);
+
+ if (length > (int) sizeof(struct ext2_inode_large)) {
+ w_inode = malloc(length);
+ if (!w_inode) {
+ retval = ENOMEM;
+ goto errout;
+ }
+ } else
+ w_inode = &temp_inode;
+ memset(w_inode, 0, length);
+
+#ifdef WORDS_BIGENDIAN
+ ext2fs_swap_inode_full(fs, w_inode,
+ (struct ext2_inode_large *) inode,
+ 1, bufsize);
+#else
+ memcpy(w_inode, inode, bufsize);
+#endif
+
group = (ino - 1) / EXT2_INODES_PER_GROUP(fs->super);
offset = ((ino - 1) % EXT2_INODES_PER_GROUP(fs->super)) *
EXT2_INODE_SIZE(fs->super);
block = offset >> EXT2_BLOCK_SIZE_BITS(fs->super);
- if (!fs->group_desc[(unsigned) group].bg_inode_table)
- return EXT2_ET_MISSING_INODE_TABLE;
- block_nr = fs->group_desc[(unsigned) group].bg_inode_table + block;
+ if (!ext2fs_inode_table_loc(fs, (unsigned) group)) {
+ retval = EXT2_ET_MISSING_INODE_TABLE;
+ goto errout;
+ }
+ block_nr = ext2fs_inode_table_loc(fs, (unsigned) group) + block;
+
offset &= (EXT2_BLOCK_SIZE(fs->super) - 1);
- ptr = (char *) fs->icache->buffer + (unsigned) offset;
length = EXT2_INODE_SIZE(fs->super);
- clen = length;
- if (length > sizeof(struct ext2_inode))
- length = sizeof(struct ext2_inode);
-
- if (fs->icache->buffer_blk != block_nr) {
- retval = io_channel_read_blk(fs->io, block_nr, 1,
- fs->icache->buffer);
- if (retval)
- return retval;
- fs->icache->buffer_blk = block_nr;
- }
-
- if ((offset + length) > EXT2_BLOCK_SIZE(fs->super)) {
- clen = (int) (EXT2_BLOCK_SIZE(fs->super) - offset);
- length -= clen;
- } else {
- length = 0;
- }
- memcpy(ptr, &temp_inode, clen);
- retval = io_channel_write_blk(fs->io, block_nr, 1, fs->icache->buffer);
- if (retval)
- return retval;
+ if (length > bufsize)
+ length = bufsize;
- if (length) {
- retval = io_channel_read_blk(fs->io, ++block_nr, 1,
- fs->icache->buffer);
- if (retval) {
- fs->icache->buffer_blk = 0;
- return retval;
+ ptr = (char *) w_inode;
+
+ while (length) {
+ clen = length;
+ if ((offset + length) > fs->blocksize)
+ clen = fs->blocksize - offset;
+
+ if (fs->icache->buffer_blk != block_nr) {
+ retval = io_channel_read_blk64(fs->io, block_nr, 1,
+ fs->icache->buffer);
+ if (retval)
+ goto errout;
+ fs->icache->buffer_blk = block_nr;
}
- fs->icache->buffer_blk = block_nr;
- memcpy(fs->icache->buffer, ((char *) &temp_inode) + clen,
- length);
- retval = io_channel_write_blk(fs->io, block_nr, 1,
+
+ memcpy((char *) fs->icache->buffer + (unsigned) offset,
+ ptr, clen);
+
+ retval = io_channel_write_blk64(fs->io, block_nr, 1,
fs->icache->buffer);
if (retval)
- return retval;
+ goto errout;
+
+ offset = 0;
+ ptr += clen;
+ length -= clen;
+ block_nr++;
}
-
+
fs->flags |= EXT2_FLAG_CHANGED;
- return 0;
+errout:
+ if (w_inode && w_inode != &temp_inode)
+ free(w_inode);
+ return retval;
+}
+
+errcode_t ext2fs_write_inode(ext2_filsys fs, ext2_ino_t ino,
+ struct ext2_inode *inode)
+{
+ return ext2fs_write_inode_full(fs, ino, inode,
+ sizeof(struct ext2_inode));
+}
+
+/*
+ * This function should be called when writing a new inode. It makes
+ * sure that extra part of large inodes is initialized properly.
+ */
+errcode_t ext2fs_write_new_inode(ext2_filsys fs, ext2_ino_t ino,
+ struct ext2_inode *inode)
+{
+ struct ext2_inode *buf;
+ int size = EXT2_INODE_SIZE(fs->super);
+ struct ext2_inode_large *large_inode;
+ errcode_t retval;
+ __u32 t = fs->now ? fs->now : time(NULL);
+
+ if (!inode->i_ctime)
+ inode->i_ctime = t;
+ if (!inode->i_mtime)
+ inode->i_mtime = t;
+ if (!inode->i_atime)
+ inode->i_atime = t;
+
+ if (size == sizeof(struct ext2_inode))
+ return ext2fs_write_inode_full(fs, ino, inode,
+ sizeof(struct ext2_inode));
+
+ buf = malloc(size);
+ if (!buf)
+ return ENOMEM;
+
+ memset(buf, 0, size);
+ *buf = *inode;
+
+ large_inode = (struct ext2_inode_large *) buf;
+ large_inode->i_extra_isize = sizeof(struct ext2_inode_large) -
+ EXT2_GOOD_OLD_INODE_SIZE;
+ if (!large_inode->i_crtime)
+ large_inode->i_crtime = t;
+
+ retval = ext2fs_write_inode_full(fs, ino, buf, size);
+ free(buf);
+ return retval;
}
-errcode_t ext2fs_get_blocks(ext2_filsys fs, ino_t ino, blk_t *blocks)
+
+errcode_t ext2fs_get_blocks(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks)
{
struct ext2_inode inode;
int i;
errcode_t retval;
-
+
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
if (ino > fs->super->s_inodes_count)
return 0;
}
-errcode_t ext2fs_check_directory(ext2_filsys fs, ino_t ino)
+errcode_t ext2fs_check_directory(ext2_filsys fs, ext2_ino_t ino)
{
struct ext2_inode inode;
errcode_t retval;
-
+
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
if (ino > fs->super->s_inodes_count)
if (retval)
return retval;
if (!LINUX_S_ISDIR(inode.i_mode))
- return EXT2_NO_DIRECTORY;
+ return EXT2_ET_NO_DIRECTORY;
return 0;
}
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff