<feed xmlns='http://www.w3.org/2005/Atom'>
<title>linux/drivers/md, branch v2.6.26</title>
<subtitle>Mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/
</subtitle>
<id>https://git.shady.money/linux/atom?h=v2.6.26</id>
<link rel='self' href='https://git.shady.money/linux/atom?h=v2.6.26'/>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/'/>
<updated>2008-07-10T16:49:46Z</updated>
<entry>
<title>Merge branch 'for-2.6.26' of git://neil.brown.name/md</title>
<updated>2008-07-10T16:49:46Z</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2008-07-10T16:49:46Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=2283af5b0b99565f516eacd756df2b1ddf9f4f85'/>
<id>urn:sha1:2283af5b0b99565f516eacd756df2b1ddf9f4f85</id>
<content type='text'>
* 'for-2.6.26' of git://neil.brown.name/md:
  md: ensure all blocks are uptodate or locked when syncing
</content>
</entry>
<entry>
<title>md: ensure all blocks are uptodate or locked when syncing</title>
<updated>2008-07-10T05:25:18Z</updated>
<author>
<name>Dan Williams</name>
<email>dan.j.williams@intel.com</email>
</author>
<published>2008-07-10T11:54:57Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=7a1fc53c5adb910751a9b212af90302eb4ffb527'/>
<id>urn:sha1:7a1fc53c5adb910751a9b212af90302eb4ffb527</id>
<content type='text'>
Remove the dubious attempt to prefer 'compute' over 'read'.  Not only is it
wrong given commit c337869d (md: do not compute parity unless it is on a failed
drive), but it can trigger a BUG_ON in handle_parity_checks5().

Cc: &lt;stable@kernel.org&gt;
Signed-off-by: Dan Williams &lt;dan.j.williams@intel.com&gt;
Signed-off-by: Neil Brown &lt;neilb@suse.de&gt;
</content>
</entry>
<entry>
<title>Merge git://git.kernel.org/pub/scm/linux/kernel/git/agk/linux-2.6-dm</title>
<updated>2008-07-03T01:55:17Z</updated>
<author>
<name>Linus Torvalds</name>
<email>torvalds@linux-foundation.org</email>
</author>
<published>2008-07-03T01:55:17Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=cefcade9e7b2331110fdd709b5871ebcc5f9a40f'/>
<id>urn:sha1:cefcade9e7b2331110fdd709b5871ebcc5f9a40f</id>
<content type='text'>
* git://git.kernel.org/pub/scm/linux/kernel/git/agk/linux-2.6-dm:
  dm crypt: use cond_resched
</content>
</entry>
<entry>
<title>dm crypt: use cond_resched</title>
<updated>2008-07-02T08:34:28Z</updated>
<author>
<name>Milan Broz</name>
<email>mbroz@redhat.com</email>
</author>
<published>2008-07-02T08:34:28Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=c7f1b2044191a82e7f0a1a674751ed582289e2e0'/>
<id>urn:sha1:c7f1b2044191a82e7f0a1a674751ed582289e2e0</id>
<content type='text'>
Add cond_resched() to prevent monopolising CPU when processing large bios.

dm-crypt processes encryption of bios in sector units.  If the bio request
is big it can spend a long time in the encryption call.

Signed-off-by: Milan Broz &lt;mbroz@redhat.com&gt;
Tested-by: Yan Li &lt;elliot.li.tech@gmail.com&gt;
Signed-off-by: Andrew Morton &lt;akpm@linux-foundation.org&gt;
Signed-off-by: Alasdair G Kergon &lt;agk@redhat.com&gt;
</content>
</entry>
<entry>
<title>Fix error paths if md_probe fails.</title>
<updated>2008-06-27T22:31:17Z</updated>
<author>
<name>Neil Brown</name>
<email>neilb@notabene.brown</email>
</author>
<published>2008-06-27T22:31:17Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=9bbbca3a0ee09293108b67835c6bdf6196d7bcb3'/>
<id>urn:sha1:9bbbca3a0ee09293108b67835c6bdf6196d7bcb3</id>
<content type='text'>
md_probe can fail (e.g. alloc_disk could fail) without
returning an error (as it alway returns NULL).
So when we call mddev_find immediately afterwards, we need
to check that md_probe actually succeeded.  This means checking
that mdev-&gt;gendisk is non-NULL.

