12 years agomd/raid456: distribute raid processing over multiple cores
Dan Williams [Sun, 30 Aug 2009 02:13:13 +0000 (19:13 -0700)]
md/raid456: distribute raid processing over multiple cores

Now that the resources to handle stripe_head operations are allocated
percpu it is possible for raid5d to distribute stripe handling over
multiple cores.  This conversion also adds a call to cond_resched() in
the non-multicore case to prevent one core from getting monopolized for
raid operations.

Cc: Arjan van de Ven <>
Signed-off-by: Dan Williams <>
12 years agomd/raid6: remove synchronous infrastructure
Yuri Tikhonov [Sun, 30 Aug 2009 02:13:13 +0000 (19:13 -0700)]
md/raid6: remove synchronous infrastructure

These routines have been replaced by there asynchronous counterparts.

Signed-off-by: Yuri Tikhonov <>
Signed-off-by: Ilya Yanok <>
Signed-off-by: Dan Williams <>
12 years agomd/raid6: asynchronous handle_stripe6
Yuri Tikhonov [Sun, 30 Aug 2009 02:13:13 +0000 (19:13 -0700)]
md/raid6: asynchronous handle_stripe6

1/ Use STRIPE_OP_BIOFILL to offload completion of read requests to
2/ Implement a handler for sh->reconstruct_state similar to the raid5 case
   (adds handling of Q parity)
3/ Prevent handle_parity_checks6 from running concurrently with 'compute'
4/ Hook up raid_run_ops

Signed-off-by: Yuri Tikhonov <>
Signed-off-by: Ilya Yanok <>
Signed-off-by: Dan Williams <>
12 years agomd/raid6: asynchronous handle_parity_check6
Dan Williams [Tue, 14 Jul 2009 20:40:57 +0000 (13:40 -0700)]
md/raid6: asynchronous handle_parity_check6

[ Based on an original patch by Yuri Tikhonov ]

Implement the state machine for handling the RAID-6 parities check and
repair functionality.  Note that the raid6 case does not need to check
for new failures, like raid5, as it will always writeback the correct
disks.  The raid5 case can be updated to check zero_sum_result to avoid
getting confused by new failures rather than retrying the entire check

Signed-off-by: Yuri Tikhonov <>
Signed-off-by: Ilya Yanok <>
Signed-off-by: Dan Williams <>
12 years agomd/raid6: asynchronous handle_stripe_dirtying6
Yuri Tikhonov [Sun, 30 Aug 2009 02:13:12 +0000 (19:13 -0700)]
md/raid6: asynchronous handle_stripe_dirtying6

In the synchronous implementation of stripe dirtying we processed a
degraded stripe with one call to handle_stripe_dirtying6().  I.e.
compute the missing blocks from the other drives, then copy in the new
data and reconstruct the parities.

In the asynchronous case we do not perform stripe operations directly.
Instead, operations are scheduled with flags to be later serviced by
raid_run_ops.  So, for the degraded case the final reconstruction step
can only be carried out after all blocks have been brought up to date by
being read, or computed.  Like the raid5 case schedule_reconstruction()
sets STRIPE_OP_RECONSTRUCT to request a parity generation pass and
through operation chaining can handle compute and reconstruct in a
single raid_run_ops pass.

[ fixup handle_stripe_dirtying6 gating]
Signed-off-by: Yuri Tikhonov <>
Signed-off-by: Ilya Yanok <>
Signed-off-by: Dan Williams <>
12 years agomd/raid6: asynchronous handle_stripe_fill6
Yuri Tikhonov [Sun, 30 Aug 2009 02:13:12 +0000 (19:13 -0700)]
md/raid6: asynchronous handle_stripe_fill6

Modify handle_stripe_fill6 to work asynchronously by introducing
fetch_block6 as the raid6 analog of fetch_block5 (schedule compute
operations for missing/out-of-sync disks).

[ compute D+Q in one pass]
Signed-off-by: Yuri Tikhonov <>
Signed-off-by: Ilya Yanok <>
Signed-off-by: Dan Williams <>
12 years agomd/raid5,6: common schedule_reconstruction for raid5/6
Yuri Tikhonov [Sun, 30 Aug 2009 02:13:12 +0000 (19:13 -0700)]
md/raid5,6: common schedule_reconstruction for raid5/6

Extend schedule_reconstruction5 for reuse by the raid6 path.  Add
support for generating Q and BUG() if a request is made to perform

Signed-off-by: Yuri Tikhonov <>
Signed-off-by: Ilya Yanok <>
Signed-off-by: Dan Williams <>
12 years agomd/raid6: asynchronous raid6 operations
Dan Williams [Tue, 14 Jul 2009 20:40:19 +0000 (13:40 -0700)]
md/raid6: asynchronous raid6 operations

[ Based on an original patch by Yuri Tikhonov ]

The raid_run_ops routine uses the asynchronous offload api and
the stripe_operations member of a stripe_head to carry out xor+pq+copy
operations asynchronously, outside the lock.

The operations performed by RAID-6 are the same as in the RAID-5 case
except for no support of STRIPE_OP_PREXOR operations. All the others
are supported:
 - copy data into request buffers to satisfy a read request
 - generate missing blocks (1 or 2) in the cache from the other blocks
 - copy data out of request buffers to satisfy a write request
 - recalculate parity for new data that has entered the cache
 - verify that the parity is correct

The flow is the same as in the RAID-5 case, and reuses some routines, namely:
1/ ops_complete_postxor (renamed to ops_complete_reconstruct)
2/ ops_complete_compute (updated to set up to 2 targets uptodate)
3/ ops_run_check (renamed to ops_run_check_p for xor parity checks)

[ fixes to get it to pass mdadm regression suite]
Reviewed-by: Andre Noll <>
Signed-off-by: Yuri Tikhonov <>
Signed-off-by: Ilya Yanok <>
Signed-off-by: Dan Williams <>
12 years agomd/raid5: factor out mark_uptodate from ops_complete_compute5
Dan Williams [Sun, 30 Aug 2009 02:13:11 +0000 (19:13 -0700)]
md/raid5: factor out mark_uptodate from ops_complete_compute5

ops_complete_compute5 can be reused in the raid6 path if it is updated to
generically handle a second target.

Signed-off-by: Dan Williams <>
12 years agoasync_tx: raid6 recovery self test
Dan Williams [Tue, 14 Jul 2009 19:20:37 +0000 (12:20 -0700)]
async_tx: raid6 recovery self test

Port drivers/md/raid6test/test.c to use the async raid6 recovery
routines.  This is meant as a unit test for raid6 acceleration drivers.  In
addition to the 16-drive test case this implements tests for the 4-disk and
5-disk special cases (dma devices can not generically handle less than 2
sources), and adds a test for the D+Q case.

Reviewed-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
12 years agodmatest: add pq support
Dan Williams [Sun, 30 Aug 2009 02:09:27 +0000 (19:09 -0700)]
dmatest: add pq support

Test raid6 p+q operations with a simple "always multiply by 1" q
calculation to fit into dmatest's current destination verification

Reviewed-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
12 years agoasync_tx: add support for asynchronous RAID6 recovery operations
Dan Williams [Tue, 14 Jul 2009 19:20:37 +0000 (12:20 -0700)]
async_tx: add support for asynchronous RAID6 recovery operations

 async_raid6_2data_recov() recovers two data disk failures

 async_raid6_datap_recov() recovers a data disk and the P disk

