linux-toradex.git/fs/nilfs2/segment.c, branch v2.6.32.52

nilfs2: fix irregular checkpoint creation due to data flush

2009-11-03T03:32:03+00:00

When nilfs flushes out dirty data to reduce memory pressure, creation
of checkpoints is wrongly postponed.  This bug causes irregular
checkpoint creation especially in small footprint systems.

To correct this issue, a timer for the checkpoint creation has to be
continued if a log writer does not create a checkpoint.

This will do the correction.

Signed-off-by: Ryusuke Konishi

nilfs2: stop using periodic write_super callback

2009-09-14T09:27:14+00:00

This removes nilfs_write_super and commit super block in nilfs
internal thread, instead of periodic write_super callback.

VFS layer calls ->write_super callback periodically.  However,
it looks like that calling back is ommited when disk I/O is busy.
And when cleanerd (nilfs GC) is runnig, disk I/O tend to be busy thus
nilfs superblock is not synchronized as nilfs designed.

To avoid it, syncing superblock by nilfs thread instead of pdflush.

Signed-off-by: Jiro SEKIBA 
Signed-off-by: Ryusuke Konishi

nilfs2: fix oops due to inconsistent state in page with discrete b-tree nodes

2009-08-01T13:48:32+00:00

Andrea Gelmini gave me a report that a kernel oops hit on a nilfs
filesystem with a 1KB block size when doing rsync.

This turned out to be caused by an inconsistency of dirty state
between a page and its buffers storing b-tree node blocks.

If the page had multiple buffers split over multiple logs, and if the
logs were written at a time, a dirty flag remained in the page even
every dirty flag in the buffers was cleared.

This will fix the failure by dropping the dirty flag properly for
pages with the discrete multiple b-tree nodes.

Reported-by: Andrea Gelmini 
Signed-off-by: Ryusuke Konishi 
Tested-by: Andrea Gelmini 
Cc: stable@kernel.org

nilfs2: fix hang problem of log writer which occurs after write failures

2009-07-05T01:44:20+00:00

Leandro Lucarella gave me a report that nilfs gets stuck after its
write function fails.

The problem turned out to be caused by bugs which leave writeback flag
on pages.  This fixes the problem by ensuring to clear the writeback
flag in error path.

Reported-by: Leandro Lucarella 
Signed-off-by: Ryusuke Konishi 
Cc: stable@kernel.org

nilfs2: remove unlikely directive causing mis-conversion of error code

2009-07-05T01:44:19+00:00

The following error code handling in nilfs_segctor_write() function
wrongly converted negative error codes to a truth value (i.e. 1):

   err = unlikely(err) ? : res;

which originaly meant to be

   err = err ? : res;

This mis-conversion caused that write or sync functions receive the
unexpected error code.  This fixes the bug by removing the unlikely
directive.

Signed-off-by: Ryusuke Konishi 
Cc: stable@kernel.org

nilfs2: eliminate removal list of segments

2009-06-10T14:41:09+00:00

This will clean up the removal list of segments and the related
functions from segment.c and ioctl.c, which have hurt code
readability.