cc: &lt;stable@kernel.org&gt;
Cc: Dave Jones &lt;davej@redhat.com&gt;
Signed-off-by: Neil Brown &lt;neilb@suse.de&gt;
</content>
</entry>
<entry>
<title>Don't acknowlege that stripe-expand is complete until it really is.</title>
<updated>2008-06-27T22:31:14Z</updated>
<author>
<name>Neil Brown</name>
<email>neilb@notabene.brown</email>
</author>
<published>2008-06-27T22:31:14Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=efe311431869b40d67911820a309f9a1a41306f3'/>
<id>urn:sha1:efe311431869b40d67911820a309f9a1a41306f3</id>
<content type='text'>
We shouldn't acknowledge that a stripe has been expanded (When
reshaping a raid5 by adding a device) until the moved data has
actually been written out.  However we are currently
acknowledging (by calling md_done_sync) when the POST_XOR
is complete and before the write.

So track in s.locked whether there are pending writes, and don't
call md_done_sync yet if there are.

Note: we all set R5_LOCKED on devices which are are about to
read from.  This probably isn't technically necessary, but is
usually done when writing a block, and justifies the use of
s.locked here.

This bug can lead to a crash if an array is stopped while an reshape
is in progress.

Cc: &lt;stable@kernel.org&gt;
Signed-off-by: Neil Brown &lt;neilb@suse.de&gt;
</content>
</entry>
<entry>
<title>Ensure interrupted recovery completed properly (v1 metadata plus bitmap)</title>
<updated>2008-06-27T22:30:52Z</updated>
<author>
<name>Neil Brown</name>
<email>neilb@notabene.brown</email>
</author>
<published>2008-06-27T22:30:52Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=8c2e870a625bd336b2e7a65a97c1836acef07322'/>
<id>urn:sha1:8c2e870a625bd336b2e7a65a97c1836acef07322</id>
<content type='text'>
If, while assembling an array, we find a device which is not fully
in-sync with the array, it is important to set the "fullsync" flags.
This is an exact analog to the setting of this flag in hot_add_disk
methods.

Currently, only v1.x metadata supports having devices in an array
which are not fully in-sync (it keep track of how in sync they are).
The 'fullsync' flag only makes a difference when a write-intent bitmap
is being used.  In this case it tells recovery to ignore the bitmap
and recovery all blocks.

This fix is already in place for raid1, but not raid5/6 or raid10.

So without this fix, a raid1 ir raid4/5/6 array with version 1.x
metadata and a write intent bitmaps, that is stopped in the middle
of a recovery, will appear to complete the recovery instantly
after it is reassembled, but the recovery will not be correct.

If you might have an array like that, issueing
   echo repair &gt; /sys/block/mdXX/md/sync_action

will make sure recovery completes properly.

Cc: &lt;stable@kernel.org&gt;
Signed-off-by: Neil Brown &lt;neilb@suse.de&gt;
</content>
</entry>
<entry>
<title>md: do not compute parity unless it is on a failed drive</title>
<updated>2008-06-06T18:29:08Z</updated>
<author>
<name>Dan Williams</name>
<email>dan.j.williams@intel.com</email>
</author>
<published>2008-06-06T05:45:54Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=c337869d95011495fa181536786e74aa2d7ff031'/>
<id>urn:sha1:c337869d95011495fa181536786e74aa2d7ff031</id>
<content type='text'>
If a block is computed (rather than read) then a check/repair operation
may be lead to believe that the data on disk is correct, when infact it
isn't.  So only compute blocks for failed devices.

