[Ocfs2-tools-devel] [PATCH 19/23] tunefs rework: Add feature_sparse_files.c

Joel Becker joel.becker at oracle.com
Mon Aug 11 17:32:11 PDT 2008


Enable and disable the sparse file feature.

This is the 'sparse' key to the tunefs option '--fs-features'.

Signed-off-by: Joel Becker <joel.becker at oracle.com>
---
 tunefs.ocfs2/feature_sparse_files.c |  504 +++++++++++++++++++++++++++++++++++
 1 files changed, 504 insertions(+), 0 deletions(-)
 create mode 100644 tunefs.ocfs2/feature_sparse_files.c

diff --git a/tunefs.ocfs2/feature_sparse_files.c b/tunefs.ocfs2/feature_sparse_files.c
new file mode 100644
index 0000000..513496d
--- /dev/null
+++ b/tunefs.ocfs2/feature_sparse_files.c
@@ -0,0 +1,504 @@
+/* -*- mode: c; c-basic-offset: 8; -*-
+ * vim: noexpandtab sw=8 ts=8 sts=0:
+ *
+ * feature_sparse_files.c
+ *
+ * ocfs2 tune utility for enabling and disabling the sparse file feature.
+ *
+ * Copyright (C) 2004, 2008 Oracle.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#include <inttypes.h>
+#include <assert.h>
+
+#include "ocfs2-kernel/kernel-list.h"
+#include "ocfs2/ocfs2.h"
+
+#include "libocfs2ne.h"
+
+
+struct hole_list {
+	struct list_head list;
+	uint32_t start;
+	uint32_t len;
+};
+
+/*
+ * A sparse file may have many holes.  All the holes will be stored in
+ * hole_list.  Since filling up a hole may need a new extent record and
+ * lead to some new extent block, the total hole number in the sparse file
+ * will also be recorded.
+ *
+ * Some sparse file may also have some clusters which exceed the limit of
+ * i_size, and they should be truncated.
+ */
+struct sparse_file {
+	struct list_head list;
+	uint64_t blkno;
+	struct list_head holes;
+	uint32_t holes_num;
+	uint32_t hole_clusters;
+	int truncate;
+};
+
+struct fill_hole_context {
+	errcode_t ret;
+	uint32_t more_clusters;
+	uint32_t more_ebs;
+	struct list_head files;
+};
+
+/*
+ * Truncate file according to i_size.
+ * All allocated clusters which exceeds i_size will be released.
+ */
+static errcode_t truncate_to_i_size(ocfs2_filesys *fs,
+				    struct ocfs2_dinode *di,
+				    void *unused)
+{
+	errcode_t ret = 0;
+	uint32_t new_clusters;
+	ocfs2_cached_inode *ci = NULL;
+
+	if (di->i_flags & OCFS2_SYSTEM_FL)
+		goto out;
+
+	ret = ocfs2_read_cached_inode(fs, di->i_blkno, &ci);
+	if (ret)
+		goto out;
+
+	tunefs_block_signals();
+	ret = ocfs2_zero_tail_and_truncate(fs, ci, di->i_size, &new_clusters);
+	tunefs_unblock_signals();
+	if (ret)
+		goto out;
+
+	if (new_clusters != ci->ci_inode->i_clusters) {
+		ci->ci_inode->i_clusters = new_clusters;
+		tunefs_block_signals();
+		ret = ocfs2_write_cached_inode(fs, ci);
+		tunefs_unblock_signals();
+	}
+
+out:
+	if (ci)
+		ocfs2_free_cached_inode(fs, ci);
+
+	return ret;
+}
+
+static int enable_sparse_files(ocfs2_filesys *fs, int flags)
+{
+	errcode_t ret = 0;
+	struct ocfs2_super_block *super = OCFS2_RAW_SB(fs->fs_super);
+
+	if (ocfs2_sparse_alloc(super)) {
+		verbosef(VL_APP,
+			 "Sparse file feature is already enabled; "
+			 "nothing to enable\n");
+		goto out;
+	}
+
+	if (!tunefs_interact("Enable the sparse file feature on device "
+			     "\"%s\"? ",
+			     fs->fs_devname))
+		goto out;
+
+	ret = tunefs_foreach_inode(fs, S_IFREG, truncate_to_i_size, NULL);
+	if (ret) {
+		tcom_err(ret,
+			 "while trying to remove any extraneous allocation");
+		goto out;
+	}
+
+	OCFS2_SET_INCOMPAT_FEATURE(super,
+				   OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC);
+	tunefs_block_signals();
+	ret = ocfs2_write_super(fs);
+	tunefs_unblock_signals();
+	if (ret)
+		tcom_err(ret, "while writing out the superblock");
+
+out:
+	return ret;
+}
+
+static errcode_t add_hole(struct sparse_file *file, uint32_t hole_start,
+			  uint32_t hole_len)
+{
+	errcode_t ret;
+	struct hole_list *hole = NULL;
+
+	ret = ocfs2_malloc0(sizeof(struct hole_list), &hole);
+	if (ret)
+		return ret;
+
+	hole->start = hole_start;
+	hole->len = hole_len;
+	list_add_tail(&hole->list, &file->holes);
+
+	file->hole_clusters += hole_len;
+	file->holes_num++;
+
+	return 0;
+}
+
+static void free_sparse_file(struct sparse_file *file)
+{
+	struct hole_list *hole;
+	struct list_head *n, *pos;
+
+	list_del(&file->list);
+
+	list_for_each_safe(pos, n, &file->holes) {
+		hole = list_entry(pos, struct hole_list, list);
+		list_del(&hole->list);
+		ocfs2_free(&hole);
+	}
+
+	ocfs2_free(&file);
+}
+
+static void empty_fill_hole_context(struct fill_hole_context *ctxt)
+{
+	struct sparse_file *file;
+	struct list_head *n, *pos;
+
+	list_for_each_safe(pos, n, &ctxt->files) {
+		file = list_entry(pos, struct sparse_file, list);
+		free_sparse_file(file);
+	}
+}
+
+
+/*
+ * Walk the allocations of a file, filling in the struct sparse_file.
+ */
+static errcode_t find_holes_in_file(ocfs2_filesys *fs,
+				    struct ocfs2_dinode *di,
+				    struct sparse_file *file)
+{
+	errcode_t ret;
+	uint32_t clusters, v_cluster = 0, p_cluster, num_clusters;
+	uint32_t last_v_cluster = 0;
+	uint16_t extent_flags;
+	ocfs2_cached_inode *ci = NULL;
+
+	clusters = (di->i_size + fs->fs_clustersize -1 ) /
+			fs->fs_clustersize;
+
+	ret = ocfs2_read_cached_inode(fs, di->i_blkno, &ci);
+	if (ret)
+		goto bail;
+
+	while (v_cluster < clusters) {
+		ret = ocfs2_get_clusters(ci,
+					 v_cluster, &p_cluster,
+					 &num_clusters, &extent_flags);
+		if (ret)
+			goto bail;
+
+		if (!p_cluster) {
+			/*
+			 * If the tail of the file is a hole, let the
+			 * hole length only cover the last i_size.
+			 */
+			if (v_cluster + num_clusters == UINT32_MAX)
+				num_clusters = clusters - v_cluster;
+
+			ret = add_hole(file, v_cluster, num_clusters);
+			if (ret)
+				goto bail;
+		}
+
+		if (extent_flags & OCFS2_EXT_UNWRITTEN) {
+			ret = TUNEFS_ET_UNWRITTEN_PRESENT;
+			goto bail;
+		}
+
+		v_cluster += num_clusters;
+	}
+
+	/*
+	 * If the last allocated cluster's virtual offset is greater
+	 * than the clusters we calculated from i_size, this cluster
+	 * must exceed the limit of i_size.
+	 */
+	ret = ocfs2_get_last_cluster_offset(fs, di, &last_v_cluster);
+	if (ret)
+		goto bail;
+
+	if (last_v_cluster >= clusters)
+		file->truncate = 1;
+
+bail:
+	if (ci)
+		ocfs2_free_cached_inode(fs, ci);
+	return ret;
+}
+
+
+static errcode_t hole_iterate(ocfs2_filesys *fs, struct ocfs2_dinode *di,
+			      void *user_data)
+{
+	errcode_t ret = 0;
+	uint64_t blk_num;
+	uint32_t clusters;
+	struct sparse_file *file = NULL;
+	uint32_t recs_per_eb = ocfs2_extent_recs_per_eb(fs->fs_blocksize);
+	struct fill_hole_context *ctxt = user_data;
+
+	if (di->i_flags & OCFS2_SYSTEM_FL)
+		goto bail;
+
+	assert(S_ISREG(di->i_mode));
+
+	ret = ocfs2_malloc0(sizeof(struct sparse_file), &file);
+	if (ret)
+		goto bail;
+
+	file->blkno = di->i_blkno;
+	INIT_LIST_HEAD(&file->holes);
+	ret = find_holes_in_file(fs, di, file);
+	if (ret)
+		goto bail;
+
+	/*
+	 * If there is no hole or unwritten extents in the file and we don't
+	 * need to truncate it, just free it.
+	 */
+	if (list_empty(&file->holes) && !file->truncate)
+		goto bail;
+
+	/*
+	 * We have  "hole_num" holes, so more extent records are needed,
+	 * and more extent blocks may needed here.
+	 * In order to simplify the estimation process, we take it for
+	 * granted that one hole need one extent record, so that we can
+	 * calculate the extent block we need roughly.
+	 */
+	blk_num = (file->holes_num + recs_per_eb - 1) / recs_per_eb;
+	clusters = ocfs2_clusters_in_blocks(fs, blk_num);
+	ctxt->more_ebs += clusters;
+
+	list_add_tail(&file->list, &ctxt->files);
+
+	return 0;
+
+bail:
+	if (file)
+		ocfs2_free(&file);
+	return ret;
+}
+
+static errcode_t find_sparse_files(ocfs2_filesys *fs,
+				   struct fill_hole_context *ctxt)
+{
+	errcode_t ret;
+	uint32_t free_clusters = 0;
+
+	ret = tunefs_foreach_inode(fs, S_IFREG, hole_iterate, ctxt);
+	if (ret)
+		goto bail;
+
+	ret = tunefs_get_free_clusters(fs, &free_clusters);
+	if (ret)
+		goto bail;
+
+	verbosef(VL_APP,
+		 "We have %u clusters free, and need %u clusters to fill "
+		 "every sparse file and %u clusters for more extent "
+		 "blocks\n",
+		 free_clusters, ctxt->more_clusters,
+		 ctxt->more_ebs);
+
+	if (free_clusters < (ctxt->more_clusters + ctxt->more_ebs))
+		ret = OCFS2_ET_NO_SPACE;
+
+bail:
+	return ret;
+}
+
+static errcode_t fill_one_hole(ocfs2_filesys *fs, struct sparse_file *file,
+			       struct hole_list *hole)
+{
+	errcode_t ret = 0;
+	uint32_t start = hole->start;
+	uint32_t len = hole->len;
+	uint32_t n_clusters;
+	uint64_t p_start;
+
+	while (len) {
+		tunefs_block_signals();
+		ret = ocfs2_new_clusters(fs, 1, len,
+					 &p_start, &n_clusters);
+		if ((!ret && (n_clusters == 0)) ||
+		    (ret == OCFS2_ET_BIT_NOT_FOUND))
+			ret = OCFS2_ET_NO_SPACE;
+		if (ret)
+			break;
+
+		ret = tunefs_empty_clusters(fs, p_start, n_clusters);
+		if (ret)
+			break;
+
+		ret = ocfs2_insert_extent(fs, file->blkno,
+					  start, p_start,
+					  n_clusters, 0);
+		if (ret)
+			break;
+
+		len -= n_clusters;
+		start += n_clusters;
+		tunefs_unblock_signals();
+	}
+
+	if (ret)
+		tunefs_unblock_signals();
+
+	return ret;
+}
+
+static errcode_t fill_one_file(ocfs2_filesys *fs, struct sparse_file *file)
+{
+	errcode_t ret = 0;
+	struct hole_list *hole;
+	struct list_head *pos;
+
+	list_for_each(pos, &file->holes) {
+		hole = list_entry(pos, struct hole_list, list);
+		ret = fill_one_hole(fs, file, hole);
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+
+static errcode_t fill_sparse_files(ocfs2_filesys *fs,
+				   struct fill_hole_context *ctxt)
+{
+	errcode_t ret = 0;
+	char *buf = NULL;
+	struct ocfs2_dinode *di = NULL;
+	struct list_head *pos;
+	struct sparse_file *file;
+
+	ret = ocfs2_malloc_block(fs->fs_io, &buf);
+	if (ret)
+		goto out;
+
+	/* Iterate all the holes and fill them. */
+	list_for_each(pos, &ctxt->files) {
+		file = list_entry(pos, struct sparse_file, list);
+		ret = fill_one_file(fs, file);
+		if (ret)
+			break;
+
+		if (!file->truncate)
+			continue;
+
+		ret = ocfs2_read_inode(fs, file->blkno, buf);
+		if (ret)
+			break;
+		di = (struct ocfs2_dinode *)buf;
+		ret = truncate_to_i_size(fs, di, NULL);
+		if (ret)
+			break;
+	}
+
+	ocfs2_free(&buf);
+
+out:
+	return ret;
+}
+
+static int disable_sparse_files(ocfs2_filesys *fs, int flags)
+{
+	errcode_t ret = 0;
+	struct ocfs2_super_block *super = OCFS2_RAW_SB(fs->fs_super);
+	struct fill_hole_context ctxt;
+
+	if (!ocfs2_sparse_alloc(super)) {
+		verbosef(VL_APP,
+			 "Sparse file feature is not enabled; "
+			 "nothing to disable\n");
+		goto out;
+	}
+
+	if (ocfs2_writes_unwritten_extents(super)) {
+		errorf("Unwritten extents are enabled on device \"%s\"; "
+		       "sparse files cannot be disabled\n",
+		       fs->fs_devname);
+		ret = TUNEFS_ET_UNWRITTEN_PRESENT;
+		goto out;
+	}
+
+	if (!tunefs_interact("Disable the sparse file feature on device "
+			     "\"%s\"? ",
+			     fs->fs_devname))
+		goto out;
+
+	memset(&ctxt, 0, sizeof(ctxt));
+	INIT_LIST_HEAD(&ctxt.files);
+	ret = find_sparse_files(fs, &ctxt);
+	if (ret) {
+		if (ret == OCFS2_ET_NO_SPACE)
+			errorf("There is not enough space to fill all of "
+			       "the sparse files on device \"%s\"\n",
+			       fs->fs_devname);
+		else
+			tcom_err(ret, "while trying to find sparse files");
+		goto out_cleanup;
+	}
+
+	ret = fill_sparse_files(fs, &ctxt);
+	if (ret) {
+		tcom_err(ret,
+			 "while trying to fill the sparse files on device "
+			 "\"%s\"",
+			 fs->fs_devname);
+		goto out_cleanup;
+	}
+
+	OCFS2_CLEAR_INCOMPAT_FEATURE(super,
+				     OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC);
+	tunefs_block_signals();
+	ret = ocfs2_write_super(fs);
+	tunefs_unblock_signals();
+	if (ret)
+		tcom_err(ret, "while writing out the superblock");
+
+out_cleanup:
+	empty_fill_hole_context(&ctxt);
+
+out:
+	return ret;
+}
+
+DEFINE_TUNEFS_FEATURE_INCOMPAT(sparse_files,
+			       OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC,
+			       TUNEFS_FLAG_RW | TUNEFS_FLAG_ALLOCATION,
+			       enable_sparse_files,
+			       disable_sparse_files);
+
+#ifdef DEBUG_EXE
+int main(int argc, char *argv[])
+{
+	return tunefs_feature_main(argc, argv, &sparse_files_feature);
+}
+#endif
-- 
1.5.6.3




More information about the Ocfs2-tools-devel mailing list