These routines are a port of the synchronous versions found in
drivers/md/raid6recov.c.  The primary difference is breaking out the xor
operations into separate calls to async_xor.  Two helper routines are
introduced to perform scalar multiplication where needed.
async_sum_product() multiplies two sources by scalar coefficients and
then sums (xor) the result.  async_mult() simply multiplies a single
source by a scalar.

This implemention also includes, in contrast to the original
synchronous-only code, special case handling for the 4-disk and 5-disk
array cases.  In these situations the default N-disk algorithm will
present 0-source or 1-source operations to dma devices.  To cover for
dma devices where the minimum source count is 2 we implement 4-disk and
5-disk handling in the recovery code.

[ Impact: asynchronous raid6 recovery routines for 2data and datap cases ]

Cc: Yuri Tikhonov <>
Cc: Ilya Yanok <>
Cc: H. Peter Anvin <>
Cc: David Woodhouse <>
Reviewed-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
12 years agoasync_tx: add support for asynchronous GF multiplication
Dan Williams [Tue, 14 Jul 2009 19:20:36 +0000 (12:20 -0700)]
async_tx: add support for asynchronous GF multiplication

[ Based on an original patch by Yuri Tikhonov ]

This adds support for doing asynchronous GF multiplication by adding
two additional functions to the async_tx API:

 async_gen_syndrome() does simultaneous XOR and Galois field
    multiplication of sources.

 async_syndrome_val() validates the given source buffers against known P
    and Q values.

When a request is made to run async_pq against more than the hardware
maximum number of supported sources we need to reuse the previous
generated P and Q values as sources into the next operation.  Care must
be taken to remove Q from P' and P from Q'.  For example to perform a 5
source pq op with hardware that only supports 4 sources at a time the
following approach is taken:

p, q = PQ(src0, src1, src2, src3, COEF({01}, {02}, {04}, {08}))
p', q' = PQ(p, q, q, src4, COEF({00}, {01}, {00}, {10}))

p' = p + q + q + src4 = p + src4
q' = {00}*p + {01}*q + {00}*q + {10}*src4 = q + {10}*src4

Note: 4 is the minimum acceptable maxpq otherwise we punt to
synchronous-software path.

The DMA_PREP_CONTINUE flag indicates to the driver to reuse p and q as
sources (in the above manner) and fill the remaining slots up to maxpq
with the new sources/coefficients.

Note1: Some devices have native support for P+Q continuation and can skip
this extra work.  Devices with this capability can advertise it with
dma_set_maxpq.  It is up to each driver how to handle the

Note2: The api supports disabling the generation of P when generating Q,
this is ignored by the synchronous path but is implemented by some dma
devices to save unnecessary writes.  In this case the continuation
algorithm is simplified to only reuse Q as a source.

Cc: H. Peter Anvin <>
Cc: David Woodhouse <>
Signed-off-by: Yuri Tikhonov <>
Signed-off-by: Ilya Yanok <>
Reviewed-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
12 years agoasync_tx: remove walk of tx->parent chain in dma_wait_for_async_tx
Dan Williams [Tue, 14 Jul 2009 19:19:02 +0000 (12:19 -0700)]
async_tx: remove walk of tx->parent chain in dma_wait_for_async_tx

We currently walk the parent chain when waiting for a given tx to
complete however this walk may race with the driver cleanup routine.
The routines in async_raid6_recov.c may fall back to the synchronous
path at any point so we need to be prepared to call async_tx_quiesce()
(which calls  dma_wait_for_async_tx).  To remove the ->parent walk we
guarantee that every time a dependency is attached ->issue_pending() is
invoked, then we can simply poll the initial descriptor until

This also allows for a lighter weight 'issue pending' implementation as
there is no longer a requirement to iterate through all the channels'
->issue_pending() routines as long as operations have been submitted in
an ordered chain.  async_tx_issue_pending() is added for this case.

Signed-off-by: Dan Williams <>
12 years agoasync_tx: kill needless module_{init|exit}
Dan Williams [Sun, 30 Aug 2009 02:09:26 +0000 (19:09 -0700)]
async_tx: kill needless module_{init|exit}

If module_init and module_exit are nops then neither need to be defined.

[ Impact: pure cleanup ]

Reviewed-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
12 years agoasync_tx: add sum check flags
Dan Williams [Sun, 30 Aug 2009 02:09:26 +0000 (19:09 -0700)]
async_tx: add sum check flags

Replace the flat zero_sum_result with a collection of flags to contain
the P (xor) zero-sum result, and the soon to be utilized Q (raid6 reed
solomon syndrome) zero-sum result.  Use the SUM_CHECK_ namespace instead
of DMA_ since these flags will be used on non-dma-zero-sum enabled

Reviewed-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
12 years agomd/raid5,6: add percpu scribble region for buffer lists
Dan Williams [Tue, 14 Jul 2009 18:50:52 +0000 (11:50 -0700)]
md/raid5,6: add percpu scribble region for buffer lists

Use percpu memory rather than stack for storing the buffer lists used in
parity calculations.  Include space for dma address conversions and pass
that to async_tx via the async_submit_ctl.scribble pointer.

[ Impact: move memory pressure from stack to heap ]

Signed-off-by: Dan Williams <>
12 years agomd/raid6: move the spare page to a percpu allocation
Dan Williams [Tue, 14 Jul 2009 18:48:22 +0000 (11:48 -0700)]
md/raid6: move the spare page to a percpu allocation

In preparation for asynchronous handling of raid6 operations move the
spare page to a percpu allocation to allow multiple simultaneous
synchronous raid6 recovery operations.

Make this allocation cpu hotplug aware to maximize allocation

Signed-off-by: Dan Williams <>
12 years agomd/raid6: release spare page at ->stop()
Dan Williams [Tue, 14 Jul 2009 18:48:16 +0000 (11:48 -0700)]
md/raid6: release spare page at ->stop()

Add missing call to safe_put_page from stop() by unifying open coded
raid5_conf_t de-allocation under free_conf().

Signed-off-by: Dan Williams <>
12 years agoasync_xor: permit callers to pass in a 'dma/page scribble' region
Dan Williams [Wed, 3 Jun 2009 21:22:28 +0000 (14:22 -0700)]
async_xor: permit callers to pass in a 'dma/page scribble' region

async_xor() needs space to perform dma and page address conversions.  In
most cases the code can simply reuse the struct page * array because the
size of the native pointer matches the size of a dma/page address.  In
order to support archs where sizeof(dma_addr_t) is larger than
sizeof(struct page *), or to preserve the input parameters, we utilize a
memory region passed in by the caller.

Since the code is now prepared to handle the case where it cannot
perform address conversions on the stack, we no longer need the
!HIGHMEM64G dependency in drivers/dma/Kconfig.