This issue has been around since at least 2.6.12, but has become harder to
hit in recent kernels since most reads bypass the cache.

echo repair &gt; /sys/block/mdN/md/sync_action will set the parity blocks to the
correct state.

Cc: &lt;stable@kernel.org&gt;
Signed-off-by: Dan Williams &lt;dan.j.williams@intel.com&gt;
Signed-off-by: Neil Brown &lt;neilb@suse.de&gt;
Signed-off-by: Andrew Morton &lt;akpm@linux-foundation.org&gt;
Signed-off-by: Linus Torvalds &lt;torvalds@linux-foundation.org&gt;
</content>
</entry>
<entry>
<title>md: fix uninitialized use of mddev-&gt;recovery_wait</title>
<updated>2008-06-06T18:29:08Z</updated>
<author>
<name>Dan Williams</name>
<email>dan.j.williams@intel.com</email>
</author>
<published>2008-06-06T05:45:53Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=a6d8113a986c66aeb379a26b6e0062488b3e59e1'/>
<id>urn:sha1:a6d8113a986c66aeb379a26b6e0062488b3e59e1</id>
<content type='text'>
If an array was created with --assume-clean we will oops when trying to
set -&gt;resync_max.

Fix this by initializing -&gt;recovery_wait in mddev_find.

Cc: &lt;stable@kernel.org&gt;
Signed-off-by: Dan Williams &lt;dan.j.williams@intel.com&gt;
Signed-off-by: Neil Brown &lt;neilb@suse.de&gt;
Signed-off-by: Andrew Morton &lt;akpm@linux-foundation.org&gt;
Signed-off-by: Linus Torvalds &lt;torvalds@linux-foundation.org&gt;
</content>
</entry>
<entry>
<title>md: fix prexor vs sync_request race</title>
<updated>2008-06-06T18:29:08Z</updated>
<author>
<name>Dan Williams</name>
<email>dan.j.williams@intel.com</email>
</author>
<published>2008-06-06T05:45:52Z</published>
<link rel='alternate' type='text/html' href='https://git.shady.money/linux/commit/?id=e0a115e5aa554b93150a8dc1c3fe15467708abb2'/>
<id>urn:sha1:e0a115e5aa554b93150a8dc1c3fe15467708abb2</id>
<content type='text'>
During the initial array synchronization process there is a window between
when a prexor operation is scheduled to a specific stripe and when it
completes for a sync_request to be scheduled to the same stripe.  When
this happens the prexor completes and the stripe is unconditionally marked
"insync", effectively canceling the sync_request for the stripe.  Prior to
2.6.23 this was not a problem because the prexor operation was done under
sh-&gt;lock.  The effect in older kernels being that the prexor would still
erroneously mark the stripe "insync", but sync_request would be held off
and re-mark the stripe as "!in_sync".

Change the write completion logic to not mark the stripe "in_sync" if a
prexor was performed.  The effect of the change is to sometimes not set
STRIPE_INSYNC.  The worst this can do is cause the resync to stall waiting
for STRIPE_INSYNC to be set.  If this were happening, then STRIPE_SYNCING
would be set and handle_issuing_new_read_requests would cause all
available blocks to eventually be read, at which point prexor would never
be used on that stripe any more and STRIPE_INSYNC would eventually be set.

echo repair &gt; /sys/block/mdN/md/sync_action will correct arrays that may
have lost this race.

Cc: &lt;stable@kernel.org&gt;
Signed-off-by: Dan Williams &lt;dan.j.williams@intel.com&gt;
Signed-off-by: Neil Brown &lt;neilb@suse.de&gt;
Signed-off-by: Andrew Morton &lt;akpm@linux-foundation.org&gt;
Signed-off-by: Linus Torvalds &lt;torvalds@linux-foundation.org&gt;
</content>
</entry>
</feed>
