void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap) { if (!bitmap || (bitmap->magic != EXT2_ET_MAGIC_GENERIC_BITMAP)) return; bitmap->magic = 0; if (bitmap->description) { ext2fs_free_mem(&bitmap->description); bitmap->description = 0; } if (bitmap->bitmap) { ext2fs_free_mem(&bitmap->bitmap); bitmap->bitmap = 0; } ext2fs_free_mem(&bitmap); }
/* * When caller uses this function to retrieve the inline data, it must * allocate a buffer which has the size of inline data. The size of * inline data can be know by ext2fs_inline_data_get_size(). */ errcode_t ext2fs_inline_data_get(ext2_filsys fs, ext2_ino_t ino, struct ext2_inode *inode, void *buf, size_t *size) { struct ext2_inode inode_buf; struct ext2_inline_data data; errcode_t retval; if (!inode) { retval = ext2fs_read_inode(fs, ino, &inode_buf); if (retval) return retval; inode = &inode_buf; } data.fs = fs; data.ino = ino; retval = ext2fs_inline_data_ea_get(&data); if (retval) return retval; memcpy(buf, (void *)inode->i_block, EXT4_MIN_INLINE_DATA_SIZE); if (data.ea_size > 0) memcpy(buf + EXT4_MIN_INLINE_DATA_SIZE, data.ea_data, data.ea_size); if (size) *size = EXT4_MIN_INLINE_DATA_SIZE + data.ea_size; ext2fs_free_mem(&data.ea_data); return 0; }
/* * Create an extent table */ errcode_t ext2fs_create_extent_table(ext2_extent *ret_extent, __u64 size) { ext2_extent extent; errcode_t retval; retval = ext2fs_get_mem(sizeof(struct _ext2_extent), &extent); if (retval) return retval; memset(extent, 0, sizeof(struct _ext2_extent)); extent->size = size ? size : 50; extent->cursor = 0; extent->num = 0; extent->sorted = 1; retval = ext2fs_get_array(sizeof(struct ext2_extent_entry), extent->size, &extent->list); if (retval) { ext2fs_free_mem(&extent); return retval; } memset(extent->list, 0, sizeof(struct ext2_extent_entry) * extent->size); *ret_extent = extent; return 0; }
/* * Helper function for making a badblocks list */ static errcode_t make_u32_list(int size, int num, u32 *list, ext2_u32_list *ret) { ext2_u32_list bb; errcode_t retval; retval = ext2fs_get_mem(sizeof(struct ext2_struct_u32_list), &bb); if (retval) return retval; memset(bb, 0, sizeof(struct ext2_struct_u32_list)); bb->magic = EXT2_ET_MAGIC_BADBLOCKS_LIST; bb->size = size ? size : 10; bb->num = num; retval = ext2fs_get_mem(bb->size * sizeof(blk_t), &bb->list); if (!bb->list) { ext2fs_free_mem(&bb); return retval; } if (list) memcpy(bb->list, list, bb->size * sizeof(blk_t)); else memset(bb->list, 0, bb->size * sizeof(blk_t)); *ret = bb; return 0; }
errcode_t ext2fs_extent_free_path(ext2_extent_path_t path) { EXT2_CHECK_MAGIC(path, EXT2_ET_MAGIC_EXTENT_PATH); ext2fs_free_mem(&path); return 0; }
void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap) { if (check_magic(bitmap)) return; bitmap->magic = 0; if (bitmap->description) { ext2fs_free_mem(&bitmap->description); bitmap->description = 0; } if (bitmap->bitmap) { ext2fs_free_mem(&bitmap->bitmap); bitmap->bitmap = 0; } ext2fs_free_mem(&bitmap); }
/* * Begin functions to handle an inode's extent information */ extern void ext2fs_extent_free(ext2_extent_handle_t handle) { int i; if (!handle) return; if (handle->path) { for (i=1; i <= handle->max_depth; i++) { if (handle->path[i].buf) ext2fs_free_mem(&handle->path[i].buf); } ext2fs_free_mem(&handle->path); } ext2fs_free_mem(&handle); }
static errcode_t follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t dir, ext2_ino_t inode, int link_count, char *buf, ext2_ino_t *res_inode) { char *pathname; char *buffer = 0; errcode_t retval; struct ext2_inode ei; blk64_t blk; #ifdef NAMEI_DEBUG printf("follow_link: root=%lu, dir=%lu, inode=%lu, lc=%d\n", root, dir, inode, link_count); #endif retval = ext2fs_read_inode (fs, inode, &ei); if (retval) return retval; if (!LINUX_S_ISLNK (ei.i_mode)) { *res_inode = inode; return 0; } if (link_count++ >= EXT2FS_MAX_NESTED_LINKS) return EXT2_ET_SYMLINK_LOOP; if (ext2fs_inode_data_blocks(fs,&ei)) { retval = ext2fs_bmap2(fs, inode, &ei, NULL, 0, 0, NULL, &blk); if (retval) return retval; retval = ext2fs_get_mem(fs->blocksize, &buffer); if (retval) return retval; retval = io_channel_read_blk64(fs->io, blk, 1, buffer); if (retval) { ext2fs_free_mem(&buffer); return retval; } pathname = buffer; } else pathname = (char *)&(ei.i_block[0]); retval = open_namei(fs, root, dir, pathname, ei.i_size, 1, link_count, buf, res_inode); if (buffer) ext2fs_free_mem(&buffer); return retval; }
void ext2fs_u32_list_iterate_end(ext2_u32_iterate iter) { if (!iter || (iter->magic != EXT2_ET_MAGIC_BADBLOCKS_ITERATE)) return; iter->bb = 0; ext2fs_free_mem(&iter); }
/* Free the cache buffers */ static void free_cache(struct unix_private_data *data) { struct unix_cache *cache; int i; data->access_time = 0; for (i=0, cache = data->cache; i < CACHE_SIZE; i++, cache++) { cache->block = 0; cache->access_time = 0; cache->dirty = 0; cache->in_use = 0; if (cache->buf) ext2fs_free_mem(&cache->buf); } if (data->bounce) ext2fs_free_mem(&data->bounce); }
void brelse(struct buffer_head *bh) { if (bh->b_dirty) ll_rw_block(WRITE, 1, &bh); jfs_debug(3, "freeing block %lu/%p (total %d)\n", (unsigned long) bh->b_blocknr, (void *) bh, --bh_count); ext2fs_free_mem(&bh); }
errcode_t quota_write_inode(quota_ctx_t qctx, int qtype) { int retval = 0, i; dict_t *dict; ext2_filsys fs; struct quota_handle *h = NULL; int fmt = QFMT_VFS_V1; if (!qctx) return 0; fs = qctx->fs; retval = ext2fs_get_mem(sizeof(struct quota_handle), &h); if (retval) { log_err("Unable to allocate quota handle", ""); goto out; } ext2fs_read_bitmaps(fs); for (i = 0; i < MAXQUOTAS; i++) { if ((qtype != -1) && (i != qtype)) continue; dict = qctx->quota_dict[i]; if (!dict) continue; retval = quota_file_create(h, fs, i, fmt); if (retval < 0) { log_err("Cannot initialize io on quotafile", ""); continue; } write_dquots(dict, h); retval = quota_file_close(h); if (retval < 0) { log_err("Cannot finish IO on new quotafile: %s", strerror(errno)); if (h->qh_qf.e2_file) ext2fs_file_close(h->qh_qf.e2_file); quota_inode_truncate(fs, h->qh_qf.ino); continue; } /* Set quota inode numbers in superblock. */ quota_set_sb_inum(fs, h->qh_qf.ino, i); ext2fs_mark_super_dirty(fs); ext2fs_mark_bb_dirty(fs); fs->flags &= ~EXT2_FLAG_SUPER_ONLY; } ext2fs_write_bitmaps(fs); out: if (h) ext2fs_free_mem(&h); return retval; }
static void check_block_bitmap_checksum(e2fsck_t ctx) { struct problem_context pctx; char *buf; dgrp_t i; int nbytes; blk64_t blk_itr; errcode_t retval; if (!EXT2_HAS_RO_COMPAT_FEATURE(ctx->fs->super, EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) return; /* If bitmap is dirty from being fixed, checksum will be corrected */ if (ext2fs_test_bb_dirty(ctx->fs)) return; nbytes = (size_t)(EXT2_CLUSTERS_PER_GROUP(ctx->fs->super) / 8); retval = ext2fs_get_memalign(ctx->fs->blocksize, ctx->fs->blocksize, &buf); if (retval) { com_err(ctx->program_name, 0, _("check_block_bitmap_checksum: Memory allocation error")); fatal_error(ctx, 0); } clear_problem_context(&pctx); for (i = 0; i < ctx->fs->group_desc_count; i++) { if (ext2fs_bg_flags_test(ctx->fs, i, EXT2_BG_BLOCK_UNINIT)) continue; blk_itr = EXT2FS_B2C(ctx->fs, ctx->fs->super->s_first_data_block) + (i * (nbytes << 3)); retval = ext2fs_get_block_bitmap_range2(ctx->fs->block_map, blk_itr, nbytes << 3, buf); if (retval) break; if (ext2fs_block_bitmap_csum_verify(ctx->fs, i, buf, nbytes)) continue; pctx.group = i; if (!fix_problem(ctx, PR_5_BLOCK_BITMAP_CSUM_INVALID, &pctx)) continue; /* * Fixing one checksum will rewrite all of them. The bitmap * will be checked against the one we made during pass1 for * discrepancies, and fixed if need be. */ ext2fs_mark_bb_dirty(ctx->fs); break; } ext2fs_free_mem(&buf); }
/* * Free the dir_info structure when it isn't needed any more. */ void e2fsck_free_dir_info(e2fsck_t ctx) { if (ctx->dir_info) { if (ctx->dir_info->tdb) tdb_close(ctx->dir_info->tdb); if (ctx->dir_info->tdb_fn) { unlink(ctx->dir_info->tdb_fn); free(ctx->dir_info->tdb_fn); } if (ctx->dir_info->array) ext2fs_free_mem(&ctx->dir_info->array); ctx->dir_info->array = 0; ctx->dir_info->size = 0; ctx->dir_info->count = 0; ext2fs_free_mem(&ctx->dir_info); ctx->dir_info = 0; } }
static errcode_t ext3u_write_inode(ext2_filsys fs, ext2_ino_t undel_ino, int flags) { char *buf; errcode_t retval; struct ext2_inode inode; struct mk_ext3u_struct es; __u32 num_blocks = ext3u_fifo_reserved + ext3u_skip_reserved + ext3u_index_reserved + 1; if ((retval = ext3u_create_superblock(fs, flags, &buf))) return retval; if ((retval = ext2fs_read_bitmaps(fs))) return retval; if ((retval = ext2fs_read_inode(fs, undel_ino, &inode))) return retval; if (inode.i_blocks > 0) return EEXIST; es.goal = 0; es.num_blocks = num_blocks; es.newblocks = 0; es.buf = buf; es.err = 0; es.zero_count = 0; retval = ext2fs_block_iterate2(fs, undel_ino, BLOCK_FLAG_APPEND, 0, mk_ext3u_proc, &es); if (es.err) { retval = es.err; goto errout; } if (es.zero_count) { retval = ext2fs_zero_blocks(fs, es.blk_to_zero, es.zero_count, 0, 0); if (retval) goto errout; } if ((retval = ext2fs_read_inode(fs, undel_ino, &inode))) goto errout; inode.i_size += fs->blocksize * num_blocks; ext2fs_iblk_add_blocks(fs, &inode, es.newblocks); inode.i_mtime = inode.i_ctime = fs->now ? fs->now : time(0); inode.i_links_count = 1; inode.i_mode = LINUX_S_IFREG | 0600; if ((retval = ext2fs_write_inode(fs, undel_ino, &inode))) goto errout; retval = 0; errout: ext2fs_free_mem(&buf); return retval; }
static errcode_t make_bitmap(__u32 start, __u32 end, __u32 real_end, const char *descr, char *init_map, ext2fs_generic_bitmap *ret) { ext2fs_generic_bitmap bitmap; errcode_t retval; size_t size; retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap), &bitmap); if (retval) return retval; bitmap->magic = EXT2_ET_MAGIC_GENERIC_BITMAP; bitmap->fs = NULL; bitmap->start = start; bitmap->end = end; bitmap->real_end = real_end; bitmap->base_error_code = EXT2_ET_BAD_GENERIC_MARK; if (descr) { retval = ext2fs_get_mem(strlen(descr)+1, &bitmap->description); if (retval) { ext2fs_free_mem(&bitmap); return retval; } strcpy(bitmap->description, descr); } else bitmap->description = 0; size = (size_t) (((bitmap->real_end - bitmap->start) / 8) + 1); retval = ext2fs_get_mem(size, &bitmap->bitmap); if (retval) { ext2fs_free_mem(&bitmap->description); ext2fs_free_mem(&bitmap); return retval; } if (init_map) memcpy(bitmap->bitmap, init_map, size); else memset(bitmap->bitmap, 0, size); *ret = bitmap; return 0; }
/* * Free the dx_dir_info structure when it isn't needed any more. */ void e2fsck_free_dx_dir_info(e2fsck_t ctx) { int i; struct dx_dir_info *dir; if (ctx->dx_dir_info) { dir = ctx->dx_dir_info; for (i=0; i < ctx->dx_dir_info_count; i++) { if (dir->dx_block) { ext2fs_free_mem((void **) &dir->dx_block); dir->dx_block = 0; } } ext2fs_free_mem((void **) &ctx->dx_dir_info); ctx->dx_dir_info = 0; } ctx->dx_dir_info_size = 0; ctx->dx_dir_info_count = 0; }
static errcode_t follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t dir, ext2_ino_t inode, int link_count, char *buf, ext2_ino_t *res_inode) { char *pathname; char *buffer = 0; errcode_t retval; struct ext2_inode ei; #ifdef NAMEI_DEBUG printf("follow_link: root=%lu, dir=%lu, inode=%lu, lc=%d\n", root, dir, inode, link_count); #endif retval = ext2fs_read_inode (fs, inode, &ei); if (retval) return retval; if (!LINUX_S_ISLNK (ei.i_mode)) { *res_inode = inode; return 0; } if (link_count++ > 5) { return EXT2_ET_SYMLINK_LOOP; } /* FIXME-64: Actually, this is FIXME EXTENTS */ if (ext2fs_inode_data_blocks(fs,&ei)) { retval = ext2fs_get_mem(fs->blocksize, &buffer); if (retval) return retval; retval = io_channel_read_blk(fs->io, ei.i_block[0], 1, buffer); if (retval) { ext2fs_free_mem(&buffer); return retval; } pathname = buffer; } else pathname = (char *)&(ei.i_block[0]); retval = open_namei(fs, root, dir, pathname, ei.i_size, 1, link_count, buf, res_inode); if (buffer) ext2fs_free_mem(&buffer); return retval; }
void e2fsck_free_context(e2fsck_t ctx) { if (!ctx) return; e2fsck_reset_context(ctx); if (ctx->blkid) blkid_put_cache(ctx->blkid); if (ctx->profile) profile_release(ctx->profile); if (ctx->filesystem_name) ext2fs_free_mem(&ctx->filesystem_name); if (ctx->device_name) ext2fs_free_mem(&ctx->device_name); ext2fs_free_mem(&ctx); }
void e2fsck_free_context(e2fsck_t ctx) { if (!ctx) return; e2fsck_reset_context(ctx); if (ctx->blkid) blkid_put_cache(ctx->blkid); ext2fs_free_mem(&ctx); }
void do_set_mmp_value(int argc, char *argv[]) { const char *usage = "<field> <value>\n" "\t\"set_mmp_value -l\" will list the names of " "MMP fields\n\twhich can be set."; static struct field_set_info *smmp; struct mmp_struct *mmp_s; errcode_t retval; if (argc == 2 && strcmp(argv[1], "-l") == 0) { print_possible_fields(mmp_fields); return; } if (current_fs->super->s_mmp_block == 0) { com_err(argv[0], 0, "no MMP block allocated\n"); return; } if (common_args_process(argc, argv, 2, 3, "set_mmp_value", usage, CHECK_FS_RW)) return; mmp_s = current_fs->mmp_buf; if (mmp_s == NULL) { retval = ext2fs_get_mem(current_fs->blocksize, &mmp_s); if (retval) { com_err(argv[0], retval, "allocating MMP buffer\n"); return; } retval = ext2fs_mmp_read(current_fs, current_fs->super->s_mmp_block, mmp_s); if (retval) { com_err(argv[0], retval, "reading MMP block %llu.\n", (long long)current_fs->super->s_mmp_block); ext2fs_free_mem(mmp_s); return; } current_fs->mmp_buf = mmp_s; } smmp = find_field(mmp_fields, argv[1]); if (smmp == 0) { com_err(argv[0], 0, "invalid field specifier: %s", argv[1]); return; } set_mmp = *mmp_s; if (smmp->func(smmp, argv[1], argv[2]) == 0) { ext2fs_mmp_write(current_fs, current_fs->super->s_mmp_block, &set_mmp); *mmp_s = set_mmp; } }
static errcode_t inode_close(io_channel channel) { struct inode_private_data *data; errcode_t retval = 0; EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); data = (struct inode_private_data *) channel->private_data; EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_INODE_IO_CHANNEL); if (--channel->refcount > 0) return 0; retval = ext2fs_file_close(data->file); ext2fs_free_mem(&channel->private_data); if (channel->name) ext2fs_free_mem(&channel->name); ext2fs_free_mem(&channel); return retval; }
/* * This function creates a journal using direct I/O routines. */ static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino, blk_t size, int flags) { char *buf; errcode_t retval; struct ext2_inode inode; struct mkjournal_struct es; if ((retval = ext2fs_create_journal_superblock(fs, size, flags, &buf))) return retval; if ((retval = ext2fs_read_bitmaps(fs))) return retval; if ((retval = ext2fs_read_inode(fs, journal_ino, &inode))) return retval; if (inode.i_blocks > 0) return EEXIST; es.num_blocks = size; es.newblocks = 0; es.buf = buf; es.err = 0; retval = ext2fs_block_iterate2(fs, journal_ino, BLOCK_FLAG_APPEND, 0, mkjournal_proc, &es); if (es.err) { retval = es.err; goto errout; } if ((retval = ext2fs_read_inode(fs, journal_ino, &inode))) goto errout; inode.i_size += fs->blocksize * size; inode.i_blocks += (fs->blocksize / 512) * es.newblocks; inode.i_mtime = inode.i_ctime = time(0); inode.i_links_count = 1; inode.i_mode = LINUX_S_IFREG | 0600; if ((retval = ext2fs_write_inode(fs, journal_ino, &inode))) goto errout; retval = 0; memcpy(fs->super->s_jnl_blocks, inode.i_block, EXT2_N_BLOCKS*4); fs->super->s_jnl_blocks[16] = inode.i_size; fs->super->s_jnl_backup_type = EXT3_JNL_BACKUP_BLOCKS; ext2fs_mark_super_dirty(fs); errout: ext2fs_free_mem(&buf); return retval; }
void ext2fs_free_icount(ext2_icount_t icount) { if (!icount) return; icount->magic = 0; if (icount->list) ext2fs_free_mem(&icount->list); if (icount->single) ext2fs_free_inode_bitmap(icount->single); if (icount->multiple) ext2fs_free_inode_bitmap(icount->multiple); if (icount->tdb) tdb_close(icount->tdb); if (icount->tdb_fn) { unlink(icount->tdb_fn); free(icount->tdb_fn); } ext2fs_free_mem(&icount); }
static errcode_t test_close(io_channel channel) { struct test_private_data *data; errcode_t retval = 0; EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL); data = (struct test_private_data *) channel->private_data; EXT2_CHECK_MAGIC(data, EXT2_ET_MAGIC_TEST_IO_CHANNEL); if (--channel->refcount > 0) return 0; if (data->real) retval = io_channel_close(data->real); ext2fs_free_mem((void **) &channel->private_data); if (channel->name) ext2fs_free_mem((void **) &channel->name); ext2fs_free_mem((void **) &channel); return retval; }
static int expand_dir_proc(ext2_filsys fs, blk_t *blocknr, e2_blkcnt_t blockcnt, blk_t ref_block EXT2FS_ATTR((unused)), int ref_offset EXT2FS_ATTR((unused)), void *priv_data) { struct expand_dir_struct *es = (struct expand_dir_struct *) priv_data; blk_t new_blk; static blk_t last_blk = 0; char *block; errcode_t retval; if (*blocknr) { last_blk = *blocknr; return 0; } retval = ext2fs_new_block(fs, last_blk, 0, &new_blk); if (retval) { es->err = retval; return BLOCK_ABORT; } if (blockcnt > 0) { retval = ext2fs_new_dir_block(fs, 0, 0, &block); if (retval) { es->err = retval; return BLOCK_ABORT; } es->done = 1; retval = ext2fs_write_dir_block(fs, new_blk, block); } else { retval = ext2fs_get_mem(fs->blocksize, &block); if (retval) { es->err = retval; return BLOCK_ABORT; } memset(block, 0, fs->blocksize); retval = io_channel_write_blk(fs->io, new_blk, 1, block); } if (retval) { es->err = retval; return BLOCK_ABORT; } ext2fs_free_mem(&block); *blocknr = new_blk; ext2fs_block_alloc_stats(fs, new_blk, +1); es->newblocks++; if (es->done) return (BLOCK_CHANGED | BLOCK_ABORT); else return BLOCK_CHANGED; }
errcode_t ext2fs_write_dir_block3(ext2_filsys fs, blk64_t block, void *inbuf, int flags EXT2FS_ATTR((unused))) { #ifdef WORDS_BIGENDIAN errcode_t retval; char *p, *end; char *buf = 0; unsigned int rec_len; struct ext2_dir_entry *dirent; retval = ext2fs_get_mem(fs->blocksize, &buf); if (retval) return retval; memcpy(buf, inbuf, fs->blocksize); p = buf; end = buf + fs->blocksize; while (p < end) { dirent = (struct ext2_dir_entry *) p; if ((retval = ext2fs_get_rec_len(fs, dirent, &rec_len)) != 0) return retval; if ((rec_len < 8) || (rec_len % 4)) { ext2fs_free_mem(&buf); return (EXT2_ET_DIR_CORRUPTED); } p += rec_len; dirent->inode = ext2fs_swab32(dirent->inode); dirent->rec_len = ext2fs_swab16(dirent->rec_len); dirent->name_len = ext2fs_swab16(dirent->name_len); if (flags & EXT2_DIRBLOCK_V2_STRUCT) dirent->name_len = ext2fs_swab16(dirent->name_len); } retval = io_channel_write_blk64(fs->io, block, 1, buf); ext2fs_free_mem(&buf); return retval; #else return io_channel_write_blk(fs->io, block, 1, (char *) inbuf); #endif }
/* * helper function for making a new directory block list (for * initialize and copy). */ static errcode_t make_dblist(ext2_filsys fs, ext2_ino_t size, ext2_ino_t count, struct ext2_db_entry2 *list, ext2_dblist *ret_dblist) { ext2_dblist dblist = NULL; errcode_t retval; ext2_ino_t num_dirs; size_t len; EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); if ((ret_dblist == 0) && fs->dblist && (fs->dblist->magic == EXT2_ET_MAGIC_DBLIST)) return 0; retval = ext2fs_get_mem(sizeof(struct ext2_struct_dblist), &dblist); if (retval) goto cleanup; memset(dblist, 0, sizeof(struct ext2_struct_dblist)); dblist->magic = EXT2_ET_MAGIC_DBLIST; dblist->fs = fs; if (size) dblist->size = size; else { retval = ext2fs_get_num_dirs(fs, &num_dirs); if (retval) goto cleanup; dblist->size = (num_dirs * 2) + 12; } len = (size_t) sizeof(struct ext2_db_entry2) * dblist->size; dblist->count = count; retval = ext2fs_get_array(dblist->size, sizeof(struct ext2_db_entry2), &dblist->list); if (retval) goto cleanup; if (list) memcpy(dblist->list, list, len); else memset(dblist->list, 0, len); if (ret_dblist) *ret_dblist = dblist; else fs->dblist = dblist; return 0; cleanup: if (dblist) ext2fs_free_mem(&dblist); return retval; }
void ext2fs_free_generic_bmap(ext2fs_generic_bitmap bmap) { if (!bmap) return; if (EXT2FS_IS_32_BITMAP(bmap)) { ext2fs_free_generic_bitmap(bmap); return; } if (!EXT2FS_IS_64_BITMAP(bmap)) return; bmap->bitmap_ops->free_bmap(bmap); if (bmap->description) { ext2fs_free_mem(&bmap->description); bmap->description = 0; } bmap->magic = 0; ext2fs_free_mem(&bmap); }
static void handle_exit(void) { struct exit_data *ed; for (ed = items + nr_items - 1; ed >= items; ed--) { if (ed->func == NULL) continue; ed->func(ed->data); } ext2fs_free_mem(&items); nr_items = 0; }