[ Impact: don't clobber input buffers for address conversions ]

Reviewed-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
12 years agoasync_tx: structify submission arguments, add scribble
Dan Williams [Wed, 3 Jun 2009 18:43:59 +0000 (11:43 -0700)]
async_tx: structify submission arguments, add scribble

Prepare the api for the arrival of a new parameter, 'scribble'.  This
will allow callers to identify scratchpad memory for dma address or page
address conversions.  As this adds yet another parameter, take this
opportunity to convert the common submission parameters (flags,
dependency, callback, and callback argument) into an object that is
passed by reference.

Also, take this opportunity to fix up the kerneldoc and add notes about
the relevant ASYNC_TX_* flags for each routine.

[ Impact: moves api pass-by-value parameters to a pass-by-reference struct ]

Signed-off-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
12 years agoasync_tx: kill ASYNC_TX_DEP_ACK flag
Dan Williams [Thu, 9 Apr 2009 23:16:18 +0000 (16:16 -0700)]
async_tx: kill ASYNC_TX_DEP_ACK flag

In support of inter-channel chaining async_tx utilizes an ack flag to
gate whether a dependent operation can be chained to another.  While the
flag is not set the chain can be considered open for appending.  Setting
the ack flag closes the chain and flags the descriptor for garbage
collection.  The ASYNC_TX_DEP_ACK flag essentially means "close the
chain after adding this dependency".  Since each operation can only have
one child the api now implicitly sets the ack flag at dependency
submission time.  This removes an unnecessary management burden from
clients of the api.

[ Impact: clean up and enforce one dependency per operation ]

Reviewed-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
13 years agoasync_tx: rename zero_sum to val
Dan Williams [Wed, 8 Apr 2009 21:28:37 +0000 (14:28 -0700)]
async_tx: rename zero_sum to val

'zero_sum' does not properly describe the operation of generating parity
and checking that it validates against an existing buffer.  Change the
name of the operation to 'val' (for 'validate').  This is in
anticipation of the p+q case where it is a requirement to identify the
target parity buffers separately from the source buffers, because the
target parity buffers will not have corresponding pq coefficients.

Reviewed-by: Andre Noll <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
13 years agoMerge branch 'dmaengine' into async-tx-raid6
Dan Williams [Wed, 8 Apr 2009 21:28:13 +0000 (14:28 -0700)]
Merge branch 'dmaengine' into async-tx-raid6

13 years agodma: Add SoF and EoF debugging to ipu_idmac.c, minor cleanup
Guennadi Liakhovetski [Thu, 2 Apr 2009 09:36:58 +0000 (11:36 +0200)]
dma: Add SoF and EoF debugging to ipu_idmac.c, minor cleanup

Add Start-of-Frame and End-of-Frame debugging to ipu_idmac.c, in the
future it might also be needed for the actual video processing in
mx3-camera, at which point, the ISRs will have to be transferred to
mx3_camera.c, for which ipu_irq_map() and ipu_irq_unmap() functions will
have to be exported.

Also simplify a couple of pointer-dereferences.

Signed-off-by: Guennadi Liakhovetski <>
Signed-off-by: Dan Williams <>
13 years agodw_dmac: add cyclic API to DW DMA driver
Hans-Christian Egtvedt [Wed, 1 Apr 2009 13:47:02 +0000 (15:47 +0200)]
dw_dmac: add cyclic API to DW DMA driver

This patch adds a cyclic DMA interface to the DW DMA driver. This is
very useful if you want to use the DMA controller in combination with a
sound device which uses cyclic buffers.

Using a DMA channel for cyclic DMA will disable the possibility to use
it as a normal DMA engine until the user calls the cyclic free function
on the DMA channel. Also a cyclic DMA list can not be prepared if the
channel is already active.

Signed-off-by: Hans-Christian Egtvedt <>
Acked-by: Haavard Skinnemoen <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
13 years agomd/raid5 revise rules for when to update metadata during reshape
NeilBrown [Tue, 31 Mar 2009 04:28:40 +0000 (15:28 +1100)]
md/raid5 revise rules for when to update metadata during reshape

We currently update the metadata :
 1/ every 3Megabytes
 2/ When the place we will write new-layout data to is recorded in
    the metadata as still containing old-layout data.

Rule one exists to avoid having to re-do too much reshaping in the
face of a crash/restart.  So it should really be time based rather
than size based.  So change it to "every 10 seconds".

Rule two turns out to be too harsh when restriping an array
'in-place', as in that case the metadata much be updates for every
For the in-place update, it can only possibly be safe from a crash if
some user-space program data a backup of every e.g. few hundred
stripes before allowing them to be reshaped.  In that case, the
constant metadata update is pointless.
So only update the metadata if the new metadata will report that the
end of the 'old-layout' data is beyond where we are currently
writing 'new-layout' data.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: minor code cleanups in make_request.
NeilBrown [Tue, 31 Mar 2009 04:27:18 +0000 (15:27 +1100)]
md/raid5: minor code cleanups in make_request.

... and to be certain the that make_request doesn't wait forever,
add a 'wake_up' when ->reshape_progress has been set to MaxSector

Signed-off-by: NeilBrown <>
13 years agomd: remove CONFIG_MD_RAID_RESHAPE config option.
NeilBrown [Tue, 31 Mar 2009 04:27:05 +0000 (15:27 +1100)]
md: remove CONFIG_MD_RAID_RESHAPE config option.

This was only needed when the code was experimental.  Most of it
is well tested now, so the option is no longer useful.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: be more careful about write ordering when reshaping.
NeilBrown [Tue, 31 Mar 2009 04:26:47 +0000 (15:26 +1100)]
md/raid5: be more careful about write ordering when reshaping.

When we are reshaping an array, it is very important that we read
the data from a particular sector offset before writing new data
at that offset.

In most cases when growing or shrinking an array we read long before
we even consider writing.  But when restriping an array without
changing it size, there is a small possibility that we might have
some data to available write before the read has happened at the same
location.  This would require some stripes to be in cache already.

To guard against this small possibility, we check, before writing,
that the 'old' stripe at the same location is not in the process of
being read.  And we ensure that we mark all 'source' stripes as such
before allowing new 'destination' stripes to proceed.

Signed-off-by: NeilBrown <>
13 years agomd: don't display meaningless values in sysfs files resync_start and sync_speed
NeilBrown [Tue, 31 Mar 2009 04:24:32 +0000 (15:24 +1100)]
md: don't display meaningless values in sysfs files resync_start and sync_speed

When no resync if happening, both of these files currently have
meaningless values (is slightly different ways).
Change them to "none" in that case.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: allow layout and chunksize to be changed on active array.
NeilBrown [Tue, 31 Mar 2009 04:24:23 +0000 (15:24 +1100)]
md/raid5: allow layout and chunksize to be changed on active array.

If an array has 3 or more devices, we allow the chunksize or layout
to be changed and when a reshape starts, we use these as the 'new'

Signed-off-by: NeilBrown <>
13 years agomd/raid5: reshape using largest of old and new chunk size
NeilBrown [Tue, 31 Mar 2009 04:21:40 +0000 (15:21 +1100)]
md/raid5: reshape using largest of old and new chunk size

This ensures that even when old and new stripes are overlapping,
we will try to read all of the old before having to write any
of the new.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: prepare for allowing reshape to change layout
NeilBrown [Tue, 31 Mar 2009 04:20:22 +0000 (15:20 +1100)]
md/raid5: prepare for allowing reshape to change layout

Add prev_algo to raid5_conf_t along the same lines as prev_chunk
and previous_raid_disks.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: prepare for allowing reshape to change chunksize.
NeilBrown [Tue, 31 Mar 2009 04:19:07 +0000 (15:19 +1100)]
md/raid5: prepare for allowing reshape to change chunksize.

Add "prev_chunk" to raid5_conf_t, similar to "previous_raid_disks", to
remember what the chunk size was before the reshape that is currently

This seems like duplication with "chunk_size" and "new_chunk" in
mddev_t, and to some extent it is, but there are differences.
The values in mddev_t are always defined and often the same.
The prev* values are only defined if a reshape is underway.

Also (and more significantly) the raid5_conf_t values will be changed
at the same time (inside an appropriate lock) that the reshape is
started by setting reshape_position.  In contrast, the new_chunk value
is set when the sysfs file is written which could be well before the
reshape starts.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: clearly differentiate 'before' and 'after' stripes during reshape.
NeilBrown [Tue, 31 Mar 2009 04:19:03 +0000 (15:19 +1100)]
md/raid5: clearly differentiate 'before' and 'after' stripes during reshape.

During a raid5 reshape, we have some stripes in the cache that are
'before' the reshape (and are still to be processed) and some that are
'after'.  They are currently differentiated by having different
->disks values as the only reshape current supported involves changing
the number of disks.

However we will soon support reshapes that do not change the number
of disks (chunk parity or chunk size).  So make the difference more
explicit with a 'generation' number.

Signed-off-by: NeilBrown <>
13 years agoDocumentation/md.txt update
NeilBrown [Tue, 31 Mar 2009 04:18:37 +0000 (15:18 +1100)]
Documentation/md.txt update

Update md.txt to reflect recent changes in a number of sysfs

Signed-off-by: NeilBrown <>
13 years agomd: allow number of drives in raid5 to be reduced
NeilBrown [Tue, 31 Mar 2009 04:17:38 +0000 (15:17 +1100)]
md: allow number of drives in raid5 to be reduced

When reshaping a raid5 to have fewer devices, we work from the end of
the array to the beginning.
md_do_sync gives addresses to sync_request that go from the beginning
to the end.  So largely ignore them use the internal state variable
"reshape_progress" to keep track of what to do next.

Never allow the size to be reduced below the minimum (4 for raid6,
3 otherwise).

We require that the size of the array has already been reduced before
the array is reshaped to a smaller size.  This is because simply
reducing the size is an easily reversible operation, while the reshape
is immediately destructive and so is not reversible for the blocks at
the ends of the devices.
Thus to reshape an array to have fewer devices, you must first write
an appropriately small size to md/array_size.

When reshape finished, we remove any drives that are no longer
needed and fix up ->degraded.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: change reshape-progress measurement to cope with reshaping backwards.
NeilBrown [Tue, 31 Mar 2009 04:16:46 +0000 (15:16 +1100)]
md/raid5: change reshape-progress measurement to cope with reshaping backwards.

When reducing the number of devices in a raid4/5/6, the reshape
process has to start at the end of the array and work down to the
beginning.  So we need to handle expand_progress and expand_lo

This patch renames "expand_progress" and "expand_lo" to avoid the
implication that anything is getting bigger (expand->reshape) and
every place they are used, we make sure that they are used the right
way depending on whether delta_disks is positive or negative.

Signed-off-by: NeilBrown <>
13 years agomd: add explicit method to signal the end of a reshape.
NeilBrown [Tue, 31 Mar 2009 04:15:05 +0000 (15:15 +1100)]
md: add explicit method to signal the end of a reshape.

Currently raid5 (the only module that supports restriping)
notices that the reshape has finished be sync_request being
given a large value, and handles any cleanup them.

This patch changes it so md_check_recovery calls into an
explicit finish_reshape method as well.

The clean-up from sync_request can do things that need to be
done promptly, typically things local to the raid5_conf_t

The "finish_reshape" method is called under the mddev_lock
so it can do things involving reconfiguring the device.

This allows us to get rid of md_set_array_sectors_locked, which
would have caused a deadlock if you tried to stop and array
while a reshape was happening.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: enhance raid5_size to work correctly with negative delta_disks
NeilBrown [Tue, 31 Mar 2009 04:10:36 +0000 (15:10 +1100)]
md/raid5: enhance raid5_size to work correctly with negative delta_disks

This is the first of four patches which combine to allow md/raid5 to
reduce the number of devices in the array by restriping the data over
a subset of the devices.

If the number of disks in a raid4/5/6 is being reduced, then the
default size must be based on the new number, not the old number
of devices.
In general, it should be based on the smaller of new and old.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: drop qd_idx from r6_state
NeilBrown [Tue, 31 Mar 2009 04:10:16 +0000 (15:10 +1100)]
md/raid5: drop qd_idx from r6_state

We now have this value in stripe_head so we don't need to duplicate

Signed-off-by: NeilBrown <>
13 years agomd/raid6: move raid6 data processing to raid6_pq.ko
Dan Williams [Tue, 31 Mar 2009 04:09:39 +0000 (15:09 +1100)]
md/raid6: move raid6 data processing to raid6_pq.ko

Move the raid6 data processing routines into a standalone module
(raid6_pq) to prepare them to be called from async_tx wrappers and other
non-md drivers/modules.  This precludes a circular dependency of raid456
needing the async modules for data processing while those modules in
turn depend on raid456 for the base level synchronous raid6 routines.

To support this move:
1/ The exportable definitions in raid6.h move to include/linux/raid/pq.h
2/ The raid6_call, recovery calls, and table symbols are exported
3/ Extra #ifdef __KERNEL__ statements to enable the userspace raid6test to

Signed-off-by: Dan Williams <>
Signed-off-by: NeilBrown <>
13 years agomd: raid5 run(): Fix max_degraded for raid level 4.
Andre Noll [Tue, 31 Mar 2009 04:00:56 +0000 (15:00 +1100)]
md: raid5 run(): Fix max_degraded for raid level 4.

raid4 allows only one failed disk.

Signed-off-by: Andre Noll <>
Signed-off-by: NeilBrown <>
13 years agomd: 'array_size' sysfs attribute
Dan Williams [Tue, 31 Mar 2009 04:00:31 +0000 (15:00 +1100)]
md: 'array_size' sysfs attribute

Allow userspace to set the size of the array according to the following

1/ size must be <= to the size returned by mddev->pers->size(mddev, 0, 0)
   a) If size is set before the array is running, do_md_run will fail
      if size is greater than the default size
   b) A reshape attempt that reduces the default size to less than the set
      array size should be blocked