This elimination is applied by using nilfs_sufile_updatev() previously
introduced in the patch ("nilfs2: add sufile function that can modify
multiple segment usages").

Signed-off-by: Ryusuke Konishi

nilfs2: fix lock order reversal in nilfs_clean_segments ioctl

2009-05-11T05:54:41+00:00

This is a companion patch to ("nilfs2: fix possible circular locking
for get information ioctls").

This corrects lock order reversal between mm->mmap_sem and
nilfs->ns_segctor_sem in nilfs_clean_segments() which was detected by
lockdep check:

 =======================================================
 [ INFO: possible circular locking dependency detected ]
 2.6.30-rc3-nilfs-00003-g360bdc1 #7
 -------------------------------------------------------
 mmap/5294 is trying to acquire lock:
  (&nilfs->ns_segctor_sem){++++.+}, at: [] nilfs_transaction_begin+0xb6/0x10c [nilfs2]

 but task is already holding lock:
  (&mm->mmap_sem){++++++}, at: [] do_page_fault+0x1d8/0x30a

 which lock already depends on the new lock.

 the existing dependency chain (in reverse order) is:

 -> #1 (&mm->mmap_sem){++++++}:
        [] __lock_acquire+0x1066/0x13b0
        [] lock_acquire+0xba/0xdd
        [] might_fault+0x68/0x88
        [] copy_from_user+0x2a/0x111
        [] nilfs_ioctl_prepare_clean_segments+0x1d/0xf1 [nilfs2]
        [] nilfs_clean_segments+0x6d/0x1b9 [nilfs2]
        [] nilfs_ioctl+0x2ad/0x318 [nilfs2]
        [] vfs_ioctl+0x22/0x69
        [] do_vfs_ioctl+0x460/0x499
        [] sys_ioctl+0x40/0x5a
        [] sysenter_do_call+0x12/0x38
        [] 0xffffffff

 -> #0 (&nilfs->ns_segctor_sem){++++.+}:
        [] __lock_acquire+0xdcc/0x13b0
        [] lock_acquire+0xba/0xdd
        [] down_read+0x2a/0x3e
        [] nilfs_transaction_begin+0xb6/0x10c [nilfs2]
        [] nilfs_page_mkwrite+0xe7/0x154 [nilfs2]
        [] __do_fault+0x165/0x376
        [] handle_mm_fault+0x287/0x5d1
        [] do_page_fault+0x2fb/0x30a
        [] error_code+0x72/0x78
        [] 0xffffffff

where nilfs_clean_segments() holds:

  nilfs->ns_segctor_sem -> copy_from_user()
                             --> page fault -> mm->mmap_sem

And, page fault path may hold:

  page fault -> mm->mmap_sem
         --> nilfs_page_mkwrite() -> nilfs->ns_segctor_sem

Even though nilfs_clean_segments() does not perform write access on
given user pages, it may cause deadlock because nilfs->ns_segctor_sem
is shared per device and mm->mmap_sem can be shared with other tasks.

To avoid this problem, this patch moves all calls of copy_from_user()
outside the nilfs->ns_segctor_sem lock in the ioctl.

Signed-off-by: Ryusuke Konishi

nilfs2: introduce secondary super block

2009-04-07T15:31:20+00:00

The former versions didn't have extra super blocks.  This improves the
weak point by introducing another super block at unused region in tail of
the partition.

This doesn't break disk format compatibility; older versions just ingore
the secondary super block, and new versions just recover it if it doesn't
exist.  The partition created by an old mkfs may not have unused region,
but in that case, the secondary super block will not be added.

This doesn't make more redundant copies of the super block; it is a future
work.

Signed-off-by: Ryusuke Konishi 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

nilfs2: simplify handling of active state of segments

2009-04-07T15:31:20+00:00

will reduce some lines of segment constructor.  Previously, the state was
complexly controlled through a list of segments in order to keep
consistency in meta data of usage state of segments.  Instead, this
presents ``calculated'' active flags to userland cleaner program and stop
maintaining its real flag on disk.

Only by this fake flag, the cleaner cannot exactly know if each segment is
reclaimable or not.  However, the recent extension of nilfs_sustat ioctl
struct (nilfs2-extend-nilfs_sustat-ioctl-struct.patch) can prevent the
cleaner from reclaiming in-use segment wrongly.

So, now I can apply this for simplification.

Signed-off-by: Ryusuke Konishi 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds

nilfs2: mark minor flag for checkpoint created by internal operation

2009-04-07T15:31:19+00:00

Nilfs creates checkpoints even for garbage collection or metadata updates
such as checkpoint mode change.  So, user often sees checkpoints created
only by such internal operations.

This is inconvenient in some situations.  For example, application that
monitors checkpoints and changes them to snapshots, will fall into an
infinite loop because it cannot distinguish internally created
checkpoints.

This patch solves this sort of problem by adding a flag to checkpoint for
identification.

Signed-off-by: Ryusuke Konishi 
Signed-off-by: Andrew Morton 
Signed-off-by: Linus Torvalds