2 fs/ext3/inode.c | 112 +++++++++++++++++++++
3 fs/ext3/super.c | 231 +++++++++++++++++++++++++++++++++++++++++++++
4 include/linux/ext3_fs.h | 5
5 include/linux/ext3_fs_sb.h | 10 +
6 5 files changed, 362 insertions(+)
8 --- linux-2.4.18-chaos/fs/ext3/file.c~ext3-delete_thread-2.4.18-2 2003-09-16 23:34:07.000000000 +0400
9 +++ linux-2.4.18-chaos-alexey/fs/ext3/file.c 2003-09-16 23:42:34.000000000 +0400
10 @@ -124,7 +124,11 @@ struct file_operations ext3_file_operati
13 struct inode_operations ext3_file_inode_operations = {
14 +#ifdef EXT3_DELETE_THREAD
15 + truncate: ext3_truncate_thread, /* BKL held */
17 truncate: ext3_truncate, /* BKL held */
19 setattr: ext3_setattr, /* BKL held */
22 --- linux-2.4.18-chaos/fs/ext3/inode.c~ext3-delete_thread-2.4.18-2 2003-09-16 23:39:37.000000000 +0400
23 +++ linux-2.4.18-chaos-alexey/fs/ext3/inode.c 2003-09-16 23:42:34.000000000 +0400
24 @@ -2041,6 +2041,118 @@ out_unlock:
25 return; /* AKPM: return what? */
28 +#ifdef EXT3_DELETE_THREAD
29 +/* Move blocks from to-be-truncated inode over to a new inode, and delete
30 + * that one from the delete thread instead. This avoids a lot of latency
31 + * when truncating large files.
33 + * If we have any problem deferring the truncate, just truncate it right away.
34 + * If we defer it, we also mark how many blocks it would free, so that we
35 + * can keep the statfs data correct, and we know if we should sleep on the
36 + * delete thread when we run out of space.
38 +void ext3_truncate_thread(struct inode *old_inode)
40 + struct ext3_sb_info *sbi = EXT3_SB(old_inode->i_sb);
41 + struct ext3_inode_info *nei, *oei = EXT3_I(old_inode);
42 + struct inode *new_inode;
44 + unsigned long blocks = old_inode->i_blocks >> (old_inode->i_blkbits-9);
46 + if (!test_opt(old_inode->i_sb, ASYNCDEL) || !sbi->s_delete_list.next)
49 + /* XXX This is a temporary limitation for code simplicity.
50 + * We could truncate to arbitrary sizes at some later time.
52 + if (old_inode->i_size != 0)
55 + /* We may want to truncate the inode immediately and not defer it */
56 + if (IS_SYNC(old_inode) || blocks <= EXT3_NDIR_BLOCKS ||
57 + old_inode->i_size > oei->i_disksize)
60 + /* We can't use the delete thread as-is during real orphan recovery,
61 + * as we add to the orphan list here, causing ext3_orphan_cleanup()
62 + * to loop endlessly. It would be nice to do so, but needs work.
64 + if (oei->i_state & EXT3_STATE_DELETE ||
65 + sbi->s_mount_state & EXT3_ORPHAN_FS) {
66 + ext3_debug("doing deferred inode %lu delete (%lu blocks)\n",
67 + old_inode->i_ino, blocks);
71 + ext3_discard_prealloc(old_inode);
74 + * new_inode = sb + GDT + ibitmap
75 + * orphan list = 1 inode/superblock for add, 2 inodes for del
76 + * quota files = 2 * EXT3_SINGLEDATA_TRANS_BLOCKS
78 + handle = ext3_journal_start(old_inode, 7);
82 + new_inode = ext3_new_inode(handle, old_inode, old_inode->i_mode);
83 + if (IS_ERR(new_inode)) {
84 + ext3_debug("truncate inode %lu directly (no new inodes)\n",
89 + nei = EXT3_I(new_inode);
91 + down_write(&oei->truncate_sem);
92 + new_inode->i_size = old_inode->i_size;
93 + new_inode->i_blocks = old_inode->i_blocks;
94 + new_inode->i_uid = old_inode->i_uid;
95 + new_inode->i_gid = old_inode->i_gid;
96 + new_inode->i_nlink = 0;
98 + /* FIXME when we do arbitrary truncates */
99 + old_inode->i_blocks = oei->i_file_acl ? old_inode->i_blksize / 512 : 0;
100 + old_inode->i_mtime = old_inode->i_ctime = CURRENT_TIME;
102 + memcpy(nei->i_data, oei->i_data, sizeof(nei->i_data));
103 + memset(oei->i_data, 0, sizeof(oei->i_data));
105 + nei->i_disksize = oei->i_disksize;
106 + nei->i_state |= EXT3_STATE_DELETE;
107 + up_write(&oei->truncate_sem);
109 + if (ext3_orphan_add(handle, new_inode) < 0)
112 + if (ext3_orphan_del(handle, old_inode) < 0) {
113 + ext3_orphan_del(handle, new_inode);
118 + ext3_journal_stop(handle, old_inode);
120 + spin_lock(&sbi->s_delete_lock);
121 + J_ASSERT(list_empty(&new_inode->i_dentry));
122 + list_add_tail(&new_inode->i_dentry, &sbi->s_delete_list);
123 + sbi->s_delete_blocks += blocks;
124 + sbi->s_delete_inodes++;
125 + spin_unlock(&sbi->s_delete_lock);
127 + ext3_debug("delete inode %lu (%lu blocks) by thread\n",
128 + new_inode->i_ino, blocks);
130 + wake_up(&sbi->s_delete_thread_queue);
134 + ext3_journal_stop(handle, old_inode);
136 + ext3_truncate(old_inode);
138 +#endif /* EXT3_DELETE_THREAD */
141 * ext3_get_inode_loc returns with an extra refcount against the
142 * inode's underlying buffer_head on success.
143 --- linux-2.4.18-chaos/fs/ext3/super.c~ext3-delete_thread-2.4.18-2 2003-09-16 23:42:33.000000000 +0400
144 +++ linux-2.4.18-chaos-alexey/fs/ext3/super.c 2003-09-16 23:42:34.000000000 +0400
145 @@ -398,6 +398,220 @@ static void dump_orphan_list(struct supe
149 +#ifdef EXT3_DELETE_THREAD
151 + * Delete inodes in a loop until there are no more to be deleted.
152 + * Normally, we run in the background doing the deletes and sleeping again,
153 + * and clients just add new inodes to be deleted onto the end of the list.
154 + * If someone is concerned about free space (e.g. block allocation or similar)
155 + * then they can sleep on s_delete_waiter_queue and be woken up when space
158 +int ext3_delete_thread(void *data)
160 + struct super_block *sb = data;
161 + struct ext3_sb_info *sbi = EXT3_SB(sb);
162 + struct task_struct *tsk = current;
164 + /* Almost like daemonize, but not quite */
169 + exit_files(current);
170 + reparent_to_init();
172 + sprintf(tsk->comm, "kdelext3-%s", kdevname(sb->s_dev));
173 + sigfillset(&tsk->blocked);
175 + /*tsk->flags |= PF_KERNTHREAD;*/
177 + INIT_LIST_HEAD(&sbi->s_delete_list);
178 + wake_up(&sbi->s_delete_waiter_queue);
179 + ext3_debug("delete thread on %s started\n", kdevname(sb->s_dev));
183 + wait_event_interruptible(sbi->s_delete_thread_queue,
184 + !list_empty(&sbi->s_delete_list) ||
185 + !test_opt(sb, ASYNCDEL));
186 + ext3_debug("%s woken up: %lu inodes, %lu blocks\n",
187 + tsk->comm,sbi->s_delete_inodes,sbi->s_delete_blocks);
189 + spin_lock(&sbi->s_delete_lock);
190 + if (list_empty(&sbi->s_delete_list)) {
191 + clear_opt(sbi->s_mount_opt, ASYNCDEL);
192 + memset(&sbi->s_delete_list, 0,
193 + sizeof(sbi->s_delete_list));
194 + spin_unlock(&sbi->s_delete_lock);
195 + ext3_debug("delete thread on %s exiting\n",
196 + kdevname(sb->s_dev));
197 + wake_up(&sbi->s_delete_waiter_queue);
201 + while (!list_empty(&sbi->s_delete_list)) {
202 + struct inode *inode=list_entry(sbi->s_delete_list.next,
203 + struct inode, i_dentry);
204 + unsigned long blocks = inode->i_blocks >>
205 + (inode->i_blkbits - 9);
207 + list_del_init(&inode->i_dentry);
208 + spin_unlock(&sbi->s_delete_lock);
209 + ext3_debug("%s delete ino %lu blk %lu\n",
210 + tsk->comm, inode->i_ino, blocks);
214 + spin_lock(&sbi->s_delete_lock);
215 + sbi->s_delete_blocks -= blocks;
216 + sbi->s_delete_inodes--;
218 + if (sbi->s_delete_blocks != 0 || sbi->s_delete_inodes != 0) {
219 + ext3_warning(sb, __FUNCTION__,
220 + "%lu blocks, %lu inodes on list?\n",
221 + sbi->s_delete_blocks,sbi->s_delete_inodes);
222 + sbi->s_delete_blocks = 0;
223 + sbi->s_delete_inodes = 0;
225 + spin_unlock(&sbi->s_delete_lock);
226 + wake_up(&sbi->s_delete_waiter_queue);
232 +static void ext3_start_delete_thread(struct super_block *sb)
234 + struct ext3_sb_info *sbi = EXT3_SB(sb);
237 + spin_lock_init(&sbi->s_delete_lock);
238 + init_waitqueue_head(&sbi->s_delete_thread_queue);
239 + init_waitqueue_head(&sbi->s_delete_waiter_queue);
241 + if (!test_opt(sb, ASYNCDEL))
244 + rc = kernel_thread(ext3_delete_thread, sb, CLONE_VM | CLONE_FILES);
246 + printk(KERN_ERR "EXT3-fs: cannot start delete thread: rc %d\n",
249 + wait_event(sbi->s_delete_waiter_queue, sbi->s_delete_list.next);
252 +static void ext3_stop_delete_thread(struct ext3_sb_info *sbi)
254 + if (sbi->s_delete_list.next == 0) /* thread never started */
257 + clear_opt(sbi->s_mount_opt, ASYNCDEL);
258 + wake_up(&sbi->s_delete_thread_queue);
259 + wait_event(sbi->s_delete_waiter_queue, list_empty(&sbi->s_delete_list));
262 +/* Instead of playing games with the inode flags, destruction, etc we just
263 + * create a new inode locally and put it on a list for the truncate thread.
264 + * We need large parts of the inode struct in order to complete the
265 + * truncate and unlink, so we may as well just have a real inode to do it.
267 + * If we have any problem deferring the delete, just delete it right away.
268 + * If we defer it, we also mark how many blocks it would free, so that we
269 + * can keep the statfs data correct, and we know if we should sleep on the
270 + * delete thread when we run out of space.
272 +static void ext3_delete_inode_thread(struct inode *old_inode)
274 + struct ext3_sb_info *sbi = EXT3_SB(old_inode->i_sb);
275 + struct ext3_inode_info *nei, *oei = EXT3_I(old_inode);
276 + struct inode *new_inode;
277 + unsigned long blocks = old_inode->i_blocks >> (old_inode->i_blkbits-9);
279 + if (is_bad_inode(old_inode)) {
280 + clear_inode(old_inode);
284 + if (!test_opt(old_inode->i_sb, ASYNCDEL) || !sbi->s_delete_list.next)
287 + /* We may want to delete the inode immediately and not defer it */
288 + if (IS_SYNC(old_inode) || blocks <= EXT3_NDIR_BLOCKS)
291 + /* We can't use the delete thread as-is during real orphan recovery,
292 + * as we add to the orphan list here, causing ext3_orphan_cleanup()
293 + * to loop endlessly. It would be nice to do so, but needs work.
295 + if (oei->i_state & EXT3_STATE_DELETE ||
296 + sbi->s_mount_state & EXT3_ORPHAN_FS) {
297 + ext3_debug("doing deferred inode %lu delete (%lu blocks)\n",
298 + old_inode->i_ino, blocks);
302 + /* We can iget this inode again here, because our caller has unhashed
303 + * old_inode, so new_inode will be in a different inode struct.
305 + * We need to ensure that the i_orphan pointers in the other inodes
306 + * point at the new inode copy instead of the old one so the orphan
307 + * list doesn't get corrupted when the old orphan inode is freed.
309 + down(&sbi->s_orphan_lock);
311 + sbi->s_mount_state |= EXT3_ORPHAN_FS;
312 + new_inode = iget(old_inode->i_sb, old_inode->i_ino);
313 + sbi->s_mount_state &= ~EXT3_ORPHAN_FS;
314 + if (is_bad_inode(new_inode)) {
315 + printk(KERN_WARNING "read bad inode %lu\n", old_inode->i_ino);
320 + up(&sbi->s_orphan_lock);
321 + ext3_debug("delete inode %lu directly (bad read)\n",
325 + J_ASSERT(new_inode != old_inode);
327 + J_ASSERT(!list_empty(&oei->i_orphan));
329 + nei = EXT3_I(new_inode);
330 + /* Ugh. We need to insert new_inode into the same spot on the list
331 + * as old_inode was, to ensure the in-memory orphan list is still
332 + * in the same order as the on-disk orphan list (badness otherwise).
334 + nei->i_orphan = oei->i_orphan;
335 + nei->i_orphan.next->prev = &nei->i_orphan;
336 + nei->i_orphan.prev->next = &nei->i_orphan;
337 + nei->i_state |= EXT3_STATE_DELETE;
338 + up(&sbi->s_orphan_lock);
340 + clear_inode(old_inode);
342 + spin_lock(&sbi->s_delete_lock);
343 + J_ASSERT(list_empty(&new_inode->i_dentry));
344 + list_add_tail(&new_inode->i_dentry, &sbi->s_delete_list);
345 + sbi->s_delete_blocks += blocks;
346 + sbi->s_delete_inodes++;
347 + spin_unlock(&sbi->s_delete_lock);
349 + ext3_debug("delete inode %lu (%lu blocks) by thread\n",
350 + new_inode->i_ino, blocks);
352 + wake_up(&sbi->s_delete_thread_queue);
356 + ext3_delete_inode(old_inode);
359 +#define ext3_start_delete_thread(sbi) do {} while(0)
360 +#define ext3_stop_delete_thread(sbi) do {} while(0)
361 +#endif /* EXT3_DELETE_THREAD */
363 void ext3_put_super (struct super_block * sb)
365 struct ext3_sb_info *sbi = EXT3_SB(sb);
366 @@ -405,6 +619,7 @@ void ext3_put_super (struct super_block
367 kdev_t j_dev = sbi->s_journal->j_dev;
370 + ext3_stop_delete_thread(sbi);
371 ext3_xattr_put_super(sb);
372 journal_destroy(sbi->s_journal);
373 if (!(sb->s_flags & MS_RDONLY)) {
374 @@ -453,7 +668,11 @@ static struct super_operations ext3_sops
375 write_inode: ext3_write_inode, /* BKL not held. Don't need */
376 dirty_inode: ext3_dirty_inode, /* BKL not held. We take it */
377 put_inode: ext3_put_inode, /* BKL not held. Don't need */
378 +#ifdef EXT3_DELETE_THREAD
379 + delete_inode: ext3_delete_inode_thread,/* BKL not held. We take it */
381 delete_inode: ext3_delete_inode, /* BKL not held. We take it */
383 put_super: ext3_put_super, /* BKL held */
384 write_super: ext3_write_super, /* BKL held */
385 sync_fs: ext3_sync_fs,
386 @@ -514,6 +733,14 @@ static int parse_options (char * options
387 this_char = strtok (NULL, ",")) {
388 if ((value = strchr (this_char, '=')) != NULL)
390 +#ifdef EXT3_DELETE_THREAD
391 + if (!strcmp(this_char, "asyncdel"))
392 + set_opt(*mount_options, ASYNCDEL);
393 + else if (!strcmp(this_char, "noasyncdel"))
394 + clear_opt(*mount_options, ASYNCDEL);
398 if (!strcmp (this_char, "bsddf"))
399 clear_opt (*mount_options, MINIX_DF);
400 else if (!strcmp (this_char, "nouid32")) {
401 @@ -1203,6 +1430,7 @@ struct super_block * ext3_read_super (st
404 ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
405 + ext3_start_delete_thread(sb);
407 * akpm: core read_super() calls in here with the superblock locked.
408 * That deadlocks, because orphan cleanup needs to lock the superblock
409 @@ -1643,6 +1871,9 @@ int ext3_remount (struct super_block * s
410 if (!parse_options(data, &tmp, sbi, &tmp, 1))
413 + if (!test_opt(sb, ASYNCDEL) || (*flags & MS_RDONLY))
414 + ext3_stop_delete_thread(sbi);
416 if (sbi->s_mount_opt & EXT3_MOUNT_ABORT)
417 ext3_abort(sb, __FUNCTION__, "Abort forced by user");
419 --- linux-2.4.18-chaos/include/linux/ext3_fs.h~ext3-delete_thread-2.4.18-2 2003-09-16 23:39:37.000000000 +0400
420 +++ linux-2.4.18-chaos-alexey/include/linux/ext3_fs.h 2003-09-16 23:42:34.000000000 +0400
421 @@ -195,6 +195,7 @@ struct ext3_group_desc
423 #define EXT3_STATE_JDATA 0x00000001 /* journaled data exists */
424 #define EXT3_STATE_NEW 0x00000002 /* inode is newly created */
425 +#define EXT3_STATE_DELETE 0x00000010 /* deferred delete inode */
429 @@ -322,6 +323,7 @@ struct ext3_inode {
430 #define EXT3_MOUNT_WRITEBACK_DATA 0x0C00 /* No data ordering */
431 #define EXT3_MOUNT_UPDATE_JOURNAL 0x1000 /* Update the journal format */
432 #define EXT3_MOUNT_NO_UID32 0x2000 /* Disable 32-bit UIDs */
433 +#define EXT3_MOUNT_ASYNCDEL 0x20000 /* Delayed deletion */
435 /* Compatibility, for having both ext2_fs.h and ext3_fs.h included at once */
436 #ifndef _LINUX_EXT2_FS_H
437 @@ -708,6 +710,9 @@ extern void ext3_discard_prealloc (struc
438 extern void ext3_dirty_inode(struct inode *);
439 extern int ext3_change_inode_journal_flag(struct inode *, int);
440 extern void ext3_truncate (struct inode *);
441 +#ifdef EXT3_DELETE_THREAD
442 +extern void ext3_truncate_thread(struct inode *inode);
446 extern int ext3_ioctl (struct inode *, struct file *, unsigned int,
447 --- linux-2.4.18-chaos/include/linux/ext3_fs_sb.h~ext3-delete_thread-2.4.18-2 2003-09-16 23:42:33.000000000 +0400
448 +++ linux-2.4.18-chaos-alexey/include/linux/ext3_fs_sb.h 2003-09-16 23:42:34.000000000 +0400
451 #define EXT3_MAX_GROUP_LOADED 32
453 +#define EXT3_DELETE_THREAD
456 * third extended-fs super-block data in memory
458 @@ -76,6 +78,14 @@ struct ext3_sb_info {
459 struct timer_list turn_ro_timer; /* For turning read-only (crash simulation) */
460 wait_queue_head_t ro_wait_queue; /* For people waiting for the fs to go read-only */
462 +#ifdef EXT3_DELETE_THREAD
463 + spinlock_t s_delete_lock;
464 + struct list_head s_delete_list;
465 + unsigned long s_delete_blocks;
466 + unsigned long s_delete_inodes;
467 + wait_queue_head_t s_delete_thread_queue;
468 + wait_queue_head_t s_delete_waiter_queue;
472 #endif /* _LINUX_EXT3_FS_SB */