Ocfs2: Online defragmentaion V1.
cover Ocfs2: Online defragmentaion V1.
Hi All,
It's a quite rough patches series v1 for online defragmentation on OCFS2, it's
workable anyway, may look ugly though;) The essence of online file defragmentation is extents moving like what btrfs and ext4 were doing, adding 'OCFS2_IOC_MOVE_EXT' ioctl to ocfs2 allows two strategies upon defragmentation:
1. simple-defragmentation-in-kernl, which means kernel will be responsible for claiming new clusters, and packing the defragmented extents according to a user-specified threshold.
2. simple-extents moving, in this case, userspace play much more important role when doing defragmentation, it needs to specify the new physical blk_offset where extents will be moved, kernel itself will not do anything more than moving the extents per requested, maybe kernel also needs to manage to probe/validate the new_blkoffset to guarantee enough free space around there.
Above two operations using the same OCFS2_IOC_MOVE_EXT:
-------------------------------------------------------------------------------
#define OCFS2_MOVE_EXT_FL_AUTO_DEFRAG (0x00000001) /* Kernel manages to
claim new clusters as the goal place for extents moving */
#define OCFS2_MOVE_EXT_FL_COMPLETE (0x00000002) /* Move or defragmenation
completely gets done.
*/
struct ocfs2_move_extents {
/* All values are in bytes */
/* in */
__u64 me_start; /* Virtual start in the file to move */
__u64 me_len; /* Length of the extents to be moved */
__u64 me_goal; /* Physical offset of the goal */
__u64 me_thresh; /* Maximum distance from goal or threshold
for auto defragmentation */
__u64 me_flags; /* flags for the operation:
* - auto defragmentation.
* - refcount,xattr cases.
*/
/* out */
__u64 me_moved_len; /* moved length, are we completely done? */
__u64 me_new_offset; /* Resulting physical location */
__u32 me_reserved[3]; /* reserved for futhure */
};
-------------------------------------------------------------------------------
Current V1 patches set will be focusing mostly on strategy #1 though, since #2
strategy is still there under discussion.
Following are some interesting data gathered from simple tests:
1. Performance improvement gained on I/O reads:
-------------------------------------------------------------------------------
* Before defragmentation *
[root at ocfs2-box4 ~]# sync
[root at ocfs2-box4 ~]# echo 3>/proc/sys/vm/drop_caches [root at ocfs2-box4 ~]# time dd if=/storage/testfile-1 of=/dev/null 640000+0 records in
640000+0 records out
327680000 bytes (328 MB) copied, 19.9351 s, 16.4 MB/s
real 0m19.954s
user 0m0.246s
sys 0m1.111s
* Do defragmentation *
[root at ocfs2-box4 defrag]# ./defrag -s 0 -l 293601280 -t 3145728 /storage/testfile-1
* After defragmentation *
[root at ocfs2-box4 ~]# sync
[root at ocfs2-box4 ~]# echo 3>/proc/sys/vm/drop_caches [root at ocfs2-box4 ~]# time dd if=/storage/testfile-1 of=/dev/null 640000+0 records in
640000+0 records out
327680000 bytes (328 MB) copied, 6.79885 s, 48.2 MB/s
real 0m6.969s
user 0m0.209s
sys 0m1.063s
-------------------------------------------------------------------------------
2. Extent tree layout via debugfs.ocfs2:
-------------------------------------------------------------------------------
* Before defragmentation *
Tree Depth: 1 Count: 243 Next Free Rec: 8
## Offset Clusters Block#
0 0 1173 86561
1 1173 1173 84527
2 2346 1151 81468
3 3497 1173 76362
4 4670 1173 74328
5 5843 1172 66150
6 7015 1460 70260
7 8475 662 87680
SubAlloc Bit: 1 SubAlloc Slot: 0
Blknum: 86561 Next Leaf: 84527
CRC32: abf06a6b ECC: 44bc
Tree Depth: 0 Count: 252 Next Free Rec: 252
## Offset Clusters Block# Flags
0 1 16 516104 0x0
1 17 1 554632 0x0
2 18 7 560144 0x0
3 25 1 565960 0x0
4 26 1 572632 0x
...
/* around 1700 extent records were hidden there */
...
138 9131 1 258968 0x0
139 9132 1 259568 0x0
140 9133 1 260168 0x0
141 9134 1 260768 0x0
142 9135 1 261368 0x0
143 9136 1 261968 0x0* After defragmentation *
Tree Depth: 1 Count: 243 Next Free Rec: 1 ## Offset Clusters Block# 0 0 9137 66081 SubAlloc Bit: 1 SubAlloc Slot: 0 Blknum: 66081 Next Leaf: 0 CRC32: 22897d34 ECC: 0619 Tree Depth: 0 Count: 252 Next Free Rec: 6 ## Offset Clusters Block# Flags 0 1 1600 4412936 0x0 1 1601 1595 20669448 0x0 2 3196 1600 9358856 0x0 3 4796 1404 14516232 0x0 4 6200 1600 21627400 0x0 5 7800 1337 7483400 0x0
-------------------------------------------------------------------------------
TO-DO:
1. Complete strategy #2
2. Adding refcount/xattr/unwritten_extents support.
3. Free space defragmentation.
Go to http://oss.oracle.com/osswiki/OCFS2/DesignDocs/OnlineDefrag for more details.
Tristan.
PATCH 1/8 Ocfs2: Adding new ioctl code 'OCFS2_IOC_MOVE_EXT' to ocfs2.
Patch also manages to add an manipulative struture for this ioctl.
--- fs/ocfs2/ocfs2_ioctl.h | 27 +++++++++++++++++++++++++++ 1 files changed, 27 insertions(+), 0 deletions(-)
fs/ocfs2/ocfs2_ioctl.h +27 -0
@@ -171,4 +171,31 @@ enum ocfs2_info_type {#define OCFS2_IOC_INFO _IOR('o', 5, struct ocfs2_info) +#define OCFS2_MOVE_EXT_FL_AUTO_DEFRAG (0x00000001)/* Kernel manages to +claim new clusters +as the goal place +for extents moving */ +#define OCFS2_MOVE_EXT_FL_COMPLETE (0x00000002)/* Move or defragmenation +completely gets done. +*/ +struct ocfs2_move_extents { +/* All values are in bytes */ +/* in */ +__u64 me_start;/* Virtual start in the file to move */ +__u64 me_len;/* Length of the extents to be moved */ +__u64 me_goal;/* Physical offset of the goal */ +__u64 me_thresh;/* Maximum distance from goal or threshold +for auto defragmentation */ +__u64 me_flags;/* flags for the operation: +* - auto defragmentation. +* - refcount,xattr cases. +*/ +/* out */ +__u64 me_moved_len;/* moved length */ +__u64 me_new_offset;/* Resulting physical location */ +__u32 me_reserved[2 ];/* reserved for futhure */ +}; + +#define OCFS2_IOC_MOVE_EXT _IOW('o', 6, struct ocfs2_move_extents) +#endif /* OCFS2_IOCTL_H */
Signature · 1 line
1.5.5
PATCH 2/8 Ocfs2: Add basic framework and source files for extent moving.
In reply to Tristan YePatch tries to do following things:
1. Adding new files move_extents.[c|h] and fill it with basic framework.
2. Adding handler for new ioctl OCFS2_MOVE_EXT_FL_AUTO_DEFRAG.
The pre/post-workfor extents moving is much like ocfs2_change_file_space(), also needs to validate permissions, acquire kinds of locks and update mtime etc.
Other than these, this patch also introduces a new type of context struture for manipulating the extent_moving codes better.
--- fs/ocfs2/Makefile | 1 + fs/ocfs2/cluster/masklog.h | 1 + fs/ocfs2/ioctl.c | 5 + fs/ocfs2/move_extents.c | 218 ++++++++++++++++++++++++++++++++++++++++++++ fs/ocfs2/move_extents.h | 22 +++++ 5 files changed, 247 insertions(+), 0 deletions(-) create mode 100644 fs/ocfs2/move_extents.c create mode 100644 fs/ocfs2/move_extents.h
fs/ocfs2/Makefile +1 -0
@@ -30,6 +30,7 @@ ocfs2-objs := \ namei.o \ refcounttree.o \ reservations.o \ + move_extents.o \ resize.o \ slot_map.o \ suballoc.o \
fs/ocfs2/cluster/masklog.h +1 -0
@@ -121,6 +121,7 @@#define ML_KTHREAD 0x0000000400000000ULL/* kernel thread activity */ #define ML_RESERVATIONS 0x0000000800000000ULL/* ocfs2 alloc reservations */ #define ML_CLUSTER 0x0000001000000000ULL/* cluster stack */ +#define ML_MOVE_EXT 0x0000002000000000ULL/* cluster stack */ #define MLOG_INITIAL_AND_MASK (ML_ERROR|ML_NOTICE)#define MLOG_INITIAL_NOT_MASK (ML_ENTRY|ML_EXIT)
fs/ocfs2/ioctl.c +5 -0
@@ -23,6 +23,7 @@#include "ioctl.h" #include "resize.h" #include "refcounttree.h" +#include "move_extents.h" #include <linux/ext2_fs.h>
@@ -523,6 +524,8 @@ long ocfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)return -EFAULT ;return ocfs2_info_handle (inode, &info,0 ); +case OCFS2_IOC_MOVE_EXT : +return ocfs2_ioctl_move_extents (filp, (void __user *)arg);default :return -ENOTTY ; }
@@ -565,6 +568,8 @@ long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)return -EFAULT ;return ocfs2_info_handle (inode, &info,1 ); +case OCFS2_IOC_MOVE_EXT : +break ;default :return -ENOIOCTLCMD ; }
fs/ocfs2/move_extents.c new file +218 -0
218 lines not on this page · raw message
fs/ocfs2/move_extents.h new file +22 -0
@@ -0,0 +1,22 @@ +/* -*- mode: c; c-basic-offset: 8; -*- +* vim: noexpandtab sw=8 ts=8 sts=0: +* +* move_extents.h +* +* Copyright (C) 2010 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. +*/ +#ifndef OCFS2_MOVE_EXTENTS_H +#define OCFS2_MOVE_EXTENTS_H + +int ocfs2_ioctl_move_extents (struct file *filp,void __user *argp); + +#endif /* OCFS2_MOVE_EXTENTS_H */
Signature · 1 line
1.5.5
PATCH 2/8 Ocfs2: Add basic framework and source files for extent moving.
Hi Tristan,
Some comments inlined.
On 12/28/2010 07:40 PM, Tristan Ye wrote:
<snip>
Quoted 31 lines
fs/ocfs2/move_extents.c new file +31
-0+static int ocfs2_move_extents (struct ocfs2_move_extents_context *context) +{ +int status; +handle_t *handle; +struct inode *inode = context->inode; +struct buffer_head *di_bh =NULL ; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + +if (!inode) +return -ENOENT ; + +if (ocfs2_is_hard_readonly (osb) ||ocfs2_is_soft_readonly (osb)) +return -EROFS ; + +mutex_lock (&inode->i_mutex); + +/* +* This prevents concurrent writes from other nodes +*/ + status =ocfs2_rw_lock (inode,1 ); +if (status) { +mlog_errno (status); + goto out; + } + + status =ocfs2_inode_lock (inode,&di_bh,1 ); +if (status) { +mlog_errno (status); + goto out_rw_unlock; + } +
fs/ocfs2/move_extents.c line 92
Quoted 10 lines
fs/ocfs2/move_extents.c new file +10
-0+/* +* rememer ip_xattr_sem also needs to be held if necessary +*/ +down_write (&OCFS2_I (inode)->ip_alloc_sem); + +/* +* real extents moving codes will be fulfilled later. +* +* status = __ocfs2_move_extents_range(di_bh, context); +*/
OK, so this function does nothing by now? ;)
Quoted 9 lines
fs/ocfs2/move_extents.c new file +9
-0+ +up_write (&OCFS2_I (inode)->ip_alloc_sem); +if (status) { +mlog_errno (status); + goto out_inode_unlock; + } + +/* +* We update mtime for these changes
fs/ocfs2/move_extents.c line 111
Quoted 10 lines
fs/ocfs2/move_extents.c new file +10
-0+*/ + handle =ocfs2_start_trans (osb,OCFS2_INODE_UPDATE_CREDITS ); +if (IS_ERR (handle)) { + status =PTR_ERR (handle); +mlog_errno (status); + goto out_inode_unlock; + } + + inode->i_mtime =CURRENT_TIME ; + status =ocfs2_mark_inode_dirty (handle, inode, di_bh);
We really need such a heavy function in case you just want to set di->i_mtime and di->i_mtime_nsec?
Quoted 26 lines
fs/ocfs2/move_extents.c new file +26
-0+if (status<0 ) +mlog_errno (status); + +ocfs2_commit_trans (osb, handle); + +out_inode_unlock: +brelse (di_bh); +ocfs2_inode_unlock (inode,1 ); +out_rw_unlock: +ocfs2_rw_unlock (inode,1 ); +out: +mutex_unlock (&inode->i_mutex); + +return status; +} + +int ocfs2_ioctl_move_extents (struct file *filp,void __user *argp) +{ +int status; + +struct inode *inode = filp->f_path.dentry->d_inode; +struct ocfs2_move_extents range; +struct ocfs2_move_extents_context *context =NULL ; + + status =mnt_want_write (filp->f_path.mnt); +if (status)
fs/ocfs2/move_extents.c line 147
Quoted 10 lines
fs/ocfs2/move_extents.c new file +10
-0+return status; + + status = -EINVAL ; + +if (!S_ISREG (inode->i_mode)) { + goto out; + }else { +if (!(filp->f_mode&FMODE_WRITE )) + goto out; + }
these can be just changed to:
if (!S_ISREG(inode->i_mode) || !(filp->f_mode & FMODE_WRITE)) goto out;
Quoted 40 lines
fs/ocfs2/move_extents.c new file +40
-0+ +if (inode->i_flags& (S_IMMUTABLE |S_APPEND )) { + status = -EPERM ; + goto out; + } + + context =kzalloc (sizeof (struct ocfs2_move_extents_context ),GFP_NOFS ); +if (!context) { + status = -ENOMEM ; +mlog_errno (status); + goto out; + } + + context->inode = inode; + context->file = filp; + +if (!argp) { +memset (&range,0 ,sizeof (range)); + range.me_len = (u64)-1 ; + range.me_flags |=OCFS2_MOVE_EXT_FL_AUTO_DEFRAG ; + context->auto_defrag =1 ; + }else { +if (copy_from_user (&range, (struct ocfs2_move_extents *)argp, +sizeof (range))) { + status = -EFAULT ; + goto out; + } + } + + context->range =⦥ + +if (range.me_flags&OCFS2_MOVE_EXT_FL_AUTO_DEFRAG ) { + context->auto_defrag =1 ; +if (!range.me_thresh) + range.me_thresh =1024 *1024 ; + }else { +/* +* TO-DO XXX: validate the range.me_goal here. +* +* - should be cluster aligned.
fs/ocfs2/move_extents.c
Quoted 10 lines
fs/ocfs2/move_extents.c new file +10
-0+* - should contain enough free clusters around range.me_goal. +* - strategy of moving extent to an appropriate goal is still +* being discussed. +*/ + } + +/* +* returning -EINVAL here. +*/ +if (range.me_start>i_size_read (inode))
Do we allow overlap here? If no, I guess it should be
if (range.me_start + range.me_len > i_size_read(inode))
Quoted 11 lines
fs/ocfs2/move_extents.c new file +11
-0+ goto out; + +if (range.me_start + range.me_len>i_size_read (inode)) + range.me_len =i_size_read (inode) - range.me_start; + + status =ocfs2_move_extents (context); +if (status) +mlog_errno (status); + +if (argp) { + if (copy_to_user((struct ocfs2_move_extents *)argp,&range,
fs/ocfs2/move_extents.c line 218
Quoted 10 lines
fs/ocfs2/move_extents.c new file +10
-0+ sizeof(range))) + status = -EFAULT ; + } +out: +mnt_drop_write (filp->f_path.mnt); + +kfree (context); + +return status; +}
Regards,
Tao
PATCH 2/8 Ocfs2: Add basic framework and source files for extent moving.
Quoted 2 lines · Tao Ma
Hi Tristan,
Some comments inlined.
Tao,
It's good to see your comments here, very nice;)
Quoted 37 lines · Tristan Ye
<snip>
Quoted 35 lines
+static int
ocfs2_move_extents(struct ocfs2_move_extents_context *context)fs/ocfs2/move_extents.c new file +33
-0+{ +int status; +handle_t *handle; +struct inode *inode = context->inode; +struct buffer_head *di_bh =NULL ; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + +if (!inode) +return -ENOENT ; + +if (ocfs2_is_hard_readonly (osb) ||ocfs2_is_soft_readonly (osb)) +return -EROFS ; + +mutex_lock (&inode->i_mutex); + +/* +* This prevents concurrent writes from other nodes +*/ + status =ocfs2_rw_lock (inode,1 ); +if (status) { +mlog_errno (status); + goto out; + } + + status =ocfs2_inode_lock (inode,&di_bh,1 ); +if (status) { +mlog_errno (status); + goto out_rw_unlock; + } + +/* +* rememer ip_xattr_sem also needs to be held if necessary +*/
Quoted 8 lines
fs/ocfs2/move_extents.c line 92
Quoted 7 lines
fs/ocfs2/move_extents.c new file +7
-0+down_write (&OCFS2_I (inode)->ip_alloc_sem); + +/* +* real extents moving codes will be fulfilled later. +* +* status = __ocfs2_move_extents_range(di_bh, context); +*/ OK, so this function does nothing by now? ;)
Actually, this function will be added in following patches, I commented this for a better understanding ONLY.
So without collecting the last patch, it did nothing actually;-)
Quoted 13 lines
Quoted 13 lines
fs/ocfs2/move_extents.c new file +13
-0+ +up_write (&OCFS2_I (inode)->ip_alloc_sem); +if (status) { +mlog_errno (status); + goto out_inode_unlock; + } + +/* +* We update mtime for these changes +*/ + handle =ocfs2_start_trans (osb,OCFS2_INODE_UPDATE_CREDITS ); +if (IS_ERR (handle)) { + status =PTR_ERR (handle);
Quoted 8 lines
fs/ocfs2/move_extents.c line 111
Quoted 6 lines
fs/ocfs2/move_extents.c new file +6
-0+mlog_errno (status); + goto out_inode_unlock; + } + + inode->i_mtime =CURRENT_TIME ; + status =ocfs2_mark_inode_dirty (handle, inode, di_bh);We really need such a heavy function in case you just want to set
di->i_mtimeanddi->i_mtime_nsec?
These above codes were almost borrowed from __ocfs2_change_file_space(), it just calledocfs2_mark_inode_dirty() when updating the mtime/ctime.
Maybe you're right, I'll rethink about it.
Quoted 37 lines
Quoted 26 lines
fs/ocfs2/move_extents.c new file +26
-0+if (status<0 ) +mlog_errno (status); + +ocfs2_commit_trans (osb, handle); + +out_inode_unlock: +brelse (di_bh); +ocfs2_inode_unlock (inode,1 ); +out_rw_unlock: +ocfs2_rw_unlock (inode,1 ); +out: +mutex_unlock (&inode->i_mutex); + +return status; +} + +int ocfs2_ioctl_move_extents (struct file *filp,void __user *argp) +{ +int status; + +struct inode *inode = filp->f_path.dentry->d_inode; +struct ocfs2_move_extents range; +struct ocfs2_move_extents_context *context =NULL ; + + status =mnt_want_write (filp->f_path.mnt); +if (status)fs/ocfs2/move_extents.c line 147
Quoted 10 lines
fs/ocfs2/move_extents.c new file +10
-0+return status; + + status = -EINVAL ; + +if (!S_ISREG (inode->i_mode)) { + goto out; + }else { +if (!(filp->f_mode&FMODE_WRITE )) + goto out; + }these can be just changed to:
Quoted 2 lines
if (!S_ISREG(inode->i_mode) || !(filp->f_mode & FMODE_WRITE))
goto out;Good point.
Quoted 45 lines
Quoted 45 lines
fs/ocfs2/move_extents.c new file +7
-0+ +if (inode->i_flags& (S_IMMUTABLE |S_APPEND )) { + status = -EPERM ; + goto out; + } + + context = kzalloc(sizeof(struct ocfs2_move_extents_context),
GFP_NOFS);fs/ocfs2/move_extents.c new file +37
-0+if (!context) { + status = -ENOMEM ; +mlog_errno (status); + goto out; + } + + context->inode = inode; + context->file = filp; + +if (!argp) { +memset (&range,0 ,sizeof (range)); + range.me_len = (u64)-1 ; + range.me_flags |=OCFS2_MOVE_EXT_FL_AUTO_DEFRAG ; + context->auto_defrag =1 ; + }else { +if (copy_from_user (&range, (struct ocfs2_move_extents *)argp, +sizeof (range))) { + status = -EFAULT ; + goto out; + } + } + + context->range =⦥ + +if (range.me_flags&OCFS2_MOVE_EXT_FL_AUTO_DEFRAG ) { + context->auto_defrag =1 ; +if (!range.me_thresh) + range.me_thresh =1024 *1024 ; + }else { +/* +* TO-DO XXX: validate the range.me_goal here. +* +* - should be cluster aligned. +* - should contain enough free clusters around range.me_goal. +* - strategy of moving extent to an appropriate goal is still +* being discussed. +*/
Quoted 8 lines
fs/ocfs2/move_extents.c
Quoted 6 lines
fs/ocfs2/move_extents.c new file +6
-0+ } + +/* +* returning -EINVAL here. +*/ +if (range.me_start>i_size_read (inode))Do we allow overlap here? If no, I guess it should be
if (range.me_start + range.me_len >i_size_read(inode))
What did you mean? 'range.me_start + range.me_len> i_size_read(inode)' will be judged by following codes,
It has nothing to do with the overlap issue, range.me_start was not range.me_new_start;)
Quoted 24 lines
Quoted 11 lines
fs/ocfs2/move_extents.c new file +11
-0+ goto out; + +if (range.me_start + range.me_len>i_size_read (inode)) + range.me_len =i_size_read (inode) - range.me_start; + + status =ocfs2_move_extents (context); +if (status) +mlog_errno (status); + +if (argp) { + if (copy_to_user((struct ocfs2_move_extents *)argp,&range,fs/ocfs2/move_extents.c line 218
Quoted 10 lines
fs/ocfs2/move_extents.c new file +10
-0+ sizeof(range))) + status = -EFAULT ; + } +out: +mnt_drop_write (filp->f_path.mnt); + +kfree (context); + +return status; +}Regards,
Tao
PATCH 2/8 Ocfs2: Add basic framework and source files for extent moving.
Hi,
Quoted 25 lines · Tristan Ye
Quoted 13 lines · Tao Ma
Quoted 13 lines
fs/ocfs2/move_extents.c new file +13
-0+ +up_write (&OCFS2_I (inode)->ip_alloc_sem); +if (status) { +mlog_errno (status); + goto out_inode_unlock; + } + +/* +* We update mtime for these changes +*/ + handle =ocfs2_start_trans (osb,OCFS2_INODE_UPDATE_CREDITS ); +if (IS_ERR (handle)) { + status =PTR_ERR (handle);Quoted 8 lines
fs/ocfs2/move_extents.c line 111
Quoted 6 lines
fs/ocfs2/move_extents.c new file +6
-0+mlog_errno (status); + goto out_inode_unlock; + } + + inode->i_mtime =CURRENT_TIME ; + status =ocfs2_mark_inode_dirty (handle, inode, di_bh);We really need such a heavy function in case you just want to set
di->i_mtimeanddi->i_mtime_nsec?
Quoted 6 lines
These above codes were almost borrowed from
__ocfs2_change_file_space(), it just calledocfs2_mark_inode_dirty()when updating the mtime/ctime.Maybe you're right, I'll rethink about it.
Do we really need to update modify time or change time?
modify time is "Time of last file write". no need I think since it's not a write(no touch on file contents).
change time is "Time of last inode change". I think here, the inode status includes mode, gid, uid, size, ino..... no change in those area, right? so I guess no need to update mtime nor ctime.
Also, even we need to update them, shall we check a status of the __ocfs2_move_extents_range() whether there is really a movement. think the case another node just finished defragmenting on this file.
And likely we have modified di_bh in __ocfs2_move_extents_range() and journaled it(though not checked yet). So if need, we'd better merge the transactins
BTW, just a thought, not checked all, do we only allow root to do this? Seems no security risk for the task to FS its self... attacks?
thanks,
wengang.
PATCH 2/8 Ocfs2: Add basic framework and source files for extent moving.
Quoted 41 lines · Wengang Wang
Hi,
Quoted 24 lines · Tristan Ye
Quoted 13 lines · Tao Ma
Quoted 13 lines
fs/ocfs2/move_extents.c new file +13
-0+ +up_write (&OCFS2_I (inode)->ip_alloc_sem); +if (status) { +mlog_errno (status); + goto out_inode_unlock; + } + +/* +* We update mtime for these changes +*/ + handle =ocfs2_start_trans (osb,OCFS2_INODE_UPDATE_CREDITS ); +if (IS_ERR (handle)) { + status =PTR_ERR (handle);Quoted 8 lines
fs/ocfs2/move_extents.c line 111
Quoted 6 lines
fs/ocfs2/move_extents.c new file +6
-0+mlog_errno (status); + goto out_inode_unlock; + } + + inode->i_mtime =CURRENT_TIME ; + status =ocfs2_mark_inode_dirty (handle, inode, di_bh);We really need such a heavy function in case you just want to set
di->i_mtimeanddi->i_mtime_nsec?Quoted 6 lines
These above codes were almost borrowed from
__ocfs2_change_file_space(), it just calledocfs2_mark_inode_dirty()when updating the mtime/ctime.Maybe you're right, I'll rethink about it.
Do we really need to update modify time or change time?
modify time is "Time of last file write". no need I think since it's not a write(no touch on file contents).
change time is "Time of last inode change". I think here, the inode status includes mode, gid, uid, size, ino..... no change in those area, right? so I guess no need to update mtime nor ctime.
Quoted 3 lines
Also, even we need to update them, shall we check a status of the
__ocfs2_move_extents_range()whether there is really a movement. think the case another node just finished defragmenting on this file.
Actually I borrowed these codes from ocfs2_change_file_space()
at the very beginning, your comments did make sense, but wait, dedragmentation
has the possibility of changing dinode a bit, it's the btree root, right?
mtime may not be updated as you said;)
Quoted 4 lines
And likely we have modified
di_bhin__ocfs2_move_extents_range()and journaled it(though not checked yet). So if need, we'd better merge the transactins
Good point.
Quoted 3 lines
BTW, just a thought, not checked all, do we only allow root to do this? Seems no security risk for the task to FS its self... attacks?
I did allow ordinary users to do this in this patch, didn't I?
Quoted 3 lines
thanks,
wengang.
PATCH 3/8 Ocfs2: Duplicate old clusters into new blk_offset by dirty and remap pages.
In reply to Tristan YeMost of codes for duplicating clusters into new_blkoffset where extent will be moved, were copid from refcounttree's CoW logics, the intention of making an exact copy here is to make extents moving codes work at the very beginning ,and also avoid interfering refcounttree's codes at most.
Final version will be using some common funcs with refcounttree part.
--- fs/ocfs2/move_extents.c | 107 +++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 107 insertions(+), 0 deletions(-)
fs/ocfs2/move_extents.c +107 -0
@@ -49,6 +49,113 @@ struct ocfs2_move_extents_context {struct ocfs2_cached_dealloc_ctxt dealloc; }; +static int ocfs2_clear_cow_buffer (handle_t *handle,struct buffer_head *bh) +{ +BUG_ON (buffer_dirty (bh)); + +clear_buffer_mapped (bh); + +return 0 ; +} + +#define MAX_CONTIG_BYTES 1048576 + +static inline unsigned int ocfs2_cow_contig_clusters (struct super_block *sb) +{ +return ocfs2_clusters_for_bytes (sb,MAX_CONTIG_BYTES ); +} + +/* +* Duplicate clusters into new blk_offset, following codes were almost taken +* from refcounttree.c on CoW. +*/ +int ocfs2_duplicate_clusters_by_page (handle_t *handle, +struct ocfs2_move_extents_context *context, +u32 cpos,u32 old_cluster, +u32 new_cluster,u32 len) +{ +int ret =0 , partial; +struct inode *inode = context->inode; +struct ocfs2_caching_info *ci =INODE_CACHE (inode); +struct super_block *sb =ocfs2_metadata_cache_get_super (ci); +u64 new_block =ocfs2_clusters_to_blocks (sb, new_cluster); +struct page *page; +pgoff_t page_index; +unsigned int from, to, readahead_pages; +loff_t offset, end, map_end; +struct address_space *mapping = inode->i_mapping; + +mlog (0 ,"old_cluster %u, new %u, len %u at offset %u\n" , old_cluster, + new_cluster, len, cpos); + + readahead_pages = + (ocfs2_cow_contig_clusters (sb) << +OCFS2_SB (sb)->s_clustersize_bits) >>PAGE_CACHE_SHIFT ; + offset = ((loff_t )cpos) <<OCFS2_SB (sb)->s_clustersize_bits; + end = offset + (len <<OCFS2_SB (sb)->s_clustersize_bits); + +if (end >i_size_read (inode)) + end =i_size_read (inode); + +while (offset < end) { + page_index = offset >>PAGE_CACHE_SHIFT ; + map_end = ((loff_t )page_index +1 ) <<PAGE_CACHE_SHIFT ; +if (map_end > end) + map_end = end; + + from = offset & (PAGE_CACHE_SIZE -1 ); + to =PAGE_CACHE_SIZE ; +if (map_end & (PAGE_CACHE_SIZE -1 )) + to = map_end & (PAGE_CACHE_SIZE -1 ); + + page =find_or_create_page (mapping, page_index,GFP_NOFS ); + +if (PAGE_CACHE_SIZE <=OCFS2_SB (sb)->s_clustersize) +BUG_ON (PageDirty (page)); + +if (PageReadahead (page) && context->file) { +page_cache_async_readahead (mapping, + &context->file->f_ra, + context->file, + page, page_index, + readahead_pages); + } + +if (!PageUptodate (page)) { + ret =block_read_full_page (page, ocfs2_get_block); +if (ret) { +mlog_errno (ret); + goto unlock; + } +lock_page (page); + } + +if (page_has_buffers (page)) { + ret =walk_page_buffers (handle,page_buffers (page), + from, to, &partial, + ocfs2_clear_cow_buffer); +if (ret) { +mlog_errno (ret); + goto unlock; + } + } + +ocfs2_map_and_dirty_page (inode, + handle, from, to, + page,0 , &new_block); +mark_page_accessed (page); +unlock: +unlock_page (page); +page_cache_release (page); + page =NULL ; + offset = map_end; +if (ret) +break ; + } + +return ret; +} +static int ocfs2_move_extents (struct ocfs2_move_extents_context *context) {int status;
Signature · 1 line
1.5.5
PATCH 4/8 Ocfs2: move a range of extent.
In reply to Tristan YeThe range of __ocfs2_move_extent() was within one extent always, it consists following parts:
1. Duplicates the clusters in pages to new_blkoffset, where extent to be moved.
2. Split the original extent with new extent, coalecse the nearby extents if possible
3. Append old clusters to truncate log.
--- fs/ocfs2/move_extents.c | 82 +++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 82 insertions(+), 0 deletions(-)
fs/ocfs2/move_extents.c +82 -0
@@ -156,6 +156,88 @@ unlock:return ret; } +static int __ocfs2_move_extent (handle_t *handle, +struct ocfs2_move_extents_context *context, +u32 cpos,u32 len,u32 p_cpos,u32 new_p_cpos) +{ +int ret =0 , index; +struct inode *inode = context->inode; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); +struct ocfs2_extent_rec *rec, replace_rec; +struct ocfs2_path *path =NULL ; +struct ocfs2_extent_list *el; +u64 ino =ocfs2_metadata_cache_owner (context->et.et_ci); +u64 old_blkno =ocfs2_clusters_to_blocks (inode->i_sb, p_cpos); + + ret =ocfs2_duplicate_clusters_by_page (handle, context, cpos, p_cpos, + new_p_cpos, len); +if (ret) { +mlog_errno (ret); + goto out; + } + +memset (&replace_rec,0 ,sizeof (replace_rec)); + replace_rec.e_cpos =cpu_to_le32 (cpos); + replace_rec.e_leaf_clusters =cpu_to_le16 (len); + replace_rec.e_blkno =cpu_to_le64 (ocfs2_clusters_to_blocks (inode->i_sb, + new_p_cpos)); + + path =ocfs2_new_path_from_et (&context->et); +if (!path) { + ret = -ENOMEM ; +mlog_errno (ret); + goto out; + } + + ret =ocfs2_find_path (INODE_CACHE (inode), path, cpos); +if (ret) { +mlog_errno (ret); + goto out; + } + + el =path_leaf_el (path); + + index =ocfs2_search_extent_list (el, cpos); +if (index ==-1 || index >=le16_to_cpu (el->l_next_free_rec)) { +ocfs2_error (inode->i_sb, +"Inode %llu has an extent at cpos %u which can no " +"longer be found.\n" , + (unsigned long long )ino, cpos); + ret = -EROFS ; + goto out; + } + + rec = &el->l_recs[index]; + replace_rec.e_flags = rec->e_flags; + + ret =ocfs2_journal_access_di (handle,INODE_CACHE (inode), + context->et.et_root_bh, +OCFS2_JOURNAL_ACCESS_WRITE ); +if (ret) { +mlog_errno (ret); + goto out; + } + + ret =ocfs2_split_extent (handle, &context->et, path, index, + &replace_rec, context->meta_ac, + &context->dealloc); +if (ret) { +mlog_errno (ret); + goto out; + } + +ocfs2_journal_dirty (handle, context->et.et_root_bh); + +/* +* need I to append truncate log for old clusters? +*/ +if (old_blkno) + ret =ocfs2_truncate_log_append (osb, handle, old_blkno, len); + +out: +return ret; +} +static int ocfs2_move_extents (struct ocfs2_move_extents_context *context) {int status;
Signature · 1 line
1.5.5
PATCH 5/8 Ocfs2: lock allocators and reserve metadata blocks and data clusters for extents moving.
In reply to Tristan Yeocfs2_lock_allocators_move_extents() was like the common ocfs2_lock_allocators(), to lock metadata and data alloctors during extents moving, reserve appropriate metadata blocks and data clusters, also performa a best- effort to calculate the credits for journal transaction in one run of movement.
--- fs/ocfs2/move_extents.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 61 insertions(+), 0 deletions(-)
fs/ocfs2/move_extents.c +61 -0
@@ -238,6 +238,67 @@ out:return ret; } +/* +* lock allocators, and reserving appropriate number of bits for +* meta blocks and data clusters. +* +* in some cases, we don't need to reserve clusters, just let data_ac +* be NULL. +*/ +static int ocfs2_lock_allocators_move_extents (struct inode *inode, +struct ocfs2_extent_tree *et, +u32 clusters_to_move, +u32 extents_to_split, +struct ocfs2_alloc_context **meta_ac, +struct ocfs2_alloc_context **data_ac, +int extra_blocks, +int *credits) +{ +int ret, num_free_extents; +unsigned int max_recs_needed =2 * extents_to_split + clusters_to_move; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + + num_free_extents =ocfs2_num_free_extents (osb, et); +if (num_free_extents <0 ) { + ret = num_free_extents; +mlog_errno (ret); + goto out; + } + +if (!num_free_extents || + (ocfs2_sparse_alloc (osb) && num_free_extents < max_recs_needed)) + extra_blocks +=ocfs2_extend_meta_needed (et->et_root_el); + + ret =ocfs2_reserve_new_metadata_blocks (osb, extra_blocks, meta_ac); +if (ret) { +mlog_errno (ret); + goto out; + } + +if (data_ac) { + ret =ocfs2_reserve_clusters (osb, clusters_to_move, data_ac); +if (ret) { +mlog_errno (ret); + goto out; + } + } + + *credits +=ocfs2_calc_extend_credits (osb->sb, et->et_root_el, + clusters_to_move +2 ); + +mlog (0 ,"reserve metadata_blocks: %d, data_clusters: %u, credits: %d\n" , + extra_blocks, clusters_to_move, *credits); +out: +if (ret) { +if (*meta_ac) { +ocfs2_free_alloc_context (*meta_ac); + *meta_ac =NULL ; + } + } + +return ret; +} +static int ocfs2_move_extents (struct ocfs2_move_extents_context *context) {int status;
Signature · 1 line
1.5.5
PATCH 6/8 Ocfs2: defrag a range of extent.
In reply to Tristan YeIt's a relatively complete function to accomplish defragmentation for entire or partial extent, one journal handle was kept during the operation, it was logically doing one more thing than ocfs2_move_extent() acutally, yes, it's claiming the new clusters itself;-)
--- fs/ocfs2/move_extents.c | 97 +++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 97 insertions(+), 0 deletions(-)
fs/ocfs2/move_extents.c +97 -0
@@ -299,6 +299,103 @@ out:return ret; } +/* +* Using one journal handle to guarantee the data consistency in case +* crash happens anywhere. +*/ +static int ocfs2_defrag_extent (struct ocfs2_move_extents_context *context, +u32 cpos,u32 phys_cpos,u32 len,int flags) +{ +int ret, credits =0 ; +handle_t *handle; +struct inode *inode = context->inode; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); +struct inode *tl_inode = osb->osb_tl_inode; +u32 new_phys_cpos, new_len; + + ret =ocfs2_lock_allocators_move_extents (inode, &context->et, len,1 , + &context->meta_ac, + &context->data_ac, +0 , &credits); +if (ret) { +mlog_errno (ret); +return ret; + } + +/* +* should be using allocation reservation strategy there? +* +* if (context->data_ac) +* context->data_ac->ac_resv = &OCFS2_I(inode)->ip_la_data_resv; +*/ + +mutex_lock (&tl_inode->i_mutex); + +if (ocfs2_truncate_log_needs_flush (osb)) { + ret =__ocfs2_flush_truncate_log (osb); +if (ret <0 ) { +mlog_errno (ret); + goto out; + } + } + + handle =ocfs2_start_trans (osb, credits); +if (IS_ERR (handle)) { + ret =PTR_ERR (handle); +mlog_errno (ret); + goto out; + } + + ret =__ocfs2_claim_clusters (handle, context->data_ac,1 , len, + &new_phys_cpos, &new_len); +if (ret) { +mlog_errno (ret); + goto out_commit; + } + +/* +* we're not quite patient here to make multiple attempts for claiming +* enough clusters, failure to claim clusters per-requested is not a +* disaster though, it can only mean partial range of defragmentation +* or extent movements get gone, users anyway is able to have another +* try as they wish anytime, since they're going to be returned a +* '-ENOSPC' and completed length of this movement. +* +*/ +if (new_len != len) { +mlog (0 ,"len_claimed: %u, len: %u\n" , new_len, len); + context->range->me_flags &= ~OCFS2_MOVE_EXT_FL_COMPLETE ; + ret = -ENOSPC ; + goto out_commit; + } + +mlog (0 ,"cpos: %u, phys_cpos: %u, new_phys_cpos: %u\n" , cpos, + phys_cpos, new_phys_cpos); + + ret =__ocfs2_move_extent (handle, context, cpos, len, phys_cpos, + new_phys_cpos); +if (ret) +mlog_errno (ret); + +out_commit: +ocfs2_commit_trans (osb, handle); + +out: +mutex_unlock (&tl_inode->i_mutex); + +if (context->data_ac) { +ocfs2_free_alloc_context (context->data_ac); + context->data_ac =NULL ; + } + +if (context->meta_ac) { +ocfs2_free_alloc_context (context->meta_ac); + context->meta_ac =NULL ; + } + +return ret; +} +static int ocfs2_move_extents (struct ocfs2_move_extents_context *context) {int status;
Signature · 1 line
1.5.5
PATCH 7/8 Ocfs2: move entire/partial extent.
In reply to Tristan YeThe only difference between ocfs2_move_extent() and ocfs2_defrag_extent() is that former one didn't claim new clusters itself;)
--- fs/ocfs2/move_extents.c | 50 +++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 50 insertions(+), 0 deletions(-)
fs/ocfs2/move_extents.c +50 -0
@@ -396,6 +396,56 @@ out:return ret; } +static int ocfs2_move_extent (struct ocfs2_move_extents_context *context, +u32 cpos,u32 phys_cpos,u32 new_phys_cpos, +u32 len,int flags) +{ +int ret, credits =0 ; +handle_t *handle; +struct inode *inode = context->inode; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); +struct inode *tl_inode = osb->osb_tl_inode; + + ret =ocfs2_lock_allocators_move_extents (inode, &context->et, len,1 , + &context->meta_ac, +NULL ,0 , &credits); +if (ret) { +mlog_errno (ret); +return ret; + } + +mutex_lock (&tl_inode->i_mutex); + + handle =ocfs2_start_trans (osb, credits); +if (IS_ERR (handle)) { + ret =PTR_ERR (handle); +mlog_errno (ret); + goto out; + } + + ret =__ocfs2_move_extent (handle, context, cpos, len, phys_cpos, + new_phys_cpos); +if (ret) +mlog_errno (ret); + +ocfs2_commit_trans (osb, handle); + +out: +mutex_unlock (&tl_inode->i_mutex); + +if (context->data_ac) { +ocfs2_free_alloc_context (context->data_ac); + context->data_ac =NULL ; + } + +if (context->meta_ac) { +ocfs2_free_alloc_context (context->meta_ac); + context->meta_ac =NULL ; + } + +return ret; +} +static int ocfs2_move_extents (struct ocfs2_move_extents_context *context) {int status;
Signature · 1 line
1.5.5
PATCH 8/8 Ocfs2: move extents within a certain range.
In reply to Tristan YeThe basic logic of moving extents for a file is pretty like punching-hole sequence, walk the extents within the range as user specified, calculating an appropriate len to defrag/move, then let ocfs2_defrag/move_extent() to do the actual moving.
This func ends up setting 'OCFS2_MOVE_EXT_FL_COMPLETE' to userpace if operation gets done successfully.
--- fs/ocfs2/move_extents.c | 169 +++++++++++++++++++++++++++++++++++++++++++++-- 1 files changed, 164 insertions(+), 5 deletions(-)
fs/ocfs2/move_extents.c +164 -5
@@ -446,6 +446,169 @@ out:return ret; } +/* +* Helper to calculate the defraging length in one run according to threshold. +*/ +static void ocfs2_calc_extent_defrag_len (u32 *alloc_size,u32 *len_defraged, +u32 threshold,int *skip) +{ +if ((*alloc_size + *len_defraged) < threshold) { +/* +* proceed defragmentation until we meet the thresh +*/ + *len_defraged += *alloc_size; + }else if (*len_defraged ==0 ) { +/* +* XXX: skip a large extent. +*/ + *skip =1 ; + }else { +/* +* split this extent to coalesce with former pieces as +* to reach the threshold. +* +* we're done here with one cycle of defragmentation +* in a size of 'thresh', resetting 'len_defraged' +* forces a new defragmentation. +*/ + *alloc_size = threshold - *len_defraged; + *len_defraged =0 ; + } +} + +static int __ocfs2_move_extents_range (struct buffer_head *di_bh, +struct ocfs2_move_extents_context *context) +{ +int ret, flags, do_defrag, skip =0 ; +u32 cpos, phys_cpos, move_start, len_to_move, alloc_size; +u32 len_defraged =0 , defrag_thresh, new_phys_cpos =0 ; + +struct inode *inode = context->inode; +struct ocfs2_move_extents *range = context->range; +struct ocfs2_super *osb =OCFS2_SB (inode->i_sb); + +if ((inode->i_size ==0 ) || (range->me_len ==0 )) +return 0 ; + +if (OCFS2_I (inode)->ip_dyn_features &OCFS2_INLINE_DATA_FL ) +return 0 ; + +ocfs2_init_dinode_extent_tree (&context->et,INODE_CACHE (inode), di_bh); +ocfs2_init_dealloc_ctxt (&context->dealloc); + +/* +* TO-DO XXX: +* +* - refcount tree. +* - xattr extents. +* - unwritten extents. +*/ + + do_defrag = context->auto_defrag; + +/* +* extents moving happens in unit of clusters, for the sake +* of simplicity, we may ignore two clusters where 'byte_start' +* and 'byte_start + len' were within. +*/ + move_start =ocfs2_clusters_for_bytes (osb->sb, range->me_start); + len_to_move = (range->me_start + range->me_len) >> + osb->s_clustersize_bits; +if (len_to_move >= move_start) + len_to_move -= move_start; +else + len_to_move =0 ; + +if (do_defrag) + defrag_thresh = range->me_thresh >> osb->s_clustersize_bits; +else + new_phys_cpos =ocfs2_clusters_for_bytes (osb->sb, + range->me_goal); + +mlog (0 ,"Inode: %llu, start: %llu, len: %llu, cstart: %u, clen: %u, " +"thresh: %u\n" , + (unsigned long long )OCFS2_I (inode)->ip_blkno, + (unsigned long long )range->me_start, + (unsigned long long )range->me_len, + move_start, len_to_move, defrag_thresh); + + cpos = move_start; +while (len_to_move) { + ret =ocfs2_get_clusters (inode, cpos, &phys_cpos, &alloc_size, + &flags); +if (ret) { +mlog_errno (ret); + goto out; + } + +if (alloc_size > len_to_move) + alloc_size = len_to_move; + +/* +* XXX: how to deal with a hole: +* +* - skip the hole of course +* - force a new defragmentation +*/ +if (!phys_cpos) { +if (do_defrag) + len_defraged =0 ; + + goto next; + } + +if (do_defrag) { +ocfs2_calc_extent_defrag_len (&alloc_size, &len_defraged, + defrag_thresh, &skip); +/* +* skip large extents +*/ +if (skip) { + skip =0 ; + goto next; + } + +mlog (0 ,"#Defrag: cpos: %u, phys_cpos: %u, " +"alloc_size: %u, len_defraged: %u\n" , + cpos, phys_cpos, alloc_size, len_defraged); + + ret =ocfs2_defrag_extent (context, cpos, phys_cpos, + alloc_size, flags); + }else { + ret =ocfs2_move_extent (context, cpos, phys_cpos, + new_phys_cpos, alloc_size, + flags); + + new_phys_cpos += alloc_size; + } + +if (ret <0 ) { +mlog_errno (ret); + goto out; + } + + context->clusters_moved += alloc_size; +next: + cpos += alloc_size; + len_to_move -= alloc_size; + } + + range->me_flags |=OCFS2_MOVE_EXT_FL_COMPLETE ; + +out: + range->me_moved_len =ocfs2_clusters_to_bytes (osb->sb, + context->clusters_moved); +/* +* also need to return 'me_new_offset' for none-defragmentation case +*/ + +ocfs2_schedule_truncate_log_flush (osb,1 ); +ocfs2_run_deallocs (osb, &context->dealloc); + +return ret; +} + +static int ocfs2_move_extents (struct ocfs2_move_extents_context *context) {int status;
@@ -482,11 +645,7 @@ static int ocfs2_move_extents(struct ocfs2_move_extents_context *context)*/ down_write (&OCFS2_I (inode)->ip_alloc_sem); -/* -* real extents moving codes will be fulfilled later. -* -* status = __ocfs2_move_extents_range(di_bh, context); -*/ + status =__ocfs2_move_extents_range (di_bh, context);up_write (&OCFS2_I (inode)->ip_alloc_sem);if (status) {
Signature · 1 line
1.5.5
cover Ocfs2: Online defragmentaion V1.
In reply to Tristan YeHi Guy,
I like it. Having is definitely better than no.
I will play with it when I am free :)
thanks,
wengang.
Quoted 156 lines · Tristan Ye
Hi All,
It's a quite rough patches series v1 for online defragmentation on OCFS2, it's
workable anyway, may look ugly though;) The essence of online file defragmentation is extents moving like what btrfs and ext4 were doing, adding 'OCFS2_IOC_MOVE_EXT' ioctl to ocfs2 allows two strategies upon defragmentation:1. simple-defragmentation-in-kernl, which means kernel will be responsible for claiming new clusters, and packing the defragmented extents according to a user-specified threshold.
2. simple-extents moving, in this case, userspace play much more important role when doing defragmentation, it needs to specify the new physical
blk_offsetwhere extents will be moved, kernel itself will not do anything more than moving the extents per requested, maybe kernel also needs to manage to probe/validate thenew_blkoffsetto guarantee enough free space around there.Above two operations using the same
OCFS2_IOC_MOVE_EXT:
-------------------------------------------------------------------------------
#defineOCFS2_MOVE_EXT_FL_AUTO_DEFRAG(0x00000001) /* Kernel manages to
claim new clusters as the goal place for extents moving */
#defineOCFS2_MOVE_EXT_FL_COMPLETE(0x00000002) /* Move or defragmenation
completely gets done.
*/
structocfs2_move_extents{
/* All values are in bytes */
/* in */
__u64me_start; /* Virtual start in the file to move */
__u64me_len; /* Length of the extents to be moved */
__u64me_goal; /* Physical offset of the goal */
__u64me_thresh; /* Maximum distance from goal or threshold
for auto defragmentation */
__u64me_flags; /* flags for the operation:
* - auto defragmentation.
* - refcount,xattr cases.
*//* out */
__u64me_moved_len; /* moved length, are we completely done? */
__u64me_new_offset; /* Resulting physical location */
__u32me_reserved[3]; /* reserved for futhure */
};
-------------------------------------------------------------------------------Current V1 patches set will be focusing mostly on strategy #1 though, since #2
strategy is still there under discussion.Following are some interesting data gathered from simple tests:
1. Performance improvement gained on I/O reads:
-------------------------------------------------------------------------------
* Before defragmentation *[root at ocfs2-box4 ~]# sync
[root at ocfs2-box4 ~]# echo 3>/proc/sys/vm/drop_caches [root at ocfs2-box4 ~]# time dd if=/storage/testfile-1 of=/dev/null 640000+0 records in
640000+0 records out
327680000 bytes (328 MB) copied, 19.9351 s, 16.4 MB/sreal 0m19.954s
user 0m0.246s
sys 0m1.111s* Do defragmentation *
[root at ocfs2-box4 defrag]# ./defrag -s 0 -l 293601280 -t 3145728 /storage/testfile-1
* After defragmentation *
[root at ocfs2-box4 ~]# sync
[root at ocfs2-box4 ~]# echo 3>/proc/sys/vm/drop_caches [root at ocfs2-box4 ~]# time dd if=/storage/testfile-1 of=/dev/null 640000+0 records in
640000+0 records out
327680000 bytes (328 MB) copied, 6.79885 s, 48.2 MB/sreal 0m6.969s
user 0m0.209s
sys 0m1.063s
-------------------------------------------------------------------------------2. Extent tree layout via debugfs.ocfs2:
-------------------------------------------------------------------------------
* Before defragmentation *Tree Depth: 1 Count: 243 Next Free Rec: 8 ## Offset Clusters Block# 0 0 1173 86561 1 1173 1173 84527 2 2346 1151 81468 3 3497 1173 76362 4 4670 1173 74328 5 5843 1172 66150 6 7015 1460 70260 7 8475 662 87680 SubAlloc Bit: 1 SubAlloc Slot: 0 Blknum: 86561 Next Leaf: 84527 CRC32: abf06a6b ECC: 44bc Tree Depth: 0 Count: 252 Next Free Rec: 252 ## Offset Clusters Block# Flags 0 1 16 516104 0x0 1 17 1 554632 0x0 2 18 7 560144 0x0 3 25 1 565960 0x0 4 26 1 572632 0x ... /* around 1700 extent records were hidden there */ ... 138 9131 1 258968 0x0 139 9132 1 259568 0x0 140 9133 1 260168 0x0 141 9134 1 260768 0x0 142 9135 1 261368 0x0 143 9136 1 261968 0x0* After defragmentation *
Tree Depth: 1 Count: 243 Next Free Rec: 1 ## Offset Clusters Block# 0 0 9137 66081 SubAlloc Bit: 1 SubAlloc Slot: 0 Blknum: 66081 Next Leaf: 0 CRC32: 22897d34 ECC: 0619 Tree Depth: 0 Count: 252 Next Free Rec: 6 ## Offset Clusters Block# Flags 0 1 1600 4412936 0x0 1 1601 1595 20669448 0x0 2 3196 1600 9358856 0x0 3 4796 1404 14516232 0x0 4 6200 1600 21627400 0x0 5 7800 1337 7483400 0x0-------------------------------------------------------------------------------
TO-DO:
1. Complete strategy #2
2. Adding refcount/xattr/unwritten_extents support.
3. Free space defragmentation.Go to http://oss.oracle.com/osswiki/OCFS2/DesignDocs/OnlineDefrag for more details.
Tristan.
_______________________________________________
Ocfs2-devel mailing list
Ocfs2-devel at oss.oracle.com
http://oss.oracle.com/mailman/listinfo/ocfs2-devel
cover Ocfs2: Online defragmentaion V1.
Quoted 4 lines · Wengang Wang
Hi Guy,
I like it. Having is definitely better than no.
I will play with it when I am free :)
Hi wengang,
Very cool to hear you're showing interest on it;-)
Actually the motivation at the very beginning was inspired by your original discussion on wikipage
Thanks a lot;)
Tristan
Quoted 160 lines
thanks,
wengang.Quoted 156 lines · Tristan Ye
Hi All,
It's a quite rough patches series v1 for online defragmentation on OCFS2, it's
workable anyway, may look ugly though;) The essence of online file defragmentation is extents moving like what btrfs and ext4 were doing, adding 'OCFS2_IOC_MOVE_EXT' ioctl to ocfs2 allows two strategies upon defragmentation:1. simple-defragmentation-in-kernl, which means kernel will be responsible for claiming new clusters, and packing the defragmented extents according to a user-specified threshold.
2. simple-extents moving, in this case, userspace play much more important role when doing defragmentation, it needs to specify the new physical
blk_offsetwhere extents will be moved, kernel itself will not do anything more than moving the extents per requested, maybe kernel also needs to manage to probe/validate thenew_blkoffsetto guarantee enough free space around there.Above two operations using the same
OCFS2_IOC_MOVE_EXT:
-------------------------------------------------------------------------------
#defineOCFS2_MOVE_EXT_FL_AUTO_DEFRAG(0x00000001) /* Kernel manages to
claim new clusters as the goal place for extents moving */
#defineOCFS2_MOVE_EXT_FL_COMPLETE(0x00000002) /* Move or defragmenation
completely gets done.
*/
structocfs2_move_extents{
/* All values are in bytes */
/* in */
__u64me_start; /* Virtual start in the file to move */
__u64me_len; /* Length of the extents to be moved */
__u64me_goal; /* Physical offset of the goal */
__u64me_thresh; /* Maximum distance from goal or threshold
for auto defragmentation */
__u64me_flags; /* flags for the operation:
* - auto defragmentation.
* - refcount,xattr cases.
*//* out */
__u64me_moved_len; /* moved length, are we completely done? */
__u64me_new_offset; /* Resulting physical location */
__u32me_reserved[3]; /* reserved for futhure */
};
-------------------------------------------------------------------------------Current V1 patches set will be focusing mostly on strategy #1 though, since #2
strategy is still there under discussion.Following are some interesting data gathered from simple tests:
1. Performance improvement gained on I/O reads:
-------------------------------------------------------------------------------
* Before defragmentation *[root at ocfs2-box4 ~]# sync
[root at ocfs2-box4 ~]# echo 3>/proc/sys/vm/drop_caches [root at ocfs2-box4 ~]# time dd if=/storage/testfile-1 of=/dev/null 640000+0 records in
640000+0 records out
327680000 bytes (328 MB) copied, 19.9351 s, 16.4 MB/sreal 0m19.954s
user 0m0.246s
sys 0m1.111s* Do defragmentation *
[root at ocfs2-box4 defrag]# ./defrag -s 0 -l 293601280 -t 3145728 /storage/testfile-1
* After defragmentation *
[root at ocfs2-box4 ~]# sync
[root at ocfs2-box4 ~]# echo 3>/proc/sys/vm/drop_caches [root at ocfs2-box4 ~]# time dd if=/storage/testfile-1 of=/dev/null 640000+0 records in
640000+0 records out
327680000 bytes (328 MB) copied, 6.79885 s, 48.2 MB/sreal 0m6.969s
user 0m0.209s
sys 0m1.063s
-------------------------------------------------------------------------------2. Extent tree layout via debugfs.ocfs2:
-------------------------------------------------------------------------------
* Before defragmentation *Tree Depth: 1 Count: 243 Next Free Rec: 8 ## Offset Clusters Block# 0 0 1173 86561 1 1173 1173 84527 2 2346 1151 81468 3 3497 1173 76362 4 4670 1173 74328 5 5843 1172 66150 6 7015 1460 70260 7 8475 662 87680 SubAlloc Bit: 1 SubAlloc Slot: 0 Blknum: 86561 Next Leaf: 84527 CRC32: abf06a6b ECC: 44bc Tree Depth: 0 Count: 252 Next Free Rec: 252 ## Offset Clusters Block# Flags 0 1 16 516104 0x0 1 17 1 554632 0x0 2 18 7 560144 0x0 3 25 1 565960 0x0 4 26 1 572632 0x ... /* around 1700 extent records were hidden there */ ... 138 9131 1 258968 0x0 139 9132 1 259568 0x0 140 9133 1 260168 0x0 141 9134 1 260768 0x0 142 9135 1 261368 0x0 143 9136 1 261968 0x0* After defragmentation *
Tree Depth: 1 Count: 243 Next Free Rec: 1 ## Offset Clusters Block# 0 0 9137 66081 SubAlloc Bit: 1 SubAlloc Slot: 0 Blknum: 66081 Next Leaf: 0 CRC32: 22897d34 ECC: 0619 Tree Depth: 0 Count: 252 Next Free Rec: 6 ## Offset Clusters Block# Flags 0 1 1600 4412936 0x0 1 1601 1595 20669448 0x0 2 3196 1600 9358856 0x0 3 4796 1404 14516232 0x0 4 6200 1600 21627400 0x0 5 7800 1337 7483400 0x0-------------------------------------------------------------------------------
TO-DO:
1. Complete strategy #2
2. Adding refcount/xattr/unwritten_extents support.
3. Free space defragmentation.Go to http://oss.oracle.com/osswiki/OCFS2/DesignDocs/OnlineDefrag for more details.
Tristan.
_______________________________________________
Ocfs2-devel mailing list
Ocfs2-devel at oss.oracle.com
http://oss.oracle.com/mailman/listinfo/ocfs2-devel