2/ once userspace sets the size the kernel will not change it
3/ writing 'default' to this attribute returns control of the size to the
   kernel and reverts to the size reported by the personality

Also, convert locations that need to know the default size from directly
reading ->array_sectors to <pers>_size.  Resync/reshape operations
always follow the default size.

Finally, fixup other locations that read a number of 1k-blocks from
userspace to use strict_blocks_to_sectors() which checks for unsigned
long long to sector_t overflow and blocks to sectors overflow.

Reviewed-by: Andre Noll <>
Signed-off-by: Dan Williams <>
13 years agomd: centralize ->array_sectors modifications
Dan Williams [Tue, 31 Mar 2009 03:59:03 +0000 (14:59 +1100)]
md: centralize ->array_sectors modifications

Get personalities out of the business of directly modifying
->array_sectors.  Lays groundwork to introduce policy on when
->array_sectors can be modified.

Reviewed-by: Andre Noll <>
Signed-off-by: Dan Williams <>
13 years agomd: add 'size' as a personality method
Dan Williams [Wed, 18 Mar 2009 01:10:40 +0000 (18:10 -0700)]
md: add 'size' as a personality method

In preparation for giving userspace control over ->array_sectors we need
to be able to retrieve the 'default' size, and the 'anticipated' size
when a reshape is requested.  For personalities that do not reshape emit
a warning if anything but the default size is requested.

In the raid5 case we need to update ->previous_raid_disks to make the
new 'default' size available.

Reviewed-by: Andre Noll <>
Signed-off-by: Dan Williams <>
13 years agomd: fix typo in FSF address
Atsushi SAKAI [Tue, 31 Mar 2009 03:57:37 +0000 (14:57 +1100)]
md: fix typo in FSF address


 I found a typo Bosto"m" in FSF address.
And I am checking around linux source code.
Here is the only place which uses Bosto"m" (not Boston).

Signed-off-by: Atsushi SAKAI <>
Signed-off-by: NeilBrown <>
13 years agomd: add takeover support for converting raid6 back into raid5
NeilBrown [Tue, 31 Mar 2009 03:57:20 +0000 (14:57 +1100)]
md: add takeover support for converting raid6 back into raid5

If a raid6 is still in the layout that comes from converting raid5
into a raid6. this will allow us to convert it back again.

Signed-off-by: NeilBrown <>
13 years agomd: add takeover support for raid4 -> raid5 conversion.
NeilBrown [Tue, 31 Mar 2009 03:57:09 +0000 (14:57 +1100)]
md: add takeover support for raid4 -> raid5 conversion.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: allow layout/chunksize to be changed on an active 2-drive raid5.
NeilBrown [Tue, 31 Mar 2009 03:56:41 +0000 (14:56 +1100)]
md/raid5: allow layout/chunksize to be changed on an active 2-drive raid5.

2-drive raid5's aren't very interesting.  But if you are converting
a raid1 into a raid5, you will at least temporarily have one.  And
that it a good time to set the layout/chunksize for the new RAID5
if you aren't happy with the defaults.

layout and chunksize don't actually affect the placement of data
on a 2-drive raid5, so we just do some internal book-keeping.

Signed-off-by: NeilBrown <>
13 years agomd: add ->takeover method for raid5 to be able to take over raid1
NeilBrown [Tue, 31 Mar 2009 03:39:39 +0000 (14:39 +1100)]
md: add ->takeover method for raid5 to be able to take over raid1

The RAID1 must have two drives and be a suitable size to
be a multiple of a chunksize that isn't too small.

Signed-off-by: NeilBrown <>
13 years agomd: add ->takeover method to support changing the personality managing an array
NeilBrown [Tue, 31 Mar 2009 03:39:39 +0000 (14:39 +1100)]
md: add ->takeover method to support changing the personality managing an array

Implement this for RAID6 to be able to 'takeover' a RAID5 array.  The
new RAID6 will use a layout which places Q on the last device, and
that device will be missing.
If there are any available spares, one will immediately have Q
recovered onto it.

Signed-off-by: NeilBrown <>
13 years agomd: enable suspend/resume of md devices.
NeilBrown [Tue, 31 Mar 2009 03:39:39 +0000 (14:39 +1100)]
md: enable suspend/resume of md devices.

To be able to change the 'level' of an md/raid array, we need to
suspend the device so that no requests are active - then move some
pointers around etc.

The code already keeps counts of active requests and the ->quiesce
function can be used to wait until those counts hit zero.
However the quiesce function blocks new requests once they are all
ready 'inside' the personality module, and that is too late if we want
to replace the personality modules.

So make all md requests come in through a common md_make_request
function that keeps track of how many requests have entered the
modules but may not yet be on the internal reference counts.
Allow md_make_request to be blocked when we want to suspend the
device, and make it possible to wait for all those in-transit requests
to be added to internal lists so that ->quiesce can wait for them.

There is still a problem that when a request completes, we drop the
ref count inside the personality code so there is a short time between
when the refcount hits zero, and when the personality code is no
longer being used.
The personality code never blocks (schedule or spinlock) between
dropping the refcount and exiting the routine, so this should be safe
(as put_module calls synchronize_sched() before unmapping the module

Signed-off-by: NeilBrown <>
13 years agomd: md_unregister_thread should cope with being passed NULL
NeilBrown [Tue, 31 Mar 2009 03:39:39 +0000 (14:39 +1100)]
md: md_unregister_thread should cope with being passed NULL

Mostly md_unregister_thread is only called when we know that the
thread is NULL, but sometimes we need to check first.  It is safer
to put the check inside md_unregister_thread itself.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: refactor raid5 "run"
NeilBrown [Tue, 31 Mar 2009 03:39:39 +0000 (14:39 +1100)]
md/raid5: refactor raid5 "run"

.. so that the code to create the private data structures is separate.
This will help with future code to change the level of an active

Signed-off-by: NeilBrown <>
13 years agomd: make sure new_level, new_chunksize, new_layout always have sensible values.
NeilBrown [Tue, 31 Mar 2009 03:39:38 +0000 (14:39 +1100)]
md: make sure new_level, new_chunksize, new_layout always have sensible values.

When an md array is undergoing a change, we have new_* fields that
show the new values.
When no change is happening, it is least confusing if these have
the same value as the normal fields.
This is true in most cases, but not when the values are set via sysfs.

So fix this up.

A subsequent patch will BUG_ON if these things aren't consistent.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: finish support for DDF/raid6
NeilBrown [Tue, 31 Mar 2009 03:39:38 +0000 (14:39 +1100)]
md/raid5: finish support for DDF/raid6

DDF requires RAID6 calculations over different devices in a different
For md/raid6, we calculate over just the data devices, starting
immediately after the 'Q' block.
For ddf/raid6 we calculate over all devices, using zeros in place of
the P and Q blocks.

This requires unfortunately complex loops...

Signed-off-by: NeilBrown <>
13 years agomd/raid5: Add support for new layouts for raid5 and raid6.
NeilBrown [Tue, 31 Mar 2009 03:39:38 +0000 (14:39 +1100)]
md/raid5: Add support for new layouts for raid5 and raid6.

DDF uses different layouts for P and Q blocks than current md/raid6
so add those that are missing.
Also add support for RAID6 layouts that are identical to various
raid5 layouts with the simple addition of one device to hold all of
the 'Q' blocks.
Finally add 'raid5' layouts to match raid4.
These last to will allow online level conversion.

Note that this does not provide correct support for DDF/raid6 yet
as the order in which data blocks are summed to produce the Q block
is significant and different between current md code and DDF

Signed-off-by: NeilBrown <>
13 years agomd/raid5: simplify raid5_compute_sector interface
NeilBrown [Tue, 31 Mar 2009 03:39:38 +0000 (14:39 +1100)]
md/raid5: simplify raid5_compute_sector interface

Rather than passing 'pd_idx' and 'qd_idx' to be filled in, pass
a 'struct stripe_head *' and fill in the relevant fields.  This is
more extensible.

Signed-off-by: NeilBrown <>
13 years agomd/raid6: remove expectation that Q device is immediately after P device.
NeilBrown [Tue, 31 Mar 2009 03:39:38 +0000 (14:39 +1100)]
md/raid6: remove expectation that Q device is immediately after P device.

Code currently assumes that the devices in a raid6 stripe are
  0 1 ... N-1 P Q
in some rotated order.  We will shortly add new layouts in which
this strict pattern is broken.
So remove this expectation.  We still assume that the data disks
are roughly in-order.  However P and Q can be inserted anywhere within
that order.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: change raid5_compute_sector and stripe_to_pdidx to take a 'previous' argument
NeilBrown [Tue, 31 Mar 2009 03:39:38 +0000 (14:39 +1100)]
md/raid5: change raid5_compute_sector and stripe_to_pdidx to take a 'previous' argument

This similar to the recent change to get_active_stripe.
There is no functional change, just come rearrangement to make
future patches cleaner.

Signed-off-by: NeilBrown <>
13 years agomd/raid5: simplify interface for init_stripe and get_active_stripe
NeilBrown [Tue, 31 Mar 2009 03:39:38 +0000 (14:39 +1100)]
md/raid5: simplify interface for init_stripe and get_active_stripe

Rather than passing 'pd_idx' and 'disks' to these functions, just pass
'previous' which tells whether to use the 'previous' or 'current'
geometry during a reshape, and let init_stripe calculate
disks and pd_idx and anything else it might need.

This is not a substantial simplification and even adds a division.
However we will shortly be adding more complexity to init_stripe
to handle more interesting 'reshape' activities, and without this
change, the interface to these functions would get very complex.

Signed-off-by: NeilBrown <>
13 years agomd: Represent raid device size in sectors.
Andre Noll [Tue, 31 Mar 2009 03:33:13 +0000 (14:33 +1100)]
md: Represent raid device size in sectors.

This patch renames the "size" field of struct mdk_rdev_s to
"sectors" and changes this field to store sectors instead of

All users of this field, linear.c, raid0.c and md.c, are fixed up
accordingly which gets rid of many multiplications and divisions.

Signed-off-by: Andre Noll <>
Signed-off-by: NeilBrown <>
13 years agomd: Make mddev->size sector-based.
Andre Noll [Tue, 31 Mar 2009 03:33:13 +0000 (14:33 +1100)]
md: Make mddev->size sector-based.

This patch renames the "size" field of struct mddev_s to "dev_sectors"
and stores the number of 512-byte sectors instead of the number of
1K-blocks in it.

All users of that field, including raid levels 1,4-6,10, are adjusted
accordingly. This simplifies the code a bit because it allows to get
rid of a couple of divisions/multiplications by two.

In order to make checkpatch happy, some minor coding style issues
have also been addressed. In particular, size_store() now uses
strict_strtoull() instead of simple_strtoull().

Signed-off-by: Andre Noll <>
Signed-off-by: NeilBrown <>
13 years agomd: be more consistent about setting WriteMostly flag when adding a drive to an array
NeilBrown [Tue, 31 Mar 2009 03:33:13 +0000 (14:33 +1100)]
md: be more consistent about setting WriteMostly flag when adding a drive to an array

When a drive is added to an array using ADD_NEW_DISK, there are two
places we can get certain flags from:  the metadata on the disk or the
flags passed through the IOCTL.

For the WriteMostly flag (aka MD_DISK_WRITEMOSTLY) we take the value
from either of those sources depending on if it is set (i.e. we
effectively 'or' the two sources together).

This makes it awkward to clear, and is at best inconsistent.

As documented code (in mdadm) requires that setting
MD_DISK_WRITEMOSTLY in the ioctl will be effective, we resolve the
inconsistency by always using the value for this flag from the ioctl,
and ignoring the value on disk.

Signed-off-by: NeilBrown <>
13 years agomd: occasionally checkpoint drive recovery to reduce duplicate effort after a crash
NeilBrown [Tue, 31 Mar 2009 03:33:13 +0000 (14:33 +1100)]
md: occasionally checkpoint drive recovery to reduce duplicate effort after a crash

Version 1.x metadata has the ability to record the status of a
partially completed drive recovery.
However we only update that record on a clean shutdown.
It would be nice to update it on unclean shutdowns too, particularly
when using a bitmap that removes much to the 'sync' effort after an
unclean shutdown.

One complication with checkpointing recovery is that we only know
where we are up to in terms of IO requests started, not which ones
have completed.  And we need to know what has completed to record
how much is recovered.  So occasionally pause the recovery until all
submitted requests are completed, then update the record of where
we are up to.

When we have a bitmap, we already do that pause occasionally to keep
the bitmap up-to-date.  So enhance that code to record the recovery
offset and schedule a superblock update.
And when there is no bitmap, just pause 16 times during the resync to
do a checkpoint.
'16' is a fairly arbitrary number.  But we don't really have any good
way to judge how often is acceptable, and it seems like a reasonable
number for now.

Signed-off-by: NeilBrown <>
13 years agomd: move md_k.h from include/linux/raid/ to drivers/md/
NeilBrown [Tue, 31 Mar 2009 03:33:13 +0000 (14:33 +1100)]
md: move md_k.h from include/linux/raid/ to drivers/md/

It really is nicer to keep related code together..

Signed-off-by: NeilBrown <>
13 years agomd: move lots of #include lines out of .h files and into .c
NeilBrown [Tue, 31 Mar 2009 03:33:13 +0000 (14:33 +1100)]
md: move lots of #include lines out of .h files and into .c

This makes the includes more explicit, and is preparation for moving
md_k.h to drivers/md/md.h

Remove include/raid/md.h as its only remaining use was to #include
other files.

Signed-off-by: NeilBrown <>
13 years agomd: move most content from md.h to md_k.h
NeilBrown [Tue, 31 Mar 2009 03:33:13 +0000 (14:33 +1100)]
md: move most content from md.h to md_k.h

The extern function definitions are kernel-internal definitions, so
they belong in md_k.h

The MD_*_VERSION values could reasonably go in a number of places,
but md_u.h seems most reasonable.

This leaves almost nothing in md.h.  It will go soon.

Signed-off-by: NeilBrown <>
13 years agomd: move LEVEL_* definition from md_k.h to md_u.h
NeilBrown [Tue, 31 Mar 2009 03:27:03 +0000 (14:27 +1100)]
md: move LEVEL_* definition from md_k.h to md_u.h

.. as they are part of the user-space interface.
Also move MdpMinorShift into there so we can remove duplication.

Lastly move mdp_major in.  It is less obviously part of the user-space
interface, but do_mounts_md.c uses it, and it is acting a bit like

Signed-off-by: NeilBrown <>
13 years agomd: move headers out of include/linux/raid/
Christoph Hellwig [Tue, 31 Mar 2009 03:27:03 +0000 (14:27 +1100)]
md: move headers out of include/linux/raid/

Move the headers with the local structures for the disciplines and
bitmap.h into drivers/md/ so that they are more easily grepable for
hacking and not far away.  md.h is left where it is for now as there
are some uses from the outside.

Signed-off-by: Christoph Hellwig <>
Signed-off-by: NeilBrown <>
13 years agocleanup drivers/md/Makefile
Christoph Hellwig [Tue, 31 Mar 2009 03:27:02 +0000 (14:27 +1100)]
cleanup drivers/md/Makefile

Use the -y variables instead of the old -objs so we can easily add
conditional objects to the modules.  Also always use += to add
subobjects to avoid problems when placing additional objects in
some place in the file.

Signed-off-by: Christoph Hellwig <>
Signed-off-by: NeilBrown <>
13 years agomd: stop defining MAJOR_NR
Christoph Hellwig [Tue, 31 Mar 2009 03:27:02 +0000 (14:27 +1100)]
md: stop defining MAJOR_NR

MAJOR_NR was only required for magic in linux/blk.h in 2.4 or earlier
kernels, so no need to keep it around.

Signed-off-by: Christoph Hellwig <>
Signed-off-by: NeilBrown <>
13 years agoMD data integrity support
Martin K. Petersen [Tue, 31 Mar 2009 03:27:02 +0000 (14:27 +1100)]
MD data integrity support

md: Add support for data integrity to MD

If all subdevices support the same protection format the MD device is
flagged as integrity capable.

Signed-off-by: Martin K. Petersen <>
Signed-off-by: NeilBrown <>
13 years agomd: write bitmap information to devices that are undergoing recovery.
NeilBrown [Tue, 31 Mar 2009 03:27:02 +0000 (14:27 +1100)]
md: write bitmap information to devices that are undergoing recovery.

When we add some spares to an array and start recovery, and we have
a bitmap which is stored 'internally' on all devices, we call
bitmap_write_all to make sure the bitmap is correct on the new
However that doesn't work as write_sb_page only writes to
'In_sync' devices, and devices undergoing recovery are not
'In_sync' until recovery finishes.

So extend write_sb_page (actually next_active_rdev) to include devices
that are under recovery.

Signed-off-by: NeilBrown <>
13 years agomd: never clear bit from the write-intent bitmap when the array is degraded.
NeilBrown [Tue, 31 Mar 2009 03:27:02 +0000 (14:27 +1100)]
md: never clear bit from the write-intent bitmap when the array is degraded.

It is safe to clear a bit from the write-intent bitmap for a raid1
if we know the data has been written to all devices, which is
what the current test does.

But it is not always safe to update the 'events_cleared' counter in
that case.  This is because one request could complete successfully
after some other request has partially failed.

So simply disable the clearing and updating of events_cleared whenever
the array is degraded.  This might end up not clearing some bits that
could safely be cleared, but it is safest approach.

Note that the bug fixed here did not risk corrupting data by letting
the array get out-of-sync.  Rather it meant that when a device is
removed and re-added to the array, it might incorrectly require a full
recovery rather than just recovering based on the bitmap.

Signed-off-by: NeilBrown <>
13 years agomd: Allow write-intent bitmaps to have chunksize < PAGE_SIZE
NeilBrown [Tue, 31 Mar 2009 03:27:02 +0000 (14:27 +1100)]
md: Allow write-intent bitmaps to have chunksize < PAGE_SIZE

md currently insists that the chunk size used for write-intent
bitmaps (the amount of data that corresponds to one chunk)
be at least one page.

The reason for this restriction is lost in the mists of time,
but a review of the code (and a vague memory) suggests that the only
problem would be related to resync.  Resync tries very hard to
work in multiples of a page, but also needs to sync with units
of a bitmap_chunk too.

This connection comes out in the bitmap_start_sync call.

So change bitmap_start_sync to always work in multiples of a page.
If the bitmap chunk size is less that one page, we flag multiple
chunks as 'syncing' and generally make them all appear to the
resync routines like one chunk.

All other code either already works with data ranges that could
span multiple chunks, or explicitly only cares about a single chunk.

Signed-off-by: Neil Brown <>
13 years agomd: Fix is_mddev_idle test (again).
NeilBrown [Tue, 31 Mar 2009 03:27:02 +0000 (14:27 +1100)]
md: Fix is_mddev_idle test (again).

There are two problems with is_mddev_idle.

1/ sync_io is 'atomic_t' and hence 'int'.  curr_events and all the
   rest are 'long'.
   So if sync_io were to wrap on a 64bit host, the value of
   curr_events would go very negative suddenly, and take a very
   long time to return to positive.

   So do all calculations as 'int'.  That gives us plenty of precision
   for what we need.

2/ To initialise rdev->last_events we simply call is_mddev_idle, on
   the assumption that it will make sure that last_events is in a
   suitable range.  It used to do this, but now it does not.
   So now we need to be more explicit about initialisation.

Signed-off-by: NeilBrown <>
13 years agodmaengine: Add privatecnt to revert DMA_PRIVATE property
Atsushi Nemoto [Fri, 6 Mar 2009 11:07:14 +0000 (20:07 +0900)]
dmaengine: Add privatecnt to revert DMA_PRIVATE property

Currently dma_request_channel() set DMA_PRIVATE capability but never
clear it.  So if a public channel was once grabbed by
dma_request_channel(), the device stay PRIVATE forever.  Add
privatecnt member to dma_device to correctly revert it.

[ fix bad usage of 'chan' in dma_async_device_register]
Signed-off-by: Atsushi Nemoto <>
Acked-by: Maciej Sosnowski <>
Signed-off-by: Dan Williams <>
13 years agodmatest: add dma interrupts and callbacks
Dan Williams [Wed, 25 Mar 2009 16:13:25 +0000 (09:13 -0700)]
dmatest: add dma interrupts and callbacks

Use the callback infrastructure to report driver/hardware hangs or
missed interrupts.  Since this makes the test threads much more
aggressive (from: explicit 1ms sleep to: wait_for_completion) we set the
nice value to 10 so as to not swamp legitimate tasks.

Signed-off-by: Dan Williams <>
13 years agodmatest: add xor test
Dan Williams [Wed, 25 Mar 2009 16:13:25 +0000 (09:13 -0700)]
dmatest: add xor test

Extend dmatest to launch a thread per supported operation type and add
an xor test.

Signed-off-by: Dan Williams <>
13 years agodmaengine: allow dma support for async_tx to be toggled
Dan Williams [Wed, 25 Mar 2009 16:13:25 +0000 (09:13 -0700)]
dmaengine: allow dma support for async_tx to be toggled

Provide a config option for blocking the allocation of dma channels to
the async_tx api.

Signed-off-by: Dan Williams <>
13 years agoasync_tx: provide __async_inline for HAS_DMA=n archs
Dan Williams [Wed, 25 Mar 2009 16:13:25 +0000 (09:13 -0700)]
async_tx: provide __async_inline for HAS_DMA=n archs

To allow an async_tx routine to be compiled away on HAS_DMA=n arch it
needs to be declared __always_inline otherwise the compiler may emit
code and cause a link error.

Signed-off-by: Dan Williams <>
13 years agodmaengine: kill some unused headers
Dan Williams [Wed, 25 Mar 2009 16:13:24 +0000 (09:13 -0700)]
dmaengine: kill some unused headers

The dmaengine redux left some unneeded headers in
include/linux/dmaengine.h, clean them up.

Signed-off-by: Dan Williams <>
13 years agodmaengine: initialize tx_list in dma_async_tx_descriptor_init
Dan Williams [Wed, 25 Mar 2009 16:13:24 +0000 (09:13 -0700)]
dmaengine: initialize tx_list in dma_async_tx_descriptor_init

Centralize this common initialization (and one case where ipu_idmac is
duplicating ->chan initialization).

Signed-off-by: Dan Williams <>
13 years agodma: i.MX31 IPU DMA robustness improvements
Guennadi Liakhovetski [Wed, 25 Mar 2009 16:13:24 +0000 (09:13 -0700)]
dma: i.MX31 IPU DMA robustness improvements

Add DMA error handling to the ISR, move common code fragments to functions, fix
scatter-gather element queuing in the ISR, survive channel freeing and
re-allocation in a quick succession.

Signed-off-by: Guennadi Liakhovetski <>
Signed-off-by: Dan Williams <>
13 years agodma: improve section assignment in i.MX31 IPU DMA driver
Guennadi Liakhovetski [Wed, 25 Mar 2009 16:13:24 +0000 (09:13 -0700)]
dma: improve section assignment in i.MX31 IPU DMA driver

The i.MX31 IPU DMA driver is a platform driver, but doesn't need hotplug, so we
can use __init and __exit function attributes.

Signed-off-by: Guennadi Liakhovetski <>
Signed-off-by: Dan Williams <>
13 years agodma: ipu_idmac driver cosmetic clean-up
Guennadi Liakhovetski [Wed, 25 Mar 2009 16:13:23 +0000 (09:13 -0700)]
dma: ipu_idmac driver cosmetic clean-up

Remove superfluous semicolons, update comments.

Signed-off-by: Guennadi Liakhovetski <>
Signed-off-by: Dan Williams <>
13 years agodmaengine: fail device registration if channel registration fails
Dan Williams [Wed, 25 Mar 2009 16:13:23 +0000 (09:13 -0700)]
dmaengine: fail device registration if channel registration fails

Atsushi points out:
"If alloc_percpu or kzalloc failed, chan_id does not match with its
position in device->channels list.

And above "continue" looks buggy anyway.  Keeping incomplete channels
in device->channels list looks very dangerous..."

Also, fix up leakage of idr_ref in the idr_pre_get() and channel init
fail cases.

Reported-by: Atsushi Nemoto <>
Signed-off-by: Dan Williams <>
13 years agoLinus 2.6.29-rc8 v2.6.29-rc8
Linus Torvalds [Fri, 13 Mar 2009 02:39:28 +0000 (19:39 -0700)]
Linus 2.6.29-rc8

13 years agobitmap: fix end condition in bitmap_find_free_region
Linus Torvalds [Fri, 13 Mar 2009 02:32:51 +0000 (19:32 -0700)]
bitmap: fix end condition in bitmap_find_free_region

Guennadi Liakhovetski noticed that the end condition for the loop in
bitmap_find_free_region() is wrong, and the "return if error" was also
using the wrong conditional that would only trigger if the bitmap was an
exact multiple of the allocation size, which is not necessarily the case
with dma_alloc_from_coherent().

Such a failure would end up in bitmap_find_free_region() accessing
beyond the end of the bitmap.

Reported-by: Guennadi Liakhovetski <>
Cc: Andrew Morton <>
Signed-off-by: Linus Torvalds <>
13 years agoMerge git://
Linus Torvalds [Thu, 12 Mar 2009 23:35:26 +0000 (16:35 -0700)]
Merge git://git./linux/kernel/git/sam/kbuild-fixes

* git://
  kbuild: remove unused -r option for module-init-tool depmod
  kbuild: fix 'make rpm' when CONFIG_LOCALVERSION_AUTO=y and using SCM tree
  kbuild: fix mkspec to cleanup RPM_BUILD_ROOT
  kbuild: fix C libary confusion in unifdef.c due to getline()

13 years agoMerge git://
Linus Torvalds [Thu, 12 Mar 2009 23:34:59 +0000 (16:34 -0700)]
Merge git://git./linux/kernel/git/rusty/linux-2.6-for-linus

* git://
  cpumask: mm_cpumask for accessing the struct mm_struct's cpu_vm_mask.
  cpumask: tsk_cpumask for accessing the struct task_struct's cpus_allowed.

13 years agoMerge git://
Linus Torvalds [Thu, 12 Mar 2009 23:32:36 +0000 (16:32 -0700)]
Merge git://git./linux/kernel/git/pkl/squashfs-linus

* git://
  Squashfs: Valid filesystems are flagged as bad by the corrupted fs patch

13 years agoMerge branch 'hwmon-for-linus' of git://
Linus Torvalds [Thu, 12 Mar 2009 23:25:04 +0000 (16:25 -0700)]
Merge branch 'hwmon-for-linus' of git://

* 'hwmon-for-linus' of git://
  hwmon: (f75375s) Remove unnecessary and confusing initialization
  hwmon: (it87) Properly decode -128 degrees C temperature
  hwmon: (lm90) Document support for the MAX6648/6692 chips
  hwmon: (abituguru3) Fix I/O error handling

13 years agotrivial: fix bad links in the ext2 and ext3 documentation
Jody McIntyre [Thu, 12 Mar 2009 21:39:23 +0000 (17:39 -0400)]
trivial: fix bad links in the ext2 and ext3 documentation

Trivial patch to fix bad links in the ext2 and ext3 documentation.

Signed-off-by: Jody McIntyre <>
Signed-off-by: Linus Torvalds <>
13 years agoMerge branch 'fixes-20090312' of git://
Linus Torvalds [Thu, 12 Mar 2009 23:22:51 +0000 (16:22 -0700)]
Merge branch 'fixes-20090312' of git://git./linux/kernel/git/willy/pci

* 'fixes-20090312' of git://
  PCIe: portdrv: call pci_disable_device during remove
  pci: Fix typo in message while disabling HT MSI mapping
  pci: don't disable too many HT MSI mapping
  powerpc/pseries: The RPA PCI hotplug driver depends on EEH
  PCIe: AER: during disable, check subordinate before walking
  PCI: Add PCI quirk to disable L0s ASPM state for 82575 and 82598

13 years agoRDMA/nes: Don't allow userspace QPs to use STag zero
Faisal Latif [Thu, 12 Mar 2009 21:34:59 +0000 (14:34 -0700)]
RDMA/nes: Don't allow userspace QPs to use STag zero

STag zero is a special STag that allows consumers to access any bus
address without registering memory.  The nes driver unfortunately
allows STag zero to be used even with QPs created by unprivileged
userspace consumers, which means that any process with direct verbs
access to the nes device can read and write any memory accessible to
the underlying PCI device (usually any memory in the system).  Such
access is usually given for cluster software such as MPI to use, so
this is a local privilege escalation bug on most systems running this

The driver was using STag zero to receive the last streaming mode
data; to allow STag zero to be disabled for unprivileged QPs, the
driver now registers a special MR for this data.

Cc: <>
Signed-off-by: Faisal Latif <>
Signed-off-by: Roland Dreier <>
Signed-off-by: Linus Torvalds <>
13 years agofs: new inode i_state corruption fix
Nick Piggin [Thu, 12 Mar 2009 21:31:38 +0000 (14:31 -0700)]
fs: new inode i_state corruption fix

There was a report of a data corruption  There is a script included to
reproduce the problem.

During testing, I encountered a number of strange things with ext3, so I
tried ext2 to attempt to reduce complexity of the problem.  I found that
fsstress would quickly hang in wait_on_inode, waiting for I_LOCK to be
cleared, even though instrumentation showed that unlock_new_inode had
already been called for that inode.  This points to memory scribble, or
synchronisation problme.

i_state of I_NEW inodes is not protected by inode_lock because other
processes are not supposed to touch them until I_LOCK (and I_NEW) is
cleared.  Adding WARN_ON(inode->i_state & I_NEW) to sites where we modify
i_state revealed that generic_sync_sb_inodes is picking up new inodes from
the inode lists and passing them to __writeback_single_inode without
waiting for I_NEW.  Subsequently modifying i_state causes corruption.  In
my case it would look like this:

CPU0                            CPU1
unlock_new_inode()              __sync_single_inode()
 reg <- inode->i_state
 reg -> reg & ~(I_LOCK|I_NEW)   reg <- inode->i_state
 reg -> inode->i_state          reg -> reg | I_SYNC
                                reg -> inode->i_state

Non-atomic RMW on CPU1 overwrites CPU0 store and sets I_LOCK|I_NEW again.

Fix for this is rather than wait for I_NEW inodes, just skip over them:
inodes concurrently being created are not subject to data integrity
operations, and should not significantly contribute to dirty memory

After this change, I'm unable to reproduce any of the added warnings or
hangs after ~1hour of running.  Previously, the new warnings would start
immediately and hang would happen in under 5 minutes.

I'm also testing on ext3 now, and so far no problems there either.  I
don't know whether this fixes the problem reported above, but it fixes a
real problem for me.

Cc: "Jorge Boncompte [DTI2]" <>
Reported-by: Adrian Hunter <>
Cc: Jan Kara <>
Cc: <>
Signed-off-by: Nick Piggin <>
Signed-off-by: Andrew Morton <>
Signed-off-by: Linus Torvalds <>