drivers/md/dm-raid.c

1271

jdev->mddev = &rs->md;

drivers/md/dm-raid.c

1541

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

1542

uint32_t min_stripes = max(mddev->chunk_sectors, mddev->new_chunk_sectors) / 2;

drivers/md/dm-raid.c

1556

conf = mddev->private;

drivers/md/dm-raid.c

1564

r = raid5_set_cache_size(mddev, nr_stripes);

drivers/md/dm-raid.c

1648

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

1651

delta_disks = mddev->delta_disks;

drivers/md/dm-raid.c

1683

mddev->array_sectors = array_sectors;

drivers/md/dm-raid.c

1684

mddev->dev_sectors = dev_sectors;

drivers/md/dm-raid.c

1745

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

1758

switch (mddev->level) {

drivers/md/dm-raid.c

1761

if ((mddev->new_level == 1 || mddev->new_level == 5) &&

drivers/md/dm-raid.c

1762

mddev->raid_disks == 1)

drivers/md/dm-raid.c

1766

if (mddev->new_level == 10 &&

drivers/md/dm-raid.c

1767

!(rs->raid_disks % mddev->raid_disks))

drivers/md/dm-raid.c

1771

if (__within_range(mddev->new_level, 4, 6) &&

drivers/md/dm-raid.c

1772

mddev->new_layout == ALGORITHM_PARITY_N &&

drivers/md/dm-raid.c

1773

mddev->raid_disks > 1)

drivers/md/dm-raid.c

1780

if (__is_raid10_offset(mddev->layout))

drivers/md/dm-raid.c

1783

near_copies = __raid10_near_copies(mddev->layout);

drivers/md/dm-raid.c

1786

if (mddev->new_level == 0) {

drivers/md/dm-raid.c

1789

!(mddev->raid_disks % near_copies)) {

drivers/md/dm-raid.c

1790

mddev->raid_disks /= near_copies;

drivers/md/dm-raid.c

1791

mddev->delta_disks = mddev->raid_disks;

drivers/md/dm-raid.c

1797

__raid10_far_copies(mddev->layout) > 1)

drivers/md/dm-raid.c

1804

if (mddev->new_level == 1 &&

drivers/md/dm-raid.c

1805

max(near_copies, __raid10_far_copies(mddev->layout)) == mddev->raid_disks)

drivers/md/dm-raid.c

1809

if (__within_range(mddev->new_level, 4, 5) &&

drivers/md/dm-raid.c

1810

mddev->raid_disks == 2)

drivers/md/dm-raid.c

1816

if (__within_range(mddev->new_level, 4, 5) &&

drivers/md/dm-raid.c

1817

mddev->raid_disks == 2) {

drivers/md/dm-raid.c

1818

mddev->degraded = 1;

drivers/md/dm-raid.c

1823

if (mddev->new_level == 0 &&

drivers/md/dm-raid.c

1824

mddev->raid_disks == 1)

drivers/md/dm-raid.c

1828

if (mddev->new_level == 10)

drivers/md/dm-raid.c

1834

if (mddev->new_level == 0)

drivers/md/dm-raid.c

1838

if ((mddev->new_level == 1 || mddev->new_level == 5) &&

drivers/md/dm-raid.c

1839

mddev->raid_disks == 2)

drivers/md/dm-raid.c

1843

if (__within_range(mddev->new_level, 5, 6) &&

drivers/md/dm-raid.c

1844

mddev->layout == ALGORITHM_PARITY_N)

drivers/md/dm-raid.c

1850

if (mddev->new_level == 0 &&

drivers/md/dm-raid.c

1851

mddev->layout == ALGORITHM_PARITY_N)

drivers/md/dm-raid.c

1855

if (mddev->new_level == 4 &&

drivers/md/dm-raid.c

1856

mddev->layout == ALGORITHM_PARITY_N)

drivers/md/dm-raid.c

1860

if ((mddev->new_level == 1 || mddev->new_level == 4 || mddev->new_level == 10) &&

drivers/md/dm-raid.c

1861

mddev->raid_disks == 2)

drivers/md/dm-raid.c

1865

if (mddev->new_level == 6 &&

drivers/md/dm-raid.c

1866

((mddev->layout == ALGORITHM_PARITY_N && mddev->new_layout == ALGORITHM_PARITY_N) ||

drivers/md/dm-raid.c

1867

__within_range(mddev->new_layout, ALGORITHM_LEFT_ASYMMETRIC_6, ALGORITHM_RIGHT_SYMMETRIC_6)))

drivers/md/dm-raid.c

1873

if (mddev->new_level == 0 &&

drivers/md/dm-raid.c

1874

mddev->layout == ALGORITHM_PARITY_N)

drivers/md/dm-raid.c

1878

if (mddev->new_level == 4 &&

drivers/md/dm-raid.c

1879

mddev->layout == ALGORITHM_PARITY_N)

drivers/md/dm-raid.c

1883

if (mddev->new_level == 5 &&

drivers/md/dm-raid.c

1884

((mddev->layout == ALGORITHM_PARITY_N && mddev->new_layout == ALGORITHM_PARITY_N) ||

drivers/md/dm-raid.c

1885

__within_range(mddev->new_layout, ALGORITHM_LEFT_ASYMMETRIC, ALGORITHM_RIGHT_SYMMETRIC)))

drivers/md/dm-raid.c

1915

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

1931

mddev->raid_disks != rs->raid_disks;

drivers/md/dm-raid.c

1936

!__is_raid10_far(mddev->new_layout) &&

drivers/md/dm-raid.c

2043

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

2045

if (!mddev->pers || !mddev->pers->check_reshape)

drivers/md/dm-raid.c

2047

else if (mddev->degraded)

drivers/md/dm-raid.c

2073

md_error(rdev->mddev, rdev);

drivers/md/dm-raid.c

2110

static void super_sync(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/dm-raid.c

2116

struct raid_set *rs = container_of(mddev, struct raid_set, md);

drivers/md/dm-raid.c

2140

sb->num_devices = cpu_to_le32(mddev->raid_disks);

drivers/md/dm-raid.c

2143

sb->events = cpu_to_le64(mddev->events);

drivers/md/dm-raid.c

2146

sb->array_resync_offset = cpu_to_le64(mddev->resync_offset);

drivers/md/dm-raid.c

2148

sb->level = cpu_to_le32(mddev->level);

drivers/md/dm-raid.c

2149

sb->layout = cpu_to_le32(mddev->layout);

drivers/md/dm-raid.c

2150

sb->stripe_sectors = cpu_to_le32(mddev->chunk_sectors);

drivers/md/dm-raid.c

2157

sb->new_level = cpu_to_le32(mddev->new_level);

drivers/md/dm-raid.c

2158

sb->new_layout = cpu_to_le32(mddev->new_layout);

drivers/md/dm-raid.c

2159

sb->new_stripe_sectors = cpu_to_le32(mddev->new_chunk_sectors);

drivers/md/dm-raid.c

2161

sb->delta_disks = cpu_to_le32(mddev->delta_disks);

drivers/md/dm-raid.c

2164

sb->reshape_position = cpu_to_le64(mddev->reshape_position);

drivers/md/dm-raid.c

2169

if (mddev->delta_disks < 0 || mddev->reshape_backwards)

drivers/md/dm-raid.c

2176

sb->array_sectors = cpu_to_le64(mddev->array_sectors);

drivers/md/dm-raid.c

2214

super_sync(rdev->mddev, rdev);

drivers/md/dm-raid.c

2220

set_bit(MD_SB_CHANGE_DEVS, &rdev->mddev->sb_flags);

drivers/md/dm-raid.c

2240

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

2254

mddev->events = events_sb ? : 1;

drivers/md/dm-raid.c

2256

mddev->reshape_position = MaxSector;

drivers/md/dm-raid.c

2258

mddev->raid_disks = le32_to_cpu(sb->num_devices);

drivers/md/dm-raid.c

2259

mddev->level = le32_to_cpu(sb->level);

drivers/md/dm-raid.c

2260

mddev->layout = le32_to_cpu(sb->layout);

drivers/md/dm-raid.c

2261

mddev->chunk_sectors = le32_to_cpu(sb->stripe_sectors);

drivers/md/dm-raid.c

2269

mddev->new_level = le32_to_cpu(sb->new_level);

drivers/md/dm-raid.c

2270

mddev->new_layout = le32_to_cpu(sb->new_layout);

drivers/md/dm-raid.c

2271

mddev->new_chunk_sectors = le32_to_cpu(sb->new_stripe_sectors);

drivers/md/dm-raid.c

2272

mddev->delta_disks = le32_to_cpu(sb->delta_disks);

drivers/md/dm-raid.c

2273

mddev->array_sectors = le64_to_cpu(sb->array_sectors);

drivers/md/dm-raid.c

2282

if (mddev->delta_disks < 0 ||

drivers/md/dm-raid.c

2283

(!mddev->delta_disks && (le32_to_cpu(sb->flags) & SB_FLAG_RESHAPE_BACKWARDS)))

drivers/md/dm-raid.c

2284

mddev->reshape_backwards = 1;

drivers/md/dm-raid.c

2286

mddev->reshape_backwards = 0;

drivers/md/dm-raid.c

2288

mddev->reshape_position = le64_to_cpu(sb->reshape_position);

drivers/md/dm-raid.c

2289

rs->raid_type = get_raid_type_by_ll(mddev->level, mddev->layout);

drivers/md/dm-raid.c

2298

struct raid_type *rt_cur = get_raid_type_by_ll(mddev->level, mddev->layout);

drivers/md/dm-raid.c

2299

struct raid_type *rt_new = get_raid_type_by_ll(mddev->new_level, mddev->new_layout);

drivers/md/dm-raid.c

2310

if (mddev->layout != mddev->new_layout) {

drivers/md/dm-raid.c

2316

le32_to_cpu(sb->layout), mddev->new_layout);

drivers/md/dm-raid.c

2318

if (mddev->chunk_sectors != mddev->new_chunk_sectors)

drivers/md/dm-raid.c

2320

mddev->chunk_sectors, mddev->new_chunk_sectors);

drivers/md/dm-raid.c

2323

mddev->raid_disks, mddev->raid_disks + rs->delta_disks);

drivers/md/dm-raid.c

2326

raid10_md_layout_to_format(mddev->layout),

drivers/md/dm-raid.c

2327

raid10_md_layout_to_copies(mddev->layout));

drivers/md/dm-raid.c

2329

raid10_md_layout_to_format(mddev->new_layout),

drivers/md/dm-raid.c

2330

raid10_md_layout_to_copies(mddev->new_layout));

drivers/md/dm-raid.c

2339

mddev->resync_offset = le64_to_cpu(sb->array_resync_offset);

drivers/md/dm-raid.c

2356

rdev_for_each(r, mddev) {

drivers/md/dm-raid.c

2377

set_bit(MD_ARRAY_FIRST_USE, &mddev->flags);

drivers/md/dm-raid.c

2396

(unsigned long long) mddev->resync_offset);

drivers/md/dm-raid.c

2400

(unsigned long long) mddev->reshape_position);

drivers/md/dm-raid.c

2410

rdev_for_each(r, mddev) {

drivers/md/dm-raid.c

2427

if (rs_is_raid10(rs) && __is_raid10_near(mddev->layout)) {

drivers/md/dm-raid.c

2428

if (mddev->raid_disks % __raid10_near_copies(mddev->layout) ||

drivers/md/dm-raid.c

245

struct mddev md;

drivers/md/dm-raid.c

2461

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

2473

if (!mddev->events && super_init_validation(rs, rdev))

drivers/md/dm-raid.c

2488

mddev->bitmap_info.offset = (rt_is_raid0(rs->raid_type) || rs->journal_dev.dev) ? 0 : to_sector(4096);

drivers/md/dm-raid.c

2489

mddev->bitmap_info.default_offset = mddev->bitmap_info.offset;

drivers/md/dm-raid.c

2534

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

2538

set_bit(MD_ARRAY_FIRST_USE, &mddev->flags);

drivers/md/dm-raid.c

2541

rdev_for_each(rdev, mddev) {

drivers/md/dm-raid.c

2614

rdev_for_each(rdev, mddev)

drivers/md/dm-raid.c

263

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

265

l->new_level = mddev->new_level;

drivers/md/dm-raid.c

266

l->new_layout = mddev->new_layout;

drivers/md/dm-raid.c

267

l->new_chunk_sectors = mddev->new_chunk_sectors;

drivers/md/dm-raid.c

272

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

274

mddev->new_level = l->new_level;

drivers/md/dm-raid.c

2741

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

2743

unsigned int d = mddev->raid_disks = rs->raid_disks;

drivers/md/dm-raid.c

275

mddev->new_layout = l->new_layout;

drivers/md/dm-raid.c

2752

mddev->layout = raid10_format_to_md_layout(rs, ALGORITHM_RAID10_FAR,

drivers/md/dm-raid.c

2756

mddev->layout = raid10_format_to_md_layout(rs, ALGORITHM_RAID10_NEAR,

drivers/md/dm-raid.c

276

mddev->new_chunk_sectors = l->new_chunk_sectors;

drivers/md/dm-raid.c

2763

clear_bit(MD_ARRAY_FIRST_USE, &mddev->flags);

drivers/md/dm-raid.c

2764

mddev->resync_offset = MaxSector;

drivers/md/dm-raid.c

2772

mddev->resync_offset = rdev->recovery_offset = 0;

drivers/md/dm-raid.c

2774

set_bit(MD_ARRAY_FIRST_USE, &mddev->flags);

drivers/md/dm-raid.c

2787

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

2790

if (rs->raid_disks != mddev->raid_disks &&

drivers/md/dm-raid.c

2791

__is_raid10_near(mddev->layout) &&

drivers/md/dm-raid.c

2793

rs->raid10_copies != __raid10_near_copies(mddev->layout)) {

drivers/md/dm-raid.c

2807

mddev->layout = raid10_format_to_md_layout(rs, ALGORITHM_RAID10_NEAR,

drivers/md/dm-raid.c

2809

mddev->new_layout = mddev->layout;

drivers/md/dm-raid.c

2820

mddev->degraded = rs->delta_disks < 0 ? -rs->delta_disks : rs->delta_disks;

drivers/md/dm-raid.c

2824

mddev->raid_disks = rs->raid_disks;

drivers/md/dm-raid.c

2835

} else if (mddev->raid_disks < rs->raid_disks)

drivers/md/dm-raid.c

2854

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

2857

mddev->delta_disks = rs->delta_disks;

drivers/md/dm-raid.c

2858

cur_raid_devs = mddev->raid_disks;

drivers/md/dm-raid.c

2861

if (mddev->delta_disks &&

drivers/md/dm-raid.c

2862

mddev->layout != mddev->new_layout) {

drivers/md/dm-raid.c

2864

mddev->new_layout = mddev->layout;

drivers/md/dm-raid.c

2903

rdev->sectors = mddev->dev_sectors;

drivers/md/dm-raid.c

2907

mddev->reshape_backwards = 0; /* adding disk(s) -> forward reshape */

drivers/md/dm-raid.c

2912

mddev->reshape_backwards = 1; /* removing disk(s) -> backward reshape */

drivers/md/dm-raid.c

2937

mddev->reshape_backwards = rs->dev[0].rdev.data_offset ? 0 : 1;

drivers/md/dm-raid.c

2944

if (!mddev->reshape_backwards)

drivers/md/dm-raid.c

3344

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3354

if (unlikely(bio_has_data(bio) && bio_end_sector(bio) > mddev->array_sectors))

drivers/md/dm-raid.c

3357

if (unlikely(!md_handle_request(mddev, bio)))

drivers/md/dm-raid.c

3382

static enum sync_state decipher_sync_action(struct mddev *mddev, unsigned long recovery)

drivers/md/dm-raid.c

3390

(md_is_rdwr(mddev) && test_bit(MD_RECOVERY_NEEDED, &recovery)))) {

drivers/md/dm-raid.c

3405

if (mddev->reshape_position != MaxSector)

drivers/md/dm-raid.c

3443

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3454

r = mddev->resync_offset;

drivers/md/dm-raid.c

3456

r = mddev->curr_resync_completed;

drivers/md/dm-raid.c

3508

rdev_for_each(rdev, mddev)

drivers/md/dm-raid.c

3530

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3531

struct r5conf *conf = rs_is_raid456(rs) ? mddev->private : NULL;

drivers/md/dm-raid.c

3544

rt = get_raid_type_by_ll(mddev->new_level, mddev->new_layout);

drivers/md/dm-raid.c

3548

DMEMIT("%s %d ", rt->name, mddev->raid_disks);

drivers/md/dm-raid.c

3554

mddev->resync_max_sectors : mddev->dev_sectors;

drivers/md/dm-raid.c

3556

state = decipher_sync_action(mddev, recovery);

drivers/md/dm-raid.c

3558

resync_mismatches = mddev->last_sync_action == ACTION_CHECK ?

drivers/md/dm-raid.c

3559

atomic64_read(&mddev->resync_mismatches) : 0;

drivers/md/dm-raid.c

3636

DMEMIT("%s %u %u", rs->raid_type->name, raid_param_cnt, mddev->new_chunk_sectors);

drivers/md/dm-raid.c

3647

mddev->bitmap_info.daemon_sleep);

drivers/md/dm-raid.c

3650

mddev->sync_speed_min);

drivers/md/dm-raid.c

3653

mddev->sync_speed_max);

drivers/md/dm-raid.c

3661

mddev->bitmap_info.max_write_behind);

drivers/md/dm-raid.c

3667

(unsigned long long) to_sector(mddev->bitmap_info.chunksize));

drivers/md/dm-raid.c

3670

raid10_md_layout_to_copies(mddev->layout));

drivers/md/dm-raid.c

3673

raid10_md_layout_to_format(mddev->layout));

drivers/md/dm-raid.c

3676

max(rs->delta_disks, mddev->delta_disks));

drivers/md/dm-raid.c

3693

rt = get_raid_type_by_ll(mddev->new_level, mddev->new_layout);

drivers/md/dm-raid.c

3698

DMEMIT(",raid_type=%s,raid_disks=%d", rt->name, mddev->raid_disks);

drivers/md/dm-raid.c

3703

state = decipher_sync_action(mddev, recovery);

drivers/md/dm-raid.c

3736

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3739

if (!mddev->pers || !mddev->pers->sync_request)

drivers/md/dm-raid.c

3747

ret = mddev_lock(mddev);

drivers/md/dm-raid.c

3751

md_frozen_sync_thread(mddev);

drivers/md/dm-raid.c

3752

mddev_unlock(mddev);

drivers/md/dm-raid.c

3754

ret = mddev_lock(mddev);

drivers/md/dm-raid.c

3758

md_idle_sync_thread(mddev);

drivers/md/dm-raid.c

3759

mddev_unlock(mddev);

drivers/md/dm-raid.c

3762

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/dm-raid.c

3763

if (decipher_sync_action(mddev, mddev->recovery) != st_idle)

drivers/md/dm-raid.c

3768

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/dm-raid.c

3771

set_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/dm-raid.c

3772

set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/dm-raid.c

3773

set_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/dm-raid.c

3775

set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/dm-raid.c

3776

set_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/dm-raid.c

3780

if (mddev->ro == MD_AUTO_READ) {

drivers/md/dm-raid.c

3784

mddev->ro = MD_RDWR;

drivers/md/dm-raid.c

3785

if (!mddev->suspended)

drivers/md/dm-raid.c

3786

md_wakeup_thread(mddev->sync_thread);

drivers/md/dm-raid.c

3788

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/dm-raid.c

3789

if (!mddev->suspended)

drivers/md/dm-raid.c

3790

md_wakeup_thread(mddev->thread);

drivers/md/dm-raid.c

3827

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3835

if (!reshape_interrupted(mddev))

drivers/md/dm-raid.c

3843

if (mddev->pers && mddev->pers->prepare_suspend)

drivers/md/dm-raid.c

3844

mddev->pers->prepare_suspend(mddev);

drivers/md/dm-raid.c

3876

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3880

if (!mddev->pers || !mddev->pers->hot_add_disk || !mddev->pers->hot_remove_disk)

drivers/md/dm-raid.c

3909

if (mddev->pers->hot_remove_disk(mddev, r)) {

drivers/md/dm-raid.c

3920

if (mddev->pers->hot_add_disk(mddev, r)) {

drivers/md/dm-raid.c

3959

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3961

if (md_bitmap_enabled(mddev, false)) {

drivers/md/dm-raid.c

3962

r = mddev->bitmap_ops->load(mddev);

drivers/md/dm-raid.c

3974

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3975

int ro = mddev->ro;

drivers/md/dm-raid.c

3977

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/dm-raid.c

3978

mddev->ro = MD_RDWR;

drivers/md/dm-raid.c

3979

md_update_sb(mddev, 1);

drivers/md/dm-raid.c

3980

mddev->ro = ro;

drivers/md/dm-raid.c

3993

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3994

struct md_personality *pers = mddev->pers;

drivers/md/dm-raid.c

3997

set_bit(MD_RECOVERY_WAIT, &mddev->recovery);

drivers/md/dm-raid.c

4008

r = pers->check_reshape(mddev);

drivers/md/dm-raid.c

4019

r = pers->start_reshape(mddev);

drivers/md/dm-raid.c

4040

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

4048

rs->array_sectors != mddev->array_sectors)

drivers/md/dm-raid.c

4067

mddev->array_sectors = rs->array_sectors;

drivers/md/dm-raid.c

4068

mddev->dev_sectors = rs->dev_sectors;

drivers/md/dm-raid.c

4074

if (test_bit(RT_FLAG_RS_BITMAP_LOADED, &rs->runtime_flags) && mddev->bitmap &&

drivers/md/dm-raid.c

4077

mddev->bitmap_info.chunksize != to_bytes(rs->requested_bitmap_chunk_sectors)))) {

drivers/md/dm-raid.c

4078

int chunksize = to_bytes(rs->requested_bitmap_chunk_sectors) ?: mddev->bitmap_info.chunksize;

drivers/md/dm-raid.c

4080

if (md_bitmap_enabled(mddev, false)) {

drivers/md/dm-raid.c

4081

r = mddev->bitmap_ops->resize(mddev, mddev->dev_sectors,

drivers/md/dm-raid.c

4089

if (mddev->resync_offset && mddev->resync_offset < MaxSector) {

drivers/md/dm-raid.c

4090

set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/dm-raid.c

4091

mddev->resync_min = mddev->resync_offset;

drivers/md/dm-raid.c

4093

mddev->resync_max_sectors = mddev->dev_sectors;

drivers/md/dm-raid.c

4100

mddev_lock_nointr(mddev);

drivers/md/dm-raid.c

4102

mddev_unlock(mddev);

drivers/md/dm-raid.c

4114

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

4122

mddev_lock_nointr(mddev);

drivers/md/dm-raid.c

4124

mddev_unlock(mddev);

drivers/md/dm-raid.c

4129

if (mddev->delta_disks < 0)

drivers/md/dm-raid.c

4132

mddev_lock_nointr(mddev);

drivers/md/dm-raid.c

4133

WARN_ON_ONCE(!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery));

drivers/md/dm-raid.c

4134

WARN_ON_ONCE(rcu_dereference_protected(mddev->sync_thread,

drivers/md/dm-raid.c

4135

lockdep_is_held(&mddev->reconfig_mutex)));

drivers/md/dm-raid.c

4137

mddev->ro = MD_RDWR;

drivers/md/dm-raid.c

4138

mddev->in_sync = 0;

drivers/md/dm-raid.c

4139

md_unfrozen_sync_thread(mddev);

drivers/md/dm-raid.c

4140

mddev_unlock_and_resume(mddev);

drivers/md/dm-raid.c

686

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

693

rdev_for_each(rdev, mddev)

drivers/md/dm-raid.c

695

rdev->sectors = mddev->dev_sectors;

drivers/md/dm-raid.c

714

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

716

mddev->new_level = mddev->level;

drivers/md/dm-raid.c

717

mddev->new_layout = mddev->layout;

drivers/md/dm-raid.c

718

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/dm-raid.c

727

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

729

mddev->level = mddev->new_level;

drivers/md/dm-raid.c

730

mddev->layout = mddev->new_layout;

drivers/md/dm-raid.c

731

mddev->chunk_sectors = mddev->new_chunk_sectors;

drivers/md/dm-raid.c

732

mddev->raid_disks = rs->raid_disks;

drivers/md/dm-raid.c

733

mddev->delta_disks = 0;

drivers/md/dm-raid.c

851

rs->dev[i].rdev.mddev = &rs->md;

drivers/md/md-autodetect.c

128

struct mddev *mddev;

drivers/md/md-autodetect.c

172

mddev = md_alloc(mdev, name);

drivers/md/md-autodetect.c

173

if (IS_ERR(mddev)) {

drivers/md/md-autodetect.c

178

err = mddev_suspend_and_lock(mddev);

drivers/md/md-autodetect.c

184

if (!list_empty(&mddev->disks) || mddev->raid_disks) {

drivers/md/md-autodetect.c

201

err = md_set_array_info(mddev, &ainfo);

drivers/md/md-autodetect.c

216

md_add_new_disk(mddev, &dinfo);

drivers/md/md-autodetect.c

220

err = do_md_run(mddev);

drivers/md/md-autodetect.c

224

mddev_unlock_and_resume(mddev);

drivers/md/md-autodetect.c

226

mddev_put(mddev);

drivers/md/md-bitmap.c

1159

if (mddev_is_clustered(bitmap->mddev))

drivers/md/md-bitmap.c

1190

if (mddev_is_clustered(bitmap->mddev))

drivers/md/md-bitmap.c

1251

mddev_add_trace_msg(bitmap->mddev,

drivers/md/md-bitmap.c

1295

static void bitmap_unplug(struct mddev *mddev, bool sync)

drivers/md/md-bitmap.c

1297

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1324

struct mddev *mddev = bitmap->mddev;

drivers/md/md-bitmap.c

1333

if (!file && !mddev->bitmap_info.offset) {

drivers/md/md-bitmap.c

1357

if (mddev_is_clustered(mddev))

drivers/md/md-bitmap.c

1373

ret = read_sb_page(mddev, 0, page, i + node_offset,

drivers/md/md-bitmap.c

1388

if (i == 0 && !mddev->bitmap_info.external)

drivers/md/md-bitmap.c

1444

static void bitmap_write_all(struct mddev *mddev)

drivers/md/md-bitmap.c

1447

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1484

static void mddev_set_timeout(struct mddev *mddev, unsigned long timeout,

drivers/md/md-bitmap.c

1490

thread = rcu_dereference(mddev->thread);

drivers/md/md-bitmap.c

1506

static void bitmap_daemon_work(struct mddev *mddev)

drivers/md/md-bitmap.c

1517

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

1518

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1520

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

1524

+ mddev->bitmap_info.daemon_sleep))

drivers/md/md-bitmap.c

1529

mddev_set_timeout(mddev, MAX_SCHEDULE_TIMEOUT, true);

drivers/md/md-bitmap.c

1534

mddev_add_trace_msg(bitmap->mddev, "md bitmap_daemon_work");

drivers/md/md-bitmap.c

1547

mddev->bitmap_info.external == 0) {

drivers/md/md-bitmap.c

1623

mddev_set_timeout(mddev, mddev->bitmap_info.daemon_sleep, true);

drivers/md/md-bitmap.c

1624

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

167

struct mddev *mddev; /* the md device that the bitmap is for */

drivers/md/md-bitmap.c

1677

static void bitmap_start_write(struct mddev *mddev, sector_t offset,

drivers/md/md-bitmap.c

1680

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1731

static void bitmap_end_write(struct mddev *mddev, sector_t offset,

drivers/md/md-bitmap.c

1734

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1751

if (!bitmap->mddev->degraded) {

drivers/md/md-bitmap.c

1752

if (bitmap->events_cleared < bitmap->mddev->events) {

drivers/md/md-bitmap.c

1753

bitmap->events_cleared = bitmap->mddev->events;

drivers/md/md-bitmap.c

1804

static bool bitmap_start_sync(struct mddev *mddev, sector_t offset,

drivers/md/md-bitmap.c

1819

rv |= __bitmap_start_sync(mddev->bitmap, offset,

drivers/md/md-bitmap.c

1855

static void bitmap_end_sync(struct mddev *mddev, sector_t offset,

drivers/md/md-bitmap.c

1858

__bitmap_end_sync(mddev->bitmap, offset, blocks, true);

drivers/md/md-bitmap.c

1861

static void bitmap_close_sync(struct mddev *mddev)

drivers/md/md-bitmap.c

1869

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1874

while (sector < bitmap->mddev->resync_max_sectors) {

drivers/md/md-bitmap.c

1880

static void bitmap_cond_end_sync(struct mddev *mddev, sector_t sector,

drivers/md/md-bitmap.c

1885

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1894

+ bitmap->mddev->bitmap_info.daemon_sleep)))

drivers/md/md-bitmap.c

1896

wait_event(bitmap->mddev->recovery_wait,

drivers/md/md-bitmap.c

1897

atomic_read(&bitmap->mddev->recovery_active) == 0);

drivers/md/md-bitmap.c

1899

bitmap->mddev->curr_resync_completed = sector;

drivers/md/md-bitmap.c

1900

set_bit(MD_SB_CHANGE_CLEAN, &bitmap->mddev->sb_flags);

drivers/md/md-bitmap.c

1903

while (s < sector && s < bitmap->mddev->resync_max_sectors) {

drivers/md/md-bitmap.c

1908

sysfs_notify_dirent_safe(bitmap->mddev->sysfs_completed);

drivers/md/md-bitmap.c

1911

static void bitmap_sync_with_cluster(struct mddev *mddev,

drivers/md/md-bitmap.c

1915

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1925

bitmap_start_sync(mddev, sector, &blocks, false);

drivers/md/md-bitmap.c

1958

static void bitmap_dirty_bits(struct mddev *mddev, unsigned long s,

drivers/md/md-bitmap.c

1962

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1972

if (sec < bitmap->mddev->resync_offset)

drivers/md/md-bitmap.c

1977

bitmap->mddev->resync_offset = sec;

drivers/md/md-bitmap.c

1981

static void bitmap_flush(struct mddev *mddev)

drivers/md/md-bitmap.c

1983

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1992

sleep = mddev->bitmap_info.daemon_sleep * 2;

drivers/md/md-bitmap.c

1994

bitmap_daemon_work(mddev);

drivers/md/md-bitmap.c

1996

bitmap_daemon_work(mddev);

drivers/md/md-bitmap.c

1998

bitmap_daemon_work(mddev);

drivers/md/md-bitmap.c

1999

if (mddev->bitmap_info.external)

drivers/md/md-bitmap.c

2000

md_super_wait(mddev);

drivers/md/md-bitmap.c

2016

if (mddev_is_clustered(bitmap->mddev) && bitmap->mddev->cluster_info &&

drivers/md/md-bitmap.c

2017

bitmap->cluster_slot == bitmap->mddev->cluster_ops->slot_number(bitmap->mddev))

drivers/md/md-bitmap.c

2018

md_cluster_stop(bitmap->mddev);

drivers/md/md-bitmap.c

2040

static void bitmap_start_behind_write(struct mddev *mddev)

drivers/md/md-bitmap.c

2042

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2051

bw, bitmap->mddev->bitmap_info.max_write_behind);

drivers/md/md-bitmap.c

2054

static void bitmap_end_behind_write(struct mddev *mddev)

drivers/md/md-bitmap.c

2056

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2062

bitmap->mddev->bitmap_info.max_write_behind);

drivers/md/md-bitmap.c

2065

static void bitmap_wait_behind_writes(struct mddev *mddev)

drivers/md/md-bitmap.c

2067

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2072

mdname(mddev));

drivers/md/md-bitmap.c

2079

static void bitmap_destroy(struct mddev *mddev)

drivers/md/md-bitmap.c

2081

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2086

bitmap_wait_behind_writes(mddev);

drivers/md/md-bitmap.c

2087

if (!test_bit(MD_SERIALIZE_POLICY, &mddev->flags))

drivers/md/md-bitmap.c

2088

mddev_destroy_serial_pool(mddev, NULL);

drivers/md/md-bitmap.c

2090

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2091

spin_lock(&mddev->lock);

drivers/md/md-bitmap.c

2092

mddev->bitmap = NULL; /* disconnect from the md device */

drivers/md/md-bitmap.c

2093

spin_unlock(&mddev->lock);

drivers/md/md-bitmap.c

2094

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2095

mddev_set_timeout(mddev, MAX_SCHEDULE_TIMEOUT, true);

drivers/md/md-bitmap.c

2105

static struct bitmap *__bitmap_create(struct mddev *mddev, int slot)

drivers/md/md-bitmap.c

2108

sector_t blocks = mddev->resync_max_sectors;

drivers/md/md-bitmap.c

2109

struct file *file = mddev->bitmap_info.file;

drivers/md/md-bitmap.c

2115

BUG_ON(file && mddev->bitmap_info.offset);

drivers/md/md-bitmap.c

2117

if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {

drivers/md/md-bitmap.c

2119

mdname(mddev));

drivers/md/md-bitmap.c

2133

bitmap->mddev = mddev;

drivers/md/md-bitmap.c

2136

if (mddev->kobj.sd)

drivers/md/md-bitmap.c

2137

bm = sysfs_get_dirent(mddev->kobj.sd, "bitmap");

drivers/md/md-bitmap.c

2154

if (!mddev->bitmap_info.external) {

drivers/md/md-bitmap.c

2159

if (test_and_clear_bit(MD_ARRAY_FIRST_USE, &mddev->flags))

drivers/md/md-bitmap.c

2165

if (mddev->bitmap_info.chunksize == 0 ||

drivers/md/md-bitmap.c

2166

mddev->bitmap_info.daemon_sleep == 0)

drivers/md/md-bitmap.c

2175

err = __bitmap_resize(bitmap, blocks, mddev->bitmap_info.chunksize,

drivers/md/md-bitmap.c

2193

static int bitmap_create(struct mddev *mddev)

drivers/md/md-bitmap.c

2195

struct bitmap *bitmap = __bitmap_create(mddev, -1);

drivers/md/md-bitmap.c

2200

mddev->bitmap = bitmap;

drivers/md/md-bitmap.c

2204

static int bitmap_load(struct mddev *mddev)

drivers/md/md-bitmap.c

2209

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2215

rdev_for_each(rdev, mddev)

drivers/md/md-bitmap.c

2216

mddev_create_serial_pool(mddev, rdev);

drivers/md/md-bitmap.c

2218

if (mddev_is_clustered(mddev))

drivers/md/md-bitmap.c

2219

mddev->cluster_ops->load_bitmaps(mddev, mddev->bitmap_info.nodes);

drivers/md/md-bitmap.c

2226

while (sector < mddev->resync_max_sectors) {

drivers/md/md-bitmap.c

2228

bitmap_start_sync(mddev, sector, &blocks, false);

drivers/md/md-bitmap.c

2231

bitmap_close_sync(mddev);

drivers/md/md-bitmap.c

2233

if (mddev->degraded == 0

drivers/md/md-bitmap.c

2234

|| bitmap->events_cleared == mddev->events)

drivers/md/md-bitmap.c

2237

start = mddev->resync_offset;

drivers/md/md-bitmap.c

2239

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2241

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2248

set_bit(MD_RECOVERY_NEEDED, &bitmap->mddev->recovery);

drivers/md/md-bitmap.c

225

return bitmap->mddev ? mdname(bitmap->mddev) : "mdX";

drivers/md/md-bitmap.c

2250

mddev_set_timeout(mddev, mddev->bitmap_info.daemon_sleep, true);

drivers/md/md-bitmap.c

2251

md_wakeup_thread(mddev->thread);

drivers/md/md-bitmap.c

2262

static void *bitmap_get_from_slot(struct mddev *mddev, int slot)

drivers/md/md-bitmap.c

2267

bitmap = __bitmap_create(mddev, slot);

drivers/md/md-bitmap.c

2285

static int bitmap_copy_from_slot(struct mddev *mddev, int slot, sector_t *low,

drivers/md/md-bitmap.c

2293

bitmap = bitmap_get_from_slot(mddev, slot);

drivers/md/md-bitmap.c

2307

md_bitmap_set_memory_bits(mddev->bitmap, block, 1);

drivers/md/md-bitmap.c

2308

md_bitmap_file_set_bit(mddev->bitmap, block);

drivers/md/md-bitmap.c

2321

__bitmap_unplug(mddev->bitmap);

drivers/md/md-bitmap.c

2398

long space = bitmap->mddev->bitmap_info.space;

drivers/md/md-bitmap.c

2405

if (!bitmap->mddev->bitmap_info.external)

drivers/md/md-bitmap.c

2408

bitmap->mddev->bitmap_info.space = space;

drivers/md/md-bitmap.c

2417

if (!bitmap->mddev->bitmap_info.external)

drivers/md/md-bitmap.c

2426

if (bitmap->mddev->bitmap_info.offset || bitmap->mddev->bitmap_info.file)

drivers/md/md-bitmap.c

2428

!bitmap->mddev->bitmap_info.external,

drivers/md/md-bitmap.c

2429

mddev_is_clustered(bitmap->mddev)

drivers/md/md-bitmap.c

2446

bitmap->mddev->pers->quiesce(bitmap->mddev, 1);

drivers/md/md-bitmap.c

2455

mutex_lock(&bitmap->mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2466

bitmap->mddev->bitmap_info.chunksize = 1UL << (chunkshift +

drivers/md/md-bitmap.c

2473

if (mddev_is_clustered(bitmap->mddev)) {

drivers/md/md-bitmap.c

2492

bitmap->mddev->bitmap_info.chunksize =

drivers/md/md-bitmap.c

2563

mutex_unlock(&bitmap->mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2566

bitmap->mddev->pers->quiesce(bitmap->mddev, 0);

drivers/md/md-bitmap.c

2573

static int bitmap_resize(struct mddev *mddev, sector_t blocks, int chunksize)

drivers/md/md-bitmap.c

2575

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2584

location_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2587

if (mddev->bitmap_info.file)

drivers/md/md-bitmap.c

2589

else if (mddev->bitmap_info.offset)

drivers/md/md-bitmap.c

2590

len = sprintf(page, "%+lld", (long long)mddev->bitmap_info.offset);

drivers/md/md-bitmap.c

2598

location_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-bitmap.c

2602

rv = mddev_suspend_and_lock(mddev);

drivers/md/md-bitmap.c

2606

if (mddev->pers) {

drivers/md/md-bitmap.c

2607

if (mddev->recovery || mddev->sync_thread) {

drivers/md/md-bitmap.c

2613

if (mddev->bitmap || mddev->bitmap_info.file ||

drivers/md/md-bitmap.c

2614

mddev->bitmap_info.offset) {

drivers/md/md-bitmap.c

2621

bitmap_destroy(mddev);

drivers/md/md-bitmap.c

2622

mddev->bitmap_info.offset = 0;

drivers/md/md-bitmap.c

2623

if (mddev->bitmap_info.file) {

drivers/md/md-bitmap.c

2624

struct file *f = mddev->bitmap_info.file;

drivers/md/md-bitmap.c

2625

mddev->bitmap_info.file = NULL;

drivers/md/md-bitmap.c

2649

if (mddev->bitmap_info.external == 0 &&

drivers/md/md-bitmap.c

2650

mddev->major_version == 0 &&

drivers/md/md-bitmap.c

2651

offset != mddev->bitmap_info.default_offset) {

drivers/md/md-bitmap.c

2656

mddev->bitmap_info.offset = offset;

drivers/md/md-bitmap.c

2657

rv = bitmap_create(mddev);

drivers/md/md-bitmap.c

2661

rv = bitmap_load(mddev);

drivers/md/md-bitmap.c

2663

mddev->bitmap_info.offset = 0;

drivers/md/md-bitmap.c

2664

bitmap_destroy(mddev);

drivers/md/md-bitmap.c

2669

if (!mddev->external) {

drivers/md/md-bitmap.c

2673

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md-bitmap.c

2674

md_wakeup_thread(mddev->thread);

drivers/md/md-bitmap.c

2678

mddev_unlock_and_resume(mddev);

drivers/md/md-bitmap.c

2692

space_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2694

return sprintf(page, "%lu\n", mddev->bitmap_info.space);

drivers/md/md-bitmap.c

2698

space_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-bitmap.c

2711

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2718

mddev->bitmap_info.space = sectors;

drivers/md/md-bitmap.c

2726

timeout_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2729

unsigned long secs = mddev->bitmap_info.daemon_sleep / HZ;

drivers/md/md-bitmap.c

2730

unsigned long jifs = mddev->bitmap_info.daemon_sleep % HZ;

drivers/md/md-bitmap.c

2740

timeout_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-bitmap.c

2759

mddev->bitmap_info.daemon_sleep = timeout;

drivers/md/md-bitmap.c

2760

mddev_set_timeout(mddev, timeout, false);

drivers/md/md-bitmap.c

2761

md_wakeup_thread(mddev->thread);

drivers/md/md-bitmap.c

2770

backlog_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2772

return sprintf(page, "%lu\n", mddev->bitmap_info.max_write_behind);

drivers/md/md-bitmap.c

2776

backlog_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-bitmap.c

2779

unsigned long old_mwb = mddev->bitmap_info.max_write_behind;

drivers/md/md-bitmap.c

2788

rv = mddev_suspend_and_lock(mddev);

drivers/md/md-bitmap.c

2796

rdev_for_each(rdev, mddev) {

drivers/md/md-bitmap.c

2804

mdname(mddev));

drivers/md/md-bitmap.c

2805

mddev_unlock(mddev);

drivers/md/md-bitmap.c

2809

mddev->bitmap_info.max_write_behind = backlog;

drivers/md/md-bitmap.c

2810

if (!backlog && mddev->serial_info_pool) {

drivers/md/md-bitmap.c

2812

if (!test_bit(MD_SERIALIZE_POLICY, &mddev->flags))

drivers/md/md-bitmap.c

2813

mddev_destroy_serial_pool(mddev, NULL);

drivers/md/md-bitmap.c

2814

} else if (backlog && !mddev->serial_info_pool) {

drivers/md/md-bitmap.c

2816

rdev_for_each(rdev, mddev)

drivers/md/md-bitmap.c

2817

mddev_create_serial_pool(mddev, rdev);

drivers/md/md-bitmap.c

2820

bitmap_update_sb(mddev->bitmap);

drivers/md/md-bitmap.c

2822

mddev_unlock_and_resume(mddev);

drivers/md/md-bitmap.c

2830

chunksize_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2832

return sprintf(page, "%lu\n", mddev->bitmap_info.chunksize);

drivers/md/md-bitmap.c

2836

chunksize_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-bitmap.c

2841

if (mddev->bitmap)

drivers/md/md-bitmap.c

2852

mddev->bitmap_info.chunksize = csize;

drivers/md/md-bitmap.c

2859

static ssize_t metadata_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2861

if (mddev_is_clustered(mddev))

drivers/md/md-bitmap.c

2863

return sprintf(page, "%s\n", (mddev->bitmap_info.external

drivers/md/md-bitmap.c

2867

static ssize_t metadata_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-bitmap.c

2869

if (mddev->bitmap ||

drivers/md/md-bitmap.c

2870

mddev->bitmap_info.file ||

drivers/md/md-bitmap.c

2871

mddev->bitmap_info.offset)

drivers/md/md-bitmap.c

2874

mddev->bitmap_info.external = 1;

drivers/md/md-bitmap.c

2877

mddev->bitmap_info.external = 0;

drivers/md/md-bitmap.c

2886

static ssize_t can_clear_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2891

spin_lock(&mddev->lock);

drivers/md/md-bitmap.c

2892

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2898

spin_unlock(&mddev->lock);

drivers/md/md-bitmap.c

2902

static ssize_t can_clear_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-bitmap.c

2904

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2915

if (mddev->degraded)

drivers/md/md-bitmap.c

2928

behind_writes_used_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2933

spin_lock(&mddev->lock);

drivers/md/md-bitmap.c

2934

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2939

spin_unlock(&mddev->lock);

drivers/md/md-bitmap.c

2945

behind_writes_used_reset(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-bitmap.c

2947

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

347

static int read_sb_page(struct mddev *mddev, loff_t offset,

drivers/md/md-bitmap.c

351

sector_t sector = mddev->bitmap_info.offset + offset +

drivers/md/md-bitmap.c

355

rdev_for_each(rdev, mddev) {

drivers/md/md-bitmap.c

369

static struct md_rdev *next_active_rdev(struct md_rdev *rdev, struct mddev *mddev)

drivers/md/md-bitmap.c

387

rdev = list_entry(&mddev->disks, struct md_rdev, same_set);

drivers/md/md-bitmap.c

390

rdev_dec_pending(rdev, mddev);

drivers/md/md-bitmap.c

392

list_for_each_entry_continue_rcu(rdev, &mddev->disks, same_set) {

drivers/md/md-bitmap.c

431

struct mddev *mddev = bitmap->mddev;

drivers/md/md-bitmap.c

435

loff_t sboff, offset = mddev->bitmap_info.offset;

drivers/md/md-bitmap.c

456

if (mddev->external) {

drivers/md/md-bitmap.c

459

sboff < (doff + mddev->dev_sectors + PAGE_SIZE / SECTOR_SIZE))

drivers/md/md-bitmap.c

468

if (doff + mddev->dev_sectors > sboff)

drivers/md/md-bitmap.c

479

md_write_metadata(mddev, rdev, sboff + ps, (int)min(size, bitmap_limit),

drivers/md/md-bitmap.c

487

struct mddev *mddev = bitmap->mddev;

drivers/md/md-bitmap.c

492

while ((rdev = next_active_rdev(rdev, mddev)) != NULL) {

drivers/md/md-bitmap.c

498

} while (wait && md_super_wait(mddev) < 0);

drivers/md/md-bitmap.c

645

if (mddev_is_clustered(bitmap->mddev)) {

drivers/md/md-bitmap.c

674

md_super_wait(bitmap->mddev);

drivers/md/md-bitmap.c

684

if (!bitmap || !bitmap->mddev) /* no bitmap for this array */

drivers/md/md-bitmap.c

686

if (bitmap->mddev->bitmap_info.external)

drivers/md/md-bitmap.c

691

sb->events = cpu_to_le64(bitmap->mddev->events);

drivers/md/md-bitmap.c

692

if (bitmap->mddev->events < bitmap->events_cleared)

drivers/md/md-bitmap.c

694

bitmap->events_cleared = bitmap->mddev->events;

drivers/md/md-bitmap.c

702

sb->daemon_sleep = cpu_to_le32(bitmap->mddev->bitmap_info.daemon_sleep/HZ);

drivers/md/md-bitmap.c

703

sb->write_behind = cpu_to_le32(bitmap->mddev->bitmap_info.max_write_behind);

drivers/md/md-bitmap.c

705

sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);

drivers/md/md-bitmap.c

706

sb->chunksize = cpu_to_le32(bitmap->mddev->bitmap_info.chunksize);

drivers/md/md-bitmap.c

707

sb->nodes = cpu_to_le32(bitmap->mddev->bitmap_info.nodes);

drivers/md/md-bitmap.c

708

sb->sectors_reserved = cpu_to_le32(bitmap->mddev->

drivers/md/md-bitmap.c

773

chunksize = bitmap->mddev->bitmap_info.chunksize;

drivers/md/md-bitmap.c

782

daemon_sleep = bitmap->mddev->bitmap_info.daemon_sleep;

drivers/md/md-bitmap.c

788

bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;

drivers/md/md-bitmap.c

794

write_behind = bitmap->mddev->bitmap_info.max_write_behind;

drivers/md/md-bitmap.c

798

bitmap->mddev->bitmap_info.max_write_behind = write_behind;

drivers/md/md-bitmap.c

801

sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);

drivers/md/md-bitmap.c

803

memcpy(sb->uuid, bitmap->mddev->uuid, 16);

drivers/md/md-bitmap.c

807

bitmap->events_cleared = bitmap->mddev->events;

drivers/md/md-bitmap.c

808

sb->events_cleared = cpu_to_le64(bitmap->mddev->events);

drivers/md/md-bitmap.c

809

bitmap->mddev->bitmap_info.nodes = 0;

drivers/md/md-bitmap.c

829

if (!bitmap->storage.file && !bitmap->mddev->bitmap_info.offset) {

drivers/md/md-bitmap.c

846

sector_t bm_blocks = bitmap->mddev->resync_max_sectors;

drivers/md/md-bitmap.c

849

(bitmap->mddev->bitmap_info.chunksize >> 9));

drivers/md/md-bitmap.c

866

err = read_sb_page(bitmap->mddev, offset, sb_page, 0,

drivers/md/md-bitmap.c

906

strscpy(bitmap->mddev->bitmap_info.cluster_name,

drivers/md/md-bitmap.c

911

sb->sync_size = cpu_to_le64(bitmap->mddev->resync_max_sectors);

drivers/md/md-bitmap.c

913

if (bitmap->mddev->persistent) {

drivers/md/md-bitmap.c

918

if (memcmp(sb->uuid, bitmap->mddev->uuid, 16)) {

drivers/md/md-bitmap.c

924

if (!nodes && (events < bitmap->mddev->events)) {

drivers/md/md-bitmap.c

927

(unsigned long long) bitmap->mddev->events);

drivers/md/md-bitmap.c

943

bitmap->mddev->bitmap_info.chunksize = chunksize;

drivers/md/md-bitmap.c

944

err = md_setup_cluster(bitmap->mddev, nodes);

drivers/md/md-bitmap.c

950

bitmap->cluster_slot = bitmap->mddev->cluster_ops->slot_number(bitmap->mddev);

drivers/md/md-bitmap.c

957

bitmap->events_cleared = bitmap->mddev->events;

drivers/md/md-bitmap.c

958

bitmap->mddev->bitmap_info.chunksize = chunksize;

drivers/md/md-bitmap.c

959

bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;

drivers/md/md-bitmap.c

960

bitmap->mddev->bitmap_info.max_write_behind = write_behind;

drivers/md/md-bitmap.c

961

bitmap->mddev->bitmap_info.nodes = nodes;

drivers/md/md-bitmap.c

962

if (bitmap->mddev->bitmap_info.space == 0 ||

drivers/md/md-bitmap.c

963

bitmap->mddev->bitmap_info.space > sectors_reserved)

drivers/md/md-bitmap.c

964

bitmap->mddev->bitmap_info.space = sectors_reserved;

drivers/md/md-bitmap.c

968

md_cluster_stop(bitmap->mddev);

drivers/md/md-bitmap.h

100

void (*end_behind_write)(struct mddev *mddev);

drivers/md/md-bitmap.h

101

void (*wait_behind_writes)(struct mddev *mddev);

drivers/md/md-bitmap.h

108

sector_t (*skip_sync_blocks)(struct mddev *mddev, sector_t offset);

drivers/md/md-bitmap.h

109

bool (*blocks_synced)(struct mddev *mddev, sector_t offset);

drivers/md/md-bitmap.h

110

bool (*start_sync)(struct mddev *mddev, sector_t offset,

drivers/md/md-bitmap.h

112

void (*end_sync)(struct mddev *mddev, sector_t offset, sector_t *blocks);

drivers/md/md-bitmap.h

113

void (*cond_end_sync)(struct mddev *mddev, sector_t sector, bool force);

drivers/md/md-bitmap.h

114

void (*close_sync)(struct mddev *mddev);

drivers/md/md-bitmap.h

119

void (*sync_with_cluster)(struct mddev *mddev,

drivers/md/md-bitmap.h

122

void *(*get_from_slot)(struct mddev *mddev, int slot);

drivers/md/md-bitmap.h

123

int (*copy_from_slot)(struct mddev *mddev, int slot, sector_t *lo,

drivers/md/md-bitmap.h

132

static inline bool md_bitmap_registered(struct mddev *mddev)

drivers/md/md-bitmap.h

134

return mddev->bitmap_ops != NULL;

drivers/md/md-bitmap.h

137

static inline bool md_bitmap_enabled(struct mddev *mddev, bool flush)

drivers/md/md-bitmap.h

140

if (!md_bitmap_registered(mddev))

drivers/md/md-bitmap.h

143

if (!mddev->bitmap)

drivers/md/md-bitmap.h

146

return mddev->bitmap_ops->enabled(mddev->bitmap, flush);

drivers/md/md-bitmap.h

149

static inline bool md_bitmap_start_sync(struct mddev *mddev, sector_t offset,

drivers/md/md-bitmap.h

153

if (!md_bitmap_enabled(mddev, false)) {

drivers/md/md-bitmap.h

158

return mddev->bitmap_ops->start_sync(mddev, offset, blocks, degraded);

drivers/md/md-bitmap.h

161

static inline void md_bitmap_end_sync(struct mddev *mddev, sector_t offset,

drivers/md/md-bitmap.h

164

if (!md_bitmap_enabled(mddev, false)) {

drivers/md/md-bitmap.h

169

mddev->bitmap_ops->end_sync(mddev, offset, blocks);

drivers/md/md-bitmap.h

80

typedef void (md_bitmap_fn)(struct mddev *mddev, sector_t offset,

drivers/md/md-bitmap.h

87

int (*create)(struct mddev *mddev);

drivers/md/md-bitmap.h

88

int (*resize)(struct mddev *mddev, sector_t blocks, int chunksize);

drivers/md/md-bitmap.h

90

int (*load)(struct mddev *mddev);

drivers/md/md-bitmap.h

91

void (*destroy)(struct mddev *mddev);

drivers/md/md-bitmap.h

92

void (*flush)(struct mddev *mddev);

drivers/md/md-bitmap.h

93

void (*write_all)(struct mddev *mddev);

drivers/md/md-bitmap.h

94

void (*dirty_bits)(struct mddev *mddev, unsigned long s,

drivers/md/md-bitmap.h

96

void (*unplug)(struct mddev *mddev, bool sync);

drivers/md/md-bitmap.h

97

void (*daemon_work)(struct mddev *mddev);

drivers/md/md-bitmap.h

99

void (*start_behind_write)(struct mddev *mddev);

drivers/md/md-cluster.c

1006

static void resync_bitmap(struct mddev *mddev)

drivers/md/md-cluster.c

1008

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1019

static void unlock_all_bitmaps(struct mddev *mddev);

drivers/md/md-cluster.c

1020

static int leave(struct mddev *mddev)

drivers/md/md-cluster.c

1022

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1035

if ((cinfo->slot_number > 0 && mddev->resync_offset != MaxSector) ||

drivers/md/md-cluster.c

1036

(mddev->reshape_position != MaxSector &&

drivers/md/md-cluster.c

1037

test_bit(MD_CLOSING, &mddev->flags)))

drivers/md/md-cluster.c

1038

resync_bitmap(mddev);

drivers/md/md-cluster.c

1041

md_unregister_thread(mddev, &cinfo->recovery_thread);

drivers/md/md-cluster.c

1042

md_unregister_thread(mddev, &cinfo->recv_thread);

drivers/md/md-cluster.c

1049

unlock_all_bitmaps(mddev);

drivers/md/md-cluster.c

1059

static int slot_number(struct mddev *mddev)

drivers/md/md-cluster.c

1061

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1072

static int metadata_update_start(struct mddev *mddev)

drivers/md/md-cluster.c

1074

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1084

md_wakeup_thread(mddev->thread);

drivers/md/md-cluster.c

1101

static int metadata_update_finish(struct mddev *mddev)

drivers/md/md-cluster.c

1103

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1113

rdev_for_each(rdev, mddev)

drivers/md/md-cluster.c

1128

static void metadata_update_cancel(struct mddev *mddev)

drivers/md/md-cluster.c

1130

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1135

static int update_bitmap_size(struct mddev *mddev, sector_t size)

drivers/md/md-cluster.c

1137

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1150

static int resize_bitmaps(struct mddev *mddev, sector_t newsize, sector_t oldsize)

drivers/md/md-cluster.c

1152

void *bitmap = mddev->bitmap;

drivers/md/md-cluster.c

1157

rv = mddev->bitmap_ops->get_stats(bitmap, &stats);

drivers/md/md-cluster.c

1166

rv = update_bitmap_size(mddev, newsize);

drivers/md/md-cluster.c

1170

for (i = 0; i < mddev->bitmap_info.nodes; i++) {

drivers/md/md-cluster.c

1174

if (i == slot_number(mddev))

drivers/md/md-cluster.c

1177

bitmap = mddev->bitmap_ops->get_from_slot(mddev, i);

drivers/md/md-cluster.c

1184

rv = mddev->bitmap_ops->get_stats(bitmap, &stats);

drivers/md/md-cluster.c

1192

bm_lockres = lockres_init(mddev, str, NULL, 1);

drivers/md/md-cluster.c

1200

mddev->bitmap_ops->set_pages(bitmap, my_pages);

drivers/md/md-cluster.c

1209

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1214

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1215

update_bitmap_size(mddev, oldsize);

drivers/md/md-cluster.c

1222

static int cluster_check_sync_size(struct mddev *mddev)

drivers/md/md-cluster.c

1224

int current_slot = slot_number(mddev);

drivers/md/md-cluster.c

1225

int node_num = mddev->bitmap_info.nodes;

drivers/md/md-cluster.c

1228

void *bitmap = mddev->bitmap;

drivers/md/md-cluster.c

1234

rv = mddev->bitmap_ops->get_stats(bitmap, &stats);

drivers/md/md-cluster.c

1244

bitmap = mddev->bitmap_ops->get_from_slot(mddev, i);

drivers/md/md-cluster.c

1255

bm_lockres = lockres_init(mddev, str, NULL, 1);

drivers/md/md-cluster.c

1258

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1264

mddev->bitmap_ops->update_sb(bitmap);

drivers/md/md-cluster.c

1267

rv = mddev->bitmap_ops->get_stats(bitmap, &stats);

drivers/md/md-cluster.c

1269

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1276

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1279

mddev->bitmap_ops->free(bitmap);

drivers/md/md-cluster.c

1295

static void update_size(struct mddev *mddev, sector_t old_dev_sectors)

drivers/md/md-cluster.c

1297

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1303

md_update_sb(mddev, 1);

drivers/md/md-cluster.c

1311

rdev_for_each(rdev, mddev)

drivers/md/md-cluster.c

1341

if (cluster_check_sync_size(mddev) == 0) {

drivers/md/md-cluster.c

1348

set_capacity_and_notify(mddev->gendisk, mddev->array_sectors);

drivers/md/md-cluster.c

1351

ret = mddev->pers->resize(mddev, old_dev_sectors);

drivers/md/md-cluster.c

1360

static int resync_start(struct mddev *mddev)

drivers/md/md-cluster.c

1362

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1363

return dlm_lock_sync_interruptible(cinfo->resync_lockres, DLM_LOCK_EX, mddev);

drivers/md/md-cluster.c

1366

static void resync_info_get(struct mddev *mddev, sector_t *lo, sector_t *hi)

drivers/md/md-cluster.c

1368

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1376

static int resync_status_get(struct mddev *mddev)

drivers/md/md-cluster.c

1378

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1383

static int resync_start_notify(struct mddev *mddev)

drivers/md/md-cluster.c

1385

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1393

static int resync_info_update(struct mddev *mddev, sector_t lo, sector_t hi)

drivers/md/md-cluster.c

1395

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1423

static int resync_finish(struct mddev *mddev)

drivers/md/md-cluster.c

1425

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1428

clear_bit(MD_RESYNCING_REMOTE, &mddev->recovery);

drivers/md/md-cluster.c

1434

if (!test_bit(MD_CLOSING, &mddev->flags))

drivers/md/md-cluster.c

1435

ret = resync_info_update(mddev, 0, 0);

drivers/md/md-cluster.c

1440

static int area_resyncing(struct mddev *mddev, int direction,

drivers/md/md-cluster.c

1443

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1461

static int add_new_disk(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md-cluster.c

1463

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1508

static void add_new_disk_cancel(struct mddev *mddev)

drivers/md/md-cluster.c

1510

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1515

static int new_disk_ack(struct mddev *mddev, bool ack)

drivers/md/md-cluster.c

1517

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1520

pr_warn("md-cluster(%s): Spurious cluster confirmation\n", mdname(mddev));

drivers/md/md-cluster.c

1530

static int remove_disk(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md-cluster.c

1533

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1539

static int lock_all_bitmaps(struct mddev *mddev)

drivers/md/md-cluster.c

1543

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1547

mddev->bitmap_info.nodes - 1);

drivers/md/md-cluster.c

1553

my_slot = slot_number(mddev);

drivers/md/md-cluster.c

1554

for (slot = 0; slot < mddev->bitmap_info.nodes; slot++) {

drivers/md/md-cluster.c

1560

cinfo->other_bitmap_lockres[i] = lockres_init(mddev, str, NULL, 1);

drivers/md/md-cluster.c

1574

static void unlock_all_bitmaps(struct mddev *mddev)

drivers/md/md-cluster.c

1576

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1581

for (i = 0; i < mddev->bitmap_info.nodes - 1; i++) {

drivers/md/md-cluster.c

159

struct mddev *mddev)

drivers/md/md-cluster.c

1596

struct mddev *mddev = rdev->mddev;

drivers/md/md-cluster.c

1597

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

1605

for (sn = 0; sn < mddev->bitmap_info.nodes; sn++) {

drivers/md/md-cluster.c

1608

err = mddev->bitmap_ops->copy_from_slot(mddev, sn, &lo, &hi, false);

drivers/md/md-cluster.c

1613

if ((hi > 0) && (lo < mddev->resync_offset))

drivers/md/md-cluster.c

1614

mddev->resync_offset = lo;

drivers/md/md-cluster.c

171

|| test_bit(MD_CLOSING, &mddev->flags));

drivers/md/md-cluster.c

192

static struct dlm_lock_resource *lockres_init(struct mddev *mddev,

drivers/md/md-cluster.c

197

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

205

res->mddev = mddev;

drivers/md/md-cluster.c

277

static int read_resync_info(struct mddev *mddev,

drivers/md/md-cluster.c

28

struct mddev *mddev; /* pointing back to mddev. */

drivers/md/md-cluster.c

281

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

297

struct mddev *mddev = thread->mddev;

drivers/md/md-cluster.c

298

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

308

bm_lockres = lockres_init(mddev, str, NULL, 1);

drivers/md/md-cluster.c

314

ret = dlm_lock_sync_interruptible(bm_lockres, DLM_LOCK_PW, mddev);

drivers/md/md-cluster.c

320

ret = mddev->bitmap_ops->copy_from_slot(mddev, slot, &lo, &hi, true);

drivers/md/md-cluster.c

334

if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&

drivers/md/md-cluster.c

335

test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&

drivers/md/md-cluster.c

336

mddev->reshape_position != MaxSector)

drivers/md/md-cluster.c

337

md_wakeup_thread(mddev->sync_thread);

drivers/md/md-cluster.c

340

if (lo < mddev->resync_offset)

drivers/md/md-cluster.c

341

mddev->resync_offset = lo;

drivers/md/md-cluster.c

344

if (mddev->resync_offset != MaxSector) {

drivers/md/md-cluster.c

350

&mddev->recovery);

drivers/md/md-cluster.c

351

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md-cluster.c

352

md_wakeup_thread(mddev->thread);

drivers/md/md-cluster.c

363

struct mddev *mddev = arg;

drivers/md/md-cluster.c

364

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

368

static void __recover_slot(struct mddev *mddev, int slot)

drivers/md/md-cluster.c

370

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

375

md_register_thread(recover_bitmaps, mddev, "recover"));

drivers/md/md-cluster.c

386

struct mddev *mddev = arg;

drivers/md/md-cluster.c

387

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

390

mddev->bitmap_info.cluster_name,

drivers/md/md-cluster.c

395

__recover_slot(mddev, slot->slot - 1);

drivers/md/md-cluster.c

402

struct mddev *mddev = arg;

drivers/md/md-cluster.c

403

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

431

struct md_cluster_info *cinfo = res->mddev->cluster_info;

drivers/md/md-cluster.c

441

static void remove_suspend_info(struct mddev *mddev, int slot)

drivers/md/md-cluster.c

443

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

444

mddev->pers->quiesce(mddev, 1);

drivers/md/md-cluster.c

449

mddev->pers->quiesce(mddev, 0);

drivers/md/md-cluster.c

452

static void process_suspend_info(struct mddev *mddev,

drivers/md/md-cluster.c

455

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

464

clear_bit(MD_RESYNCING_REMOTE, &mddev->recovery);

drivers/md/md-cluster.c

465

remove_suspend_info(mddev, slot);

drivers/md/md-cluster.c

466

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md-cluster.c

468

md_wakeup_thread(mddev->thread);

drivers/md/md-cluster.c

472

rdev_for_each(rdev, mddev)

drivers/md/md-cluster.c

500

mddev->bitmap_ops->sync_with_cluster(mddev, cinfo->sync_low,

drivers/md/md-cluster.c

505

mddev->pers->quiesce(mddev, 1);

drivers/md/md-cluster.c

511

mddev->pers->quiesce(mddev, 0);

drivers/md/md-cluster.c

514

static int process_add_new_disk(struct mddev *mddev, struct cluster_msg *cmsg)

drivers/md/md-cluster.c

517

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

530

kobject_uevent_env(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE, envp);

drivers/md/md-cluster.c

543

static void process_metadata_update(struct mddev *mddev, struct cluster_msg *msg)

drivers/md/md-cluster.c

547

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

548

mddev->good_device_nr = le32_to_cpu(msg->raid_slot);

drivers/md/md-cluster.c

552

thread = rcu_dereference_protected(mddev->thread, true);

drivers/md/md-cluster.c

560

(got_lock = mddev_trylock(mddev)) ||

drivers/md/md-cluster.c

562

md_reload_sb(mddev, mddev->good_device_nr);

drivers/md/md-cluster.c

564

mddev_unlock(mddev);

drivers/md/md-cluster.c

567

static void process_remove_disk(struct mddev *mddev, struct cluster_msg *msg)

drivers/md/md-cluster.c

572

rdev = md_find_rdev_nr_rcu(mddev, le32_to_cpu(msg->raid_slot));

drivers/md/md-cluster.c

575

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md-cluster.c

576

md_wakeup_thread(mddev->thread);

drivers/md/md-cluster.c

584

static void process_readd_disk(struct mddev *mddev, struct cluster_msg *msg)

drivers/md/md-cluster.c

589

rdev = md_find_rdev_nr_rcu(mddev, le32_to_cpu(msg->raid_slot));

drivers/md/md-cluster.c

598

static int process_recvd_msg(struct mddev *mddev, struct cluster_msg *msg)

drivers/md/md-cluster.c

602

if (WARN(mddev->cluster_info->slot_number - 1 == le32_to_cpu(msg->slot),

drivers/md/md-cluster.c

607

process_metadata_update(mddev, msg);

drivers/md/md-cluster.c

610

set_capacity_and_notify(mddev->gendisk, mddev->array_sectors);

drivers/md/md-cluster.c

613

clear_bit(MD_CLUSTER_WAITING_FOR_SYNC, &mddev->cluster_info->state);

drivers/md/md-cluster.c

616

set_bit(MD_RESYNCING_REMOTE, &mddev->recovery);

drivers/md/md-cluster.c

617

process_suspend_info(mddev, le32_to_cpu(msg->slot),

drivers/md/md-cluster.c

622

if (process_add_new_disk(mddev, msg))

drivers/md/md-cluster.c

626

process_remove_disk(mddev, msg);

drivers/md/md-cluster.c

629

process_readd_disk(mddev, msg);

drivers/md/md-cluster.c

63

struct mddev *mddev; /* the md device which md_cluster_info belongs to */

drivers/md/md-cluster.c

632

__recover_slot(mddev, le32_to_cpu(msg->slot));

drivers/md/md-cluster.c

635

if (le64_to_cpu(msg->high) != mddev->pers->size(mddev, 0, 0))

drivers/md/md-cluster.c

636

ret = mddev->bitmap_ops->resize(mddev,

drivers/md/md-cluster.c

653

struct md_cluster_info *cinfo = thread->mddev->cluster_info;

drivers/md/md-cluster.c

669

ret = process_recvd_msg(thread->mddev, &msg);

drivers/md/md-cluster.c

718

struct mddev *mddev = cinfo->mddev;

drivers/md/md-cluster.c

731

md_wakeup_thread(mddev->thread);

drivers/md/md-cluster.c

824

static int gather_all_resync_info(struct mddev *mddev, int total_slots)

drivers/md/md-cluster.c

826

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

836

bm_lockres = lockres_init(mddev, str, NULL, 1);

drivers/md/md-cluster.c

847

if (read_resync_info(mddev, bm_lockres)) {

drivers/md/md-cluster.c

865

ret = mddev->bitmap_ops->copy_from_slot(mddev, i, &lo, &hi, false);

drivers/md/md-cluster.c

871

if ((hi > 0) && (lo < mddev->resync_offset)) {

drivers/md/md-cluster.c

872

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md-cluster.c

873

mddev->resync_offset = lo;

drivers/md/md-cluster.c

874

md_check_recovery(mddev);

drivers/md/md-cluster.c

883

static int join(struct mddev *mddev, int nodes)

drivers/md/md-cluster.c

900

mddev->cluster_info = cinfo;

drivers/md/md-cluster.c

901

cinfo->mddev = mddev;

drivers/md/md-cluster.c

904

sprintf(str, "%pU", mddev->uuid);

drivers/md/md-cluster.c

905

ret = dlm_new_lockspace(str, mddev->bitmap_info.cluster_name,

drivers/md/md-cluster.c

906

DLM_LSFL_SOFTIRQ, LVB_SIZE, &md_ls_ops, mddev,

drivers/md/md-cluster.c

920

md_register_thread(recv_daemon, mddev, "cluster_recv"));

drivers/md/md-cluster.c

925

cinfo->message_lockres = lockres_init(mddev, "message", NULL, 1);

drivers/md/md-cluster.c

928

cinfo->token_lockres = lockres_init(mddev, "token", NULL, 0);

drivers/md/md-cluster.c

931

cinfo->no_new_dev_lockres = lockres_init(mddev, "no-new-dev", NULL, 0);

drivers/md/md-cluster.c

941

cinfo->ack_lockres = lockres_init(mddev, "ack", ack_bast, 0);

drivers/md/md-cluster.c

958

cinfo->bitmap_lockres = lockres_init(mddev, str, NULL, 1);

drivers/md/md-cluster.c

969

cinfo->resync_lockres = lockres_init(mddev, "resync", NULL, 0);

drivers/md/md-cluster.c

978

md_unregister_thread(mddev, &cinfo->recovery_thread);

drivers/md/md-cluster.c

979

md_unregister_thread(mddev, &cinfo->recv_thread);

drivers/md/md-cluster.c

988

mddev->cluster_info = NULL;

drivers/md/md-cluster.c

993

static void load_bitmaps(struct mddev *mddev, int total_slots)

drivers/md/md-cluster.c

995

struct md_cluster_info *cinfo = mddev->cluster_info;

drivers/md/md-cluster.c

998

if (gather_all_resync_info(mddev, total_slots))

drivers/md/md-cluster.h

15

int (*join)(struct mddev *mddev, int nodes);

drivers/md/md-cluster.h

16

int (*leave)(struct mddev *mddev);

drivers/md/md-cluster.h

17

int (*slot_number)(struct mddev *mddev);

drivers/md/md-cluster.h

18

int (*resync_info_update)(struct mddev *mddev, sector_t lo, sector_t hi);

drivers/md/md-cluster.h

19

int (*resync_start_notify)(struct mddev *mddev);

drivers/md/md-cluster.h

20

int (*resync_status_get)(struct mddev *mddev);

drivers/md/md-cluster.h

21

void (*resync_info_get)(struct mddev *mddev, sector_t *lo, sector_t *hi);

drivers/md/md-cluster.h

22

int (*metadata_update_start)(struct mddev *mddev);

drivers/md/md-cluster.h

23

int (*metadata_update_finish)(struct mddev *mddev);

drivers/md/md-cluster.h

24

void (*metadata_update_cancel)(struct mddev *mddev);

drivers/md/md-cluster.h

25

int (*resync_start)(struct mddev *mddev);

drivers/md/md-cluster.h

26

int (*resync_finish)(struct mddev *mddev);

drivers/md/md-cluster.h

27

int (*area_resyncing)(struct mddev *mddev, int direction, sector_t lo, sector_t hi);

drivers/md/md-cluster.h

28

int (*add_new_disk)(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md-cluster.h

29

void (*add_new_disk_cancel)(struct mddev *mddev);

drivers/md/md-cluster.h

30

int (*new_disk_ack)(struct mddev *mddev, bool ack);

drivers/md/md-cluster.h

31

int (*remove_disk)(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md-cluster.h

32

void (*load_bitmaps)(struct mddev *mddev, int total_slots);

drivers/md/md-cluster.h

34

int (*resize_bitmaps)(struct mddev *mddev, sector_t newsize, sector_t oldsize);

drivers/md/md-cluster.h

35

int (*lock_all_bitmaps)(struct mddev *mddev);

drivers/md/md-cluster.h

36

void (*unlock_all_bitmaps)(struct mddev *mddev);

drivers/md/md-cluster.h

37

void (*update_size)(struct mddev *mddev, sector_t old_dev_sectors);

drivers/md/md-cluster.h

40

extern int md_setup_cluster(struct mddev *mddev, int nodes);

drivers/md/md-cluster.h

41

extern void md_cluster_stop(struct mddev *mddev);

drivers/md/md-cluster.h

42

extern void md_reload_sb(struct mddev *mddev, int raid_disk);

drivers/md/md-cluster.h

9

struct mddev;

drivers/md/md-linear.c

115

rdev_for_each(rdev, mddev) {

drivers/md/md-linear.c

122

mdname(mddev));

drivers/md/md-linear.c

127

if (mddev->chunk_sectors) {

drivers/md/md-linear.c

129

sector_div(sectors, mddev->chunk_sectors);

drivers/md/md-linear.c

130

rdev->sectors = sectors * mddev->chunk_sectors;

drivers/md/md-linear.c

138

mdname(mddev));

drivers/md/md-linear.c

152

if (!mddev_is_dm(mddev)) {

drivers/md/md-linear.c

153

ret = linear_set_limits(mddev);

drivers/md/md-linear.c

165

static int linear_run(struct mddev *mddev)

drivers/md/md-linear.c

170

if (md_check_no_bitmap(mddev))

drivers/md/md-linear.c

173

conf = linear_conf(mddev, mddev->raid_disks);

drivers/md/md-linear.c

177

mddev->private = conf;

drivers/md/md-linear.c

178

md_set_array_sectors(mddev, linear_size(mddev, 0, 0));

drivers/md/md-linear.c

180

ret = md_integrity_register(mddev);

drivers/md/md-linear.c

183

mddev->private = NULL;

drivers/md/md-linear.c

188

static int linear_add(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md-linear.c

200

if (rdev->saved_raid_disk != mddev->raid_disks)

drivers/md/md-linear.c

206

newconf = linear_conf(mddev, mddev->raid_disks + 1);

drivers/md/md-linear.c

216

oldconf = rcu_dereference_protected(mddev->private,

drivers/md/md-linear.c

217

lockdep_is_held(&mddev->reconfig_mutex));

drivers/md/md-linear.c

218

mddev->raid_disks++;

drivers/md/md-linear.c

219

WARN_ONCE(mddev->raid_disks != newconf->raid_disks,

drivers/md/md-linear.c

221

rcu_assign_pointer(mddev->private, newconf);

drivers/md/md-linear.c

222

md_set_array_sectors(mddev, linear_size(mddev, 0, 0));

drivers/md/md-linear.c

223

set_capacity_and_notify(mddev->gendisk, mddev->array_sectors);

drivers/md/md-linear.c

228

static void linear_free(struct mddev *mddev, void *priv)

drivers/md/md-linear.c

235

static bool linear_make_request(struct mddev *mddev, struct bio *bio)

drivers/md/md-linear.c

242

&& md_flush_request(mddev, bio))

drivers/md/md-linear.c

245

tmp_dev = which_dev(mddev, bio_sector);

drivers/md/md-linear.c

255

md_error(mddev, tmp_dev->rdev);

drivers/md/md-linear.c

263

&mddev->bio_set);

drivers/md/md-linear.c

268

md_account_bio(mddev, &bio);

drivers/md/md-linear.c

278

if (mddev->gendisk)

drivers/md/md-linear.c

279

trace_block_bio_remap(bio, disk_devt(mddev->gendisk),

drivers/md/md-linear.c

281

mddev_check_write_zeroes(mddev, bio);

drivers/md/md-linear.c

288

mdname(mddev),

drivers/md/md-linear.c

297

static void linear_status(struct seq_file *seq, struct mddev *mddev)

drivers/md/md-linear.c

299

seq_printf(seq, " %dk rounding", mddev->chunk_sectors / 2);

drivers/md/md-linear.c

30

static inline struct dev_info *which_dev(struct mddev *mddev, sector_t sector)

drivers/md/md-linear.c

302

static void linear_error(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md-linear.c

304

if (!test_and_set_bit(MD_BROKEN, &mddev->flags)) {

drivers/md/md-linear.c

305

char *md_name = mdname(mddev);

drivers/md/md-linear.c

312

static void linear_quiesce(struct mddev *mddev, int state)

drivers/md/md-linear.c

36

hi = mddev->raid_disks - 1;

drivers/md/md-linear.c

37

conf = mddev->private;

drivers/md/md-linear.c

55

static sector_t linear_size(struct mddev *mddev, sector_t sectors, int raid_disks)

drivers/md/md-linear.c

60

conf = mddev->private;

drivers/md/md-linear.c

68

static int linear_set_limits(struct mddev *mddev)

drivers/md/md-linear.c

74

lim.max_hw_sectors = mddev->chunk_sectors;

drivers/md/md-linear.c

75

lim.logical_block_size = mddev->logical_block_size;

drivers/md/md-linear.c

76

lim.max_write_zeroes_sectors = mddev->chunk_sectors;

drivers/md/md-linear.c

77

lim.max_hw_wzeroes_unmap_sectors = mddev->chunk_sectors;

drivers/md/md-linear.c

78

lim.io_min = mddev->chunk_sectors << 9;

drivers/md/md-linear.c

80

err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);

drivers/md/md-linear.c

84

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/md/md-linear.c

87

static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks)

drivers/md/md-llbitmap.c

1001

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1004

mddev->bitmap = NULL;

drivers/md/md-llbitmap.c

1010

static int llbitmap_resize(struct mddev *mddev, sector_t blocks, int chunksize)

drivers/md/md-llbitmap.c

1012

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1020

while (chunks > mddev->bitmap_info.space << SECTOR_SHIFT) {

drivers/md/md-llbitmap.c

1032

static int llbitmap_load(struct mddev *mddev)

drivers/md/md-llbitmap.c

1035

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1044

static void llbitmap_destroy(struct mddev *mddev)

drivers/md/md-llbitmap.c

1046

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1051

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1057

mddev->bitmap = NULL;

drivers/md/md-llbitmap.c

1060

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1063

static void llbitmap_start_write(struct mddev *mddev, sector_t offset,

drivers/md/md-llbitmap.c

1066

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1080

static void llbitmap_end_write(struct mddev *mddev, sector_t offset,

drivers/md/md-llbitmap.c

1083

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1095

static void llbitmap_start_discard(struct mddev *mddev, sector_t offset,

drivers/md/md-llbitmap.c

1098

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1112

static void llbitmap_end_discard(struct mddev *mddev, sector_t offset,

drivers/md/md-llbitmap.c

1115

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1146

md_super_wait(llbitmap->mddev);

drivers/md/md-llbitmap.c

1161

static void llbitmap_unplug(struct mddev *mddev, bool sync)

drivers/md/md-llbitmap.c

1164

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1190

static void __llbitmap_flush(struct mddev *mddev)

drivers/md/md-llbitmap.c

1192

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1206

md_super_wait(llbitmap->mddev);

drivers/md/md-llbitmap.c

1209

static void llbitmap_flush(struct mddev *mddev)

drivers/md/md-llbitmap.c

1211

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1221

__llbitmap_flush(mddev);

drivers/md/md-llbitmap.c

1225

static bool llbitmap_blocks_synced(struct mddev *mddev, sector_t offset)

drivers/md/md-llbitmap.c

1227

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1234

static sector_t llbitmap_skip_sync_blocks(struct mddev *mddev, sector_t offset)

drivers/md/md-llbitmap.c

1236

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1246

if (mddev->degraded)

drivers/md/md-llbitmap.c

1251

test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&

drivers/md/md-llbitmap.c

1252

!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))

drivers/md/md-llbitmap.c

1258

static bool llbitmap_start_sync(struct mddev *mddev, sector_t offset,

drivers/md/md-llbitmap.c

1261

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1274

static void llbitmap_end_sync(struct mddev *mddev, sector_t offset,

drivers/md/md-llbitmap.c

1277

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1286

static void llbitmap_close_sync(struct mddev *mddev)

drivers/md/md-llbitmap.c

1288

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1306

static void llbitmap_cond_end_sync(struct mddev *mddev, sector_t sector,

drivers/md/md-llbitmap.c

1309

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1317

HZ * mddev->bitmap_info.daemon_sleep))

drivers/md/md-llbitmap.c

1320

wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));

drivers/md/md-llbitmap.c

1322

mddev->curr_resync_completed = sector;

drivers/md/md-llbitmap.c

1323

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md-llbitmap.c

1326

__llbitmap_flush(mddev);

drivers/md/md-llbitmap.c

1329

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md-llbitmap.c

1339

static void llbitmap_dirty_bits(struct mddev *mddev, unsigned long s,

drivers/md/md-llbitmap.c

1342

llbitmap_state_machine(mddev->bitmap, s, e, BitmapActionStartwrite);

drivers/md/md-llbitmap.c

1351

md_super_wait(llbitmap->mddev);

drivers/md/md-llbitmap.c

1357

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

1367

mdname(mddev));

drivers/md/md-llbitmap.c

1372

if (mddev->events < llbitmap->events_cleared)

drivers/md/md-llbitmap.c

1373

llbitmap->events_cleared = mddev->events;

drivers/md/md-llbitmap.c

1376

sb->events = cpu_to_le64(mddev->events);

drivers/md/md-llbitmap.c

1379

sb->sync_size = cpu_to_le64(mddev->resync_max_sectors);

drivers/md/md-llbitmap.c

1381

sb->sectors_reserved = cpu_to_le32(mddev->bitmap_info.space);

drivers/md/md-llbitmap.c

1382

sb->daemon_sleep = cpu_to_le32(mddev->bitmap_info.daemon_sleep);

drivers/md/md-llbitmap.c

1406

static void llbitmap_write_all(struct mddev *mddev)

drivers/md/md-llbitmap.c

1409

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1419

static void llbitmap_start_behind_write(struct mddev *mddev)

drivers/md/md-llbitmap.c

1421

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1426

static void llbitmap_end_behind_write(struct mddev *mddev)

drivers/md/md-llbitmap.c

1428

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1434

static void llbitmap_wait_behind_writes(struct mddev *mddev)

drivers/md/md-llbitmap.c

1436

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1446

static ssize_t bits_show(struct mddev *mddev, char *page)

drivers/md/md-llbitmap.c

1452

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1453

llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1455

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1460

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1475

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1483

static ssize_t metadata_show(struct mddev *mddev, char *page)

drivers/md/md-llbitmap.c

1488

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1489

llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1491

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1497

llbitmap->chunks, mddev->bitmap_info.offset,

drivers/md/md-llbitmap.c

1498

llbitmap->mddev->bitmap_info.daemon_sleep);

drivers/md/md-llbitmap.c

1499

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1507

daemon_sleep_show(struct mddev *mddev, char *page)

drivers/md/md-llbitmap.c

1509

return sprintf(page, "%lu\n", mddev->bitmap_info.daemon_sleep);

drivers/md/md-llbitmap.c

1513

daemon_sleep_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-llbitmap.c

1521

mddev->bitmap_info.daemon_sleep = timeout;

drivers/md/md-llbitmap.c

1528

barrier_idle_show(struct mddev *mddev, char *page)

drivers/md/md-llbitmap.c

1530

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1536

barrier_idle_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md-llbitmap.c

1538

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

257

struct mddev *mddev;

drivers/md/md-llbitmap.c

350

static void __llbitmap_flush(struct mddev *mddev);

drivers/md/md-llbitmap.c

369

bool level_456 = raid_is_456(llbitmap->mddev);

drivers/md/md-llbitmap.c

401

if (llbitmap->mddev->degraded) {

drivers/md/md-llbitmap.c

446

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

459

rdev_for_each(rdev, mddev) {

drivers/md/md-llbitmap.c

465

sector = mddev->bitmap_info.offset +

drivers/md/md-llbitmap.c

472

md_error(mddev, rdev);

drivers/md/md-llbitmap.c

482

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

492

rdev_for_each(rdev, mddev) {

drivers/md/md-llbitmap.c

499

sector = mddev->bitmap_info.offset + rdev->sb_start +

drivers/md/md-llbitmap.c

502

md_write_metadata(mddev, rdev, sector,

drivers/md/md-llbitmap.c

605

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

607

bool level_456 = raid_is_456(llbitmap->mddev);

drivers/md/md-llbitmap.c

630

need_resync = !mddev->degraded;

drivers/md/md-llbitmap.c

635

if (unlikely(mddev->degraded)) {

drivers/md/md-llbitmap.c

662

need_resync = !mddev->degraded;

drivers/md/md-llbitmap.c

666

jiffies + mddev->bitmap_info.daemon_sleep * HZ);

drivers/md/md-llbitmap.c

675

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md-llbitmap.c

676

set_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md-llbitmap.c

677

md_wakeup_thread(mddev->thread);

drivers/md/md-llbitmap.c

679

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md-llbitmap.c

680

set_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md-llbitmap.c

681

md_wakeup_thread(mddev->thread);

drivers/md/md-llbitmap.c

715

llbitmap->mddev->bitmap_info.daemon_sleep * HZ)) {

drivers/md/md-llbitmap.c

732

static int llbitmap_check_support(struct mddev *mddev)

drivers/md/md-llbitmap.c

734

if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {

drivers/md/md-llbitmap.c

736

mdname(mddev));

drivers/md/md-llbitmap.c

740

if (mddev->bitmap_info.space == 0) {

drivers/md/md-llbitmap.c

741

if (mddev->bitmap_info.default_space == 0) {

drivers/md/md-llbitmap.c

743

mdname(mddev));

drivers/md/md-llbitmap.c

748

if (!mddev->persistent) {

drivers/md/md-llbitmap.c

750

mdname(mddev));

drivers/md/md-llbitmap.c

754

if (mddev->bitmap_info.file) {

drivers/md/md-llbitmap.c

756

mdname(mddev));

drivers/md/md-llbitmap.c

760

if (mddev->bitmap_info.external) {

drivers/md/md-llbitmap.c

762

mdname(mddev));

drivers/md/md-llbitmap.c

766

if (mddev_is_dm(mddev)) {

drivers/md/md-llbitmap.c

768

mdname(mddev));

drivers/md/md-llbitmap.c

777

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

778

sector_t blocks = mddev->resync_max_sectors;

drivers/md/md-llbitmap.c

781

unsigned long space = mddev->bitmap_info.space << SECTOR_SHIFT;

drivers/md/md-llbitmap.c

793

mddev->bitmap_info.daemon_sleep = DEFAULT_DAEMON_SLEEP;

drivers/md/md-llbitmap.c

802

__llbitmap_flush(mddev);

drivers/md/md-llbitmap.c

809

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

817

if (!mddev->bitmap_info.offset) {

drivers/md/md-llbitmap.c

818

pr_err("md/llbitmap: %s: no super block found", mdname(mddev));

drivers/md/md-llbitmap.c

825

mdname(mddev));

drivers/md/md-llbitmap.c

832

mdname(mddev));

drivers/md/md-llbitmap.c

838

mdname(mddev));

drivers/md/md-llbitmap.c

842

if (memcmp(sb->uuid, mddev->uuid, 16)) {

drivers/md/md-llbitmap.c

844

mdname(mddev));

drivers/md/md-llbitmap.c

848

if (mddev->bitmap_info.space == 0) {

drivers/md/md-llbitmap.c

852

mddev->bitmap_info.space = room;

drivers/md/md-llbitmap.c

854

mddev->bitmap_info.space = mddev->bitmap_info.default_space;

drivers/md/md-llbitmap.c

865

mdname(mddev));

drivers/md/md-llbitmap.c

869

if (chunksize < DIV_ROUND_UP_SECTOR_T(mddev->resync_max_sectors,

drivers/md/md-llbitmap.c

870

mddev->bitmap_info.space << SECTOR_SHIFT)) {

drivers/md/md-llbitmap.c

872

mdname(mddev), chunksize, mddev->resync_max_sectors,

drivers/md/md-llbitmap.c

873

mddev->bitmap_info.space);

drivers/md/md-llbitmap.c

880

mdname(mddev), daemon_sleep);

drivers/md/md-llbitmap.c

885

if (events < mddev->events) {

drivers/md/md-llbitmap.c

887

mdname(mddev), events, mddev->events);

drivers/md/md-llbitmap.c

891

sb->sync_size = cpu_to_le64(mddev->resync_max_sectors);

drivers/md/md-llbitmap.c

892

mddev->bitmap_info.chunksize = chunksize;

drivers/md/md-llbitmap.c

893

mddev->bitmap_info.daemon_sleep = daemon_sleep;

drivers/md/md-llbitmap.c

897

llbitmap->chunks = DIV_ROUND_UP_SECTOR_T(mddev->resync_max_sectors, chunksize);

drivers/md/md-llbitmap.c

914

mdname(llbitmap->mddev),

drivers/md/md-llbitmap.c

915

llbitmap->mddev->bitmap_info.daemon_sleep);

drivers/md/md-llbitmap.c

932

if (llbitmap->mddev->degraded)

drivers/md/md-llbitmap.c

955

mdname(llbitmap->mddev), __func__, idx);

drivers/md/md-llbitmap.c

973

jiffies + llbitmap->mddev->bitmap_info.daemon_sleep * HZ);

drivers/md/md-llbitmap.c

976

static int llbitmap_create(struct mddev *mddev)

drivers/md/md-llbitmap.c

981

ret = llbitmap_check_support(mddev);

drivers/md/md-llbitmap.c

989

llbitmap->mddev = mddev;

drivers/md/md-llbitmap.c

990

llbitmap->io_size = bdev_logical_block_size(mddev->gendisk->part0);

drivers/md/md-llbitmap.c

998

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

999

mddev->bitmap = llbitmap;

drivers/md/md.c

100

static void mddev_detach(struct mddev *mddev);

drivers/md/md.c

10000

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

10001

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/md.c

10002

clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/md.c

10005

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

10010

if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))

drivers/md/md.c

10019

struct mddev *mddev = container_of(ws, struct mddev, sync_work);

drivers/md/md.c

10028

if (mddev->reshape_position == MaxSector &&

drivers/md/md.c

10029

md_spares_need_change(mddev)) {

drivers/md/md.c

10031

mddev_suspend(mddev, false);

drivers/md/md.c

10034

mddev_lock_nointr(mddev);

drivers/md/md.c

10035

if (!md_is_rdwr(mddev)) {

drivers/md/md.c

10043

remove_and_add_spares(mddev, NULL);

drivers/md/md.c

10047

if (!md_choose_sync_action(mddev, &spares))

drivers/md/md.c

10050

if (!mddev->pers->sync_request)

drivers/md/md.c

10057

if (spares && md_bitmap_enabled(mddev, true))

drivers/md/md.c

10058

mddev->bitmap_ops->write_all(mddev);

drivers/md/md.c

1006

struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev)

drivers/md/md.c

10060

name = test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ?

drivers/md/md.c

10062

rcu_assign_pointer(mddev->sync_thread,

drivers/md/md.c

10063

md_register_thread(md_do_sync, mddev, name));

drivers/md/md.c

10064

if (!mddev->sync_thread) {

drivers/md/md.c

10066

mdname(mddev));

drivers/md/md.c

10071

mddev_unlock(mddev);

drivers/md/md.c

10079

__mddev_resume(mddev, false);

drivers/md/md.c

10080

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

10081

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

10086

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

10087

clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/md.c

10088

clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/md.c

10089

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/md.c

10090

clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10091

mddev_unlock(mddev);

drivers/md/md.c

10099

__mddev_resume(mddev, false);

drivers/md/md.c

101

static void export_rdev(struct md_rdev *rdev, struct mddev *mddev);

drivers/md/md.c

1010

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.c

10102

if (test_and_clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&

drivers/md/md.c

10103

mddev->sysfs_action)

drivers/md/md.c

10104

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

10107

static void unregister_sync_thread(struct mddev *mddev)

drivers/md/md.c

10109

if (!test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {

drivers/md/md.c

10111

clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10115

if (WARN_ON_ONCE(!mddev->sync_thread))

drivers/md/md.c

10118

md_reap_sync_thread(mddev);

drivers/md/md.c

10121

static bool md_should_do_recovery(struct mddev *mddev)

drivers/md/md.c

10127

if (test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||

drivers/md/md.c

10128

test_bit(MD_RECOVERY_DONE, &mddev->recovery))

drivers/md/md.c

10135

if (!md_is_rdwr(mddev))

drivers/md/md.c

10143

if (mddev->sb_flags & ~ (1<<MD_SB_CHANGE_PENDING))

drivers/md/md.c

10151

if (mddev->external == 0 && mddev->safemode == 1)

drivers/md/md.c

10160

if (mddev->safemode == 2 && !mddev->in_sync &&

drivers/md/md.c

10161

mddev->resync_offset == MaxSector)

drivers/md/md.c

10189

void md_check_recovery(struct mddev *mddev)

drivers/md/md.c

10191

if (md_bitmap_enabled(mddev, false) && mddev->bitmap_ops->daemon_work)

drivers/md/md.c

10192

mddev->bitmap_ops->daemon_work(mddev);

drivers/md/md.c

10195

if (mddev->pers->sync_request && !mddev->external) {

drivers/md/md.c

10197

mdname(mddev));

drivers/md/md.c

10198

mddev->safemode = 2;

drivers/md/md.c

10203

if (!md_should_do_recovery(mddev))

drivers/md/md.c

10206

if (mddev_trylock(mddev)) {

drivers/md/md.c

10207

bool try_set_sync = mddev->safemode != 0;

drivers/md/md.c

10209

if (!mddev->external && mddev->safemode == 1)

drivers/md/md.c

10210

mddev->safemode = 0;

drivers/md/md.c

10212

if (!md_is_rdwr(mddev)) {

drivers/md/md.c

10215

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {

drivers/md/md.c

10216

unregister_sync_thread(mddev);

drivers/md/md.c

10220

if (!mddev->external && mddev->in_sync)

drivers/md/md.c

10227

rdev_for_each(rdev, mddev)

drivers/md/md.c

10234

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

10235

md_reap_sync_thread(mddev);

drivers/md/md.c

10241

if (md_spares_need_change(mddev)) {

drivers/md/md.c

10242

set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10243

queue_work(md_misc_wq, &mddev->sync_work);

drivers/md/md.c

10246

clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

10247

clear_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md.c

10248

clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10249

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

10254

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

10259

rdev_for_each_safe(rdev, tmp, mddev) {

drivers/md/md.c

10266

if (try_set_sync && !mddev->external && !mddev->in_sync) {

drivers/md/md.c

10267

spin_lock(&mddev->lock);

drivers/md/md.c

10268

set_in_sync(mddev);

drivers/md/md.c

10269

spin_unlock(&mddev->lock);

drivers/md/md.c

10272

if (mddev->sb_flags)

drivers/md/md.c

10273

md_update_sb(mddev, 0);

drivers/md/md.c

10279

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {

drivers/md/md.c

10280

unregister_sync_thread(mddev);

drivers/md/md.c

10287

mddev->curr_resync_completed = 0;

drivers/md/md.c

10288

spin_lock(&mddev->lock);

drivers/md/md.c

10289

set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10290

spin_unlock(&mddev->lock);

drivers/md/md.c

10294

clear_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

10295

clear_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/md.c

10297

if (test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) &&

drivers/md/md.c

10298

!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {

drivers/md/md.c

10299

queue_work(md_misc_wq, &mddev->sync_work);

drivers/md/md.c

10301

clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10306

wake_up(&mddev->sb_wait);

drivers/md/md.c

10307

mddev_unlock(mddev);

drivers/md/md.c

10312

void md_reap_sync_thread(struct mddev *mddev)

drivers/md/md.c

10315

sector_t old_dev_sectors = mddev->dev_sectors;

drivers/md/md.c

10316

bool is_reshaped = test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/md.c

10319

md_unregister_thread(mddev, &mddev->sync_thread);

drivers/md/md.c

10320

atomic_inc(&mddev->sync_seq);

drivers/md/md.c

10322

if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&

drivers/md/md.c

10323

!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&

drivers/md/md.c

10324

mddev->degraded != mddev->raid_disks) {

drivers/md/md.c

10327

if (mddev->pers->spare_active(mddev)) {

drivers/md/md.c

10328

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

10329

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

10336

if (!mddev->degraded)

drivers/md/md.c

10337

rdev_for_each(rdev, mddev)

drivers/md/md.c

10340

md_update_sb(mddev, 1);

drivers/md/md.c

10344

if (test_and_clear_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags))

drivers/md/md.c

10345

mddev->cluster_ops->resync_finish(mddev);

drivers/md/md.c

10346

clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10347

clear_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/md.c

10348

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

10349

clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/md.c

10350

clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/md.c

10351

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/md.c

10352

clear_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md.c

10358

if (mddev_is_clustered(mddev) && is_reshaped &&

drivers/md/md.c

10359

mddev->pers->finish_reshape &&

drivers/md/md.c

10360

!test_bit(MD_CLOSING, &mddev->flags))

drivers/md/md.c

10361

mddev->cluster_ops->update_size(mddev, old_dev_sectors);

drivers/md/md.c

10363

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10364

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

10365

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

10367

if (mddev->event_work.func)

drivers/md/md.c

10368

queue_work(md_misc_wq, &mddev->event_work);

drivers/md/md.c

10373

void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)

drivers/md/md.c

10378

rdev_dec_pending(rdev, mddev);

drivers/md/md.c

10382

void md_finish_reshape(struct mddev *mddev)

drivers/md/md.c

10387

rdev_for_each(rdev, mddev) {

drivers/md/md.c

10403

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

10425

md_error(mddev, rdev);

drivers/md/md.c

10433

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/md.c

10435

md_wakeup_thread(rdev->mddev->thread);

drivers/md/md.c

10459

struct mddev *mddev;

drivers/md/md.c

10462

list_for_each_entry(mddev, &all_mddevs, all_mddevs) {

drivers/md/md.c

10463

if (!mddev_get(mddev))

drivers/md/md.c

10466

if (mddev_trylock(mddev)) {

drivers/md/md.c

10467

if (mddev->pers)

drivers/md/md.c

10468

__md_stop_writes(mddev);

drivers/md/md.c

10469

if (mddev->persistent)

drivers/md/md.c

10470

mddev->safemode = 2;

drivers/md/md.c

10471

mddev_unlock(mddev);

drivers/md/md.c

10474

mddev_put_locked(mddev);

drivers/md/md.c

10542

static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

10552

if (mddev->dev_sectors != le64_to_cpu(sb->size)) {

drivers/md/md.c

10553

ret = mddev->pers->resize(mddev, le64_to_cpu(sb->size));

drivers/md/md.c

10556

else if (md_bitmap_enabled(mddev, false))

drivers/md/md.c

10557

mddev->bitmap_ops->update_sb(mddev->bitmap);

drivers/md/md.c

10561

rdev_for_each_safe(rdev2, tmp, mddev) {

drivers/md/md.c

10564

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10589

!mddev->cluster_ops->resync_status_get(mddev)) {

drivers/md/md.c

10600

ret = remove_and_add_spares(mddev, rdev2);

drivers/md/md.c

10605

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10606

md_wakeup_thread(mddev->thread);

drivers/md/md.c

10615

md_error(mddev, rdev2);

drivers/md/md.c

10621

if (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) {

drivers/md/md.c

10622

ret = update_raid_disks(mddev, le32_to_cpu(sb->raid_disks));

drivers/md/md.c

10631

if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&

drivers/md/md.c

10637

mddev->reshape_position = le64_to_cpu(sb->reshape_position);

drivers/md/md.c

10638

if (mddev->pers->update_reshape_pos)

drivers/md/md.c

10639

mddev->pers->update_reshape_pos(mddev);

drivers/md/md.c

10640

if (mddev->pers->start_reshape)

drivers/md/md.c

10641

mddev->pers->start_reshape(mddev);

drivers/md/md.c

10642

} else if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&

drivers/md/md.c

10643

mddev->reshape_position != MaxSector &&

drivers/md/md.c

10646

mddev->reshape_position = MaxSector;

drivers/md/md.c

10647

if (mddev->pers->update_reshape_pos)

drivers/md/md.c

10648

mddev->pers->update_reshape_pos(mddev);

drivers/md/md.c

10652

mddev->events = le64_to_cpu(sb->events);

drivers/md/md.c

10655

static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

10669

err = super_types[mddev->major_version].

drivers/md/md.c

10670

load_super(rdev, NULL, mddev->minor_version);

drivers/md/md.c

10695

mddev->pers->spare_active(mddev))

drivers/md/md.c

10696

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

10702

void md_reload_sb(struct mddev *mddev, int nr)

drivers/md/md.c

10708

rdev_for_each_rcu(iter, mddev) {

drivers/md/md.c

10720

err = read_rdev(mddev, rdev);

drivers/md/md.c

10724

check_sb_changes(mddev, rdev);

drivers/md/md.c

10727

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

10729

read_rdev(mddev, rdev);

drivers/md/md.c

10805

struct mddev *mddev;

drivers/md/md.c

10826

list_for_each_entry(mddev, &all_mddevs, all_mddevs) {

drivers/md/md.c

10827

if (!mddev_get(mddev))

drivers/md/md.c

10830

export_array(mddev);

drivers/md/md.c

10831

mddev->ctime = 0;

drivers/md/md.c

10832

mddev->hold_active = 0;

drivers/md/md.c

10839

mddev_put_locked(mddev);

drivers/md/md.c

1088

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

1093

md_error(mddev, rdev);

drivers/md/md.c

1096

set_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags);

drivers/md/md.c

1104

rdev_dec_pending(rdev, mddev);

drivers/md/md.c

1106

if (atomic_dec_and_test(&mddev->pending_writes))

drivers/md/md.c

1107

wake_up(&mddev->sb_wait);

drivers/md/md.c

1126

void md_write_metadata(struct mddev *mddev, struct md_rdev *rdev,

drivers/md/md.c

1142

GFP_NOIO, &mddev->sync_set);

drivers/md/md.c

1151

if (test_bit(MD_FAILFAST_SUPPORTED, &mddev->flags) &&

drivers/md/md.c

1156

atomic_inc(&mddev->pending_writes);

drivers/md/md.c

1160

int md_super_wait(struct mddev *mddev)

drivers/md/md.c

1163

wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);

drivers/md/md.c

1164

if (test_and_clear_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags))

drivers/md/md.c

1182

else if (rdev->mddev->reshape_position != MaxSector &&

drivers/md/md.c

1183

(rdev->mddev->reshape_backwards ==

drivers/md/md.c

1184

(sector >= rdev->mddev->reshape_position)))

drivers/md/md.c

1321

int (*validate_super)(struct mddev *mddev,

drivers/md/md.c

1324

void (*sync_super)(struct mddev *mddev,

drivers/md/md.c

1340

int md_check_no_bitmap(struct mddev *mddev)

drivers/md/md.c

1342

if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)

drivers/md/md.c

1345

mdname(mddev), mddev->pers->head.name);

drivers/md/md.c

137

static int speed_min(struct mddev *mddev)

drivers/md/md.c

139

return mddev->sync_speed_min ?

drivers/md/md.c

140

mddev->sync_speed_min : sysctl_speed_limit_min;

drivers/md/md.c

143

static int speed_max(struct mddev *mddev)

drivers/md/md.c

145

return mddev->sync_speed_max ?

drivers/md/md.c

1452

static u64 md_bitmap_events_cleared(struct mddev *mddev)

drivers/md/md.c

1457

if (!md_bitmap_enabled(mddev, false))

drivers/md/md.c

146

mddev->sync_speed_max : sysctl_speed_limit_max;

drivers/md/md.c

1460

err = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/md.c

1471

static int super_90_validate(struct mddev *mddev, struct md_rdev *freshest, struct md_rdev *rdev)

drivers/md/md.c

1483

if (mddev->raid_disks == 0) {

drivers/md/md.c

1484

mddev->major_version = 0;

drivers/md/md.c

1485

mddev->minor_version = sb->minor_version;

drivers/md/md.c

1486

mddev->patch_version = sb->patch_version;

drivers/md/md.c

1487

mddev->external = 0;

drivers/md/md.c

1488

mddev->chunk_sectors = sb->chunk_size >> 9;

drivers/md/md.c

1489

mddev->ctime = sb->ctime;

drivers/md/md.c

149

static int sync_io_depth(struct mddev *mddev)

drivers/md/md.c

1490

mddev->utime = sb->utime;

drivers/md/md.c

1491

mddev->level = sb->level;

drivers/md/md.c

1492

mddev->clevel[0] = 0;

drivers/md/md.c

1493

mddev->layout = sb->layout;

drivers/md/md.c

1494

mddev->raid_disks = sb->raid_disks;

drivers/md/md.c

1495

mddev->dev_sectors = ((sector_t)sb->size) * 2;

drivers/md/md.c

1496

mddev->events = ev1;

drivers/md/md.c

1497

mddev->bitmap_info.offset = 0;

drivers/md/md.c

1498

mddev->bitmap_info.space = 0;

drivers/md/md.c

1500

mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;

drivers/md/md.c

1501

mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);

drivers/md/md.c

1502

mddev->reshape_backwards = 0;

drivers/md/md.c

1504

if (mddev->minor_version >= 91) {

drivers/md/md.c

1505

mddev->reshape_position = sb->reshape_position;

drivers/md/md.c

1506

mddev->delta_disks = sb->delta_disks;

drivers/md/md.c

1507

mddev->new_level = sb->new_level;

drivers/md/md.c

1508

mddev->new_layout = sb->new_layout;

drivers/md/md.c

1509

mddev->new_chunk_sectors = sb->new_chunk >> 9;

drivers/md/md.c

151

return mddev->sync_io_depth ?

drivers/md/md.c

1510

if (mddev->delta_disks < 0)

drivers/md/md.c

1511

mddev->reshape_backwards = 1;

drivers/md/md.c

1513

mddev->reshape_position = MaxSector;

drivers/md/md.c

1514

mddev->delta_disks = 0;

drivers/md/md.c

1515

mddev->new_level = mddev->level;

drivers/md/md.c

1516

mddev->new_layout = mddev->layout;

drivers/md/md.c

1517

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

1519

if (mddev->level == 0)

drivers/md/md.c

152

mddev->sync_io_depth : sysctl_sync_io_depth;

drivers/md/md.c

1520

mddev->layout = -1;

drivers/md/md.c

1523

mddev->resync_offset = MaxSector;

drivers/md/md.c

1527

mddev->resync_offset = sb->recovery_cp;

drivers/md/md.c

1529

mddev->resync_offset = 0;

drivers/md/md.c

1532

memcpy(mddev->uuid+0, &sb->set_uuid0, 4);

drivers/md/md.c

1533

memcpy(mddev->uuid+4, &sb->set_uuid1, 4);

drivers/md/md.c

1534

memcpy(mddev->uuid+8, &sb->set_uuid2, 4);

drivers/md/md.c

1535

memcpy(mddev->uuid+12,&sb->set_uuid3, 4);

drivers/md/md.c

1537

mddev->max_disks = MD_SB_DISKS;

drivers/md/md.c

1540

mddev->bitmap_info.file == NULL) {

drivers/md/md.c

1541

mddev->bitmap_info.offset =

drivers/md/md.c

1542

mddev->bitmap_info.default_offset;

drivers/md/md.c

1543

mddev->bitmap_info.space =

drivers/md/md.c

1544

mddev->bitmap_info.default_space;

drivers/md/md.c

1547

} else if (mddev->pers == NULL) {

drivers/md/md.c

1553

if (ev1 < mddev->events)

drivers/md/md.c

1555

} else if (mddev->bitmap) {

drivers/md/md.c

1559

if (ev1 < md_bitmap_events_cleared(mddev))

drivers/md/md.c

1561

if (ev1 < mddev->events)

drivers/md/md.c

1564

if (ev1 < mddev->events)

drivers/md/md.c

1582

if (mddev->minor_version >= 91) {

drivers/md/md.c

1597

static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

1601

int next_spare = mddev->raid_disks;

drivers/md/md.c

1623

sb->major_version = mddev->major_version;

drivers/md/md.c

1624

sb->patch_version = mddev->patch_version;

drivers/md/md.c

1626

memcpy(&sb->set_uuid0, mddev->uuid+0, 4);

drivers/md/md.c

1627

memcpy(&sb->set_uuid1, mddev->uuid+4, 4);

drivers/md/md.c

1628

memcpy(&sb->set_uuid2, mddev->uuid+8, 4);

drivers/md/md.c

1629

memcpy(&sb->set_uuid3, mddev->uuid+12,4);

drivers/md/md.c

1631

sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);

drivers/md/md.c

1632

sb->level = mddev->level;

drivers/md/md.c

1633

sb->size = mddev->dev_sectors / 2;

drivers/md/md.c

1634

sb->raid_disks = mddev->raid_disks;

drivers/md/md.c

1635

sb->md_minor = mddev->md_minor;

drivers/md/md.c

1637

sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);

drivers/md/md.c

1639

sb->events_hi = (mddev->events>>32);

drivers/md/md.c

164

static void rdevs_uninit_serial(struct mddev *mddev)

drivers/md/md.c

1640

sb->events_lo = (u32)mddev->events;

drivers/md/md.c

1642

if (mddev->reshape_position == MaxSector)

drivers/md/md.c

1646

sb->reshape_position = mddev->reshape_position;

drivers/md/md.c

1647

sb->new_level = mddev->new_level;

drivers/md/md.c

1648

sb->delta_disks = mddev->delta_disks;

drivers/md/md.c

1649

sb->new_layout = mddev->new_layout;

drivers/md/md.c

1650

sb->new_chunk = mddev->new_chunk_sectors << 9;

drivers/md/md.c

1652

mddev->minor_version = sb->minor_version;

drivers/md/md.c

1653

if (mddev->in_sync)

drivers/md/md.c

1655

sb->recovery_cp = mddev->resync_offset;

drivers/md/md.c

1656

sb->cp_events_hi = (mddev->events>>32);

drivers/md/md.c

1657

sb->cp_events_lo = (u32)mddev->events;

drivers/md/md.c

1658

if (mddev->resync_offset == MaxSector)

drivers/md/md.c

1663

sb->layout = mddev->layout;

drivers/md/md.c

1664

sb->chunk_size = mddev->chunk_sectors << 9;

drivers/md/md.c

1666

if (mddev->bitmap && mddev->bitmap_info.file == NULL)

drivers/md/md.c

1670

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

168

rdev_for_each(rdev, mddev)

drivers/md/md.c

1718

for (i=0 ; i < mddev->raid_disks ; i++) {

drivers/md/md.c

1744

if (num_sectors && num_sectors < rdev->mddev->dev_sectors)

drivers/md/md.c

1746

if (rdev->mddev->bitmap_info.offset)

drivers/md/md.c

1754

if ((u64)num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)

drivers/md/md.c

1757

md_write_metadata(rdev->mddev, rdev, rdev->sb_start,

drivers/md/md.c

1759

} while (md_super_wait(rdev->mddev) < 0);

drivers/md/md.c

1979

static int super_1_validate(struct mddev *mddev, struct md_rdev *freshest, struct md_rdev *rdev)

drivers/md/md.c

1991

if (mddev->raid_disks == 0) {

drivers/md/md.c

1992

mddev->major_version = 1;

drivers/md/md.c

1993

mddev->patch_version = 0;

drivers/md/md.c

1994

mddev->external = 0;

drivers/md/md.c

1995

mddev->chunk_sectors = le32_to_cpu(sb->chunksize);

drivers/md/md.c

1996

mddev->ctime = le64_to_cpu(sb->ctime);

drivers/md/md.c

1997

mddev->utime = le64_to_cpu(sb->utime);

drivers/md/md.c

1998

mddev->level = le32_to_cpu(sb->level);

drivers/md/md.c

1999

mddev->clevel[0] = 0;

drivers/md/md.c

200

static int rdevs_init_serial(struct mddev *mddev)

drivers/md/md.c

2000

mddev->layout = le32_to_cpu(sb->layout);

drivers/md/md.c

2001

mddev->raid_disks = le32_to_cpu(sb->raid_disks);

drivers/md/md.c

2002

mddev->dev_sectors = le64_to_cpu(sb->size);

drivers/md/md.c

2003

mddev->events = ev1;

drivers/md/md.c

2004

mddev->bitmap_info.offset = 0;

drivers/md/md.c

2005

mddev->bitmap_info.space = 0;

drivers/md/md.c

2009

mddev->bitmap_info.default_offset = 1024 >> 9;

drivers/md/md.c

2010

mddev->bitmap_info.default_space = (4096-1024) >> 9;

drivers/md/md.c

2011

mddev->reshape_backwards = 0;

drivers/md/md.c

2013

mddev->resync_offset = le64_to_cpu(sb->resync_offset);

drivers/md/md.c

2014

memcpy(mddev->uuid, sb->set_uuid, 16);

drivers/md/md.c

2016

mddev->max_disks = (4096-256)/2;

drivers/md/md.c

2018

if (!mddev->logical_block_size)

drivers/md/md.c

2019

mddev->logical_block_size = le32_to_cpu(sb->logical_block_size);

drivers/md/md.c

2022

mddev->bitmap_info.file == NULL) {

drivers/md/md.c

2023

mddev->bitmap_info.offset =

drivers/md/md.c

2030

if (mddev->minor_version > 0)

drivers/md/md.c

2031

mddev->bitmap_info.space = 0;

drivers/md/md.c

2032

else if (mddev->bitmap_info.offset > 0)

drivers/md/md.c

2033

mddev->bitmap_info.space =

drivers/md/md.c

2034

8 - mddev->bitmap_info.offset;

drivers/md/md.c

2036

mddev->bitmap_info.space =

drivers/md/md.c

2037

-mddev->bitmap_info.offset;

drivers/md/md.c

2041

mddev->reshape_position = le64_to_cpu(sb->reshape_position);

drivers/md/md.c

2042

mddev->delta_disks = le32_to_cpu(sb->delta_disks);

drivers/md/md.c

2043

mddev->new_level = le32_to_cpu(sb->new_level);

drivers/md/md.c

2044

mddev->new_layout = le32_to_cpu(sb->new_layout);

drivers/md/md.c

2045

mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);

drivers/md/md.c

2046

if (mddev->delta_disks < 0 ||

drivers/md/md.c

2047

(mddev->delta_disks == 0 &&

drivers/md/md.c

205

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2050

mddev->reshape_backwards = 1;

drivers/md/md.c

2052

mddev->reshape_position = MaxSector;

drivers/md/md.c

2053

mddev->delta_disks = 0;

drivers/md/md.c

2054

mddev->new_level = mddev->level;

drivers/md/md.c

2055

mddev->new_layout = mddev->layout;

drivers/md/md.c

2056

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

2059

if (mddev->level == 0 &&

drivers/md/md.c

2061

mddev->layout = -1;

drivers/md/md.c

2064

set_bit(MD_HAS_JOURNAL, &mddev->flags);

drivers/md/md.c

2075

set_bit(MD_HAS_PPL, &mddev->flags);

drivers/md/md.c

2077

} else if (mddev->pers == NULL) {

drivers/md/md.c

2087

if (ev1 + 1 < mddev->events)

drivers/md/md.c

2089

} else if (mddev->bitmap) {

drivers/md/md.c

2093

if (ev1 < md_bitmap_events_cleared(mddev))

drivers/md/md.c

2095

if (ev1 < mddev->events)

drivers/md/md.c

2098

if (ev1 < mddev->events)

drivers/md/md.c

2107

} else if (mddev->pers == NULL && freshest && ev1 < mddev->events) {

drivers/md/md.c

212

if (ret && !mddev->serial_info_pool)

drivers/md/md.c

2128

mdname(mddev), rdev->bdev, rdev->desc_nr,

drivers/md/md.c

213

rdevs_uninit_serial(mddev);

drivers/md/md.c

2135

mdname(mddev), rdev->bdev, role, role, freshest->bdev);

drivers/md/md.c

2169

&mddev->recovery))

drivers/md/md.c

2185

static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

2199

sb->utime = cpu_to_le64((__u64)mddev->utime);

drivers/md/md.c

2200

sb->events = cpu_to_le64(mddev->events);

drivers/md/md.c

2201

if (mddev->in_sync)

drivers/md/md.c

2202

sb->resync_offset = cpu_to_le64(mddev->resync_offset);

drivers/md/md.c

2203

else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags))

drivers/md/md.c

2210

sb->raid_disks = cpu_to_le32(mddev->raid_disks);

drivers/md/md.c

2211

sb->size = cpu_to_le64(mddev->dev_sectors);

drivers/md/md.c

2212

sb->chunksize = cpu_to_le32(mddev->chunk_sectors);

drivers/md/md.c

2213

sb->level = cpu_to_le32(mddev->level);

drivers/md/md.c

2214

sb->layout = cpu_to_le32(mddev->layout);

drivers/md/md.c

2215

sb->logical_block_size = cpu_to_le32(mddev->logical_block_size);

drivers/md/md.c

2228

if (mddev->bitmap && mddev->bitmap_info.file == NULL) {

drivers/md/md.c

2229

sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);

drivers/md/md.c

2239

if (rdev->saved_raid_disk >= 0 && mddev->bitmap)

drivers/md/md.c

225

return (rdev && rdev->mddev->bitmap_info.max_write_behind > 0 &&

drivers/md/md.c

2250

if (mddev->reshape_position != MaxSector) {

drivers/md/md.c

2252

sb->reshape_position = cpu_to_le64(mddev->reshape_position);

drivers/md/md.c

2253

sb->new_layout = cpu_to_le32(mddev->new_layout);

drivers/md/md.c

2254

sb->delta_disks = cpu_to_le32(mddev->delta_disks);

drivers/md/md.c

2255

sb->new_level = cpu_to_le32(mddev->new_level);

drivers/md/md.c

2256

sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);

drivers/md/md.c

2257

if (mddev->delta_disks == 0 &&

drivers/md/md.c

2258

mddev->reshape_backwards)

drivers/md/md.c

2269

if (mddev_is_clustered(mddev))

drivers/md/md.c

2276

md_error(mddev, rdev);

drivers/md/md.c

2307

rdev_for_each(rdev2, mddev)

drivers/md/md.c

2324

if (test_bit(MD_HAS_JOURNAL, &mddev->flags))

drivers/md/md.c

2327

if (test_bit(MD_HAS_PPL, &mddev->flags)) {

drivers/md/md.c

2328

if (test_bit(MD_HAS_MULTIPLE_PPLS, &mddev->flags))

drivers/md/md.c

2337

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

235

void mddev_create_serial_pool(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

2377

if (num_sectors && num_sectors < rdev->mddev->dev_sectors)

drivers/md/md.c

2386

} else if (rdev->mddev->bitmap_info.offset) {

drivers/md/md.c

2414

md_write_metadata(rdev->mddev, rdev, rdev->sb_start,

drivers/md/md.c

2416

} while (md_super_wait(rdev->mddev) < 0);

drivers/md/md.c

2425

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

2433

if (mddev->minor_version == 0)

drivers/md/md.c

244

ret = rdevs_init_serial(mddev);

drivers/md/md.c

2445

if (md_bitmap_registered(mddev) && !mddev->bitmap_info.file) {

drivers/md/md.c

2449

err = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/md.c

2450

if (!err && rdev->sb_start + mddev->bitmap_info.offset +

drivers/md/md.c

2482

static void sync_super(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

2484

if (mddev->sync_super) {

drivers/md/md.c

2485

mddev->sync_super(mddev, rdev);

drivers/md/md.c

2489

BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));

drivers/md/md.c

2491

super_types[mddev->major_version].sync_super(mddev, rdev);

drivers/md/md.c

2494

static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)

drivers/md/md.c

250

if (mddev->serial_info_pool == NULL) {

drivers/md/md.c

2528

int md_integrity_register(struct mddev *mddev)

drivers/md/md.c

2530

if (list_empty(&mddev->disks))

drivers/md/md.c

2532

if (mddev_is_dm(mddev) || !blk_get_integrity(mddev->gendisk))

drivers/md/md.c

2535

pr_debug("md: data integrity enabled on %s\n", mdname(mddev));

drivers/md/md.c

2546

static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)

drivers/md/md.c

255

mddev->serial_info_pool =

drivers/md/md.c

2552

if (find_rdev(mddev, rdev->bdev->bd_dev))

drivers/md/md.c

2555

if (rdev_read_only(rdev) && mddev->pers)

drivers/md/md.c

2561

(mddev->dev_sectors == 0 || rdev->sectors < mddev->dev_sectors)) {

drivers/md/md.c

2562

if (mddev->pers) {

drivers/md/md.c

2567

if (mddev->level > 0)

drivers/md/md.c

2570

mddev->dev_sectors = rdev->sectors;

drivers/md/md.c

258

if (!mddev->serial_info_pool) {

drivers/md/md.c

2580

if (mddev->pers)

drivers/md/md.c

2581

choice = mddev->raid_disks;

drivers/md/md.c

2582

while (md_find_rdev_nr_rcu(mddev, choice))

drivers/md/md.c

2586

if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {

drivers/md/md.c

259

rdevs_uninit_serial(mddev);

drivers/md/md.c

2593

mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {

drivers/md/md.c

2595

mdname(mddev), mddev->max_disks);

drivers/md/md.c

2601

rdev->mddev = mddev;

drivers/md/md.c

2604

if (mddev->raid_disks)

drivers/md/md.c

2605

mddev_create_serial_pool(mddev, rdev);

drivers/md/md.c

2607

if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))

drivers/md/md.c

2618

list_add_rcu(&rdev->same_set, &mddev->disks);

drivers/md/md.c

2619

bd_link_disk_holder(rdev->bdev, mddev->gendisk);

drivers/md/md.c

2625

b, mdname(mddev));

drivers/md/md.c

2626

mddev_destroy_serial_pool(mddev, rdev);

drivers/md/md.c

2635

static void export_rdev(struct md_rdev *rdev, struct mddev *mddev)

drivers/md/md.c

2650

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

2652

bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);

drivers/md/md.c

2655

mddev_destroy_serial_pool(rdev->mddev, rdev);

drivers/md/md.c

2656

WRITE_ONCE(rdev->mddev, NULL);

drivers/md/md.c

2673

list_add(&rdev->same_set, &mddev->deleting);

drivers/md/md.c

2676

static void export_array(struct mddev *mddev)

drivers/md/md.c

2680

while (!list_empty(&mddev->disks)) {

drivers/md/md.c

2681

rdev = list_first_entry(&mddev->disks, struct md_rdev,

drivers/md/md.c

2685

mddev->raid_disks = 0;

drivers/md/md.c

2686

mddev->major_version = 0;

drivers/md/md.c

2689

static bool set_in_sync(struct mddev *mddev)

drivers/md/md.c

2691

lockdep_assert_held(&mddev->lock);

drivers/md/md.c

2692

if (!mddev->in_sync) {

drivers/md/md.c

2693

mddev->sync_checkers++;

drivers/md/md.c

2694

spin_unlock(&mddev->lock);

drivers/md/md.c

2695

percpu_ref_switch_to_atomic_sync(&mddev->writes_pending);

drivers/md/md.c

2696

spin_lock(&mddev->lock);

drivers/md/md.c

2697

if (!mddev->in_sync &&

drivers/md/md.c

2698

percpu_ref_is_zero(&mddev->writes_pending)) {

drivers/md/md.c

2699

mddev->in_sync = 1;

drivers/md/md.c

2705

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

2706

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

2708

if (--mddev->sync_checkers == 0)

drivers/md/md.c

2709

percpu_ref_switch_to_percpu(&mddev->writes_pending);

drivers/md/md.c

271

void mddev_destroy_serial_pool(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

2711

if (mddev->safemode == 1)

drivers/md/md.c

2712

mddev->safemode = 0;

drivers/md/md.c

2713

return mddev->in_sync;

drivers/md/md.c

2716

static void sync_sbs(struct mddev *mddev, int nospares)

drivers/md/md.c

2725

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2726

if (rdev->sb_events == mddev->events ||

drivers/md/md.c

2729

rdev->sb_events+1 == mddev->events)) {

drivers/md/md.c

2733

sync_super(mddev, rdev);

drivers/md/md.c

2739

static bool does_sb_need_changing(struct mddev *mddev)

drivers/md/md.c

2746

rdev_for_each(iter, mddev)

drivers/md/md.c

2758

rdev_for_each(rdev, mddev) {

drivers/md/md.c

276

if (mddev->serial_info_pool) {

drivers/md/md.c

2770

if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||

drivers/md/md.c

2771

(mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||

drivers/md/md.c

2772

(mddev->layout != le32_to_cpu(sb->layout)) ||

drivers/md/md.c

2773

(mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||

drivers/md/md.c

2774

(mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))

drivers/md/md.c

2780

void md_update_sb(struct mddev *mddev, int force_change)

drivers/md/md.c

2788

if (!md_is_rdwr(mddev)) {

drivers/md/md.c

2790

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

2791

pr_err("%s: can't update sb for read-only array %s\n", __func__, mdname(mddev));

drivers/md/md.c

2796

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

2797

if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))

drivers/md/md.c

2799

if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))

drivers/md/md.c

280

rdev_for_each(temp, mddev) {

drivers/md/md.c

2801

ret = mddev->cluster_ops->metadata_update_start(mddev);

drivers/md/md.c

2803

if (!does_sb_need_changing(mddev)) {

drivers/md/md.c

2805

mddev->cluster_ops->metadata_update_cancel(mddev);

drivers/md/md.c

2806

bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),

drivers/md/md.c

2819

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2821

mddev->delta_disks >= 0 &&

drivers/md/md.c

2822

test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&

drivers/md/md.c

2823

test_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&

drivers/md/md.c

2824

!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&

drivers/md/md.c

2827

mddev->curr_resync_completed > rdev->recovery_offset)

drivers/md/md.c

2828

rdev->recovery_offset = mddev->curr_resync_completed;

drivers/md/md.c

283

&mddev->flags) ||

drivers/md/md.c

2831

if (!mddev->persistent) {

drivers/md/md.c

2832

clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

2833

clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

2834

if (!mddev->external) {

drivers/md/md.c

2835

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

2836

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2840

md_error(mddev, rdev);

drivers/md/md.c

2847

wake_up(&mddev->sb_wait);

drivers/md/md.c

2851

spin_lock(&mddev->lock);

drivers/md/md.c

2853

mddev->utime = ktime_get_real_seconds();

drivers/md/md.c

2855

if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))

drivers/md/md.c

2857

if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))

drivers/md/md.c

2865

if (mddev->degraded)

drivers/md/md.c

2877

sync_req = mddev->in_sync;

drivers/md/md.c

2882

&& (mddev->in_sync && mddev->resync_offset == MaxSector)

drivers/md/md.c

2883

&& mddev->can_decrease_events

drivers/md/md.c

2884

&& mddev->events != 1) {

drivers/md/md.c

2885

mddev->events--;

drivers/md/md.c

2886

mddev->can_decrease_events = 0;

drivers/md/md.c

2889

mddev->events ++;

drivers/md/md.c

2890

mddev->can_decrease_events = nospares;

drivers/md/md.c

2898

WARN_ON(mddev->events == 0);

drivers/md/md.c

2900

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2907

sync_sbs(mddev, nospares);

drivers/md/md.c

2908

spin_unlock(&mddev->lock);

drivers/md/md.c

2911

mdname(mddev), mddev->in_sync);

drivers/md/md.c

2913

mddev_add_trace_msg(mddev, "md md_update_sb");

drivers/md/md.c

2915

if (md_bitmap_enabled(mddev, false))

drivers/md/md.c

2916

mddev->bitmap_ops->update_sb(mddev->bitmap);

drivers/md/md.c

2917

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2922

md_write_metadata(mddev, rdev, rdev->sb_start,

drivers/md/md.c

2927

rdev->sb_events = mddev->events;

drivers/md/md.c

2929

md_write_metadata(mddev, rdev,

drivers/md/md.c

2940

if (md_super_wait(mddev) < 0)

drivers/md/md.c

2944

if (mddev_is_clustered(mddev) && ret == 0)

drivers/md/md.c

2945

mddev->cluster_ops->metadata_update_finish(mddev);

drivers/md/md.c

2947

if (mddev->in_sync != sync_req ||

drivers/md/md.c

2948

!bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),

drivers/md/md.c

2952

wake_up(&mddev->sb_wait);

drivers/md/md.c

2953

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/md.c

2954

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

2956

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2970

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

2974

if (!mddev->pers->hot_remove_disk || add_journal) {

drivers/md/md.c

2979

super_types[mddev->major_version].

drivers/md/md.c

2980

validate_super(mddev, NULL/*freshest*/, rdev);

drivers/md/md.c

2981

err = mddev->pers->hot_add_disk(mddev, rdev);

drivers/md/md.c

2989

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

299

mempool_destroy(mddev->serial_info_pool);

drivers/md/md.c

2990

if (mddev->degraded)

drivers/md/md.c

2991

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

2992

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

300

mddev->serial_info_pool = NULL;

drivers/md/md.c

3083

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

3087

if (cmd_match(buf, "faulty") && rdev->mddev->pers) {

drivers/md/md.c

3088

md_error(rdev->mddev, rdev);

drivers/md/md.c

3090

if (test_bit(MD_BROKEN, &rdev->mddev->flags))

drivers/md/md.c

3095

if (rdev->mddev->pers) {

drivers/md/md.c

3097

remove_and_add_spares(rdev->mddev, rdev);

drivers/md/md.c

3103

if (mddev_is_clustered(mddev))

drivers/md/md.c

3104

err = mddev->cluster_ops->remove_disk(mddev, rdev);

drivers/md/md.c

3108

if (mddev->pers)

drivers/md/md.c

3109

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

3115

mddev_create_serial_pool(rdev->mddev, rdev);

drivers/md/md.c

3119

mddev_destroy_serial_pool(rdev->mddev, rdev);

drivers/md/md.c

3133

md_error(rdev->mddev, rdev);

drivers/md/md.c

3138

set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);

drivers/md/md.c

3154

if (rdev->mddev->pers == NULL) {

drivers/md/md.c

3175

set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);

drivers/md/md.c

3188

if (rdev->mddev->pers)

drivers/md/md.c

3196

if (rdev->mddev->pers)

drivers/md/md.c

3203

if (!rdev->mddev->pers)

drivers/md/md.c

3213

if (!mddev_is_clustered(rdev->mddev) ||

drivers/md/md.c

3214

(err = mddev->cluster_ops->gather_bitmaps(rdev)) == 0) {

drivers/md/md.c

3220

} else if (cmd_match(buf, "external_bbl") && (rdev->mddev->external)) {

drivers/md/md.c

3224

} else if (cmd_match(buf, "-external_bbl") && (rdev->mddev->external)) {

drivers/md/md.c

3229

md_update_sb(mddev, 1);

drivers/md/md.c

3287

if (rdev->mddev->pers && slot == -1) {

drivers/md/md.c

3298

if (rdev->mddev->pers->hot_remove_disk == NULL)

drivers/md/md.c

3301

remove_and_add_spares(rdev->mddev, rdev);

drivers/md/md.c

3304

set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);

drivers/md/md.c

3305

} else if (rdev->mddev->pers) {

drivers/md/md.c

3314

if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))

drivers/md/md.c

3317

if (rdev->mddev->pers->hot_add_disk == NULL)

drivers/md/md.c

3320

if (slot >= rdev->mddev->raid_disks &&

drivers/md/md.c

3321

slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)

drivers/md/md.c

3331

err = rdev->mddev->pers->hot_add_disk(rdev->mddev, rdev);

drivers/md/md.c

3338

sysfs_link_rdev(rdev->mddev, rdev);

drivers/md/md.c

3341

if (slot >= rdev->mddev->raid_disks &&

drivers/md/md.c

3342

slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)

drivers/md/md.c

3369

if (rdev->mddev->pers && rdev->raid_disk >= 0)

drivers/md/md.c

3371

if (rdev->sectors && rdev->mddev->external)

drivers/md/md.c

3393

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

3398

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/md.c

3406

+ mddev->dev_sectors > rdev->sectors)

drivers/md/md.c

3415

mddev->reshape_backwards)

drivers/md/md.c

3422

!mddev->reshape_backwards)

drivers/md/md.c

3425

if (mddev->pers && mddev->persistent &&

drivers/md/md.c

3426

!super_types[mddev->major_version]

drivers/md/md.c

3431

mddev->reshape_backwards = 1;

drivers/md/md.c

3433

mddev->reshape_backwards = 0;

drivers/md/md.c

3458

struct mddev *mddev;

drivers/md/md.c

3462

list_for_each_entry(mddev, &all_mddevs, all_mddevs) {

drivers/md/md.c

3463

if (test_bit(MD_DELETED, &mddev->flags))

drivers/md/md.c

3465

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

3499

struct mddev *my_mddev = rdev->mddev;

drivers/md/md.c

3568

if (rdev->mddev->pers &&

drivers/md/md.c

3636

if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&

drivers/md/md.c

3640

if (rdev->mddev->persistent) {

drivers/md/md.c

3641

if (rdev->mddev->major_version == 0)

drivers/md/md.c

3649

} else if (!rdev->mddev->external) {

drivers/md/md.c

3673

if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&

drivers/md/md.c

3677

if (rdev->mddev->persistent) {

drivers/md/md.c

3678

if (rdev->mddev->major_version == 0)

drivers/md/md.c

3682

} else if (!rdev->mddev->external) {

drivers/md/md.c

371

static bool is_md_suspended(struct mddev *mddev)

drivers/md/md.c

3715

if (!rdev->mddev)

drivers/md/md.c

3729

struct mddev *mddev = READ_ONCE(rdev->mddev);

drivers/md/md.c

373

return percpu_ref_is_dying(&mddev->active_io);

drivers/md/md.c

3735

if (!mddev)

drivers/md/md.c

3747

rv = suspend ? mddev_suspend_and_lock(mddev) : mddev_lock(mddev);

drivers/md/md.c

3749

if (rdev->mddev == NULL)

drivers/md/md.c

3753

suspend ? mddev_unlock_and_resume(mddev) : mddev_unlock(mddev);

drivers/md/md.c

382

static bool is_suspended(struct mddev *mddev, struct bio *bio)

drivers/md/md.c

384

if (is_md_suspended(mddev))

drivers/md/md.c

388

if (READ_ONCE(mddev->suspend_lo) >= READ_ONCE(mddev->suspend_hi))

drivers/md/md.c

3883

static int analyze_sbs(struct mddev *mddev)

drivers/md/md.c

3888

rdev_for_each_safe(rdev, tmp, mddev)

drivers/md/md.c

3889

switch (super_types[mddev->major_version].

drivers/md/md.c

3890

load_super(rdev, freshest, mddev->minor_version)) {

drivers/md/md.c

390

if (bio->bi_iter.bi_sector >= READ_ONCE(mddev->suspend_hi))

drivers/md/md.c

3908

super_types[mddev->major_version].

drivers/md/md.c

3909

validate_super(mddev, NULL/*freshest*/, freshest);

drivers/md/md.c

3911

rdev_for_each_safe(rdev, tmp, mddev) {

drivers/md/md.c

3912

if (mddev->max_disks &&

drivers/md/md.c

3913

rdev->desc_nr >= mddev->max_disks) {

drivers/md/md.c

3915

mdname(mddev), rdev->bdev,

drivers/md/md.c

3916

mddev->max_disks);

drivers/md/md.c

392

if (bio_end_sector(bio) < READ_ONCE(mddev->suspend_lo))

drivers/md/md.c

3921

if (super_types[mddev->major_version].

drivers/md/md.c

3922

validate_super(mddev, freshest, rdev)) {

drivers/md/md.c

3929

if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks)) &&

drivers/md/md.c

397

bool md_handle_request(struct mddev *mddev, struct bio *bio)

drivers/md/md.c

3976

safe_delay_show(struct mddev *mddev, char *page)

drivers/md/md.c

3978

unsigned int msec = ((unsigned long)mddev->safemode_delay*1000)/HZ;

drivers/md/md.c

3983

safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)

drivers/md/md.c

3987

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

3995

mddev->safemode_delay = 0;

drivers/md/md.c

3997

unsigned long old_delay = mddev->safemode_delay;

drivers/md/md.c

400

if (is_suspended(mddev, bio)) {

drivers/md/md.c

4002

mddev->safemode_delay = new_delay;

drivers/md/md.c

4004

mod_timer(&mddev->safemode_timer, jiffies+1);

drivers/md/md.c

4012

level_show(struct mddev *mddev, char *page)

drivers/md/md.c

4016

spin_lock(&mddev->lock);

drivers/md/md.c

4017

p = mddev->pers;

drivers/md/md.c

4020

else if (mddev->clevel[0])

drivers/md/md.c

4021

ret = sprintf(page, "%s\n", mddev->clevel);

drivers/md/md.c

4022

else if (mddev->level != LEVEL_NONE)

drivers/md/md.c

4023

ret = sprintf(page, "%d\n", mddev->level);

drivers/md/md.c

4026

spin_unlock(&mddev->lock);

drivers/md/md.c

4031

level_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4044

rv = mddev_suspend_and_lock(mddev);

drivers/md/md.c

4048

if (mddev->pers == NULL) {

drivers/md/md.c

4049

memcpy(mddev->clevel, buf, slen);

drivers/md/md.c

4050

if (mddev->clevel[slen-1] == '\n')

drivers/md/md.c

4052

mddev->clevel[slen] = 0;

drivers/md/md.c

4053

mddev->level = LEVEL_NONE;

drivers/md/md.c

4058

if (!md_is_rdwr(mddev))

drivers/md/md.c

4068

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||

drivers/md/md.c

4069

mddev->reshape_position != MaxSector ||

drivers/md/md.c

4070

mddev->sysfs_active)

drivers/md/md.c

4074

if (!mddev->pers->quiesce) {

drivers/md/md.c

4076

mdname(mddev), mddev->pers->head.name);

drivers/md/md.c

408

prepare_to_wait(&mddev->sb_wait, &__wait,

drivers/md/md.c

4096

if (pers == mddev->pers) {

drivers/md/md.c

410

if (!is_suspended(mddev, bio))

drivers/md/md.c

4105

mdname(mddev), clevel);

drivers/md/md.c

4110

rdev_for_each(rdev, mddev)

drivers/md/md.c

4116

priv = pers->takeover(mddev);

drivers/md/md.c

4118

mddev->new_level = mddev->level;

drivers/md/md.c

4119

mddev->new_layout = mddev->layout;

drivers/md/md.c

4120

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

4121

mddev->raid_disks -= mddev->delta_disks;

drivers/md/md.c

4122

mddev->delta_disks = 0;

drivers/md/md.c

4123

mddev->reshape_backwards = 0;

drivers/md/md.c

4126

mdname(mddev), clevel);

drivers/md/md.c

4132

mddev_detach(mddev);

drivers/md/md.c

4134

spin_lock(&mddev->lock);

drivers/md/md.c

4135

oldpers = mddev->pers;

drivers/md/md.c

4136

oldpriv = mddev->private;

drivers/md/md.c

4137

mddev->pers = pers;

drivers/md/md.c

4138

mddev->private = priv;

drivers/md/md.c

4139

strscpy(mddev->clevel, pers->head.name, sizeof(mddev->clevel));

drivers/md/md.c

414

finish_wait(&mddev->sb_wait, &__wait);

drivers/md/md.c

4140

mddev->level = mddev->new_level;

drivers/md/md.c

4141

mddev->layout = mddev->new_layout;

drivers/md/md.c

4142

mddev->chunk_sectors = mddev->new_chunk_sectors;

drivers/md/md.c

4143

mddev->delta_disks = 0;

drivers/md/md.c

4144

mddev->reshape_backwards = 0;

drivers/md/md.c

4145

mddev->degraded = 0;

drivers/md/md.c

4146

spin_unlock(&mddev->lock);

drivers/md/md.c

4149

mddev->external) {

drivers/md/md.c

4157

mddev->in_sync = 0;

drivers/md/md.c

4158

mddev->safemode_delay = 0;

drivers/md/md.c

4159

mddev->safemode = 0;

drivers/md/md.c

416

if (!percpu_ref_tryget_live(&mddev->active_io))

drivers/md/md.c

4162

oldpers->free(mddev, oldpriv);

drivers/md/md.c

4167

if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))

drivers/md/md.c

4169

mdname(mddev));

drivers/md/md.c

4170

mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");

drivers/md/md.c

4171

mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");

drivers/md/md.c

4172

mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");

drivers/md/md.c

4177

if (mddev->to_remove == NULL)

drivers/md/md.c

4178

mddev->to_remove = &md_redundancy_group;

drivers/md/md.c

4183

rdev_for_each(rdev, mddev) {

drivers/md/md.c

4186

if (rdev->new_raid_disk >= mddev->raid_disks)

drivers/md/md.c

419

if (!mddev->pers->make_request(mddev, bio)) {

drivers/md/md.c

4190

sysfs_unlink_rdev(mddev, rdev);

drivers/md/md.c

4192

rdev_for_each(rdev, mddev) {

drivers/md/md.c

420

percpu_ref_put(&mddev->active_io);

drivers/md/md.c

4201

if (sysfs_link_rdev(mddev, rdev))

drivers/md/md.c

4203

rdev->raid_disk, mdname(mddev));

drivers/md/md.c

421

if (!mddev->gendisk && mddev->pers->prepare_suspend)

drivers/md/md.c

4211

mddev->in_sync = 1;

drivers/md/md.c

4212

timer_delete_sync(&mddev->safemode_timer);

drivers/md/md.c

4214

pers->run(mddev);

drivers/md/md.c

4215

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

4216

if (!mddev->thread)

drivers/md/md.c

4217

md_update_sb(mddev, 1);

drivers/md/md.c

4218

sysfs_notify_dirent_safe(mddev->sysfs_level);

drivers/md/md.c

4222

mddev_unlock_and_resume(mddev);

drivers/md/md.c

4230

new_level_show(struct mddev *mddev, char *page)

drivers/md/md.c

4232

return sprintf(page, "%d\n", mddev->new_level);

drivers/md/md.c

4236

new_level_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4244

err = mddev_lock(mddev);

drivers/md/md.c

4248

mddev->new_level = n;

drivers/md/md.c

4249

md_update_sb(mddev, 1);

drivers/md/md.c

4251

mddev_unlock(mddev);

drivers/md/md.c

4258

bitmap_type_show(struct mddev *mddev, char *page)

drivers/md/md.c

426

percpu_ref_put(&mddev->active_io);

drivers/md/md.c

4264

if (mddev->bitmap_id == ID_BITMAP_NONE)

drivers/md/md.c

4274

if (mddev->bitmap_id == head->id)

drivers/md/md.c

4286

bitmap_type_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4295

if (mddev->bitmap_ops) {

drivers/md/md.c

4301

mddev->bitmap_id = ID_BITMAP_NONE;

drivers/md/md.c

4307

mddev->bitmap_id = head->id;

drivers/md/md.c

4317

mddev->bitmap_id = id;

drivers/md/md.c

4323

mddev->bitmap_id = id;

drivers/md/md.c

4338

layout_show(struct mddev *mddev, char *page)

drivers/md/md.c

434

struct mddev *mddev = bio->bi_bdev->bd_disk->private_data;

drivers/md/md.c

4341

if (mddev->reshape_position != MaxSector &&

drivers/md/md.c

4342

mddev->layout != mddev->new_layout)

drivers/md/md.c

4344

mddev->new_layout, mddev->layout);

drivers/md/md.c

4345

return sprintf(page, "%d\n", mddev->layout);

drivers/md/md.c

4349

layout_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4357

err = mddev_lock(mddev);

drivers/md/md.c

436

if (mddev == NULL || mddev->pers == NULL) {

drivers/md/md.c

4361

if (mddev->pers) {

drivers/md/md.c

4362

if (mddev->pers->check_reshape == NULL)

drivers/md/md.c

4364

else if (!md_is_rdwr(mddev))

drivers/md/md.c

4367

mddev->new_layout = n;

drivers/md/md.c

4368

err = mddev->pers->check_reshape(mddev);

drivers/md/md.c

4370

mddev->new_layout = mddev->layout;

drivers/md/md.c

4373

mddev->new_layout = n;

drivers/md/md.c

4374

if (mddev->reshape_position == MaxSector)

drivers/md/md.c

4375

mddev->layout = n;

drivers/md/md.c

4377

mddev_unlock(mddev);

drivers/md/md.c

4384

raid_disks_show(struct mddev *mddev, char *page)

drivers/md/md.c

4386

if (mddev->raid_disks == 0)

drivers/md/md.c

4388

if (mddev->reshape_position != MaxSector &&

drivers/md/md.c

4389

mddev->delta_disks != 0)

drivers/md/md.c

4390

return sprintf(page, "%d (%d)\n", mddev->raid_disks,

drivers/md/md.c

4391

mddev->raid_disks - mddev->delta_disks);

drivers/md/md.c

4392

return sprintf(page, "%d\n", mddev->raid_disks);

drivers/md/md.c

4395

static int update_raid_disks(struct mddev *mddev, int raid_disks);

drivers/md/md.c

4398

raid_disks_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4407

err = mddev_suspend_and_lock(mddev);

drivers/md/md.c

441

if (unlikely(test_bit(MD_BROKEN, &mddev->flags)) && (rw == WRITE)) {

drivers/md/md.c

4410

if (mddev->pers)

drivers/md/md.c

4411

err = update_raid_disks(mddev, n);

drivers/md/md.c

4412

else if (mddev->reshape_position != MaxSector) {

drivers/md/md.c

4414

int olddisks = mddev->raid_disks - mddev->delta_disks;

drivers/md/md.c

4417

rdev_for_each(rdev, mddev) {

drivers/md/md.c

4426

mddev->delta_disks = n - olddisks;

drivers/md/md.c

4427

mddev->raid_disks = n;

drivers/md/md.c

4428

mddev->reshape_backwards = (mddev->delta_disks < 0);

drivers/md/md.c

4430

mddev->raid_disks = n;

drivers/md/md.c

4432

mddev_unlock_and_resume(mddev);

drivers/md/md.c

4439

uuid_show(struct mddev *mddev, char *page)

drivers/md/md.c

4441

return sprintf(page, "%pU\n", mddev->uuid);

drivers/md/md.c

4447

chunk_size_show(struct mddev *mddev, char *page)

drivers/md/md.c

4449

if (mddev->reshape_position != MaxSector &&

drivers/md/md.c

4450

mddev->chunk_sectors != mddev->new_chunk_sectors)

drivers/md/md.c

4452

mddev->new_chunk_sectors << 9,

drivers/md/md.c

4453

mddev->chunk_sectors << 9);

drivers/md/md.c

4454

return sprintf(page, "%d\n", mddev->chunk_sectors << 9);

drivers/md/md.c

4458

chunk_size_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4467

err = mddev_lock(mddev);

drivers/md/md.c

4470

if (mddev->pers) {

drivers/md/md.c

4471

if (mddev->pers->check_reshape == NULL)

drivers/md/md.c

4473

else if (!md_is_rdwr(mddev))

drivers/md/md.c

4476

mddev->new_chunk_sectors = n >> 9;

drivers/md/md.c

4477

err = mddev->pers->check_reshape(mddev);

drivers/md/md.c

4479

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

4482

mddev->new_chunk_sectors = n >> 9;

drivers/md/md.c

4483

if (mddev->reshape_position == MaxSector)

drivers/md/md.c

4484

mddev->chunk_sectors = n >> 9;

drivers/md/md.c

4486

mddev_unlock(mddev);

drivers/md/md.c

4493

resync_start_show(struct mddev *mddev, char *page)

drivers/md/md.c

4495

if (mddev->resync_offset == MaxSector)

drivers/md/md.c

4497

return sprintf(page, "%llu\n", (unsigned long long)mddev->resync_offset);

drivers/md/md.c

450

if (mddev->ro == MD_RDONLY && unlikely(rw == WRITE)) {

drivers/md/md.c

4501

resync_start_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4516

err = mddev_lock(mddev);

drivers/md/md.c

4519

if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))

drivers/md/md.c

4523

mddev->resync_offset = n;

drivers/md/md.c

4524

if (mddev->pers)

drivers/md/md.c

4525

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

4527

mddev_unlock(mddev);

drivers/md/md.c

4590

array_state_show(struct mddev *mddev, char *page)

drivers/md/md.c

4594

if (mddev->pers && !test_bit(MD_NOT_READY, &mddev->flags)) {

drivers/md/md.c

4595

switch(mddev->ro) {

drivers/md/md.c

460

md_handle_request(mddev, bio);

drivers/md/md.c

4603

spin_lock(&mddev->lock);

drivers/md/md.c

4604

if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))

drivers/md/md.c

4606

else if (mddev->in_sync)

drivers/md/md.c

4608

else if (mddev->safemode)

drivers/md/md.c

4612

spin_unlock(&mddev->lock);

drivers/md/md.c

4615

if (test_bit(MD_BROKEN, &mddev->flags) && st == clean)

drivers/md/md.c

4618

if (list_empty(&mddev->disks) &&

drivers/md/md.c

4619

mddev->raid_disks == 0 &&

drivers/md/md.c

4620

mddev->dev_sectors == 0)

drivers/md/md.c

4628

static int do_md_stop(struct mddev *mddev, int ro);

drivers/md/md.c

4629

static int md_set_readonly(struct mddev *mddev);

drivers/md/md.c

4630

static int restart_array(struct mddev *mddev);

drivers/md/md.c

4633

array_state_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4650

if (!mddev->pers || !md_is_rdwr(mddev))

drivers/md/md.c

4653

err = mddev_set_closing_and_sync_blockdev(mddev, 0);

drivers/md/md.c

4661

if (mddev->pers && (st == active || st == clean) &&

drivers/md/md.c

4662

mddev->ro != MD_RDONLY) {

drivers/md/md.c

4666

spin_lock(&mddev->lock);

drivers/md/md.c

4668

restart_array(mddev);

drivers/md/md.c

4669

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

467

int mddev_suspend(struct mddev *mddev, bool interruptible)

drivers/md/md.c

4670

md_wakeup_thread(mddev->thread);

drivers/md/md.c

4671

wake_up(&mddev->sb_wait);

drivers/md/md.c

4673

restart_array(mddev);

drivers/md/md.c

4674

if (!set_in_sync(mddev))

drivers/md/md.c

4678

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

4679

spin_unlock(&mddev->lock);

drivers/md/md.c

4682

err = mddev_lock(mddev);

drivers/md/md.c

4689

if (mddev->pers)

drivers/md/md.c

4690

err = do_md_stop(mddev, 2);

drivers/md/md.c

4693

err = do_md_stop(mddev, 0);

drivers/md/md.c

4696

if (mddev->pers)

drivers/md/md.c

4697

err = md_set_readonly(mddev);

drivers/md/md.c

4699

mddev->ro = MD_RDONLY;

drivers/md/md.c

4700

set_disk_ro(mddev->gendisk, 1);

drivers/md/md.c

4701

err = do_md_run(mddev);

drivers/md/md.c

4705

if (mddev->pers) {

drivers/md/md.c

4706

if (md_is_rdwr(mddev))

drivers/md/md.c

4707

err = md_set_readonly(mddev);

drivers/md/md.c

4708

else if (mddev->ro == MD_RDONLY)

drivers/md/md.c

4709

err = restart_array(mddev);

drivers/md/md.c

4711

mddev->ro = MD_AUTO_READ;

drivers/md/md.c

4712

set_disk_ro(mddev->gendisk, 0);

drivers/md/md.c

4715

mddev->ro = MD_AUTO_READ;

drivers/md/md.c

4716

err = do_md_run(mddev);

drivers/md/md.c

4720

if (mddev->pers) {

drivers/md/md.c

4721

err = restart_array(mddev);

drivers/md/md.c

4724

spin_lock(&mddev->lock);

drivers/md/md.c

4725

if (!set_in_sync(mddev))

drivers/md/md.c

4727

spin_unlock(&mddev->lock);

drivers/md/md.c

4732

if (mddev->pers) {

drivers/md/md.c

4733

err = restart_array(mddev);

drivers/md/md.c

4736

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

4737

wake_up(&mddev->sb_wait);

drivers/md/md.c

4740

mddev->ro = MD_RDWR;

drivers/md/md.c

4741

set_disk_ro(mddev->gendisk, 0);

drivers/md/md.c

4742

err = do_md_run(mddev);

drivers/md/md.c

4751

if (mddev->hold_active == UNTIL_IOCTL)

drivers/md/md.c

4752

mddev->hold_active = 0;

drivers/md/md.c

4753

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

4755

mddev_unlock(mddev);

drivers/md/md.c

4759

clear_bit(MD_CLOSING, &mddev->flags);

drivers/md/md.c

476

lockdep_assert_not_held(&mddev->reconfig_mutex);

drivers/md/md.c

4767

max_corrected_read_errors_show(struct mddev *mddev, char *page) {

drivers/md/md.c

4769

atomic_read(&mddev->max_corr_read_errors));

drivers/md/md.c

4773

max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4783

atomic_set(&mddev->max_corr_read_errors, n);

drivers/md/md.c

479

err = mutex_lock_interruptible(&mddev->suspend_mutex);

drivers/md/md.c

4792

null_show(struct mddev *mddev, char *page)

drivers/md/md.c

4798

new_dev_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

481

mutex_lock(&mddev->suspend_mutex);

drivers/md/md.c

4824

err = mddev_suspend_and_lock(mddev);

drivers/md/md.c

4827

if (mddev->persistent) {

drivers/md/md.c

4828

rdev = md_import_device(dev, mddev->major_version,

drivers/md/md.c

4829

mddev->minor_version);

drivers/md/md.c

4830

if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {

drivers/md/md.c

4832

= list_entry(mddev->disks.next,

drivers/md/md.c

4834

err = super_types[mddev->major_version]

drivers/md/md.c

4835

.load_super(rdev, rdev0, mddev->minor_version);

drivers/md/md.c

4839

} else if (mddev->external)

drivers/md/md.c

4845

mddev_unlock_and_resume(mddev);

drivers/md/md.c

4848

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

485

if (mddev->suspended) {

drivers/md/md.c

4851

export_rdev(rdev, mddev);

drivers/md/md.c

4852

mddev_unlock_and_resume(mddev);

drivers/md/md.c

486

WRITE_ONCE(mddev->suspended, mddev->suspended + 1);

drivers/md/md.c

4862

bitmap_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4868

if (!md_bitmap_enabled(mddev, false))

drivers/md/md.c

487

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

4871

err = mddev_lock(mddev);

drivers/md/md.c

4874

if (!mddev->bitmap)

drivers/md/md.c

4892

mddev->bitmap_ops->dirty_bits(mddev, chunk, end_chunk);

drivers/md/md.c

4895

mddev->bitmap_ops->unplug(mddev, true); /* flush the bits to disk */

drivers/md/md.c

4897

mddev_unlock(mddev);

drivers/md/md.c

4905

size_show(struct mddev *mddev, char *page)

drivers/md/md.c

4908

(unsigned long long)mddev->dev_sectors / 2);

drivers/md/md.c

491

percpu_ref_kill(&mddev->active_io);

drivers/md/md.c

4911

static int update_size(struct mddev *mddev, sector_t num_sectors);

drivers/md/md.c

4914

size_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

4925

err = mddev_lock(mddev);

drivers/md/md.c

4928

if (mddev->pers) {

drivers/md/md.c

4929

err = update_size(mddev, sectors);

drivers/md/md.c

493

err = wait_event_interruptible(mddev->sb_wait,

drivers/md/md.c

4931

md_update_sb(mddev, 1);

drivers/md/md.c

4933

if (mddev->dev_sectors == 0 ||

drivers/md/md.c

4934

mddev->dev_sectors > sectors)

drivers/md/md.c

4935

mddev->dev_sectors = sectors;

drivers/md/md.c

4939

mddev_unlock(mddev);

drivers/md/md.c

494

percpu_ref_is_zero(&mddev->active_io));

drivers/md/md.c

4953

metadata_show(struct mddev *mddev, char *page)

drivers/md/md.c

4955

if (mddev->persistent)

drivers/md/md.c

4957

mddev->major_version, mddev->minor_version);

drivers/md/md.c

4958

else if (mddev->external)

drivers/md/md.c

4959

return sprintf(page, "external:%s\n", mddev->metadata_type);

drivers/md/md.c

496

wait_event(mddev->sb_wait,

drivers/md/md.c

4965

metadata_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

497

percpu_ref_is_zero(&mddev->active_io));

drivers/md/md.c

4975

err = mddev_lock(mddev);

drivers/md/md.c

4979

if (mddev->external && strncmp(buf, "external:", 9) == 0)

drivers/md/md.c

4981

else if (!list_empty(&mddev->disks))

drivers/md/md.c

4986

mddev->persistent = 0;

drivers/md/md.c

4987

mddev->external = 0;

drivers/md/md.c

4988

mddev->major_version = 0;

drivers/md/md.c

4989

mddev->minor_version = 90;

drivers/md/md.c

499

percpu_ref_resurrect(&mddev->active_io);

drivers/md/md.c

4994

if (namelen >= sizeof(mddev->metadata_type))

drivers/md/md.c

4995

namelen = sizeof(mddev->metadata_type)-1;

drivers/md/md.c

4996

memcpy(mddev->metadata_type, buf+9, namelen);

drivers/md/md.c

4997

mddev->metadata_type[namelen] = 0;

drivers/md/md.c

4998

if (namelen && mddev->metadata_type[namelen-1] == '\n')

drivers/md/md.c

4999

mddev->metadata_type[--namelen] = 0;

drivers/md/md.c

500

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

5000

mddev->persistent = 0;

drivers/md/md.c

5001

mddev->external = 1;

drivers/md/md.c

5002

mddev->major_version = 0;

drivers/md/md.c

5003

mddev->minor_version = 90;

drivers/md/md.c

5017

mddev->major_version = major;

drivers/md/md.c

5018

mddev->minor_version = minor;

drivers/md/md.c

5019

mddev->persistent = 1;

drivers/md/md.c

5020

mddev->external = 0;

drivers/md/md.c

5023

mddev_unlock(mddev);

drivers/md/md.c

5039

static enum sync_action md_get_active_sync_action(struct mddev *mddev)

drivers/md/md.c

5044

if (mddev->resync_offset < MaxSector)

drivers/md/md.c

5047

if (mddev->reshape_position != MaxSector)

drivers/md/md.c

5051

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

5062

enum sync_action md_sync_action(struct mddev *mddev)

drivers/md/md.c

5064

unsigned long recovery = mddev->recovery;

drivers/md/md.c

5078

if (!md_is_rdwr(mddev))

drivers/md/md.c

509

WRITE_ONCE(mddev->suspended, mddev->suspended + 1);

drivers/md/md.c

5095

active_action = md_get_active_sync_action(mddev);

drivers/md/md.c

512

mddev->noio_flag = memalloc_noio_save();

drivers/md/md.c

514

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

5142

action_show(struct mddev *mddev, char *page)

drivers/md/md.c

5144

enum sync_action action = md_sync_action(mddev);

drivers/md/md.c

5156

static void stop_sync_thread(struct mddev *mddev, bool locked)

drivers/md/md.c

5158

int sync_seq = atomic_read(&mddev->sync_seq);

drivers/md/md.c

5160

if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {

drivers/md/md.c

5162

mddev_unlock(mddev);

drivers/md/md.c

5166

mddev_unlock(mddev);

drivers/md/md.c

5168

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

5173

md_wakeup_thread_directly(&mddev->sync_thread);

drivers/md/md.c

5174

if (work_pending(&mddev->sync_work))

drivers/md/md.c

5175

flush_work(&mddev->sync_work);

drivers/md/md.c

5178

!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||

drivers/md/md.c

5179

(!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery) &&

drivers/md/md.c

5180

sync_seq != atomic_read(&mddev->sync_seq)));

drivers/md/md.c

5183

mddev_lock_nointr(mddev);

drivers/md/md.c

5186

void md_idle_sync_thread(struct mddev *mddev)

drivers/md/md.c

5188

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

519

static void __mddev_resume(struct mddev *mddev, bool recovery_needed)

drivers/md/md.c

5190

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5191

stop_sync_thread(mddev, true);

drivers/md/md.c

5195

void md_frozen_sync_thread(struct mddev *mddev)

drivers/md/md.c

5197

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

5199

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5200

stop_sync_thread(mddev, true);

drivers/md/md.c

5204

void md_unfrozen_sync_thread(struct mddev *mddev)

drivers/md/md.c

5206

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

5208

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5209

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

521

lockdep_assert_not_held(&mddev->reconfig_mutex);

drivers/md/md.c

5210

md_wakeup_thread(mddev->thread);

drivers/md/md.c

5211

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

5215

static int mddev_start_reshape(struct mddev *mddev)

drivers/md/md.c

5219

if (mddev->pers->start_reshape == NULL)

drivers/md/md.c

5222

if (mddev->reshape_position == MaxSector ||

drivers/md/md.c

5223

mddev->pers->check_reshape == NULL ||

drivers/md/md.c

5224

mddev->pers->check_reshape(mddev)) {

drivers/md/md.c

5225

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5226

ret = mddev->pers->start_reshape(mddev);

drivers/md/md.c

523

mutex_lock(&mddev->suspend_mutex);

drivers/md/md.c

5235

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5238

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

524

WRITE_ONCE(mddev->suspended, mddev->suspended - 1);

drivers/md/md.c

5243

action_store(struct mddev *mddev, const char *page, size_t len)

drivers/md/md.c

5248

if (!mddev->pers || !mddev->pers->sync_request)

drivers/md/md.c

525

if (mddev->suspended) {

drivers/md/md.c

5252

if (work_busy(&mddev->sync_work))

drivers/md/md.c

5253

flush_work(&mddev->sync_work);

drivers/md/md.c

5255

ret = mddev_lock(mddev);

drivers/md/md.c

5259

if (work_busy(&mddev->sync_work)) {

drivers/md/md.c

526

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

5260

mddev_unlock(mddev);

drivers/md/md.c

5267

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {

drivers/md/md.c

5270

md_frozen_sync_thread(mddev);

drivers/md/md.c

5274

md_idle_sync_thread(mddev);

drivers/md/md.c

5290

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5294

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5295

ret = mddev_start_reshape(mddev);

drivers/md/md.c

5300

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5301

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

5304

set_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/md.c

5307

set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/md.c

5308

set_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

531

memalloc_noio_restore(mddev->noio_flag);

drivers/md/md.c

5312

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5320

if (mddev->ro == MD_AUTO_READ) {

drivers/md/md.c

5324

mddev->ro = MD_RDWR;

drivers/md/md.c

5325

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

5328

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

5329

md_wakeup_thread(mddev->thread);

drivers/md/md.c

533

percpu_ref_resurrect(&mddev->active_io);

drivers/md/md.c

5330

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

5334

mddev_unlock(mddev);

drivers/md/md.c

534

wake_up(&mddev->sb_wait);

drivers/md/md.c

5342

last_sync_action_show(struct mddev *mddev, char *page)

drivers/md/md.c

5345

md_sync_action_name(mddev->last_sync_action));

drivers/md/md.c

5351

mismatch_cnt_show(struct mddev *mddev, char *page)

drivers/md/md.c

5355

atomic64_read(&mddev->resync_mismatches));

drivers/md/md.c

5361

sync_min_show(struct mddev *mddev, char *page)

drivers/md/md.c

5363

return sprintf(page, "%d (%s)\n", speed_min(mddev),

drivers/md/md.c

5364

mddev->sync_speed_min ? "local" : "system");

drivers/md/md.c

5368

sync_min_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

537

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

538

md_wakeup_thread(mddev->thread);

drivers/md/md.c

5382

mddev->sync_speed_min = min;

drivers/md/md.c

539

md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */

drivers/md/md.c

5390

sync_max_show(struct mddev *mddev, char *page)

drivers/md/md.c

5392

return sprintf(page, "%d (%s)\n", speed_max(mddev),

drivers/md/md.c

5393

mddev->sync_speed_max ? "local" : "system");

drivers/md/md.c

5397

sync_max_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

541

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

5411

mddev->sync_speed_max = max;

drivers/md/md.c

5419

sync_io_depth_show(struct mddev *mddev, char *page)

drivers/md/md.c

5421

return sprintf(page, "%d (%s)\n", sync_io_depth(mddev),

drivers/md/md.c

5422

mddev->sync_io_depth ? "local" : "system");

drivers/md/md.c

5426

sync_io_depth_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

544

void mddev_resume(struct mddev *mddev)

drivers/md/md.c

5440

mddev->sync_io_depth = max;

drivers/md/md.c

5448

degraded_show(struct mddev *mddev, char *page)

drivers/md/md.c

5450

return sprintf(page, "%d\n", mddev->degraded);

drivers/md/md.c

5455

sync_force_parallel_show(struct mddev *mddev, char *page)

drivers/md/md.c

5457

return sprintf(page, "%d\n", mddev->parallel_resync);

drivers/md/md.c

546

return __mddev_resume(mddev, true);

drivers/md/md.c

5461

sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5471

mddev->parallel_resync = n;

drivers/md/md.c

5473

if (mddev->sync_thread)

drivers/md/md.c

5485

sync_speed_show(struct mddev *mddev, char *page)

drivers/md/md.c

5488

if (mddev->curr_resync == MD_RESYNC_NONE)

drivers/md/md.c

5490

resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);

drivers/md/md.c

5491

dt = (jiffies - mddev->resync_mark) / HZ;

drivers/md/md.c

5493

db = resync - mddev->resync_mark_cnt;

drivers/md/md.c

5500

sync_completed_show(struct mddev *mddev, char *page)

drivers/md/md.c

5504

if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/md.c

5507

if (mddev->curr_resync == MD_RESYNC_YIELDED ||

drivers/md/md.c

5508

mddev->curr_resync == MD_RESYNC_DELAYED)

drivers/md/md.c

551

static int mddev_set_closing_and_sync_blockdev(struct mddev *mddev, int opener_num)

drivers/md/md.c

5511

if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||

drivers/md/md.c

5512

test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))

drivers/md/md.c

5513

max_sectors = mddev->resync_max_sectors;

drivers/md/md.c

5515

max_sectors = mddev->dev_sectors;

drivers/md/md.c

5517

resync = mddev->curr_resync_completed;

drivers/md/md.c

5525

min_sync_show(struct mddev *mddev, char *page)

drivers/md/md.c

5528

(unsigned long long)mddev->resync_min);

drivers/md/md.c

553

mutex_lock(&mddev->open_mutex);

drivers/md/md.c

5531

min_sync_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5539

spin_lock(&mddev->lock);

drivers/md/md.c

554

if (mddev->pers && atomic_read(&mddev->openers) > opener_num) {

drivers/md/md.c

5541

if (min > mddev->resync_max)

drivers/md/md.c

5545

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/md.c

5549

mddev->resync_min = round_down(min, 8);

drivers/md/md.c

555

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

5553

spin_unlock(&mddev->lock);

drivers/md/md.c

5561

max_sync_show(struct mddev *mddev, char *page)

drivers/md/md.c

5563

if (mddev->resync_max == MaxSector)

drivers/md/md.c

5567

(unsigned long long)mddev->resync_max);

drivers/md/md.c

5570

max_sync_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5573

spin_lock(&mddev->lock);

drivers/md/md.c

5575

mddev->resync_max = MaxSector;

drivers/md/md.c

558

if (test_and_set_bit(MD_CLOSING, &mddev->flags)) {

drivers/md/md.c

5583

if (max < mddev->resync_min)

drivers/md/md.c

5587

if (max < mddev->resync_max && md_is_rdwr(mddev) &&

drivers/md/md.c

5588

test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/md.c

559

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

5592

chunk = mddev->chunk_sectors;

drivers/md/md.c

5600

mddev->resync_max = max;

drivers/md/md.c

5602

wake_up(&mddev->recovery_wait);

drivers/md/md.c

5605

spin_unlock(&mddev->lock);

drivers/md/md.c

5613

suspend_lo_show(struct mddev *mddev, char *page)

drivers/md/md.c

5616

(unsigned long long)READ_ONCE(mddev->suspend_lo));

drivers/md/md.c

562

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

5620

suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5631

err = mddev_suspend(mddev, true);

drivers/md/md.c

5635

WRITE_ONCE(mddev->suspend_lo, new);

drivers/md/md.c

5636

mddev_resume(mddev);

drivers/md/md.c

564

sync_blockdev(mddev->gendisk->part0);

drivers/md/md.c

5644

suspend_hi_show(struct mddev *mddev, char *page)

drivers/md/md.c

5647

(unsigned long long)READ_ONCE(mddev->suspend_hi));

drivers/md/md.c

5651

suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5662

err = mddev_suspend(mddev, true);

drivers/md/md.c

5666

WRITE_ONCE(mddev->suspend_hi, new);

drivers/md/md.c

5667

mddev_resume(mddev);

drivers/md/md.c

5675

reshape_position_show(struct mddev *mddev, char *page)

drivers/md/md.c

5677

if (mddev->reshape_position != MaxSector)

drivers/md/md.c

5679

(unsigned long long)mddev->reshape_position);

drivers/md/md.c

5685

reshape_position_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5696

err = mddev_lock(mddev);

drivers/md/md.c

5700

if (mddev->pers)

drivers/md/md.c

5702

mddev->reshape_position = new;

drivers/md/md.c

5703

mddev->delta_disks = 0;

drivers/md/md.c

5704

mddev->reshape_backwards = 0;

drivers/md/md.c

5705

mddev->new_level = mddev->level;

drivers/md/md.c

5706

mddev->new_layout = mddev->layout;

drivers/md/md.c

5707

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

5708

rdev_for_each(rdev, mddev)

drivers/md/md.c

5712

mddev_unlock(mddev);

drivers/md/md.c

5721

reshape_direction_show(struct mddev *mddev, char *page)

drivers/md/md.c

5724

mddev->reshape_backwards ? "backwards" : "forwards");

drivers/md/md.c

5728

reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5739

if (mddev->reshape_backwards == backwards)

drivers/md/md.c

5742

err = mddev_lock(mddev);

drivers/md/md.c

5746

if (mddev->delta_disks)

drivers/md/md.c

5748

else if (mddev->persistent &&

drivers/md/md.c

5749

mddev->major_version == 0)

drivers/md/md.c

5752

mddev->reshape_backwards = backwards;

drivers/md/md.c

5753

mddev_unlock(mddev);

drivers/md/md.c

5762

array_size_show(struct mddev *mddev, char *page)

drivers/md/md.c

5764

if (mddev->external_size)

drivers/md/md.c

5766

(unsigned long long)mddev->array_sectors/2);

drivers/md/md.c

5772

array_size_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5777

err = mddev_lock(mddev);

drivers/md/md.c

5782

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

5783

mddev_unlock(mddev);

drivers/md/md.c

5788

if (mddev->pers)

drivers/md/md.c

5789

sectors = mddev->pers->size(mddev, 0, 0);

drivers/md/md.c

5791

sectors = mddev->array_sectors;

drivers/md/md.c

5793

mddev->external_size = 0;

drivers/md/md.c

5797

else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)

drivers/md/md.c

5800

mddev->external_size = 1;

drivers/md/md.c

5804

mddev->array_sectors = sectors;

drivers/md/md.c

5805

if (mddev->pers)

drivers/md/md.c

5806

set_capacity_and_notify(mddev->gendisk,

drivers/md/md.c

5807

mddev->array_sectors);

drivers/md/md.c

5809

mddev_unlock(mddev);

drivers/md/md.c

5818

consistency_policy_show(struct mddev *mddev, char *page)

drivers/md/md.c

5822

if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {

drivers/md/md.c

5824

} else if (test_bit(MD_HAS_PPL, &mddev->flags)) {

drivers/md/md.c

5826

} else if (mddev->bitmap) {

drivers/md/md.c

5828

} else if (mddev->pers) {

drivers/md/md.c

5829

if (mddev->pers->sync_request)

drivers/md/md.c

5841

consistency_policy_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5845

if (mddev->pers) {

drivers/md/md.c

5846

if (mddev->pers->change_consistency_policy)

drivers/md/md.c

5847

err = mddev->pers->change_consistency_policy(mddev, buf);

drivers/md/md.c

5850

} else if (mddev->external && strncmp(buf, "ppl", 3) == 0) {

drivers/md/md.c

5851

set_bit(MD_HAS_PPL, &mddev->flags);

drivers/md/md.c

5863

static ssize_t fail_last_dev_show(struct mddev *mddev, char *page)

drivers/md/md.c

5865

return sprintf(page, "%d\n", test_bit(MD_FAILLAST_DEV, &mddev->flags));

drivers/md/md.c

5873

fail_last_dev_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

588

bool md_flush_request(struct mddev *mddev, struct bio *bio)

drivers/md/md.c

5883

set_bit(MD_FAILLAST_DEV, &mddev->flags);

drivers/md/md.c

5885

clear_bit(MD_FAILLAST_DEV, &mddev->flags);

drivers/md/md.c

5893

static ssize_t serialize_policy_show(struct mddev *mddev, char *page)

drivers/md/md.c

5895

if (mddev->pers == NULL || (mddev->pers->head.id != ID_RAID1))

drivers/md/md.c

5899

test_bit(MD_SERIALIZE_POLICY, &mddev->flags));

drivers/md/md.c

5907

serialize_policy_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

5916

if (value == test_bit(MD_SERIALIZE_POLICY, &mddev->flags))

drivers/md/md.c

5919

err = mddev_suspend_and_lock(mddev);

drivers/md/md.c

5922

if (mddev->pers == NULL || (mddev->pers->head.id != ID_RAID1)) {

drivers/md/md.c

5929

mddev_create_serial_pool(mddev, NULL);

drivers/md/md.c

5930

set_bit(MD_SERIALIZE_POLICY, &mddev->flags);

drivers/md/md.c

5932

mddev_destroy_serial_pool(mddev, NULL);

drivers/md/md.c

5933

clear_bit(MD_SERIALIZE_POLICY, &mddev->flags);

drivers/md/md.c

5936

mddev_unlock_and_resume(mddev);

drivers/md/md.c

5944

static int mddev_set_logical_block_size(struct mddev *mddev,

drivers/md/md.c

5950

if (queue_logical_block_size(mddev->gendisk->queue) >= lbs) {

drivers/md/md.c

5952

mdname(mddev), lbs);

drivers/md/md.c

5956

lim = queue_limits_start_update(mddev->gendisk->queue);

drivers/md/md.c

5959

mdname(mddev));

drivers/md/md.c

5960

err = queue_limits_commit_update(mddev->gendisk->queue, &lim);

drivers/md/md.c

5964

mddev->logical_block_size = lbs;

drivers/md/md.c

5966

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

5971

lbs_show(struct mddev *mddev, char *page)

drivers/md/md.c

5973

return sprintf(page, "%u\n", mddev->logical_block_size);

drivers/md/md.c

5977

lbs_store(struct mddev *mddev, const char *buf, size_t len)

drivers/md/md.c

598

WARN_ON(percpu_ref_is_zero(&mddev->active_io));

drivers/md/md.c

5983

if (mddev->major_version == 0)

drivers/md/md.c

5990

if (mddev->pers) {

drivers/md/md.c

5993

if (mddev->logical_block_size)

drivers/md/md.c

600

rdev_for_each(rdev, mddev) {

drivers/md/md.c

6002

curr_lbs = queue_logical_block_size(mddev->gendisk->queue);

drivers/md/md.c

6006

mddev->logical_block_size = curr_lbs;

drivers/md/md.c

6007

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

6009

mdname(mddev));

drivers/md/md.c

6013

err = mddev_lock(mddev);

drivers/md/md.c

6017

err = mddev_set_logical_block_size(mddev, lbs);

drivers/md/md.c

6020

mddev_unlock(mddev);

drivers/md/md.c

606

&mddev->bio_set);

drivers/md/md.c

6088

struct mddev *mddev = container_of(kobj, struct mddev, kobj);

drivers/md/md.c

6094

if (!mddev_get(mddev)) {

drivers/md/md.c

6100

rv = entry->show(mddev, page);

drivers/md/md.c

6101

mddev_put(mddev);

drivers/md/md.c

6110

struct mddev *mddev = container_of(kobj, struct mddev, kobj);

drivers/md/md.c

6123

if (!mddev_get(mddev)) {

drivers/md/md.c

6130

rv = entry->store(mddev, page, length);

drivers/md/md.c

6131

mddev_put(mddev);

drivers/md/md.c

6141

struct mddev *mddev = container_of(ko, struct mddev, kobj);

drivers/md/md.c

6144

if (mddev->sysfs_state)

drivers/md/md.c

6145

sysfs_put(mddev->sysfs_state);

drivers/md/md.c

6146

if (mddev->sysfs_level)

drivers/md/md.c

6147

sysfs_put(mddev->sysfs_level);

drivers/md/md.c

6148

del_gendisk(mddev->gendisk);

drivers/md/md.c

6150

put_disk(mddev->gendisk);

drivers/md/md.c

6166

int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,

drivers/md/md.c

6171

rdev_for_each(rdev, mddev) {

drivers/md/md.c

6173

mddev->gendisk->disk_name);

drivers/md/md.c

6185

mdname(mddev));

drivers/md/md.c

6190

if (mddev->major_version == 0)

drivers/md/md.c

6199

if (!mddev->events) {

drivers/md/md.c

6201

mdname(mddev));

drivers/md/md.c

6202

mddev->logical_block_size = lim->logical_block_size;

drivers/md/md.c

6205

if (!mddev->logical_block_size)

drivers/md/md.c

6208

mdname(mddev));

drivers/md/md.c

6215

int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

6219

if (mddev_is_dm(mddev))

drivers/md/md.c

6223

queue_logical_block_size(mddev->gendisk->queue)) {

drivers/md/md.c

6225

mdname(mddev));

drivers/md/md.c

6229

lim = queue_limits_start_update(mddev->gendisk->queue);

drivers/md/md.c

623

static inline struct mddev *mddev_get(struct mddev *mddev)

drivers/md/md.c

6231

mddev->gendisk->disk_name);

drivers/md/md.c

6235

mdname(mddev), rdev->bdev);

drivers/md/md.c

6236

queue_limits_cancel_update(mddev->gendisk->queue);

drivers/md/md.c

6240

return queue_limits_commit_update(mddev->gendisk->queue, &lim);

drivers/md/md.c

6245

void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes)

drivers/md/md.c

6249

if (mddev_is_dm(mddev))

drivers/md/md.c

6253

if (mddev_suspend(mddev, false) < 0)

drivers/md/md.c

6255

lim = queue_limits_start_update(mddev->gendisk->queue);

drivers/md/md.c

6257

queue_limits_commit_update(mddev->gendisk->queue, &lim);

drivers/md/md.c

6258

mddev_resume(mddev);

drivers/md/md.c

6264

struct mddev *mddev = container_of(ws, struct mddev, del_work);

drivers/md/md.c

6266

kobject_put(&mddev->kobj);

drivers/md/md.c

627

if (test_bit(MD_DELETED, &mddev->flags))

drivers/md/md.c

6277

struct mddev *md_alloc(dev_t dev, char *name)

drivers/md/md.c

6289

struct mddev *mddev;

drivers/md/md.c

629

atomic_inc(&mddev->active);

drivers/md/md.c

630

return mddev;

drivers/md/md.c

6303

mddev = mddev_alloc(dev);

drivers/md/md.c

6304

if (IS_ERR(mddev)) {

drivers/md/md.c

6305

error = PTR_ERR(mddev);

drivers/md/md.c

6309

partitioned = (MAJOR(mddev->unit) != MD_MAJOR);

drivers/md/md.c

6311

unit = MINOR(mddev->unit) >> shift;

drivers/md/md.c

6316

struct mddev *mddev2;

drivers/md/md.c

6332

mddev->hold_active = UNTIL_STOP;

drivers/md/md.c

6340

disk->major = MAJOR(mddev->unit);

drivers/md/md.c

635

static void __mddev_put(struct mddev *mddev)

drivers/md/md.c

6350

disk->private_data = mddev;

drivers/md/md.c

6353

mddev->gendisk = disk;

drivers/md/md.c

6358

kobject_init(&mddev->kobj, &md_ktype);

drivers/md/md.c

6359

error = kobject_add(&mddev->kobj, &disk_to_dev(disk)->kobj, "%s", "md");

drivers/md/md.c

6366

mddev->hold_active = 0;

drivers/md/md.c

6368

mddev_put(mddev);

drivers/md/md.c

637

if (mddev->raid_disks || !list_empty(&mddev->disks) ||

drivers/md/md.c

6372

kobject_uevent(&mddev->kobj, KOBJ_ADD);

drivers/md/md.c

6373

mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");

drivers/md/md.c

6374

mddev->sysfs_level = sysfs_get_dirent_safe(mddev->kobj.sd, "level");

drivers/md/md.c

6376

return mddev;

drivers/md/md.c

638

mddev->ctime || mddev->hold_active)

drivers/md/md.c

6381

mddev_free(mddev);

drivers/md/md.c

6389

struct mddev *mddev = md_alloc(dev, name);

drivers/md/md.c

6394

if (IS_ERR(mddev))

drivers/md/md.c

6395

return PTR_ERR(mddev);

drivers/md/md.c

6396

mddev_put(mddev);

drivers/md/md.c

6439

struct mddev *mddev = timer_container_of(mddev, t, safemode_timer);

drivers/md/md.c

6441

mddev->safemode = 1;

drivers/md/md.c

6442

if (mddev->external)

drivers/md/md.c

6443

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

6445

md_wakeup_thread(mddev->thread);

drivers/md/md.c

6450

static int md_bitmap_create(struct mddev *mddev)

drivers/md/md.c

6452

if (mddev->bitmap_id == ID_BITMAP_NONE)

drivers/md/md.c

6455

if (!mddev_set_bitmap_ops(mddev))

drivers/md/md.c

6458

return mddev->bitmap_ops->create(mddev);

drivers/md/md.c

646

set_bit(MD_DELETED, &mddev->flags);

drivers/md/md.c

6461

static void md_bitmap_destroy(struct mddev *mddev)

drivers/md/md.c

6463

if (!md_bitmap_registered(mddev))

drivers/md/md.c

6466

mddev->bitmap_ops->destroy(mddev);

drivers/md/md.c

6467

mddev_clear_bitmap_ops(mddev);

drivers/md/md.c

6470

int md_run(struct mddev *mddev)

drivers/md/md.c

6477

if (list_empty(&mddev->disks))

drivers/md/md.c

6481

if (mddev->pers)

drivers/md/md.c

6484

if (mddev->sysfs_active)

drivers/md/md.c

6490

if (!mddev->raid_disks) {

drivers/md/md.c

6491

if (!mddev->persistent)

drivers/md/md.c

6493

err = analyze_sbs(mddev);

drivers/md/md.c

6498

if (mddev->level != LEVEL_NONE)

drivers/md/md.c

6499

request_module("md-level-%d", mddev->level);

drivers/md/md.c

6500

else if (mddev->clevel[0])

drivers/md/md.c

6501

request_module("md-%s", mddev->clevel);

drivers/md/md.c

6508

clear_bit(MD_HAS_SUPERBLOCK, &mddev->flags);

drivers/md/md.c

6509

rdev_for_each(rdev, mddev) {

drivers/md/md.c

651

queue_work(md_misc_wq, &mddev->del_work);

drivers/md/md.c

6514

if (mddev->ro != MD_RDONLY && rdev_read_only(rdev)) {

drivers/md/md.c

6515

mddev->ro = MD_RDONLY;

drivers/md/md.c

6516

if (!mddev_is_dm(mddev))

drivers/md/md.c

6517

set_disk_ro(mddev->gendisk, 1);

drivers/md/md.c

6521

set_bit(MD_HAS_SUPERBLOCK, &mddev->flags);

drivers/md/md.c

6530

if (mddev->dev_sectors &&

drivers/md/md.c

6531

rdev->data_offset + mddev->dev_sectors

drivers/md/md.c

6534

mdname(mddev));

drivers/md/md.c

654

static void mddev_put_locked(struct mddev *mddev)

drivers/md/md.c

6541

mdname(mddev));

drivers/md/md.c

6549

pers = get_pers(mddev->level, mddev->clevel);

drivers/md/md.c

6552

if (mddev->level != pers->head.id) {

drivers/md/md.c

6553

mddev->level = pers->head.id;

drivers/md/md.c

6554

mddev->new_level = pers->head.id;

drivers/md/md.c

6556

strscpy(mddev->clevel, pers->head.name, sizeof(mddev->clevel));

drivers/md/md.c

6558

if (mddev->reshape_position != MaxSector &&

drivers/md/md.c

656

if (atomic_dec_and_test(&mddev->active))

drivers/md/md.c

657

__mddev_put(mddev);

drivers/md/md.c

6572

rdev_for_each(rdev, mddev)

drivers/md/md.c

6573

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

6578

mdname(mddev),

drivers/md/md.c

6590

if (mddev->gendisk)

drivers/md/md.c

6591

mddev->recovery = 0;

drivers/md/md.c

6594

mddev->resync_max_sectors = mddev->dev_sectors;

drivers/md/md.c

6596

mddev->ok_start_degraded = start_dirty_degraded;

drivers/md/md.c

6598

if (start_readonly && md_is_rdwr(mddev))

drivers/md/md.c

6599

mddev->ro = MD_AUTO_READ; /* read-only, but switch on first write */

drivers/md/md.c

660

void mddev_put(struct mddev *mddev)

drivers/md/md.c

6601

err = pers->run(mddev);

drivers/md/md.c

6604

else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {

drivers/md/md.c

6605

WARN_ONCE(!mddev->external_size,

drivers/md/md.c

6609

(unsigned long long)mddev->array_sectors / 2,

drivers/md/md.c

6610

(unsigned long long)pers->size(mddev, 0, 0) / 2);

drivers/md/md.c

6614

(mddev->bitmap_info.file || mddev->bitmap_info.offset)) {

drivers/md/md.c

6615

err = md_bitmap_create(mddev);

drivers/md/md.c

6618

mdname(mddev), err);

drivers/md/md.c

662

if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))

drivers/md/md.c

6623

if (mddev->bitmap_info.max_write_behind > 0) {

drivers/md/md.c

6626

rdev_for_each(rdev, mddev) {

drivers/md/md.c

6631

if (create_pool && mddev->serial_info_pool == NULL) {

drivers/md/md.c

6632

mddev->serial_info_pool =

drivers/md/md.c

6635

if (!mddev->serial_info_pool) {

drivers/md/md.c

6643

if (mddev->kobj.sd &&

drivers/md/md.c

6644

sysfs_create_group(&mddev->kobj, &md_redundancy_group))

drivers/md/md.c

6646

mdname(mddev));

drivers/md/md.c

6647

mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");

drivers/md/md.c

6648

mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");

drivers/md/md.c

6649

mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");

drivers/md/md.c

665

__mddev_put(mddev);

drivers/md/md.c

6650

} else if (mddev->ro == MD_AUTO_READ)

drivers/md/md.c

6651

mddev->ro = MD_RDWR;

drivers/md/md.c

6653

atomic_set(&mddev->max_corr_read_errors,

drivers/md/md.c

6655

mddev->safemode = 0;

drivers/md/md.c

6656

if (mddev_is_clustered(mddev))

drivers/md/md.c

6657

mddev->safemode_delay = 0;

drivers/md/md.c

6659

mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;

drivers/md/md.c

6660

mddev->in_sync = 1;

drivers/md/md.c

6662

spin_lock(&mddev->lock);

drivers/md/md.c

6663

mddev->pers = pers;

drivers/md/md.c

6664

spin_unlock(&mddev->lock);

drivers/md/md.c

6665

rdev_for_each(rdev, mddev)

drivers/md/md.c

6667

sysfs_link_rdev(mddev, rdev); /* failure here is OK */

drivers/md/md.c

6669

if (mddev->degraded && md_is_rdwr(mddev))

drivers/md/md.c

6673

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

6674

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

6676

if (mddev->sb_flags)

drivers/md/md.c

6677

md_update_sb(mddev, 0);

drivers/md/md.c

6683

mddev_detach(mddev);

drivers/md/md.c

6684

if (mddev->private)

drivers/md/md.c

6685

pers->free(mddev, mddev->private);

drivers/md/md.c

6686

mddev->private = NULL;

drivers/md/md.c

6688

md_bitmap_destroy(mddev);

drivers/md/md.c

6693

int do_md_run(struct mddev *mddev)

drivers/md/md.c

6697

set_bit(MD_NOT_READY, &mddev->flags);

drivers/md/md.c

6698

err = md_run(mddev);

drivers/md/md.c

6702

if (md_bitmap_registered(mddev)) {

drivers/md/md.c

6703

err = mddev->bitmap_ops->load(mddev);

drivers/md/md.c

6705

md_bitmap_destroy(mddev);

drivers/md/md.c

6710

if (mddev_is_clustered(mddev))

drivers/md/md.c

6711

md_allow_write(mddev);

drivers/md/md.c

6714

md_start(mddev);

drivers/md/md.c

6716

md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */

drivers/md/md.c

6718

set_capacity_and_notify(mddev->gendisk, mddev->array_sectors);

drivers/md/md.c

6719

clear_bit(MD_NOT_READY, &mddev->flags);

drivers/md/md.c

6720

mddev->changed = 1;

drivers/md/md.c

6721

kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);

drivers/md/md.c

6722

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

6723

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

6724

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

6726

clear_bit(MD_NOT_READY, &mddev->flags);

drivers/md/md.c

6730

int md_start(struct mddev *mddev)

drivers/md/md.c

6734

if (mddev->pers->start) {

drivers/md/md.c

6735

set_bit(MD_RECOVERY_WAIT, &mddev->recovery);

drivers/md/md.c

6736

ret = mddev->pers->start(mddev);

drivers/md/md.c

6737

clear_bit(MD_RECOVERY_WAIT, &mddev->recovery);

drivers/md/md.c

6738

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

674

struct mddev *mddev = container_of(ref, struct mddev, active_io);

drivers/md/md.c

6744

static int restart_array(struct mddev *mddev)

drivers/md/md.c

6746

struct gendisk *disk = mddev->gendisk;

drivers/md/md.c

6752

if (list_empty(&mddev->disks))

drivers/md/md.c

6754

if (!mddev->pers)

drivers/md/md.c

6756

if (md_is_rdwr(mddev))

drivers/md/md.c

676

wake_up(&mddev->sb_wait);

drivers/md/md.c

6760

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

6768

if (test_bit(MD_HAS_JOURNAL, &mddev->flags) && !has_journal)

drivers/md/md.c

6774

mddev->safemode = 0;

drivers/md/md.c

6775

mddev->ro = MD_RDWR;

drivers/md/md.c

6777

pr_debug("md: %s switched to read-write mode.\n", mdname(mddev));

drivers/md/md.c

6779

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

6780

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

6781

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

6785

static void md_clean(struct mddev *mddev)

drivers/md/md.c

6787

mddev->array_sectors = 0;

drivers/md/md.c

6788

mddev->external_size = 0;

drivers/md/md.c

6789

mddev->dev_sectors = 0;

drivers/md/md.c

6790

mddev->raid_disks = 0;

drivers/md/md.c

6791

mddev->resync_offset = 0;

drivers/md/md.c

6792

mddev->resync_min = 0;

drivers/md/md.c

6793

mddev->resync_max = MaxSector;

drivers/md/md.c

6794

mddev->reshape_position = MaxSector;

drivers/md/md.c

6796

mddev->persistent = 0;

drivers/md/md.c

6797

mddev->level = LEVEL_NONE;

drivers/md/md.c

6798

mddev->clevel[0] = 0;

drivers/md/md.c

6807

if (legacy_async_del_gendisk && mddev->hold_active) {

drivers/md/md.c

6808

clear_bit(MD_CLOSING, &mddev->flags);

drivers/md/md.c

681

static bool mddev_set_bitmap_ops(struct mddev *mddev)

drivers/md/md.c

6811

mddev->hold_active = 0;

drivers/md/md.c

6813

mddev->flags &= BIT_ULL_MASK(MD_CLOSING);

drivers/md/md.c

6815

mddev->sb_flags = 0;

drivers/md/md.c

6816

mddev->ro = MD_RDWR;

drivers/md/md.c

6817

mddev->metadata_type[0] = 0;

drivers/md/md.c

6818

mddev->chunk_sectors = 0;

drivers/md/md.c

6819

mddev->ctime = mddev->utime = 0;

drivers/md/md.c

6820

mddev->layout = 0;

drivers/md/md.c

6821

mddev->logical_block_size = 0;

drivers/md/md.c

6822

mddev->max_disks = 0;

drivers/md/md.c

6823

mddev->events = 0;

drivers/md/md.c

6824

mddev->can_decrease_events = 0;

drivers/md/md.c

6825

mddev->delta_disks = 0;

drivers/md/md.c

6826

mddev->reshape_backwards = 0;

drivers/md/md.c

6827

mddev->new_level = LEVEL_NONE;

drivers/md/md.c

6828

mddev->new_layout = 0;

drivers/md/md.c

6829

mddev->new_chunk_sectors = 0;

drivers/md/md.c

683

struct bitmap_operations *old = mddev->bitmap_ops;

drivers/md/md.c

6830

mddev->curr_resync = MD_RESYNC_NONE;

drivers/md/md.c

6831

atomic64_set(&mddev->resync_mismatches, 0);

drivers/md/md.c

6832

mddev->suspend_lo = mddev->suspend_hi = 0;

drivers/md/md.c

6833

mddev->sync_speed_min = mddev->sync_speed_max = 0;

drivers/md/md.c

6834

mddev->recovery = 0;

drivers/md/md.c

6835

mddev->in_sync = 0;

drivers/md/md.c

6836

mddev->changed = 0;

drivers/md/md.c

6837

mddev->degraded = 0;

drivers/md/md.c

6838

mddev->safemode = 0;

drivers/md/md.c

6839

mddev->private = NULL;

drivers/md/md.c

6840

mddev->cluster_info = NULL;

drivers/md/md.c

6841

mddev->bitmap_info.offset = 0;

drivers/md/md.c

6842

mddev->bitmap_info.default_offset = 0;

drivers/md/md.c

6843

mddev->bitmap_info.default_space = 0;

drivers/md/md.c

6844

mddev->bitmap_info.chunksize = 0;

drivers/md/md.c

6845

mddev->bitmap_info.daemon_sleep = 0;

drivers/md/md.c

6846

mddev->bitmap_info.max_write_behind = 0;

drivers/md/md.c

6847

mddev->bitmap_info.nodes = 0;

drivers/md/md.c

6850

static void __md_stop_writes(struct mddev *mddev)

drivers/md/md.c

6852

timer_delete_sync(&mddev->safemode_timer);

drivers/md/md.c

6854

if (md_is_rdwr(mddev) || !mddev_is_dm(mddev)) {

drivers/md/md.c

6855

if (mddev->pers && mddev->pers->quiesce) {

drivers/md/md.c

6856

mddev->pers->quiesce(mddev, 1);

drivers/md/md.c

6857

mddev->pers->quiesce(mddev, 0);

drivers/md/md.c

686

if (mddev->bitmap_id == ID_BITMAP_NONE ||

drivers/md/md.c

6860

if (md_bitmap_enabled(mddev, true))

drivers/md/md.c

6861

mddev->bitmap_ops->flush(mddev);

drivers/md/md.c

6864

if (md_is_rdwr(mddev) &&

drivers/md/md.c

6865

((!mddev->in_sync && !mddev_is_clustered(mddev)) ||

drivers/md/md.c

6866

mddev->sb_flags)) {

drivers/md/md.c

6868

if (!mddev_is_clustered(mddev))

drivers/md/md.c

6869

mddev->in_sync = 1;

drivers/md/md.c

687

(old && old->head.id == mddev->bitmap_id))

drivers/md/md.c

6870

md_update_sb(mddev, 1);

drivers/md/md.c

6873

clear_bit(MD_SERIALIZE_POLICY, &mddev->flags);

drivers/md/md.c

6874

mddev_destroy_serial_pool(mddev, NULL);

drivers/md/md.c

6877

void md_stop_writes(struct mddev *mddev)

drivers/md/md.c

6879

mddev_lock_nointr(mddev);

drivers/md/md.c

6880

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

6881

stop_sync_thread(mddev, true);

drivers/md/md.c

6882

__md_stop_writes(mddev);

drivers/md/md.c

6883

mddev_unlock(mddev);

drivers/md/md.c

6887

static void mddev_detach(struct mddev *mddev)

drivers/md/md.c

6889

if (md_bitmap_enabled(mddev, false))

drivers/md/md.c

6890

mddev->bitmap_ops->wait_behind_writes(mddev);

drivers/md/md.c

6891

if (mddev->pers && mddev->pers->quiesce && !is_md_suspended(mddev)) {

drivers/md/md.c

6892

mddev->pers->quiesce(mddev, 1);

drivers/md/md.c

6893

mddev->pers->quiesce(mddev, 0);

drivers/md/md.c

6895

md_unregister_thread(mddev, &mddev->thread);

drivers/md/md.c

6898

if (!mddev_is_dm(mddev))

drivers/md/md.c

6899

blk_sync_queue(mddev->gendisk->queue);

drivers/md/md.c

6902

static void __md_stop(struct mddev *mddev)

drivers/md/md.c

6904

struct md_personality *pers = mddev->pers;

drivers/md/md.c

6906

md_bitmap_destroy(mddev);

drivers/md/md.c

6907

mddev_detach(mddev);

drivers/md/md.c

6908

spin_lock(&mddev->lock);

drivers/md/md.c

6909

mddev->pers = NULL;

drivers/md/md.c

691

head = xa_load(&md_submodule, mddev->bitmap_id);

drivers/md/md.c

6910

spin_unlock(&mddev->lock);

drivers/md/md.c

6911

if (mddev->private)

drivers/md/md.c

6912

pers->free(mddev, mddev->private);

drivers/md/md.c

6913

mddev->private = NULL;

drivers/md/md.c

6915

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

6918

void md_stop(struct mddev *mddev)

drivers/md/md.c

6920

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

6925

__md_stop_writes(mddev);

drivers/md/md.c

6926

__md_stop(mddev);

drivers/md/md.c

6932

static int md_set_readonly(struct mddev *mddev)

drivers/md/md.c

6937

if (mddev->external && test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))

drivers/md/md.c

694

pr_warn("md: can't find bitmap id %d\n", mddev->bitmap_id);

drivers/md/md.c

6940

if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {

drivers/md/md.c

6942

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

6945

stop_sync_thread(mddev, false);

drivers/md/md.c

6946

wait_event(mddev->sb_wait,

drivers/md/md.c

6947

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/md.c

6948

mddev_lock_nointr(mddev);

drivers/md/md.c

6950

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {

drivers/md/md.c

6951

pr_warn("md: %s still in use.\n",mdname(mddev));

drivers/md/md.c

6956

__md_stop_writes(mddev);

drivers/md/md.c

6958

if (mddev->ro == MD_RDONLY) {

drivers/md/md.c

6963

mddev->ro = MD_RDONLY;

drivers/md/md.c

6964

set_disk_ro(mddev->gendisk, 1);

drivers/md/md.c

6968

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

6969

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

6970

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

6980

static int do_md_stop(struct mddev *mddev, int mode)

drivers/md/md.c

6982

struct gendisk *disk = mddev->gendisk;

drivers/md/md.c

6986

if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {

drivers/md/md.c

6988

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

699

pr_warn("md: invalid bitmap id %d\n", mddev->bitmap_id);

drivers/md/md.c

6991

stop_sync_thread(mddev, true);

drivers/md/md.c

6993

if (mddev->sysfs_active ||

drivers/md/md.c

6994

test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {

drivers/md/md.c

6995

pr_warn("md: %s still in use.\n",mdname(mddev));

drivers/md/md.c

6997

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

6998

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

7002

if (mddev->pers) {

drivers/md/md.c

7003

if (!md_is_rdwr(mddev))

drivers/md/md.c

7006

if (mode == 2 && mddev->pers->sync_request &&

drivers/md/md.c

7007

mddev->to_remove == NULL)

drivers/md/md.c

7008

mddev->to_remove = &md_redundancy_group;

drivers/md/md.c

7010

__md_stop_writes(mddev);

drivers/md/md.c

7011

__md_stop(mddev);

drivers/md/md.c

7014

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

7016

rdev_for_each(rdev, mddev)

drivers/md/md.c

7018

sysfs_unlink_rdev(mddev, rdev);

drivers/md/md.c

7021

mddev->changed = 1;

drivers/md/md.c

7023

if (!md_is_rdwr(mddev))

drivers/md/md.c

7024

mddev->ro = MD_RDWR;

drivers/md/md.c

703

mddev->bitmap_ops = (void *)head;

drivers/md/md.c

7030

pr_info("md: %s stopped.\n", mdname(mddev));

drivers/md/md.c

7032

if (mddev->bitmap_info.file) {

drivers/md/md.c

7033

struct file *f = mddev->bitmap_info.file;

drivers/md/md.c

7034

spin_lock(&mddev->lock);

drivers/md/md.c

7035

mddev->bitmap_info.file = NULL;

drivers/md/md.c

7036

spin_unlock(&mddev->lock);

drivers/md/md.c

7039

mddev->bitmap_info.offset = 0;

drivers/md/md.c

7041

export_array(mddev);

drivers/md/md.c

7042

md_clean(mddev);

drivers/md/md.c

7044

set_bit(MD_DELETED, &mddev->flags);

drivers/md/md.c

7047

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

7052

static void autorun_array(struct mddev *mddev)

drivers/md/md.c

7057

if (list_empty(&mddev->disks))

drivers/md/md.c

706

if (!mddev_is_dm(mddev) && mddev->bitmap_ops->group) {

drivers/md/md.c

7062

rdev_for_each(rdev, mddev) {

drivers/md/md.c

7067

err = do_md_run(mddev);

drivers/md/md.c

707

if (sysfs_create_group(&mddev->kobj, mddev->bitmap_ops->group))

drivers/md/md.c

7070

do_md_stop(mddev, 0);

drivers/md/md.c

7089

struct mddev *mddev;

drivers/md/md.c

709

mdname(mddev));

drivers/md/md.c

7126

mddev = md_alloc(dev, NULL);

drivers/md/md.c

7127

if (IS_ERR(mddev))

drivers/md/md.c

7130

if (mddev_suspend_and_lock(mddev))

drivers/md/md.c

7131

pr_warn("md: %s locked, cannot run\n", mdname(mddev));

drivers/md/md.c

7132

else if (mddev->raid_disks || mddev->major_version

drivers/md/md.c

7133

|| !list_empty(&mddev->disks)) {

drivers/md/md.c

7135

mdname(mddev), rdev0->bdev);

drivers/md/md.c

7136

mddev_unlock_and_resume(mddev);

drivers/md/md.c

7138

pr_debug("md: created %s\n", mdname(mddev));

drivers/md/md.c

7139

mddev->persistent = 1;

drivers/md/md.c

7142

if (bind_rdev_to_array(rdev, mddev))

drivers/md/md.c

7143

export_rdev(rdev, mddev);

drivers/md/md.c

7145

autorun_array(mddev);

drivers/md/md.c

7146

mddev_unlock_and_resume(mddev);

drivers/md/md.c

715

kobject_uevent(&mddev->kobj, KOBJ_CHANGE);

drivers/md/md.c

7153

export_rdev(rdev, mddev);

drivers/md/md.c

7155

mddev_put(mddev);

drivers/md/md.c

7175

static int get_array_info(struct mddev *mddev, void __user *arg)

drivers/md/md.c

7183

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

7200

info.major_version = mddev->major_version;

drivers/md/md.c

7201

info.minor_version = mddev->minor_version;

drivers/md/md.c

7203

info.ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);

drivers/md/md.c

7204

info.level = mddev->level;

drivers/md/md.c

7205

info.size = mddev->dev_sectors / 2;

drivers/md/md.c

7206

if (info.size != mddev->dev_sectors / 2) /* overflow */

drivers/md/md.c

7209

info.raid_disks = mddev->raid_disks;

drivers/md/md.c

7210

info.md_minor = mddev->md_minor;

drivers/md/md.c

7211

info.not_persistent= !mddev->persistent;

drivers/md/md.c

7213

info.utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);

drivers/md/md.c

7215

if (mddev->in_sync)

drivers/md/md.c

7217

if (mddev->bitmap && mddev->bitmap_info.offset)

drivers/md/md.c

7219

if (mddev_is_clustered(mddev))

drivers/md/md.c

7226

info.layout = mddev->layout;

drivers/md/md.c

7227

info.chunk_size = mddev->chunk_sectors << 9;

drivers/md/md.c

7235

static int get_bitmap_file(struct mddev *mddev, void __user * arg)

drivers/md/md.c

724

static void mddev_clear_bitmap_ops(struct mddev *mddev)

drivers/md/md.c

7246

spin_lock(&mddev->lock);

drivers/md/md.c

7248

if (mddev->bitmap_info.file) {

drivers/md/md.c

7249

ptr = file_path(mddev->bitmap_info.file, file->pathname,

drivers/md/md.c

7257

spin_unlock(&mddev->lock);

drivers/md/md.c

726

if (!mddev_is_dm(mddev) && mddev->bitmap_ops &&

drivers/md/md.c

7267

static int get_disk_info(struct mddev *mddev, void __user * arg)

drivers/md/md.c

727

mddev->bitmap_ops->group)

drivers/md/md.c

7276

rdev = md_find_rdev_nr_rcu(mddev, info.number);

drivers/md/md.c

728

sysfs_remove_group(&mddev->kobj, mddev->bitmap_ops->group);

drivers/md/md.c

730

mddev->bitmap_ops = NULL;

drivers/md/md.c

7307

int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info)

drivers/md/md.c

7312

if (mddev_is_clustered(mddev) &&

drivers/md/md.c

7315

mdname(mddev));

drivers/md/md.c

7322

if (!mddev->raid_disks) {

drivers/md/md.c

7325

rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);

drivers/md/md.c

733

int mddev_init(struct mddev *mddev)

drivers/md/md.c

7331

if (!list_empty(&mddev->disks)) {

drivers/md/md.c

7333

= list_entry(mddev->disks.next,

drivers/md/md.c

7335

err = super_types[mddev->major_version]

drivers/md/md.c

7336

.load_super(rdev, rdev0, mddev->minor_version);

drivers/md/md.c

7341

export_rdev(rdev, mddev);

drivers/md/md.c

7345

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

7347

export_rdev(rdev, mddev);

drivers/md/md.c

7356

if (mddev->pers) {

drivers/md/md.c

7358

if (!mddev->pers->hot_add_disk) {

drivers/md/md.c

7360

mdname(mddev));

drivers/md/md.c

7363

if (mddev->persistent)

drivers/md/md.c

7364

rdev = md_import_device(dev, mddev->major_version,

drivers/md/md.c

7365

mddev->minor_version);

drivers/md/md.c

7374

if (!mddev->persistent) {

drivers/md/md.c

7376

info->raid_disk < mddev->raid_disks) {

drivers/md/md.c

738

mddev->bitmap_id = ID_BITMAP_NONE;

drivers/md/md.c

7383

super_types[mddev->major_version].

drivers/md/md.c

7384

validate_super(mddev, NULL/*freshest*/, rdev);

drivers/md/md.c

7390

export_rdev(rdev, mddev);

drivers/md/md.c

740

mddev->bitmap_id = ID_BITMAP;

drivers/md/md.c

7409

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

7415

if (has_journal || mddev->bitmap) {

drivers/md/md.c

7416

export_rdev(rdev, mddev);

drivers/md/md.c

742

if (percpu_ref_init(&mddev->active_io, active_io_release,

drivers/md/md.c

7424

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

7429

err = mddev->cluster_ops->add_new_disk(mddev, rdev);

drivers/md/md.c

7431

export_rdev(rdev, mddev);

drivers/md/md.c

7438

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

7441

export_rdev(rdev, mddev);

drivers/md/md.c

7443

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

7446

err = mddev->cluster_ops->new_disk_ack(

drivers/md/md.c

7447

mddev, err == 0);

drivers/md/md.c

7453

mddev->cluster_ops->add_new_disk_cancel(mddev);

drivers/md/md.c

746

if (percpu_ref_init(&mddev->writes_pending, no_op,

drivers/md/md.c

7467

if (mddev->major_version != 0) {

drivers/md/md.c

7468

pr_warn("%s: ADD_NEW_DISK not supported\n", mdname(mddev));

drivers/md/md.c

7481

if (info->raid_disk < mddev->raid_disks)

drivers/md/md.c

7486

if (rdev->raid_disk < mddev->raid_disks)

drivers/md/md.c

7495

if (!mddev->persistent) {

drivers/md/md.c

7502

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

7504

export_rdev(rdev, mddev);

drivers/md/md.c

7512

static int hot_remove_disk(struct mddev *mddev, dev_t dev)

drivers/md/md.c

7516

if (!mddev->pers)

drivers/md/md.c

7519

rdev = find_rdev(mddev, dev);

drivers/md/md.c

752

err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);

drivers/md/md.c

7527

remove_and_add_spares(mddev, rdev);

drivers/md/md.c

7533

if (mddev_is_clustered(mddev) &&

drivers/md/md.c

7534

mddev->cluster_ops->remove_disk(mddev, rdev))

drivers/md/md.c

7538

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

7539

if (!mddev->thread)

drivers/md/md.c

7540

md_update_sb(mddev, 1);

drivers/md/md.c

7546

rdev->bdev, mdname(mddev));

drivers/md/md.c

7550

static int hot_add_disk(struct mddev *mddev, dev_t dev)

drivers/md/md.c

7555

if (!mddev->pers)

drivers/md/md.c

7558

if (mddev->major_version != 0) {

drivers/md/md.c

756

err = bioset_init(&mddev->sync_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);

drivers/md/md.c

7560

mdname(mddev));

drivers/md/md.c

7563

if (!mddev->pers->hot_add_disk) {

drivers/md/md.c

7565

mdname(mddev));

drivers/md/md.c

7576

if (mddev->persistent)

drivers/md/md.c

7585

rdev->bdev, mdname(mddev));

drivers/md/md.c

7593

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

760

err = bioset_init(&mddev->io_clone_set, BIO_POOL_SIZE,

drivers/md/md.c

7604

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

7605

if (!mddev->thread)

drivers/md/md.c

7606

md_update_sb(mddev, 1);

drivers/md/md.c

7611

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

7616

export_rdev(rdev, mddev);

drivers/md/md.c

7620

static int set_bitmap_file(struct mddev *mddev, int fd)

drivers/md/md.c

7624

if (!md_bitmap_registered(mddev))

drivers/md/md.c

7627

if (mddev->pers) {

drivers/md/md.c

7628

if (!mddev->pers->quiesce || !mddev->thread)

drivers/md/md.c

7630

if (mddev->recovery || mddev->sync_thread)

drivers/md/md.c

7639

if (mddev->bitmap || mddev->bitmap_info.file)

drivers/md/md.c

7644

mdname(mddev));

drivers/md/md.c

7648

mdname(mddev));

drivers/md/md.c

7654

mdname(mddev));

drivers/md/md.c

766

percpu_ref_put(&mddev->writes_pending);

drivers/md/md.c

7661

mdname(mddev));

drivers/md/md.c

7665

mdname(mddev));

drivers/md/md.c

7669

mdname(mddev));

drivers/md/md.c

7676

mddev->bitmap_info.file = f;

drivers/md/md.c

7677

mddev->bitmap_info.offset = 0; /* file overrides offset */

drivers/md/md.c

7678

} else if (mddev->bitmap == NULL)

drivers/md/md.c

768

mutex_init(&mddev->open_mutex);

drivers/md/md.c

7681

if (mddev->pers) {

drivers/md/md.c

7683

err = md_bitmap_create(mddev);

drivers/md/md.c

7685

err = mddev->bitmap_ops->load(mddev);

drivers/md/md.c

7688

md_bitmap_destroy(mddev);

drivers/md/md.c

769

mutex_init(&mddev->reconfig_mutex);

drivers/md/md.c

7692

md_bitmap_destroy(mddev);

drivers/md/md.c

7697

struct file *f = mddev->bitmap_info.file;

drivers/md/md.c

7699

spin_lock(&mddev->lock);

drivers/md/md.c

770

mutex_init(&mddev->suspend_mutex);

drivers/md/md.c

7700

mddev->bitmap_info.file = NULL;

drivers/md/md.c

7701

spin_unlock(&mddev->lock);

drivers/md/md.c

771

mutex_init(&mddev->bitmap_info.mutex);

drivers/md/md.c

772

INIT_LIST_HEAD(&mddev->disks);

drivers/md/md.c

7722

int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info)

drivers/md/md.c

773

INIT_LIST_HEAD(&mddev->all_mddevs);

drivers/md/md.c

7734

mddev->major_version = info->major_version;

drivers/md/md.c

7735

mddev->minor_version = info->minor_version;

drivers/md/md.c

7736

mddev->patch_version = info->patch_version;

drivers/md/md.c

7737

mddev->persistent = !info->not_persistent;

drivers/md/md.c

774

INIT_LIST_HEAD(&mddev->deleting);

drivers/md/md.c

7741

mddev->ctime = ktime_get_real_seconds();

drivers/md/md.c

7744

mddev->major_version = MD_MAJOR_VERSION;

drivers/md/md.c

7745

mddev->minor_version = MD_MINOR_VERSION;

drivers/md/md.c

7746

mddev->patch_version = MD_PATCHLEVEL_VERSION;

drivers/md/md.c

7747

mddev->ctime = ktime_get_real_seconds();

drivers/md/md.c

7749

mddev->level = info->level;

drivers/md/md.c

775

timer_setup(&mddev->safemode_timer, md_safemode_timeout, 0);

drivers/md/md.c

7750

mddev->clevel[0] = 0;

drivers/md/md.c

7751

mddev->dev_sectors = 2 * (sector_t)info->size;

drivers/md/md.c

7752

mddev->raid_disks = info->raid_disks;

drivers/md/md.c

7757

mddev->resync_offset = MaxSector;

drivers/md/md.c

7759

mddev->resync_offset = 0;

drivers/md/md.c

776

atomic_set(&mddev->active, 1);

drivers/md/md.c

7760

mddev->persistent = ! info->not_persistent;

drivers/md/md.c

7761

mddev->external = 0;

drivers/md/md.c

7763

mddev->layout = info->layout;

drivers/md/md.c

7764

if (mddev->level == 0)

drivers/md/md.c

7766

mddev->layout = -1;

drivers/md/md.c

7767

mddev->chunk_sectors = info->chunk_size >> 9;

drivers/md/md.c

7769

if (mddev->persistent) {

drivers/md/md.c

777

atomic_set(&mddev->openers, 0);

drivers/md/md.c

7770

mddev->max_disks = MD_SB_DISKS;

drivers/md/md.c

7771

mddev->flags = 0;

drivers/md/md.c

7772

mddev->sb_flags = 0;

drivers/md/md.c

7774

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

7776

mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;

drivers/md/md.c

7777

mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);

drivers/md/md.c

7778

mddev->bitmap_info.offset = 0;

drivers/md/md.c

778

atomic_set(&mddev->sync_seq, 0);

drivers/md/md.c

7780

mddev->reshape_position = MaxSector;

drivers/md/md.c

7785

get_random_bytes(mddev->uuid, 16);

drivers/md/md.c

7787

mddev->new_level = mddev->level;

drivers/md/md.c

7788

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

7789

mddev->new_layout = mddev->layout;

drivers/md/md.c

779

spin_lock_init(&mddev->lock);

drivers/md/md.c

7790

mddev->delta_disks = 0;

drivers/md/md.c

7791

mddev->reshape_backwards = 0;

drivers/md/md.c

7796

void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)

drivers/md/md.c

7798

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

780

init_waitqueue_head(&mddev->sb_wait);

drivers/md/md.c

7800

if (mddev->external_size)

drivers/md/md.c

7803

mddev->array_sectors = array_sectors;

drivers/md/md.c

7807

static int update_size(struct mddev *mddev, sector_t num_sectors)

drivers/md/md.c

781

init_waitqueue_head(&mddev->recovery_wait);

drivers/md/md.c

7812

sector_t old_dev_sectors = mddev->dev_sectors;

drivers/md/md.c

7814

if (mddev->pers->resize == NULL)

drivers/md/md.c

782

mddev->reshape_position = MaxSector;

drivers/md/md.c

7825

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/md.c

7827

if (!md_is_rdwr(mddev))

drivers/md/md.c

783

mddev->reshape_backwards = 0;

drivers/md/md.c

7830

rdev_for_each(rdev, mddev) {

drivers/md/md.c

7838

rv = mddev->pers->resize(mddev, num_sectors);

drivers/md/md.c

784

mddev->last_sync_action = ACTION_IDLE;

drivers/md/md.c

7840

if (mddev_is_clustered(mddev))

drivers/md/md.c

7841

mddev->cluster_ops->update_size(mddev, old_dev_sectors);

drivers/md/md.c

7842

else if (!mddev_is_dm(mddev))

drivers/md/md.c

7843

set_capacity_and_notify(mddev->gendisk,

drivers/md/md.c

7844

mddev->array_sectors);

drivers/md/md.c

7849

static int update_raid_disks(struct mddev *mddev, int raid_disks)

drivers/md/md.c

785

mddev->resync_min = 0;

drivers/md/md.c

7854

if (mddev->pers->check_reshape == NULL)

drivers/md/md.c

7856

if (!md_is_rdwr(mddev))

drivers/md/md.c

7859

(mddev->max_disks && raid_disks >= mddev->max_disks))

drivers/md/md.c

786

mddev->resync_max = MaxSector;

drivers/md/md.c

7861

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||

drivers/md/md.c

7862

test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) ||

drivers/md/md.c

7863

mddev->reshape_position != MaxSector)

drivers/md/md.c

7866

rdev_for_each(rdev, mddev) {

drivers/md/md.c

7867

if (mddev->raid_disks < raid_disks &&

drivers/md/md.c

787

mddev->level = LEVEL_NONE;

drivers/md/md.c

7870

if (mddev->raid_disks > raid_disks &&

drivers/md/md.c

7875

mddev->delta_disks = raid_disks - mddev->raid_disks;

drivers/md/md.c

7876

if (mddev->delta_disks < 0)

drivers/md/md.c

7877

mddev->reshape_backwards = 1;

drivers/md/md.c

7878

else if (mddev->delta_disks > 0)

drivers/md/md.c

7879

mddev->reshape_backwards = 0;

drivers/md/md.c

7881

rv = mddev->pers->check_reshape(mddev);

drivers/md/md.c

7883

mddev->delta_disks = 0;

drivers/md/md.c

7884

mddev->reshape_backwards = 0;

drivers/md/md.c

7889

static int get_cluster_ops(struct mddev *mddev)

drivers/md/md.c

789

INIT_WORK(&mddev->sync_work, md_start_sync);

drivers/md/md.c

7892

mddev->cluster_ops = xa_load(&md_submodule, ID_CLUSTER);

drivers/md/md.c

7893

if (mddev->cluster_ops &&

drivers/md/md.c

7894

!try_module_get(mddev->cluster_ops->head.owner))

drivers/md/md.c

7895

mddev->cluster_ops = NULL;

drivers/md/md.c

7898

return mddev->cluster_ops == NULL ? -ENOENT : 0;

drivers/md/md.c

790

INIT_WORK(&mddev->del_work, mddev_delayed_delete);

drivers/md/md.c

7901

static void put_cluster_ops(struct mddev *mddev)

drivers/md/md.c

7903

if (!mddev->cluster_ops)

drivers/md/md.c

7906

mddev->cluster_ops->leave(mddev);

drivers/md/md.c

7907

module_put(mddev->cluster_ops->head.owner);

drivers/md/md.c

7908

mddev->cluster_ops = NULL;

drivers/md/md.c

7919

static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)

drivers/md/md.c

7926

if (mddev->bitmap && mddev->bitmap_info.offset)

drivers/md/md.c

7929

if (mddev->major_version != info->major_version ||

drivers/md/md.c

7930

mddev->minor_version != info->minor_version ||

drivers/md/md.c

7932

mddev->ctime != info->ctime ||

drivers/md/md.c

7933

mddev->level != info->level ||

drivers/md/md.c

7935

mddev->persistent != !info->not_persistent ||

drivers/md/md.c

7936

mddev->chunk_sectors != info->chunk_size >> 9 ||

drivers/md/md.c

7942

if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)

drivers/md/md.c

7944

if (mddev->raid_disks != info->raid_disks)

drivers/md/md.c

7946

if (mddev->layout != info->layout)

drivers/md/md.c

795

bioset_exit(&mddev->sync_set);

drivers/md/md.c

7955

if (mddev->layout != info->layout) {

drivers/md/md.c

7960

if (mddev->pers->check_reshape == NULL)

drivers/md/md.c

7963

mddev->new_layout = info->layout;

drivers/md/md.c

7964

rv = mddev->pers->check_reshape(mddev);

drivers/md/md.c

7966

mddev->new_layout = mddev->layout;

drivers/md/md.c

797

bioset_exit(&mddev->bio_set);

drivers/md/md.c

7970

if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)

drivers/md/md.c

7971

rv = update_size(mddev, (sector_t)info->size * 2);

drivers/md/md.c

7973

if (mddev->raid_disks != info->raid_disks)

drivers/md/md.c

7974

rv = update_raid_disks(mddev, info->raid_disks);

drivers/md/md.c

7977

if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {

drivers/md/md.c

7981

if (mddev->recovery || mddev->sync_thread) {

drivers/md/md.c

7987

if (mddev->bitmap) {

drivers/md/md.c

799

percpu_ref_exit(&mddev->writes_pending);

drivers/md/md.c

7991

if (mddev->bitmap_info.default_offset == 0) {

drivers/md/md.c

7995

mddev->bitmap_info.offset =

drivers/md/md.c

7996

mddev->bitmap_info.default_offset;

drivers/md/md.c

7997

mddev->bitmap_info.space =

drivers/md/md.c

7998

mddev->bitmap_info.default_space;

drivers/md/md.c

7999

rv = md_bitmap_create(mddev);

drivers/md/md.c

8001

rv = mddev->bitmap_ops->load(mddev);

drivers/md/md.c

8004

md_bitmap_destroy(mddev);

drivers/md/md.c

8008

rv = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/md.c

801

percpu_ref_exit(&mddev->active_io);

drivers/md/md.c

8017

if (mddev->bitmap_info.nodes) {

drivers/md/md.c

8019

if (mddev->cluster_ops->lock_all_bitmaps(mddev) <= 0) {

drivers/md/md.c

8022

mddev->cluster_ops->unlock_all_bitmaps(mddev);

drivers/md/md.c

8026

mddev->bitmap_info.nodes = 0;

drivers/md/md.c

8027

put_cluster_ops(mddev);

drivers/md/md.c

8028

mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;

drivers/md/md.c

8030

md_bitmap_destroy(mddev);

drivers/md/md.c

8031

mddev->bitmap_info.offset = 0;

drivers/md/md.c

8034

md_update_sb(mddev, 1);

drivers/md/md.c

8040

static int set_disk_faulty(struct mddev *mddev, dev_t dev)

drivers/md/md.c

8045

if (mddev->pers == NULL)

drivers/md/md.c

8049

rdev = md_find_rdev_rcu(mddev, dev);

drivers/md/md.c

8053

md_error(mddev, rdev);

drivers/md/md.c

8054

if (test_bit(MD_BROKEN, &mddev->flags))

drivers/md/md.c

806

void mddev_destroy(struct mddev *mddev)

drivers/md/md.c

8069

struct mddev *mddev = disk->private_data;

drivers/md/md.c

8073

geo->cylinders = mddev->array_sectors / 8;

drivers/md/md.c

808

bioset_exit(&mddev->bio_set);

drivers/md/md.c

809

bioset_exit(&mddev->sync_set);

drivers/md/md.c

810

bioset_exit(&mddev->io_clone_set);

drivers/md/md.c

811

percpu_ref_exit(&mddev->active_io);

drivers/md/md.c

8118

static int __md_set_array_info(struct mddev *mddev, void __user *argp)

drivers/md/md.c

812

percpu_ref_exit(&mddev->writes_pending);

drivers/md/md.c

8128

if (mddev->pers) {

drivers/md/md.c

8129

err = update_array_info(mddev, &info);

drivers/md/md.c

8135

if (!list_empty(&mddev->disks)) {

drivers/md/md.c

8136

pr_warn("md: array %s already has disks!\n", mdname(mddev));

drivers/md/md.c

8140

if (mddev->raid_disks) {

drivers/md/md.c

8141

pr_warn("md: array %s already initialised!\n", mdname(mddev));

drivers/md/md.c

8145

err = md_set_array_info(mddev, &info);

drivers/md/md.c

8157

struct mddev *mddev = NULL;

drivers/md/md.c

816

static struct mddev *mddev_find_locked(dev_t unit)

drivers/md/md.c

8174

mddev = bdev->bd_disk->private_data;

drivers/md/md.c

8179

if (!mddev->raid_disks && !mddev->external)

drivers/md/md.c

818

struct mddev *mddev;

drivers/md/md.c

8181

return get_array_info(mddev, argp);

drivers/md/md.c

8184

if (!mddev->raid_disks && !mddev->external)

drivers/md/md.c

8186

return get_disk_info(mddev, argp);

drivers/md/md.c

8189

return set_disk_faulty(mddev, new_decode_dev(arg));

drivers/md/md.c

8192

return get_bitmap_file(mddev, argp);

drivers/md/md.c

8199

err = mddev_set_closing_and_sync_blockdev(mddev, 1);

drivers/md/md.c

820

list_for_each_entry(mddev, &all_mddevs, all_mddevs)

drivers/md/md.c

8204

if (!md_is_rdwr(mddev))

drivers/md/md.c

8205

flush_work(&mddev->sync_work);

drivers/md/md.c

8207

err = md_ioctl_need_suspend(cmd) ? mddev_suspend_and_lock(mddev) :

drivers/md/md.c

8208

mddev_lock(mddev);

drivers/md/md.c

821

if (mddev->unit == unit)

drivers/md/md.c

8216

err = __md_set_array_info(mddev, argp);

drivers/md/md.c

822

return mddev;

drivers/md/md.c

8225

if ((!mddev->raid_disks && !mddev->external)

drivers/md/md.c

8238

err = restart_array(mddev);

drivers/md/md.c

8242

err = do_md_stop(mddev, 0);

drivers/md/md.c

8246

if (mddev->pers)

drivers/md/md.c

8247

err = md_set_readonly(mddev);

drivers/md/md.c

8251

err = hot_remove_disk(mddev, new_decode_dev(arg));

drivers/md/md.c

8259

if (mddev->pers) {

drivers/md/md.c

8267

err = md_add_new_disk(mddev, &info);

drivers/md/md.c

8277

if (!md_is_rdwr(mddev) && mddev->pers) {

drivers/md/md.c

8278

if (mddev->ro != MD_AUTO_READ) {

drivers/md/md.c

8282

mddev->ro = MD_RDWR;

drivers/md/md.c

8283

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

8284

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

8289

if (test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)) {

drivers/md/md.c

8290

mddev_unlock(mddev);

drivers/md/md.c

8291

wait_event(mddev->sb_wait,

drivers/md/md.c

8292

!test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags) &&

drivers/md/md.c

8293

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/md.c

8294

mddev_lock_nointr(mddev);

drivers/md/md.c

8305

err = md_add_new_disk(mddev, &info);

drivers/md/md.c

8310

if (mddev_is_clustered(mddev))

drivers/md/md.c

8311

mddev->cluster_ops->new_disk_ack(mddev, false);

drivers/md/md.c

8317

err = hot_add_disk(mddev, new_decode_dev(arg));

drivers/md/md.c

8321

err = do_md_run(mddev);

drivers/md/md.c

8325

err = set_bitmap_file(mddev, (int)arg);

drivers/md/md.c

8334

if (mddev->hold_active == UNTIL_IOCTL &&

drivers/md/md.c

8336

mddev->hold_active = 0;

drivers/md/md.c

8338

md_ioctl_need_suspend(cmd) ? mddev_unlock_and_resume(mddev) :

drivers/md/md.c

8339

mddev_unlock(mddev);

drivers/md/md.c

8343

clear_bit(MD_CLOSING, &mddev->flags);

drivers/md/md.c

8368

struct mddev *mddev = bdev->bd_disk->private_data;

drivers/md/md.c

8371

err = mddev_lock(mddev);

drivers/md/md.c

8375

if (!mddev->raid_disks && !mddev->external) {

drivers/md/md.c

8384

if (!ro && mddev->ro == MD_RDONLY && mddev->pers) {

drivers/md/md.c

8385

err = restart_array(mddev);

drivers/md/md.c

8388

mddev->ro = MD_AUTO_READ;

drivers/md/md.c

8392

mddev_unlock(mddev);

drivers/md/md.c

8398

struct mddev *mddev;

drivers/md/md.c

8402

mddev = mddev_get(disk->private_data);

drivers/md/md.c

8404

if (!mddev)

drivers/md/md.c

8407

err = mutex_lock_interruptible(&mddev->open_mutex);

drivers/md/md.c

8412

if (test_bit(MD_CLOSING, &mddev->flags))

drivers/md/md.c

8415

atomic_inc(&mddev->openers);

drivers/md/md.c

8416

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

8422

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

8424

mddev_put(mddev);

drivers/md/md.c

8430

struct mddev *mddev = disk->private_data;

drivers/md/md.c

8432

BUG_ON(!mddev);

drivers/md/md.c

8433

atomic_dec(&mddev->openers);

drivers/md/md.c

8434

mddev_put(mddev);

drivers/md/md.c

8439

struct mddev *mddev = disk->private_data;

drivers/md/md.c

8442

if (mddev->changed)

drivers/md/md.c

8444

mddev->changed = 0;

drivers/md/md.c

8450

struct mddev *mddev = disk->private_data;

drivers/md/md.c

8452

mddev_free(mddev);

drivers/md/md.c

848

static struct mddev *mddev_alloc(dev_t unit)

drivers/md/md.c

850

struct mddev *new;

drivers/md/md.c

8540

struct mddev *mddev, const char *name)

drivers/md/md.c

8551

thread->mddev = mddev;

drivers/md/md.c

8555

mdname(thread->mddev),

drivers/md/md.c

8565

void md_unregister_thread(struct mddev *mddev, struct md_thread __rcu **threadp)

drivers/md/md.c

8568

lockdep_is_held(&mddev->reconfig_mutex));

drivers/md/md.c

8582

void md_error(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

8587

if (!mddev->pers || !mddev->pers->error_handler)

drivers/md/md.c

8589

mddev->pers->error_handler(mddev, rdev);

drivers/md/md.c

8591

if (mddev->pers->head.id == ID_RAID0 ||

drivers/md/md.c

8592

mddev->pers->head.id == ID_LINEAR)

drivers/md/md.c

8595

if (mddev->degraded && !test_bit(MD_BROKEN, &mddev->flags))

drivers/md/md.c

8596

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

8598

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

8599

if (!test_bit(MD_BROKEN, &mddev->flags)) {

drivers/md/md.c

8600

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

8601

md_wakeup_thread(mddev->thread);

drivers/md/md.c

8603

if (mddev->event_work.func)

drivers/md/md.c

8604

queue_work(md_misc_wq, &mddev->event_work);

drivers/md/md.c

8644

static int status_resync(struct seq_file *seq, struct mddev *mddev)

drivers/md/md.c

8652

if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||

drivers/md/md.c

8653

test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))

drivers/md/md.c

8654

max_sectors = mddev->resync_max_sectors;

drivers/md/md.c

8656

max_sectors = mddev->dev_sectors;

drivers/md/md.c

8658

resync = mddev->curr_resync;

drivers/md/md.c

8660

if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))

drivers/md/md.c

8666

res = atomic_read(&mddev->recovery_active);

drivers/md/md.c

8679

if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery)) {

drivers/md/md.c

8682

rdev_for_each(rdev, mddev)

drivers/md/md.c

8690

if (mddev->reshape_position != MaxSector)

drivers/md/md.c

8696

if (mddev->resync_offset < MaxSector) {

drivers/md/md.c

8733

(test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?

drivers/md/md.c

8735

(test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?

drivers/md/md.c

8737

(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?

drivers/md/md.c

8760

dt = ((jiffies - mddev->resync_mark) / HZ);

drivers/md/md.c

8763

curr_mark_cnt = mddev->curr_mark_cnt;

drivers/md/md.c

8764

recovery_active = atomic_read(&mddev->recovery_active);

drivers/md/md.c

8765

resync_mark_cnt = mddev->resync_mark_cnt;

drivers/md/md.c

8802

static void md_bitmap_status(struct seq_file *seq, struct mddev *mddev)

drivers/md/md.c

8809

if (!md_bitmap_enabled(mddev, false))

drivers/md/md.c

8812

err = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/md.c

8816

chunk_kb = mddev->bitmap_info.chunksize >> 10;

drivers/md/md.c

8821

chunk_kb ? chunk_kb : mddev->bitmap_info.chunksize,

drivers/md/md.c

8834

struct mddev *mddev;

drivers/md/md.c

8845

mddev = list_entry(v, struct mddev, all_mddevs);

drivers/md/md.c

8846

if (!mddev_get(mddev))

drivers/md/md.c

8852

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md.c

8854

spin_lock(&mddev->lock);

drivers/md/md.c

8855

if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {

drivers/md/md.c

8856

seq_printf(seq, "%s : ", mdname(mddev));

drivers/md/md.c

8857

if (mddev->pers) {

drivers/md/md.c

8858

if (test_bit(MD_BROKEN, &mddev->flags))

drivers/md/md.c

8862

if (mddev->ro == MD_RDONLY)

drivers/md/md.c

8864

if (mddev->ro == MD_AUTO_READ)

drivers/md/md.c

8866

seq_printf(seq, " %s", mddev->pers->head.name);

drivers/md/md.c

8873

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

8892

if (!list_empty(&mddev->disks)) {

drivers/md/md.c

8893

if (mddev->pers)

drivers/md/md.c

8896

mddev->array_sectors / 2);

drivers/md/md.c

8901

if (mddev->persistent) {

drivers/md/md.c

8902

if (mddev->major_version != 0 ||

drivers/md/md.c

8903

mddev->minor_version != 90) {

drivers/md/md.c

8905

mddev->major_version,

drivers/md/md.c

8906

mddev->minor_version);

drivers/md/md.c

8908

} else if (mddev->external)

drivers/md/md.c

8910

mddev->metadata_type);

drivers/md/md.c

8914

if (mddev->pers) {

drivers/md/md.c

8915

mddev->pers->status(seq, mddev);

drivers/md/md.c

8917

if (mddev->pers->sync_request) {

drivers/md/md.c

8918

if (status_resync(seq, mddev))

drivers/md/md.c

8924

md_bitmap_status(seq, mddev);

drivers/md/md.c

8928

spin_unlock(&mddev->lock);

drivers/md/md.c

8929

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md.c

8932

if (mddev == list_last_entry(&all_mddevs, struct mddev, all_mddevs))

drivers/md/md.c

8935

mddev_put_locked(mddev);

drivers/md/md.c

896

static void mddev_free(struct mddev *mddev)

drivers/md/md.c

899

list_del(&mddev->all_mddevs);

drivers/md/md.c

8998

int md_setup_cluster(struct mddev *mddev, int nodes)

drivers/md/md.c

9000

int ret = get_cluster_ops(mddev);

drivers/md/md.c

9004

ret = get_cluster_ops(mddev);

drivers/md/md.c

9013

ret = mddev->cluster_ops->join(mddev, nodes);

drivers/md/md.c

9015

mddev->safemode_delay = 0;

drivers/md/md.c

9019

void md_cluster_stop(struct mddev *mddev)

drivers/md/md.c

902

mddev_destroy(mddev);

drivers/md/md.c

9021

put_cluster_ops(mddev);

drivers/md/md.c

903

kfree(mddev);

drivers/md/md.c

9051

static bool is_mddev_idle(struct mddev *mddev, int init)

drivers/md/md.c

9053

unsigned long last_events = mddev->normal_io_events;

drivers/md/md.c

9058

disk = mddev_is_dm(mddev) ? mddev->dm_gendisk : mddev->gendisk;

drivers/md/md.c

9062

mddev->normal_io_events = part_stat_read_accum(disk->part0, sectors);

drivers/md/md.c

9063

if (!init && (mddev->normal_io_events > last_events ||

drivers/md/md.c

9068

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.c

9076

void md_done_sync(struct mddev *mddev, int blocks)

drivers/md/md.c

9079

atomic_sub(blocks, &mddev->recovery_active);

drivers/md/md.c

908

void mddev_unlock(struct mddev *mddev)

drivers/md/md.c

9080

wake_up(&mddev->recovery_wait);

drivers/md/md.c

9084

void md_sync_error(struct mddev *mddev)

drivers/md/md.c

9087

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

9088

md_wakeup_thread(mddev->thread);

drivers/md/md.c

9099

void md_write_start(struct mddev *mddev, struct bio *bi)

drivers/md/md.c

9106

BUG_ON(mddev->ro == MD_RDONLY);

drivers/md/md.c

9107

if (mddev->ro == MD_AUTO_READ) {

drivers/md/md.c

9109

mddev->ro = MD_RDWR;

drivers/md/md.c

9110

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

9111

md_wakeup_thread(mddev->thread);

drivers/md/md.c

9112

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

9116

percpu_ref_get(&mddev->writes_pending);

drivers/md/md.c

9118

if (mddev->safemode == 1)

drivers/md/md.c

9119

mddev->safemode = 0;

drivers/md/md.c

9121

if (mddev->in_sync || mddev->sync_checkers) {

drivers/md/md.c

9122

spin_lock(&mddev->lock);

drivers/md/md.c

9123

if (mddev->in_sync) {

drivers/md/md.c

9124

mddev->in_sync = 0;

drivers/md/md.c

9125

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

9126

set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

9127

md_wakeup_thread(mddev->thread);

drivers/md/md.c

9130

spin_unlock(&mddev->lock);

drivers/md/md.c

9134

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

9135

if (!test_bit(MD_HAS_SUPERBLOCK, &mddev->flags))

drivers/md/md.c

9137

wait_event(mddev->sb_wait,

drivers/md/md.c

9138

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/md.c

914

if (!list_empty(&mddev->deleting))

drivers/md/md.c

915

list_splice_init(&mddev->deleting, &delete);

drivers/md/md.c

9150

void md_write_inc(struct mddev *mddev, struct bio *bi)

drivers/md/md.c

9154

WARN_ON_ONCE(mddev->in_sync || !md_is_rdwr(mddev));

drivers/md/md.c

9155

percpu_ref_get(&mddev->writes_pending);

drivers/md/md.c

9159

void md_write_end(struct mddev *mddev)

drivers/md/md.c

9161

percpu_ref_put(&mddev->writes_pending);

drivers/md/md.c

9163

if (mddev->safemode == 2)

drivers/md/md.c

9164

md_wakeup_thread(mddev->thread);

drivers/md/md.c

9165

else if (mddev->safemode_delay)

drivers/md/md.c

9169

mod_timer(&mddev->safemode_timer,

drivers/md/md.c

917

if (mddev->to_remove) {

drivers/md/md.c

9170

roundup(jiffies, mddev->safemode_delay) +

drivers/md/md.c

9171

mddev->safemode_delay);

drivers/md/md.c

9177

void md_submit_discard_bio(struct mddev *mddev, struct md_rdev *rdev,

drivers/md/md.c

9188

mddev_trace_remap(mddev, discard_bio, bio->bi_iter.bi_sector);

drivers/md/md.c

9193

static void md_bitmap_start(struct mddev *mddev,

drivers/md/md.c

9197

mddev->bitmap_ops->start_discard :

drivers/md/md.c

9198

mddev->bitmap_ops->start_write;

drivers/md/md.c

9200

if (mddev->pers->bitmap_sector)

drivers/md/md.c

9201

mddev->pers->bitmap_sector(mddev, &md_io_clone->offset,

drivers/md/md.c

9204

fn(mddev, md_io_clone->offset, md_io_clone->sectors);

drivers/md/md.c

9207

static void md_bitmap_end(struct mddev *mddev, struct md_io_clone *md_io_clone)

drivers/md/md.c

9210

mddev->bitmap_ops->end_discard :

drivers/md/md.c

9211

mddev->bitmap_ops->end_write;

drivers/md/md.c

9213

fn(mddev, md_io_clone->offset, md_io_clone->sectors);

drivers/md/md.c

9220

struct mddev *mddev = md_io_clone->mddev;

drivers/md/md.c

9222

if (bio_data_dir(orig_bio) == WRITE && md_bitmap_enabled(mddev, false))

drivers/md/md.c

9223

md_bitmap_end(mddev, md_io_clone);

drivers/md/md.c

9233

percpu_ref_put(&mddev->active_io);

drivers/md/md.c

9236

static void md_clone_bio(struct mddev *mddev, struct bio **bio)

drivers/md/md.c

9241

bio_alloc_clone(bdev, *bio, GFP_NOIO, &mddev->io_clone_set);

drivers/md/md.c

9245

md_io_clone->mddev = mddev;

drivers/md/md.c

9249

if (bio_data_dir(*bio) == WRITE && md_bitmap_enabled(mddev, false)) {

drivers/md/md.c

9253

md_bitmap_start(mddev, md_io_clone);

drivers/md/md.c

9261

void md_account_bio(struct mddev *mddev, struct bio **bio)

drivers/md/md.c

9263

percpu_ref_get(&mddev->active_io);

drivers/md/md.c

9264

md_clone_bio(mddev, bio);

drivers/md/md.c

9272

struct mddev *mddev = md_io_clone->mddev;

drivers/md/md.c

9274

if (bio_data_dir(orig_bio) == WRITE && md_bitmap_enabled(mddev, false))

drivers/md/md.c

9275

md_bitmap_end(mddev, md_io_clone);

drivers/md/md.c

9284

percpu_ref_put(&mddev->active_io);

drivers/md/md.c

9294

void md_allow_write(struct mddev *mddev)

drivers/md/md.c

9296

if (!mddev->pers)

drivers/md/md.c

9298

if (!md_is_rdwr(mddev))

drivers/md/md.c

930

const struct attribute_group *to_remove = mddev->to_remove;

drivers/md/md.c

9300

if (!mddev->pers->sync_request)

drivers/md/md.c

9303

spin_lock(&mddev->lock);

drivers/md/md.c

9304

if (mddev->in_sync) {

drivers/md/md.c

9305

mddev->in_sync = 0;

drivers/md/md.c

9306

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

9307

set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

9308

if (mddev->safemode_delay &&

drivers/md/md.c

9309

mddev->safemode == 0)

drivers/md/md.c

931

mddev->to_remove = NULL;

drivers/md/md.c

9310

mddev->safemode = 1;

drivers/md/md.c

9311

spin_unlock(&mddev->lock);

drivers/md/md.c

9312

md_update_sb(mddev, 0);

drivers/md/md.c

9313

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

9315

wait_event(mddev->sb_wait,

drivers/md/md.c

9316

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/md.c

9318

spin_unlock(&mddev->lock);

drivers/md/md.c

932

mddev->sysfs_active = 1;

drivers/md/md.c

9322

static sector_t md_sync_max_sectors(struct mddev *mddev,

drivers/md/md.c

9329

atomic64_set(&mddev->resync_mismatches, 0);

drivers/md/md.c

933

mutex_unlock(&mddev->reconfig_mutex);

drivers/md/md.c

9332

return mddev->resync_max_sectors;

drivers/md/md.c

9334

return mddev->dev_sectors;

drivers/md/md.c

9345

static bool mddev_select_lazy_recover_rdev(struct mddev *mddev)

drivers/md/md.c

935

if (mddev->kobj.sd) {

drivers/md/md.c

9352

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

937

sysfs_remove_group(&mddev->kobj, to_remove);

drivers/md/md.c

9373

static sector_t md_sync_position(struct mddev *mddev, enum sync_action action)

drivers/md/md.c

938

if (mddev->pers == NULL ||

drivers/md/md.c

9381

return mddev->resync_min;

drivers/md/md.c

9383

if (!mddev->bitmap)

drivers/md/md.c

9384

return mddev->resync_offset;

drivers/md/md.c

939

mddev->pers->sync_request == NULL) {

drivers/md/md.c

9392

if (mddev_is_clustered(mddev) &&

drivers/md/md.c

9393

mddev->reshape_position != MaxSector)

drivers/md/md.c

9394

return mddev->reshape_position;

drivers/md/md.c

9399

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.c

940

sysfs_remove_group(&mddev->kobj, &md_redundancy_group);

drivers/md/md.c

9408

if (test_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery) &&

drivers/md/md.c

9409

start == MaxSector && mddev_select_lazy_recover_rdev(mddev))

drivers/md/md.c

941

if (mddev->sysfs_action)

drivers/md/md.c

942

sysfs_put(mddev->sysfs_action);

drivers/md/md.c

9420

if (mddev->bitmap) {

drivers/md/md.c

9421

mddev->pers->quiesce(mddev, 1);

drivers/md/md.c

9422

mddev->pers->quiesce(mddev, 0);

drivers/md/md.c

943

if (mddev->sysfs_completed)

drivers/md/md.c

9430

static bool sync_io_within_limit(struct mddev *mddev)

drivers/md/md.c

9436

return atomic_read(&mddev->recovery_active) <

drivers/md/md.c

9437

(raid_is_456(mddev) ? 8 : 128) * sync_io_depth(mddev);

drivers/md/md.c

944

sysfs_put(mddev->sysfs_completed);

drivers/md/md.c

9443

static void md_finish_sync(struct mddev *mddev, enum sync_action action)

drivers/md/md.c

945

if (mddev->sysfs_degraded)

drivers/md/md.c

9450

if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/md.c

9451

mddev->curr_resync = MaxSector;

drivers/md/md.c

9452

mddev->resync_offset = mddev->curr_resync;

drivers/md/md.c

9455

if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/md.c

9456

mddev->curr_resync = MaxSector;

drivers/md/md.c

9458

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.c

9459

if (mddev->delta_disks >= 0 &&

drivers/md/md.c

946

sysfs_put(mddev->sysfs_degraded);

drivers/md/md.c

9460

rdev_needs_recovery(rdev, mddev->curr_resync))

drivers/md/md.c

9461

rdev->recovery_offset = mddev->curr_resync;

drivers/md/md.c

9465

if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&

drivers/md/md.c

9466

mddev->delta_disks > 0 &&

drivers/md/md.c

9467

mddev->pers->finish_reshape &&

drivers/md/md.c

9468

mddev->pers->size &&

drivers/md/md.c

9469

!mddev_is_dm(mddev)) {

drivers/md/md.c

947

mddev->sysfs_action = NULL;

drivers/md/md.c

9470

mddev_lock_nointr(mddev);

drivers/md/md.c

9471

md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0));

drivers/md/md.c

9472

mddev_unlock(mddev);

drivers/md/md.c

9473

if (!mddev_is_clustered(mddev))

drivers/md/md.c

9474

set_capacity_and_notify(mddev->gendisk,

drivers/md/md.c

9475

mddev->array_sectors);

drivers/md/md.c

9477

if (mddev->pers->finish_reshape)

drivers/md/md.c

9478

mddev->pers->finish_reshape(mddev);

drivers/md/md.c

948

mddev->sysfs_completed = NULL;

drivers/md/md.c

949

mddev->sysfs_degraded = NULL;

drivers/md/md.c

9492

struct mddev *mddev = thread->mddev;

drivers/md/md.c

9493

struct mddev *mddev2;

drivers/md/md.c

9508

if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))

drivers/md/md.c

9511

if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/md.c

9514

if (test_bit(MD_RECOVERY_WAIT, &mddev->recovery) ||

drivers/md/md.c

9515

!md_is_rdwr(mddev)) {/* never try to sync a read-only array */

drivers/md/md.c

9516

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

952

mddev->sysfs_active = 0;

drivers/md/md.c

9520

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

9521

ret = mddev->cluster_ops->resync_start(mddev);

drivers/md/md.c

9525

set_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags);

drivers/md/md.c

9526

if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||

drivers/md/md.c

9527

test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||

drivers/md/md.c

9528

test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))

drivers/md/md.c

9529

&& ((unsigned long long)mddev->curr_resync_completed

drivers/md/md.c

9530

< (unsigned long long)mddev->resync_max_sectors))

drivers/md/md.c

9534

action = md_sync_action(mddev);

drivers/md/md.c

9536

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

954

mutex_unlock(&mddev->reconfig_mutex);

drivers/md/md.c

9541

mddev->last_sync_action = action;

drivers/md/md.c

9552

if (mddev_is_clustered(mddev))

drivers/md/md.c

9553

mddev->cluster_ops->resync_start_notify(mddev);

drivers/md/md.c

9556

mddev->curr_resync = MD_RESYNC_DELAYED;

drivers/md/md.c

9559

if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/md.c

956

md_wakeup_thread(mddev->thread);

drivers/md/md.c

9565

if (mddev2 == mddev)

drivers/md/md.c

9567

if (!mddev->parallel_resync

drivers/md/md.c

9569

&& match_mddev_units(mddev, mddev2)) {

drivers/md/md.c

957

wake_up(&mddev->sb_wait);

drivers/md/md.c

9571

if (mddev < mddev2 &&

drivers/md/md.c

9572

mddev->curr_resync == MD_RESYNC_DELAYED) {

drivers/md/md.c

9574

mddev->curr_resync = MD_RESYNC_YIELDED;

drivers/md/md.c

9577

if (mddev > mddev2 &&

drivers/md/md.c

9578

mddev->curr_resync == MD_RESYNC_YIELDED)

drivers/md/md.c

9588

if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&

drivers/md/md.c

9589

mddev2->curr_resync >= mddev->curr_resync) {

drivers/md/md.c

9593

desc, mdname(mddev),

drivers/md/md.c

9608

} while (mddev->curr_resync < MD_RESYNC_DELAYED);

drivers/md/md.c

9610

max_sectors = md_sync_max_sectors(mddev, action);

drivers/md/md.c

9611

j = md_sync_position(mddev, action);

drivers/md/md.c

9613

pr_info("md: %s of RAID array %s\n", desc, mdname(mddev));

drivers/md/md.c

9614

pr_debug("md: minimum _guaranteed_ speed: %d KB/sec/disk.\n", speed_min(mddev));

drivers/md/md.c

9616

speed_max(mddev), desc);

drivers/md/md.c

9618

is_mddev_idle(mddev, 1); /* this initializes IO event counters */

drivers/md/md.c

962

export_rdev(rdev, mddev);

drivers/md/md.c

9626

mddev->resync_mark = mark[last_mark];

drivers/md/md.c

9627

mddev->resync_mark_cnt = mark_cnt[last_mark];

drivers/md/md.c

9636

atomic_set(&mddev->recovery_active, 0);

drivers/md/md.c

9641

desc, mdname(mddev));

drivers/md/md.c

9642

mddev->curr_resync = j;

drivers/md/md.c

9644

mddev->curr_resync = MD_RESYNC_ACTIVE; /* no longer delayed */

drivers/md/md.c

9645

mddev->curr_resync_completed = j;

drivers/md/md.c

9646

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

9656

if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&

drivers/md/md.c

9657

((mddev->curr_resync > mddev->curr_resync_completed &&

drivers/md/md.c

9658

(mddev->curr_resync - mddev->curr_resync_completed)

drivers/md/md.c

9661

(j - mddev->curr_resync_completed)*2

drivers/md/md.c

9662

>= mddev->resync_max - mddev->curr_resync_completed ||

drivers/md/md.c

9663

mddev->curr_resync_completed > mddev->resync_max

drivers/md/md.c

9666

wait_event(mddev->recovery_wait,

drivers/md/md.c

9667

atomic_read(&mddev->recovery_active) == 0);

drivers/md/md.c

9668

mddev->curr_resync_completed = j;

drivers/md/md.c

9669

if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&

drivers/md/md.c

9670

j > mddev->resync_offset)

drivers/md/md.c

9671

mddev->resync_offset = j;

drivers/md/md.c

9673

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

9674

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

9677

while (j >= mddev->resync_max &&

drivers/md/md.c

9678

!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {

drivers/md/md.c

9684

wait_event_interruptible(mddev->recovery_wait,

drivers/md/md.c

9685

mddev->resync_max > j

drivers/md/md.c

9687

&mddev->recovery));

drivers/md/md.c

9690

if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/md.c

9693

if (mddev->bitmap_ops && mddev->bitmap_ops->skip_sync_blocks) {

drivers/md/md.c

9694

sectors = mddev->bitmap_ops->skip_sync_blocks(mddev, j);

drivers/md/md.c

9699

sectors = mddev->pers->sync_request(mddev, j, max_sectors,

drivers/md/md.c

9702

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

9708

atomic_add(sectors, &mddev->recovery_active);

drivers/md/md.c

9711

if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/md.c

9720

mddev->curr_resync = j;

drivers/md/md.c

9721

mddev->curr_mark_cnt = io_sectors;

drivers/md/md.c

9737

mddev->resync_mark = mark[next];

drivers/md/md.c

9738

mddev->resync_mark_cnt = mark_cnt[next];

drivers/md/md.c

974

if (test_bit(MD_DELETED, &mddev->flags) &&

drivers/md/md.c

9740

mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);

drivers/md/md.c

9744

if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/md.c

975

!test_and_set_bit(MD_DO_DELETE, &mddev->flags)) {

drivers/md/md.c

9757

recovery_done = io_sectors - atomic_read(&mddev->recovery_active);

drivers/md/md.c

9758

currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2

drivers/md/md.c

9759

/((jiffies-mddev->resync_mark)/HZ +1) +1;

drivers/md/md.c

976

kobject_del(&mddev->kobj);

drivers/md/md.c

9761

if (currspeed > speed_min(mddev)) {

drivers/md/md.c

9762

if (currspeed > speed_max(mddev)) {

drivers/md/md.c

9766

if (!sync_io_within_limit(mddev) &&

drivers/md/md.c

9767

!is_mddev_idle(mddev, 0)) {

drivers/md/md.c

977

del_gendisk(mddev->gendisk);

drivers/md/md.c

9772

wait_event(mddev->recovery_wait,

drivers/md/md.c

9773

!atomic_read(&mddev->recovery_active));

drivers/md/md.c

9777

pr_info("md: %s: %s %s.\n",mdname(mddev), desc,

drivers/md/md.c

9778

test_bit(MD_RECOVERY_INTR, &mddev->recovery)

drivers/md/md.c

9784

wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));

drivers/md/md.c

9786

if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&

drivers/md/md.c

9787

mddev->curr_resync >= MD_RESYNC_ACTIVE) {

drivers/md/md.c

9789

mddev->curr_resync_completed = mddev->curr_resync;

drivers/md/md.c

9790

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

9792

mddev->pers->sync_request(mddev, max_sectors, max_sectors, &skipped);

drivers/md/md.c

9794

if (mddev->curr_resync > MD_RESYNC_ACTIVE)

drivers/md/md.c

9795

md_finish_sync(mddev, action);

drivers/md/md.c

98

static int remove_and_add_spares(struct mddev *mddev,

drivers/md/md.c

9800

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/md.c

9802

spin_lock(&mddev->lock);

drivers/md/md.c

9803

if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {

drivers/md/md.c

9805

if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))

drivers/md/md.c

9806

mddev->resync_min = 0;

drivers/md/md.c

9807

mddev->resync_max = MaxSector;

drivers/md/md.c

9808

} else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))

drivers/md/md.c

9809

mddev->resync_min = mddev->curr_resync_completed;

drivers/md/md.c

9810

set_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/md.c

9811

mddev->curr_resync = MD_RESYNC_NONE;

drivers/md/md.c

9812

spin_unlock(&mddev->lock);

drivers/md/md.c

9815

md_wakeup_thread(mddev->thread);

drivers/md/md.c

983

struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)

drivers/md/md.c

9866

struct mddev *mddev;

drivers/md/md.c

9868

mddev = READ_ONCE(rdev->mddev);

drivers/md/md.c

9869

if (!mddev)

drivers/md/md.c

987

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.c

9882

if (md_is_rdwr(mddev))

drivers/md/md.c

9895

static bool md_spares_need_change(struct mddev *mddev)

drivers/md/md.c

9900

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

9910

static int remove_spares(struct mddev *mddev, struct md_rdev *this)

drivers/md/md.c

9915

rdev_for_each(rdev, mddev) {

drivers/md/md.c

9917

!mddev->pers->hot_remove_disk(mddev, rdev)) {

drivers/md/md.c

9918

sysfs_unlink_rdev(mddev, rdev);

drivers/md/md.c

9925

if (removed && mddev->kobj.sd)

drivers/md/md.c

9926

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

9931

static int remove_and_add_spares(struct mddev *mddev,

drivers/md/md.c

9938

if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/md.c

9942

removed = remove_spares(mddev, this);

drivers/md/md.c

9946

rdev_for_each(rdev, mddev) {

drivers/md/md.c

995

static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)

drivers/md/md.c

9955

if (mddev->pers->hot_add_disk(mddev, rdev) == 0) {

drivers/md/md.c

9957

sysfs_link_rdev(mddev, rdev);

drivers/md/md.c

9961

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

9966

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

9970

static bool md_choose_sync_action(struct mddev *mddev, int *spares)

drivers/md/md.c

9973

if (mddev->reshape_position != MaxSector) {

drivers/md/md.c

9974

if (mddev->pers->check_reshape == NULL ||

drivers/md/md.c

9975

mddev->pers->check_reshape(mddev) != 0)

drivers/md/md.c

9978

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/md.c

9979

clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

9980

clear_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md.c

9985

if (mddev->resync_offset < MaxSector) {

drivers/md/md.c

9986

remove_spares(mddev, NULL);

drivers/md/md.c

9987

set_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

9988

clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

9989

clear_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md.c

999

rdev_for_each(rdev, mddev)

drivers/md/md.c

9998

*spares = remove_and_add_spares(mddev, NULL);

drivers/md/md.c

9999

if (*spares || test_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery)) {

drivers/md/md.h

1001

ret = mddev_suspend(mddev, true);

drivers/md/md.h

1005

ret = mddev_lock(mddev);

drivers/md/md.h

1007

mddev_resume(mddev);

drivers/md/md.h

1012

static inline void mddev_suspend_and_lock_nointr(struct mddev *mddev)

drivers/md/md.h

1014

mddev_suspend(mddev, false);

drivers/md/md.h

1015

mutex_lock(&mddev->reconfig_mutex);

drivers/md/md.h

1018

static inline void mddev_unlock_and_resume(struct mddev *mddev)

drivers/md/md.h

1020

mddev_unlock(mddev);

drivers/md/md.h

1021

mddev_resume(mddev);

drivers/md/md.h

1029

int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info);

drivers/md/md.h

1030

int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info);

drivers/md/md.h

1031

int do_md_run(struct mddev *mddev);

drivers/md/md.h

1033

int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,

drivers/md/md.h

1035

int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md.h

1036

void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes);

drivers/md/md.h

1043

static inline bool mddev_is_dm(struct mddev *mddev)

drivers/md/md.h

1045

return !mddev->gendisk;

drivers/md/md.h

1048

static inline bool raid_is_456(struct mddev *mddev)

drivers/md/md.h

1050

return mddev->level == ID_RAID4 || mddev->level == ID_RAID5 ||

drivers/md/md.h

1051

mddev->level == ID_RAID6;

drivers/md/md.h

1054

static inline void mddev_trace_remap(struct mddev *mddev, struct bio *bio,

drivers/md/md.h

1057

if (!mddev_is_dm(mddev))

drivers/md/md.h

1058

trace_block_bio_remap(bio, disk_devt(mddev->gendisk), sector);

drivers/md/md.h

1085

#define mddev_add_trace_msg(mddev, fmt, args...) \

drivers/md/md.h

1087

if (!mddev_is_dm(mddev)) \

drivers/md/md.h

1088

blk_add_trace_msg((mddev)->gendisk->queue, fmt, ##args); \

drivers/md/md.h

139

struct mddev *mddev; /* RAID array if running */

drivers/md/md.h

615

void (*sync_super)(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md.h

681

static inline bool md_is_rdwr(struct mddev *mddev)

drivers/md/md.h

683

return (mddev->ro == MD_RDWR);

drivers/md/md.h

686

static inline bool reshape_interrupted(struct mddev *mddev)

drivers/md/md.h

689

if (mddev->reshape_position == MaxSector)

drivers/md/md.h

693

if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/md.h

697

if (test_bit(MD_RECOVERY_WAIT, &mddev->recovery) ||

drivers/md/md.h

698

test_bit(MD_RECOVERY_INTR, &mddev->recovery) ||

drivers/md/md.h

699

test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))

drivers/md/md.h

705

static inline int __must_check mddev_lock(struct mddev *mddev)

drivers/md/md.h

709

ret = mutex_lock_interruptible(&mddev->reconfig_mutex);

drivers/md/md.h

714

if (!ret && test_bit(MD_DELETED, &mddev->flags)) {

drivers/md/md.h

716

mutex_unlock(&mddev->reconfig_mutex);

drivers/md/md.h

728

static inline void mddev_lock_nointr(struct mddev *mddev)

drivers/md/md.h

730

mutex_lock(&mddev->reconfig_mutex);

drivers/md/md.h

733

static inline int mddev_trylock(struct mddev *mddev)

drivers/md/md.h

737

ret = mutex_trylock(&mddev->reconfig_mutex);

drivers/md/md.h

738

if (ret && test_bit(MD_DELETED, &mddev->flags)) {

drivers/md/md.h

740

mutex_unlock(&mddev->reconfig_mutex);

drivers/md/md.h

744

extern void mddev_unlock(struct mddev *mddev);

drivers/md/md.h

750

bool __must_check (*make_request)(struct mddev *mddev, struct bio *bio);

drivers/md/md.h

755

int (*run)(struct mddev *mddev);

drivers/md/md.h

757

int (*start)(struct mddev *mddev);

drivers/md/md.h

758

void (*free)(struct mddev *mddev, void *priv);

drivers/md/md.h

759

void (*status)(struct seq_file *seq, struct mddev *mddev);

drivers/md/md.h

763

void (*error_handler)(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md.h

764

int (*hot_add_disk) (struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md.h

765

int (*hot_remove_disk) (struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md.h

766

int (*spare_active) (struct mddev *mddev);

drivers/md/md.h

767

sector_t (*sync_request)(struct mddev *mddev, sector_t sector_nr,

drivers/md/md.h

769

int (*resize) (struct mddev *mddev, sector_t sectors);

drivers/md/md.h

770

sector_t (*size) (struct mddev *mddev, sector_t sectors, int raid_disks);

drivers/md/md.h

771

int (*check_reshape) (struct mddev *mddev);

drivers/md/md.h

772

int (*start_reshape) (struct mddev *mddev);

drivers/md/md.h

773

void (*finish_reshape) (struct mddev *mddev);

drivers/md/md.h

774

void (*update_reshape_pos) (struct mddev *mddev);

drivers/md/md.h

775

void (*prepare_suspend) (struct mddev *mddev);

drivers/md/md.h

780

void (*quiesce) (struct mddev *mddev, int quiesce);

drivers/md/md.h

790

void *(*takeover) (struct mddev *mddev);

drivers/md/md.h

792

int (*change_consistency_policy)(struct mddev *mddev, const char *buf);

drivers/md/md.h

794

void (*bitmap_sector)(struct mddev *mddev, sector_t *offset,

drivers/md/md.h

800

ssize_t (*show)(struct mddev *, char *);

drivers/md/md.h

801

ssize_t (*store)(struct mddev *, const char *, size_t);

drivers/md/md.h

816

static inline char * mdname (struct mddev * mddev)

drivers/md/md.h

818

return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";

drivers/md/md.h

821

static inline int sysfs_link_rdev(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.h

826

mddev->kobj.sd) {

drivers/md/md.h

828

return sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);

drivers/md/md.h

833

static inline void sysfs_unlink_rdev(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.h

838

mddev->kobj.sd) {

drivers/md/md.h

840

sysfs_remove_link(&mddev->kobj, nm);

drivers/md/md.h

854

#define rdev_for_each(rdev, mddev) \

drivers/md/md.h

855

list_for_each_entry(rdev, &((mddev)->disks), same_set)

drivers/md/md.h

857

#define rdev_for_each_safe(rdev, tmp, mddev) \

drivers/md/md.h

858

list_for_each_entry_safe(rdev, tmp, &((mddev)->disks), same_set)

drivers/md/md.h

860

#define rdev_for_each_rcu(rdev, mddev) \

drivers/md/md.h

861

list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)

drivers/md/md.h

865

struct mddev *mddev;

drivers/md/md.h

874

struct mddev *mddev;

drivers/md/md.h

901

struct mddev *mddev,

drivers/md/md.h

903

extern void md_unregister_thread(struct mddev *mddev, struct md_thread __rcu **threadp);

drivers/md/md.h

905

extern void md_check_recovery(struct mddev *mddev);

drivers/md/md.h

906

extern void md_reap_sync_thread(struct mddev *mddev);

drivers/md/md.h

907

extern enum sync_action md_sync_action(struct mddev *mddev);

drivers/md/md.h

910

extern void md_write_start(struct mddev *mddev, struct bio *bi);

drivers/md/md.h

911

extern void md_write_inc(struct mddev *mddev, struct bio *bi);

drivers/md/md.h

912

extern void md_write_end(struct mddev *mddev);

drivers/md/md.h

913

extern void md_done_sync(struct mddev *mddev, int blocks);

drivers/md/md.h

914

extern void md_sync_error(struct mddev *mddev);

drivers/md/md.h

915

extern void md_error(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md.h

916

extern void md_finish_reshape(struct mddev *mddev);

drivers/md/md.h

917

void md_submit_discard_bio(struct mddev *mddev, struct md_rdev *rdev,

drivers/md/md.h

919

void md_account_bio(struct mddev *mddev, struct bio **bio);

drivers/md/md.h

922

extern bool __must_check md_flush_request(struct mddev *mddev, struct bio *bio);

drivers/md/md.h

923

void md_write_metadata(struct mddev *mddev, struct md_rdev *rdev,

drivers/md/md.h

926

extern int md_super_wait(struct mddev *mddev);

drivers/md/md.h

931

extern void md_allow_write(struct mddev *mddev);

drivers/md/md.h

932

extern void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev);

drivers/md/md.h

933

extern void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors);

drivers/md/md.h

934

extern int md_check_no_bitmap(struct mddev *mddev);

drivers/md/md.h

935

extern int md_integrity_register(struct mddev *mddev);

drivers/md/md.h

938

extern int mddev_init(struct mddev *mddev);

drivers/md/md.h

939

extern void mddev_destroy(struct mddev *mddev);

drivers/md/md.h

941

struct mddev *md_alloc(dev_t dev, char *name);

drivers/md/md.h

942

void mddev_put(struct mddev *mddev);

drivers/md/md.h

943

extern int md_run(struct mddev *mddev);

drivers/md/md.h

944

extern int md_start(struct mddev *mddev);

drivers/md/md.h

945

extern void md_stop(struct mddev *mddev);

drivers/md/md.h

946

extern void md_stop_writes(struct mddev *mddev);

drivers/md/md.h

950

extern bool md_handle_request(struct mddev *mddev, struct bio *bio);

drivers/md/md.h

951

extern int mddev_suspend(struct mddev *mddev, bool interruptible);

drivers/md/md.h

952

extern void mddev_resume(struct mddev *mddev);

drivers/md/md.h

953

extern void md_idle_sync_thread(struct mddev *mddev);

drivers/md/md.h

954

extern void md_frozen_sync_thread(struct mddev *mddev);

drivers/md/md.h

955

extern void md_unfrozen_sync_thread(struct mddev *mddev);

drivers/md/md.h

957

extern void md_update_sb(struct mddev *mddev, int force);

drivers/md/md.h

958

extern void mddev_create_serial_pool(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md.h

959

extern void mddev_destroy_serial_pool(struct mddev *mddev,

drivers/md/md.h

961

struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr);

drivers/md/md.h

962

struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev);

drivers/md/md.h

969

static inline void rdev_dec_pending(struct md_rdev *rdev, struct mddev *mddev)

drivers/md/md.h

973

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.h

974

md_wakeup_thread(mddev->thread);

drivers/md/md.h

978

static inline int mddev_is_clustered(struct mddev *mddev)

drivers/md/md.h

980

return mddev->cluster_info && mddev->bitmap_info.nodes > 1;

drivers/md/md.h

984

static inline void mddev_clear_unsupported_flags(struct mddev *mddev,

drivers/md/md.h

987

mddev->flags &= ~unsupported_flags;

drivers/md/md.h

990

static inline void mddev_check_write_zeroes(struct mddev *mddev, struct bio *bio)

drivers/md/md.h

994

mddev->gendisk->queue->limits.max_write_zeroes_sectors = 0;

drivers/md/md.h

997

static inline int mddev_suspend_and_lock(struct mddev *mddev)

drivers/md/raid0.c

106

mdname(mddev));

drivers/md/raid0.c

115

mdname(mddev));

drivers/md/raid0.c

120

mdname(mddev));

drivers/md/raid0.c

124

mdname(mddev));

drivers/md/raid0.c

127

mdname(mddev), conf->nr_strip_zones);

drivers/md/raid0.c

131

mdname(mddev), conf->nr_strip_zones);

drivers/md/raid0.c

137

if ((mddev->chunk_sectors << 9) % blksize) {

drivers/md/raid0.c

139

mdname(mddev),

drivers/md/raid0.c

140

mddev->chunk_sectors << 9, blksize);

drivers/md/raid0.c

151

mddev->raid_disks),

drivers/md/raid0.c

164

rdev_for_each(rdev1, mddev) {

drivers/md/raid0.c

167

if (mddev->level == 10) {

drivers/md/raid0.c

173

if (mddev->level == 1) {

drivers/md/raid0.c

183

mdname(mddev));

drivers/md/raid0.c

186

if (j >= mddev->raid_disks) {

drivers/md/raid0.c

188

mdname(mddev), j);

drivers/md/raid0.c

193

mdname(mddev), j);

drivers/md/raid0.c

202

if (cnt != mddev->raid_disks) {

drivers/md/raid0.c

204

mdname(mddev), cnt, mddev->raid_disks);

drivers/md/raid0.c

218

dev = conf->devlist + i * mddev->raid_disks;

drivers/md/raid0.c

220

pr_debug("md/raid0:%s: zone %d\n", mdname(mddev), i);

drivers/md/raid0.c

229

mdname(mddev),

drivers/md/raid0.c

235

mdname(mddev),

drivers/md/raid0.c

242

mdname(mddev),

drivers/md/raid0.c

250

mdname(mddev),

drivers/md/raid0.c

257

mdname(mddev),

drivers/md/raid0.c

263

} else if (mddev->layout == RAID0_ORIG_LAYOUT ||

drivers/md/raid0.c

264

mddev->layout == RAID0_ALT_MULTIZONE_LAYOUT) {

drivers/md/raid0.c

265

conf->layout = mddev->layout;

drivers/md/raid0.c

271

mdname(mddev));

drivers/md/raid0.c

281

sector_div(first_sector, mddev->chunk_sectors);

drivers/md/raid0.c

289

pr_debug("md/raid0:%s: done.\n", mdname(mddev));

drivers/md/raid0.c

324

static struct md_rdev *map_sector(struct mddev *mddev, struct strip_zone *zone,

drivers/md/raid0.c

329

struct r0conf *conf = mddev->private;

drivers/md/raid0.c

331

unsigned int chunk_sects = mddev->chunk_sectors;

drivers/md/raid0.c

357

static sector_t raid0_size(struct mddev *mddev, sector_t sectors, int raid_disks)

drivers/md/raid0.c

365

rdev_for_each(rdev, mddev)

drivers/md/raid0.c

367

~(sector_t)(mddev->chunk_sectors-1));

drivers/md/raid0.c

37

static void dump_zones(struct mddev *mddev)

drivers/md/raid0.c

372

static void raid0_free(struct mddev *mddev, void *priv)

drivers/md/raid0.c

381

static int raid0_set_limits(struct mddev *mddev)

drivers/md/raid0.c

387

lim.max_hw_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

388

lim.max_write_zeroes_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

389

lim.max_hw_wzeroes_unmap_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

390

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid0.c

391

lim.io_min = mddev->chunk_sectors << 9;

drivers/md/raid0.c

392

lim.io_opt = lim.io_min * mddev->raid_disks;

drivers/md/raid0.c

393

lim.chunk_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

395

err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);

drivers/md/raid0.c

398

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/md/raid0.c

401

static int raid0_run(struct mddev *mddev)

drivers/md/raid0.c

406

if (mddev->chunk_sectors == 0) {

drivers/md/raid0.c

407

pr_warn("md/raid0:%s: chunk size must be set.\n", mdname(mddev));

drivers/md/raid0.c

410

if (md_check_no_bitmap(mddev))

drivers/md/raid0.c

413

if (!mddev_is_dm(mddev)) {

drivers/md/raid0.c

414

ret = raid0_set_limits(mddev);

drivers/md/raid0.c

42

struct r0conf *conf = mddev->private;

drivers/md/raid0.c

420

if (mddev->private == NULL) {

drivers/md/raid0.c

421

ret = create_strip_zones(mddev, &conf);

drivers/md/raid0.c

424

mddev->private = conf;

drivers/md/raid0.c

426

conf = mddev->private;

drivers/md/raid0.c

429

md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));

drivers/md/raid0.c

432

mdname(mddev),

drivers/md/raid0.c

433

(unsigned long long)mddev->array_sectors);

drivers/md/raid0.c

435

dump_zones(mddev);

drivers/md/raid0.c

437

return md_integrity_register(mddev);

drivers/md/raid0.c

45

mdname(mddev),

drivers/md/raid0.c

454

static void raid0_handle_discard(struct mddev *mddev, struct bio *bio)

drivers/md/raid0.c

456

struct r0conf *conf = mddev->private;

drivers/md/raid0.c

475

&mddev->bio_set);

drivers/md/raid0.c

489

stripe_size = zone->nb_dev * mddev->chunk_sectors;

drivers/md/raid0.c

498

sector_div(orig_start, mddev->chunk_sectors);

drivers/md/raid0.c

503

sector_div(orig_end, mddev->chunk_sectors);

drivers/md/raid0.c

509

mddev->chunk_sectors;

drivers/md/raid0.c

511

mddev->chunk_sectors;

drivers/md/raid0.c

514

mddev->chunk_sectors) +

drivers/md/raid0.c

515

first_stripe_index * mddev->chunk_sectors;

drivers/md/raid0.c

517

mddev->chunk_sectors) +

drivers/md/raid0.c

518

last_stripe_index * mddev->chunk_sectors;

drivers/md/raid0.c

530

mddev->chunk_sectors;

drivers/md/raid0.c

532

dev_start = first_stripe_index * mddev->chunk_sectors;

drivers/md/raid0.c

537

dev_end = (last_stripe_index + 1) * mddev->chunk_sectors;

drivers/md/raid0.c

539

dev_end = last_stripe_index * mddev->chunk_sectors;

drivers/md/raid0.c

548

md_submit_discard_bio(mddev, rdev, bio,

drivers/md/raid0.c

555

static void raid0_map_submit_bio(struct mddev *mddev, struct bio *bio)

drivers/md/raid0.c

557

struct r0conf *conf = mddev->private;

drivers/md/raid0.c

563

md_account_bio(mddev, &bio);

drivers/md/raid0.c

565

zone = find_zone(mddev->private, &sector);

drivers/md/raid0.c

568

tmp_dev = map_sector(mddev, zone, bio_sector, &sector);

drivers/md/raid0.c

571

tmp_dev = map_sector(mddev, zone, sector, &sector);

drivers/md/raid0.c

574

WARN(1, "md/raid0:%s: Invalid layout\n", mdname(mddev));

drivers/md/raid0.c

581

md_error(mddev, tmp_dev);

drivers/md/raid0.c

588

mddev_trace_remap(mddev, bio, bio_sector);

drivers/md/raid0.c

589

mddev_check_write_zeroes(mddev, bio);

drivers/md/raid0.c

593

static bool raid0_make_request(struct mddev *mddev, struct bio *bio)

drivers/md/raid0.c

600

&& md_flush_request(mddev, bio))

drivers/md/raid0.c

604

raid0_handle_discard(mddev, bio);

drivers/md/raid0.c

609

chunk_sects = mddev->chunk_sectors;

drivers/md/raid0.c

618

&mddev->bio_set);

drivers/md/raid0.c

623

raid0_map_submit_bio(mddev, bio);

drivers/md/raid0.c

627

static void raid0_status(struct seq_file *seq, struct mddev *mddev)

drivers/md/raid0.c

629

seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);

drivers/md/raid0.c

633

static void raid0_error(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid0.c

635

if (!test_and_set_bit(MD_BROKEN, &mddev->flags)) {

drivers/md/raid0.c

636

char *md_name = mdname(mddev);

drivers/md/raid0.c

643

static void *raid0_takeover_raid45(struct mddev *mddev)

drivers/md/raid0.c

648

if (mddev->degraded != 1) {

drivers/md/raid0.c

65

static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)

drivers/md/raid0.c

650

mdname(mddev),

drivers/md/raid0.c

651

mddev->degraded);

drivers/md/raid0.c

655

rdev_for_each(rdev, mddev) {

drivers/md/raid0.c

657

if (rdev->raid_disk == mddev->raid_disks-1) {

drivers/md/raid0.c

659

mdname(mddev));

drivers/md/raid0.c

662

rdev->sectors = mddev->dev_sectors;

drivers/md/raid0.c

666

mddev->new_level = 0;

drivers/md/raid0.c

667

mddev->new_layout = 0;

drivers/md/raid0.c

668

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

669

mddev->raid_disks--;

drivers/md/raid0.c

670

mddev->delta_disks = -1;

drivers/md/raid0.c

672

mddev->resync_offset = MaxSector;

drivers/md/raid0.c

673

mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);

drivers/md/raid0.c

675

create_strip_zones(mddev, &priv_conf);

drivers/md/raid0.c

680

static void *raid0_takeover_raid10(struct mddev *mddev)

drivers/md/raid0.c

690

if (mddev->layout != ((1 << 8) + 2)) {

drivers/md/raid0.c

692

mdname(mddev),

drivers/md/raid0.c

693

mddev->layout);

drivers/md/raid0.c

696

if (mddev->raid_disks & 1) {

drivers/md/raid0.c

698

mdname(mddev));

drivers/md/raid0.c

701

if (mddev->degraded != (mddev->raid_disks>>1)) {

drivers/md/raid0.c

703

mdname(mddev));

drivers/md/raid0.c

708

mddev->new_level = 0;

drivers/md/raid0.c

709

mddev->new_layout = 0;

drivers/md/raid0.c

710

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

711

mddev->delta_disks = - mddev->raid_disks / 2;

drivers/md/raid0.c

712

mddev->raid_disks += mddev->delta_disks;

drivers/md/raid0.c

713

mddev->degraded = 0;

drivers/md/raid0.c

715

mddev->resync_offset = MaxSector;

drivers/md/raid0.c

716

mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);

drivers/md/raid0.c

718

create_strip_zones(mddev, &priv_conf);

drivers/md/raid0.c

722

static void *raid0_takeover_raid1(struct mddev *mddev)

drivers/md/raid0.c

730

if ((mddev->raid_disks - 1) != mddev->degraded) {

drivers/md/raid0.c

732

mdname(mddev));

drivers/md/raid0.c

743

while (chunksect && (mddev->array_sectors & (chunksect - 1)))

drivers/md/raid0.c

75

if (!mddev_is_dm(mddev))

drivers/md/raid0.c

751

mddev->new_level = 0;

drivers/md/raid0.c

752

mddev->new_layout = 0;

drivers/md/raid0.c

753

mddev->new_chunk_sectors = chunksect;

drivers/md/raid0.c

754

mddev->chunk_sectors = chunksect;

drivers/md/raid0.c

755

mddev->delta_disks = 1 - mddev->raid_disks;

drivers/md/raid0.c

756

mddev->raid_disks = 1;

drivers/md/raid0.c

758

mddev->resync_offset = MaxSector;

drivers/md/raid0.c

759

mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);

drivers/md/raid0.c

76

blksize = queue_logical_block_size(mddev->gendisk->queue);

drivers/md/raid0.c

761

create_strip_zones(mddev, &priv_conf);

drivers/md/raid0.c

765

static void *raid0_takeover(struct mddev *mddev)

drivers/md/raid0.c

774

if (mddev->bitmap) {

drivers/md/raid0.c

776

mdname(mddev));

drivers/md/raid0.c

779

if (mddev->level == 4)

drivers/md/raid0.c

780

return raid0_takeover_raid45(mddev);

drivers/md/raid0.c

782

if (mddev->level == 5) {

drivers/md/raid0.c

783

if (mddev->layout == ALGORITHM_PARITY_N)

drivers/md/raid0.c

784

return raid0_takeover_raid45(mddev);

drivers/md/raid0.c

787

mdname(mddev), ALGORITHM_PARITY_N);

drivers/md/raid0.c

790

if (mddev->level == 10)

drivers/md/raid0.c

791

return raid0_takeover_raid10(mddev);

drivers/md/raid0.c

793

if (mddev->level == 1)

drivers/md/raid0.c

794

return raid0_takeover_raid1(mddev);

drivers/md/raid0.c

797

mddev->level);

drivers/md/raid0.c

802

static void raid0_quiesce(struct mddev *mddev, int quiesce)

drivers/md/raid0.c

81

rdev_for_each(rdev1, mddev) {

drivers/md/raid0.c

83

mdname(mddev),

drivers/md/raid0.c

89

sector_div(sectors, mddev->chunk_sectors);

drivers/md/raid0.c

90

rdev1->sectors = sectors * mddev->chunk_sectors;

drivers/md/raid0.c

92

if (mddev_is_dm(mddev))

drivers/md/raid0.c

96

rdev_for_each(rdev2, mddev) {

drivers/md/raid0.c

99

mdname(mddev),

drivers/md/raid1-10.c

128

static inline bool raid1_add_bio_to_plug(struct mddev *mddev, struct bio *bio,

drivers/md/raid1-10.c

138

if (!md_bitmap_enabled(mddev, true)) {

drivers/md/raid1-10.c

143

cb = blk_check_plugged(unplug, mddev, sizeof(*plug));

drivers/md/raid1-10.c

164

static inline void raid1_prepare_flush_writes(struct mddev *mddev)

drivers/md/raid1-10.c

166

mddev->bitmap_ops->unplug(mddev, current->bio_list == NULL);

drivers/md/raid1-10.c

174

static inline void check_decay_read_errors(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid1-10.c

204

static inline bool exceed_read_errors(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid1-10.c

206

int max_read_errors = atomic_read(&mddev->max_corr_read_errors);

drivers/md/raid1-10.c

209

check_decay_read_errors(mddev, rdev);

drivers/md/raid1-10.c

213

mdname(mddev), rdev->bdev, read_errors, max_read_errors);

drivers/md/raid1-10.c

215

mdname(mddev), rdev->bdev);

drivers/md/raid1-10.c

216

md_error(mddev, rdev);

drivers/md/raid1-10.c

278

static inline bool raid1_should_read_first(struct mddev *mddev,

drivers/md/raid1-10.c

281

if ((mddev->resync_offset < this_sector + len))

drivers/md/raid1-10.c

284

if (mddev_is_clustered(mddev) &&

drivers/md/raid1-10.c

285

mddev->cluster_ops->area_resyncing(mddev, READ, this_sector,

drivers/md/raid1.c

1003

test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery),

drivers/md/raid1.c

1006

if (test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery)) {

drivers/md/raid1.c

101

struct mddev *mddev = rdev->mddev;

drivers/md/raid1.c

110

mempool_free(si, mddev->serial_info_pool);

drivers/md/raid1.c

1202

mddev_add_trace_msg(conf->mddev, "raid1 wait freeze");

drivers/md/raid1.c

1228

&r1_bio->mddev->bio_set);

drivers/md/raid1.c

1271

struct mddev *mddev = plug->cb.data;

drivers/md/raid1.c

1272

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1280

md_wakeup_thread(mddev->thread);

drivers/md/raid1.c

1291

static void init_r1bio(struct r1bio *r1_bio, struct mddev *mddev, struct bio *bio)

drivers/md/raid1.c

1296

r1_bio->mddev = mddev;

drivers/md/raid1.c

1301

alloc_r1bio(struct mddev *mddev, struct bio *bio)

drivers/md/raid1.c

1303

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1308

init_r1bio(r1_bio, mddev, bio);

drivers/md/raid1.c

1312

static void raid1_read_request(struct mddev *mddev, struct bio *bio,

drivers/md/raid1.c

1315

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1340

r1_bio = alloc_r1bio(mddev, bio);

drivers/md/raid1.c

1342

init_r1bio(r1_bio, mddev, bio);

drivers/md/raid1.c

1354

mdname(mddev),

drivers/md/raid1.c

1364

mdname(mddev),

drivers/md/raid1.c

1369

md_bitmap_enabled(mddev, false)) {

drivers/md/raid1.c

1374

mddev_add_trace_msg(mddev, "raid1 wait behind writes");

drivers/md/raid1.c

1375

mddev->bitmap_ops->wait_behind_writes(mddev);

drivers/md/raid1.c

1392

md_account_bio(mddev, &bio);

drivers/md/raid1.c

1396

&mddev->bio_set);

drivers/md/raid1.c

1407

mddev_trace_remap(mddev, read_bio, r1_bio->sector);

drivers/md/raid1.c

1416

static bool wait_blocked_rdev(struct mddev *mddev, struct bio *bio)

drivers/md/raid1.c

1418

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1439

mddev_add_trace_msg(rdev->mddev, "raid1 wait rdev %d blocked",

drivers/md/raid1.c

1442

md_wait_for_blocked_rdev(rdev, rdev->mddev);

drivers/md/raid1.c

1450

static void raid1_start_write_behind(struct mddev *mddev, struct r1bio *r1_bio,

drivers/md/raid1.c

1453

unsigned long max_write_behind = mddev->bitmap_info.max_write_behind;

drivers/md/raid1.c

1458

if (!md_bitmap_enabled(mddev, false))

drivers/md/raid1.c

1461

err = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats);

drivers/md/raid1.c

1470

mddev->bitmap_ops->start_behind_write(mddev);

drivers/md/raid1.c

1474

static void raid1_write_request(struct mddev *mddev, struct bio *bio,

drivers/md/raid1.c

1477

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1486

if (mddev_is_clustered(mddev) &&

drivers/md/raid1.c

1487

mddev->cluster_ops->area_resyncing(mddev, WRITE,

drivers/md/raid1.c

1498

if (!mddev->cluster_ops->area_resyncing(mddev, WRITE,

drivers/md/raid1.c

1518

if (!wait_blocked_rdev(mddev, bio)) {

drivers/md/raid1.c

1523

r1_bio = alloc_r1bio(mddev, bio);

drivers/md/raid1.c

1570

rdev_dec_pending(rdev, mddev);

drivers/md/raid1.c

1600

if (write_behind && mddev->bitmap)

drivers/md/raid1.c

1615

md_account_bio(mddev, &bio);

drivers/md/raid1.c

1630

raid1_start_write_behind(mddev, r1_bio, bio);

drivers/md/raid1.c

1637

GFP_NOIO, &mddev->bio_set);

drivers/md/raid1.c

1644

&mddev->bio_set);

drivers/md/raid1.c

1646

if (test_bit(MD_SERIALIZE_POLICY, &mddev->flags))

drivers/md/raid1.c

1657

conf->raid_disks - mddev->degraded > 1)

drivers/md/raid1.c

1662

mddev_trace_remap(mddev, mbio, r1_bio->sector);

drivers/md/raid1.c

1665

if (!raid1_add_bio_to_plug(mddev, mbio, raid1_unplug, disks)) {

drivers/md/raid1.c

1669

md_wakeup_thread(mddev->thread);

drivers/md/raid1.c

1681

rdev_dec_pending(conf->mirrors[k].rdev, mddev);

drivers/md/raid1.c

1689

static bool raid1_make_request(struct mddev *mddev, struct bio *bio)

drivers/md/raid1.c

1694

&& md_flush_request(mddev, bio))

drivers/md/raid1.c

1708

raid1_read_request(mddev, bio, sectors, NULL);

drivers/md/raid1.c

1710

md_write_start(mddev,bio);

drivers/md/raid1.c

1711

raid1_write_request(mddev, bio, sectors);

drivers/md/raid1.c

1716

static void raid1_status(struct seq_file *seq, struct mddev *mddev)

drivers/md/raid1.c

1718

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1721

lockdep_assert_held(&mddev->lock);

drivers/md/raid1.c

1724

conf->raid_disks - mddev->degraded);

drivers/md/raid1.c

1750

static void raid1_error(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid1.c

1752

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1758

(conf->raid_disks - mddev->degraded) == 1) {

drivers/md/raid1.c

1759

set_bit(MD_BROKEN, &mddev->flags);

drivers/md/raid1.c

1761

if (!test_bit(MD_FAILLAST_DEV, &mddev->flags)) {

drivers/md/raid1.c

1768

mddev->degraded++;

drivers/md/raid1.c

1774

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid1.c

1775

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/raid1.c

1779

mdname(mddev), rdev->bdev,

drivers/md/raid1.c

178

if (test_bit(MD_RECOVERY_REQUESTED, &conf->mddev->recovery))

drivers/md/raid1.c

1780

mdname(mddev), conf->raid_disks - mddev->degraded);

drivers/md/raid1.c

1792

pr_debug(" --- wd:%d rd:%d\n", conf->raid_disks - conf->mddev->degraded,

drivers/md/raid1.c

1795

lockdep_assert_held(&conf->mddev->reconfig_mutex);

drivers/md/raid1.c

1818

static int raid1_spare_active(struct mddev *mddev)

drivers/md/raid1.c

1821

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1863

mddev->degraded -= count;

drivers/md/raid1.c

1905

rdev->mddev->degraded < conf->raid_disks)

drivers/md/raid1.c

1915

static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid1.c

1917

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1940

err = mddev_stack_new_rdev(mddev, rdev);

drivers/md/raid1.c

1970

static int raid1_remove_disk(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid1.c

1972

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2019

err = md_integrity_register(mddev);

drivers/md/raid1.c

2045

static void abort_sync_write(struct mddev *mddev, struct r1bio *r1_bio)

drivers/md/raid1.c

2053

md_bitmap_end_sync(mddev, s, &sync_blocks);

drivers/md/raid1.c

2062

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2070

md_done_sync(mddev, s);

drivers/md/raid1.c

2078

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2079

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2083

abort_sync_write(mddev, r1_bio);

drivers/md/raid1.c

2087

mddev->recovery);

drivers/md/raid1.c

2109

rdev->mddev->recovery);

drivers/md/raid1.c

2129

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2130

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2142

md_error(mddev, rdev);

drivers/md/raid1.c

2185

mdname(mddev), bio->bi_bdev,

drivers/md/raid1.c

2217

rdev_dec_pending(rdev, mddev);

drivers/md/raid1.c

2251

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2252

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2282

rdev_dec_pending(conf->mirrors[primary].rdev, mddev);

drivers/md/raid1.c

2315

atomic64_add(r1_bio->sectors, &mddev->resync_mismatches);

drivers/md/raid1.c

2316

if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)

drivers/md/raid1.c

2320

rdev_dec_pending(conf->mirrors[i].rdev, mddev);

drivers/md/raid1.c

2328

static void sync_request_write(struct mddev *mddev, struct r1bio *r1_bio)

drivers/md/raid1.c

2330

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2341

if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) ||

drivers/md/raid1.c

2343

md_done_sync(mddev, r1_bio->sectors);

drivers/md/raid1.c

2344

md_sync_error(mddev);

drivers/md/raid1.c

2350

if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))

drivers/md/raid1.c

2362

!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))))

drivers/md/raid1.c

2365

abort_sync_write(mddev, r1_bio);

drivers/md/raid1.c

2395

struct mddev *mddev = conf->mddev;

drivers/md/raid1.c

2398

if (exceed_read_errors(mddev, rdev)) {

drivers/md/raid1.c

2423

rdev_dec_pending(rdev, mddev);

drivers/md/raid1.c

2451

rdev_dec_pending(rdev, mddev);

drivers/md/raid1.c

2467

mdname(mddev), s,

drivers/md/raid1.c

2472

rdev_dec_pending(rdev, mddev);

drivers/md/raid1.c

2482

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2483

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2521

GFP_NOIO, &mddev->bio_set);

drivers/md/raid1.c

2524

GFP_NOIO, &mddev->bio_set);

drivers/md/raid1.c

253

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

2568

md_done_sync(conf->mddev, s);

drivers/md/raid1.c

2582

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid1.c

2591

conf->mddev);

drivers/md/raid1.c

2604

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid1.c

261

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

2614

struct mddev *mddev = conf->mddev;

drivers/md/raid1.c

2634

if (mddev->ro == 0

drivers/md/raid1.c

2639

} else if (mddev->ro == 0 && test_bit(FailFast, &rdev->flags)) {

drivers/md/raid1.c

2640

md_error(mddev, rdev);

drivers/md/raid1.c

2645

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid1.c

2651

raid1_read_request(mddev, bio, r1_bio->sectors, r1_bio);

drivers/md/raid1.c

2657

struct mddev *mddev = thread->mddev;

drivers/md/raid1.c

2660

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2665

md_check_recovery(mddev);

drivers/md/raid1.c

2668

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {

drivers/md/raid1.c

2671

if (!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))

drivers/md/raid1.c

268

rdev_dec_pending(conf->mirrors[i].rdev, r1_bio->mddev);

drivers/md/raid1.c

2702

mddev = r1_bio->mddev;

drivers/md/raid1.c

2703

conf = mddev->private;

drivers/md/raid1.c

2709

sync_request_write(mddev, r1_bio);

drivers/md/raid1.c

2719

if (mddev->sb_flags & ~(1<<MD_SB_CHANGE_PENDING))

drivers/md/raid1.c

2720

md_check_recovery(mddev);

drivers/md/raid1.c

2763

static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,

drivers/md/raid1.c

2766

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

279

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2791

if (mddev->curr_resync < max_sector) /* aborted */

drivers/md/raid1.c

2792

md_bitmap_end_sync(mddev, mddev->curr_resync,

drivers/md/raid1.c

2797

if (md_bitmap_enabled(mddev, false))

drivers/md/raid1.c

2798

mddev->bitmap_ops->close_sync(mddev);

drivers/md/raid1.c

280

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2801

if (mddev_is_clustered(mddev)) {

drivers/md/raid1.c

2808

if (mddev->bitmap == NULL &&

drivers/md/raid1.c

2809

mddev->resync_offset == MaxSector &&

drivers/md/raid1.c

2810

!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&

drivers/md/raid1.c

2818

if (!md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, true) &&

drivers/md/raid1.c

2819

!conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {

drivers/md/raid1.c

2835

if (md_bitmap_enabled(mddev, false))

drivers/md/raid1.c

2836

mddev->bitmap_ops->cond_end_sync(mddev, sector_nr,

drivers/md/raid1.c

2837

mddev_is_clustered(mddev) &&

drivers/md/raid1.c

2855

r1_bio->mddev = mddev;

drivers/md/raid1.c

290

md_wakeup_thread(mddev->thread);

drivers/md/raid1.c

2903

test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&

drivers/md/raid1.c

2904

!test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {

drivers/md/raid1.c

2940

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid1.c

2959

if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) && read_targets > 0)

drivers/md/raid1.c

2976

if (max_sector > mddev->resync_max)

drivers/md/raid1.c

2977

max_sector = mddev->resync_max; /* Don't do IO beyond here */

drivers/md/raid1.c

2990

if (!md_bitmap_start_sync(mddev, sector_nr,

drivers/md/raid1.c

2993

!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))

drivers/md/raid1.c

3021

if (mddev_is_clustered(mddev) &&

drivers/md/raid1.c

3023

conf->cluster_sync_low = mddev->curr_resync_completed;

drivers/md/raid1.c

3026

mddev->cluster_ops->resync_info_update(mddev,

drivers/md/raid1.c

3034

if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {

drivers/md/raid1.c

3055

static sector_t raid1_size(struct mddev *mddev, sector_t sectors, int raid_disks)

drivers/md/raid1.c

3060

return mddev->dev_sectors;

drivers/md/raid1.c

3063

static struct r1conf *setup_conf(struct mddev *mddev)

drivers/md/raid1.c

3093

mddev->raid_disks, 2),

drivers/md/raid1.c

3102

r1bio_size = offsetof(struct r1bio, bios[mddev->raid_disks * 2]);

drivers/md/raid1.c

311

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

3113

conf->raid_disks = mddev->raid_disks;

drivers/md/raid1.c

3114

rdev_for_each(rdev, mddev) {

drivers/md/raid1.c

3124

conf->mddev = mddev;

drivers/md/raid1.c

3164

md_register_thread(raid1d, mddev, "raid1"));

drivers/md/raid1.c

3185

static int raid1_set_limits(struct mddev *mddev)

drivers/md/raid1.c

3193

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid1.c

3195

err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);

drivers/md/raid1.c

3198

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/md/raid1.c

3201

static int raid1_run(struct mddev *mddev)

drivers/md/raid1.c

3207

if (mddev->level != 1) {

drivers/md/raid1.c

3209

mdname(mddev), mddev->level);

drivers/md/raid1.c

3212

if (mddev->reshape_position != MaxSector) {

drivers/md/raid1.c

3214

mdname(mddev));

drivers/md/raid1.c

3223

if (mddev->private == NULL)

drivers/md/raid1.c

3224

conf = setup_conf(mddev);

drivers/md/raid1.c

3226

conf = mddev->private;

drivers/md/raid1.c

3231

if (!mddev_is_dm(mddev)) {

drivers/md/raid1.c

3232

ret = raid1_set_limits(mddev);

drivers/md/raid1.c

3234

md_unregister_thread(mddev, &conf->thread);

drivers/md/raid1.c

3235

if (!mddev->private)

drivers/md/raid1.c

3236

raid1_free(mddev, conf);

drivers/md/raid1.c

3241

mddev->degraded = 0;

drivers/md/raid1.c

3246

mddev->degraded++;

drivers/md/raid1.c

3250

if (conf->raid_disks - mddev->degraded < 1) {

drivers/md/raid1.c

3251

md_unregister_thread(mddev, &conf->thread);

drivers/md/raid1.c

3252

if (!mddev->private)

drivers/md/raid1.c

3253

raid1_free(mddev, conf);

drivers/md/raid1.c

3257

if (conf->raid_disks - mddev->degraded == 1)

drivers/md/raid1.c

3258

mddev->resync_offset = MaxSector;

drivers/md/raid1.c

3260

if (mddev->resync_offset != MaxSector)

drivers/md/raid1.c

3262

mdname(mddev));

drivers/md/raid1.c

3264

mdname(mddev), mddev->raid_disks - mddev->degraded,

drivers/md/raid1.c

3265

mddev->raid_disks);

drivers/md/raid1.c

3270

rcu_assign_pointer(mddev->thread, conf->thread);

drivers/md/raid1.c

3272

mddev->private = conf;

drivers/md/raid1.c

3273

set_bit(MD_FAILFAST_SUPPORTED, &mddev->flags);

drivers/md/raid1.c

3275

md_set_array_sectors(mddev, raid1_size(mddev, 0, 0));

drivers/md/raid1.c

3277

ret = md_integrity_register(mddev);

drivers/md/raid1.c

3279

md_unregister_thread(mddev, &mddev->thread);

drivers/md/raid1.c

3283

static void raid1_free(struct mddev *mddev, void *priv)

drivers/md/raid1.c

3298

static int raid1_resize(struct mddev *mddev, sector_t sectors)

drivers/md/raid1.c

3307

sector_t newsize = raid1_size(mddev, sectors, 0);

drivers/md/raid1.c

3309

if (mddev->external_size &&

drivers/md/raid1.c

3310

mddev->array_sectors > newsize)

drivers/md/raid1.c

3313

if (md_bitmap_enabled(mddev, false)) {

drivers/md/raid1.c

3314

int ret = mddev->bitmap_ops->resize(mddev, newsize, 0);

drivers/md/raid1.c

3320

md_set_array_sectors(mddev, newsize);

drivers/md/raid1.c

3321

if (sectors > mddev->dev_sectors &&

drivers/md/raid1.c

3322

mddev->resync_offset > mddev->dev_sectors) {

drivers/md/raid1.c

3323

mddev->resync_offset = mddev->dev_sectors;

drivers/md/raid1.c

3324

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid1.c

3326

mddev->dev_sectors = sectors;

drivers/md/raid1.c

3327

mddev->resync_max_sectors = sectors;

drivers/md/raid1.c

3331

static int raid1_reshape(struct mddev *mddev)

drivers/md/raid1.c

3347

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

3353

if (mddev->chunk_sectors != mddev->new_chunk_sectors ||

drivers/md/raid1.c

3354

mddev->layout != mddev->new_layout ||

drivers/md/raid1.c

3355

mddev->level != mddev->new_level) {

drivers/md/raid1.c

3356

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid1.c

3357

mddev->new_layout = mddev->layout;

drivers/md/raid1.c

3358

mddev->new_level = mddev->level;

drivers/md/raid1.c

3362

if (!mddev_is_clustered(mddev))

drivers/md/raid1.c

3363

md_allow_write(mddev);

drivers/md/raid1.c

3365

raid_disks = mddev->raid_disks + mddev->delta_disks;

drivers/md/raid1.c

337

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

3398

sysfs_unlink_rdev(mddev, rdev);

drivers/md/raid1.c

3400

sysfs_unlink_rdev(mddev, rdev);

drivers/md/raid1.c

3401

if (sysfs_link_rdev(mddev, rdev))

drivers/md/raid1.c

3403

mdname(mddev), rdev->raid_disk);

drivers/md/raid1.c

3412

mddev->degraded += (raid_disks - conf->raid_disks);

drivers/md/raid1.c

3414

conf->raid_disks = mddev->raid_disks = raid_disks;

drivers/md/raid1.c

3415

mddev->delta_disks = 0;

drivers/md/raid1.c

3419

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/raid1.c

3420

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid1.c

3421

md_wakeup_thread(mddev->thread);

drivers/md/raid1.c

3427

static void raid1_quiesce(struct mddev *mddev, int quiesce)

drivers/md/raid1.c

3429

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

3437

static void *raid1_takeover(struct mddev *mddev)

drivers/md/raid1.c

3442

if (mddev->level == 5 && mddev->raid_disks == 2) {

drivers/md/raid1.c

3444

mddev->new_level = 1;

drivers/md/raid1.c

3445

mddev->new_layout = 0;

drivers/md/raid1.c

3446

mddev->new_chunk_sectors = 0;

drivers/md/raid1.c

3447

conf = setup_conf(mddev);

drivers/md/raid1.c

3451

mddev_clear_unsupported_flags(mddev,

drivers/md/raid1.c

349

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

366

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

390

if (r1_bio->mddev->degraded == conf->raid_disks ||

drivers/md/raid1.c

391

(r1_bio->mddev->degraded == conf->raid_disks-1 &&

drivers/md/raid1.c

399

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid1.c

405

mdname(conf->mddev),

drivers/md/raid1.c

416

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

426

mddev->bitmap_ops->end_behind_write(mddev);

drivers/md/raid1.c

427

md_write_end(mddev);

drivers/md/raid1.c

450

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

466

conf->mddev->recovery);

drivers/md/raid1.c

472

md_error(r1_bio->mddev, rdev);

drivers/md/raid1.c

49

static void raid1_free(struct mddev *mddev, void *priv);

drivers/md/raid1.c

544

} else if (test_bit(MD_SERIALIZE_POLICY, &rdev->mddev->flags))

drivers/md/raid1.c

547

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid1.c

84

struct mddev *mddev = rdev->mddev;

drivers/md/raid1.c

869

if (raid1_should_read_first(conf->mddev, r1_bio->sector,

drivers/md/raid1.c

89

if (WARN_ON(!mddev->serial_info_pool))

drivers/md/raid1.c

902

raid1_prepare_flush_writes(conf->mddev);

drivers/md/raid1.c

91

si = mempool_alloc(mddev->serial_info_pool, GFP_NOIO);

drivers/md/raid1.h

136

struct mddev *mddev;

drivers/md/raid1.h

53

struct mddev *mddev;

drivers/md/raid10.c

1019

mddev_add_trace_msg(conf->mddev, "raid10 wait barrier");

drivers/md/raid10.c

1077

if (!test_bit(MD_RECOVERY_RESHAPE, &rdev->mddev->recovery) ||

drivers/md/raid10.c

1087

struct mddev *mddev = plug->cb.data;

drivers/md/raid10.c

1088

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1096

md_wakeup_thread(mddev->thread);

drivers/md/raid10.c

1103

raid1_prepare_flush_writes(mddev);

drivers/md/raid10.c

1122

static bool regular_request_wait(struct mddev *mddev, struct r10conf *conf,

drivers/md/raid10.c

1130

while (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&

drivers/md/raid10.c

1138

mddev_add_trace_msg(conf->mddev, "raid10 wait reshape");

drivers/md/raid10.c

1148

static void raid10_read_request(struct mddev *mddev, struct bio *bio,

drivers/md/raid10.c

1151

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1186

if (!regular_request_wait(mddev, conf, bio, r10_bio->sectors)) {

drivers/md/raid10.c

1195

mdname(mddev), b,

drivers/md/raid10.c

1203

mdname(mddev),

drivers/md/raid10.c

1222

md_account_bio(mddev, &bio);

drivers/md/raid10.c

1225

read_bio = bio_alloc_clone(rdev->bdev, bio, gfp, &mddev->bio_set);

drivers/md/raid10.c

1238

mddev_trace_remap(mddev, read_bio, r10_bio->sector);

drivers/md/raid10.c

1246

static void raid10_write_one_disk(struct mddev *mddev, struct r10bio *r10_bio,

drivers/md/raid10.c

1251

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1259

mbio = bio_alloc_clone(rdev->bdev, bio, GFP_NOIO, &mddev->bio_set);

drivers/md/raid10.c

1274

mddev_trace_remap(mddev, mbio, r10_bio->sector);

drivers/md/raid10.c

1280

if (!raid1_add_bio_to_plug(mddev, mbio, raid10_unplug, conf->copies)) {

drivers/md/raid10.c

1284

md_wakeup_thread(mddev->thread);

drivers/md/raid10.c

1288

static void wait_blocked_dev(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

1290

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1335

mddev_add_trace_msg(conf->mddev,

drivers/md/raid10.c

1338

md_wait_for_blocked_rdev(blocked_rdev, mddev);

drivers/md/raid10.c

1344

static void raid10_write_request(struct mddev *mddev, struct bio *bio,

drivers/md/raid10.c

1347

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1352

if ((mddev_is_clustered(mddev) &&

drivers/md/raid10.c

1353

mddev->cluster_ops->area_resyncing(mddev, WRITE,

drivers/md/raid10.c

1365

if (!mddev->cluster_ops->area_resyncing(mddev, WRITE,

drivers/md/raid10.c

1374

if (!regular_request_wait(mddev, conf, bio, sectors)) {

drivers/md/raid10.c

1379

if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&

drivers/md/raid10.c

1380

(mddev->reshape_backwards

drivers/md/raid10.c

1386

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid10.c

1387

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/raid10.c

1389

md_wakeup_thread(mddev->thread);

drivers/md/raid10.c

1395

mddev_add_trace_msg(conf->mddev,

drivers/md/raid10.c

1397

wait_event(mddev->sb_wait,

drivers/md/raid10.c

1398

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/raid10.c

1400

conf->reshape_safe = mddev->reshape_position;

drivers/md/raid10.c

1416

wait_blocked_dev(mddev, r10_bio);

drivers/md/raid10.c

144

if (test_bit(MD_RECOVERY_SYNC, &conf->mddev->recovery) ||

drivers/md/raid10.c

145

test_bit(MD_RECOVERY_RESHAPE, &conf->mddev->recovery))

drivers/md/raid10.c

1498

md_account_bio(mddev, &bio);

drivers/md/raid10.c

1504

raid10_write_one_disk(mddev, r10_bio, bio, false, i);

drivers/md/raid10.c

1506

raid10_write_one_disk(mddev, r10_bio, bio, true, i);

drivers/md/raid10.c

1517

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

1521

rdev_dec_pending(rrdev, mddev);

drivers/md/raid10.c

1529

static void __make_request(struct mddev *mddev, struct bio *bio, int sectors)

drivers/md/raid10.c

1531

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1539

r10_bio->mddev = mddev;

drivers/md/raid10.c

1547

raid10_read_request(mddev, bio, r10_bio, true);

drivers/md/raid10.c

1549

raid10_write_request(mddev, bio, r10_bio);

drivers/md/raid10.c

1554

struct r10conf *conf = r10bio->mddev->private;

drivers/md/raid10.c

1566

md_write_end(r10bio->mddev);

drivers/md/raid10.c

1577

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

1593

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

1602

static int raid10_handle_discard(struct mddev *mddev, struct bio *bio)

drivers/md/raid10.c

1604

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1623

if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))

drivers/md/raid10.c

1635

if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))

drivers/md/raid10.c

1727

r10_bio->mddev = mddev;

drivers/md/raid10.c

1731

wait_blocked_dev(mddev, r10_bio);

drivers/md/raid10.c

1741

md_account_bio(mddev, &bio);

drivers/md/raid10.c

1797

dev_start = (first_stripe_index + 1) * mddev->chunk_sectors;

drivers/md/raid10.c

1799

dev_start = first_stripe_index * mddev->chunk_sectors;

drivers/md/raid10.c

1804

dev_end = (last_stripe_index + 1) * mddev->chunk_sectors;

drivers/md/raid10.c

1806

dev_end = last_stripe_index * mddev->chunk_sectors;

drivers/md/raid10.c

1819

&mddev->bio_set);

drivers/md/raid10.c

1825

md_submit_discard_bio(mddev, rdev, mbio,

drivers/md/raid10.c

1833

&mddev->bio_set);

drivers/md/raid10.c

1839

md_submit_discard_bio(mddev, rrdev, rbio,

drivers/md/raid10.c

1865

static bool raid10_make_request(struct mddev *mddev, struct bio *bio)

drivers/md/raid10.c

1867

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1873

&& md_flush_request(mddev, bio))

drivers/md/raid10.c

1876

md_write_start(mddev, bio);

drivers/md/raid10.c

1879

if (!raid10_handle_discard(mddev, bio))

drivers/md/raid10.c

1894

__make_request(mddev, bio, sectors);

drivers/md/raid10.c

1901

static void raid10_status(struct seq_file *seq, struct mddev *mddev)

drivers/md/raid10.c

1903

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1906

lockdep_assert_held(&mddev->lock);

drivers/md/raid10.c

1909

seq_printf(seq, " %dK chunks", mddev->chunk_sectors / 2);

drivers/md/raid10.c

191

&conf->mddev->recovery)) {

drivers/md/raid10.c

1921

conf->geo.raid_disks - mddev->degraded);

drivers/md/raid10.c

1995

static void raid10_error(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid10.c

1997

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2003

set_bit(MD_BROKEN, &mddev->flags);

drivers/md/raid10.c

2005

if (!test_bit(MD_FAILLAST_DEV, &mddev->flags)) {

drivers/md/raid10.c

2011

mddev->degraded++;

drivers/md/raid10.c

2013

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid10.c

2016

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/raid10.c

2021

mdname(mddev), rdev->bdev,

drivers/md/raid10.c

2022

mdname(mddev), conf->geo.raid_disks - mddev->degraded);

drivers/md/raid10.c

2035

pr_debug(" --- wd:%d rd:%d\n", conf->geo.raid_disks - conf->mddev->degraded,

drivers/md/raid10.c

2038

lockdep_assert_held(&conf->mddev->reconfig_mutex);

drivers/md/raid10.c

2057

static int raid10_spare_active(struct mddev *mddev)

drivers/md/raid10.c

2060

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2098

mddev->degraded -= count;

drivers/md/raid10.c

2105

static int raid10_add_disk(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid10.c

2107

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2114

if (mddev->resync_offset < MaxSector)

drivers/md/raid10.c

2140

err = mddev_stack_new_rdev(mddev, rdev);

drivers/md/raid10.c

2157

err = mddev_stack_new_rdev(mddev, rdev);

drivers/md/raid10.c

2168

static int raid10_remove_disk(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid10.c

2170

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2177

if (unlikely(number >= mddev->raid_disks))

drivers/md/raid10.c

2211

err = md_integrity_register(mddev);

drivers/md/raid10.c

2221

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

2235

rdev_dec_pending(conf->mirrors[d].rdev, conf->mddev);

drivers/md/raid10.c

2248

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

2264

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

2275

md_done_sync(mddev, s);

drivers/md/raid10.c

2292

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

2293

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2307

md_error(mddev, rdev);

drivers/md/raid10.c

2312

&rdev->mddev->recovery);

drivers/md/raid10.c

2320

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

2341

static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

2343

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2400

atomic64_add(r10_bio->sectors, &mddev->resync_mismatches);

drivers/md/raid10.c

2401

if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))

drivers/md/raid10.c

2406

md_error(rdev->mddev, rdev);

drivers/md/raid10.c

2451

md_done_sync(mddev, r10_bio->sectors);

drivers/md/raid10.c

2475

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

2476

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2514

&rdev->mddev->recovery);

drivers/md/raid10.c

2532

mdname(mddev));

drivers/md/raid10.c

2535

&mddev->recovery);

drivers/md/raid10.c

2547

static void recovery_request_write(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

2549

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2598

&rdev->mddev->recovery);

drivers/md/raid10.c

2613

static void fix_read_error(struct r10conf *conf, struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

2630

if (exceed_read_errors(mddev, rdev)) {

drivers/md/raid10.c

2660

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

2709

mdname(mddev), s,

drivers/md/raid10.c

2716

mdname(mddev),

drivers/md/raid10.c

2719

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

2741

mdname(mddev), s,

drivers/md/raid10.c

2747

mdname(mddev),

drivers/md/raid10.c

2752

mdname(mddev), s,

drivers/md/raid10.c

2760

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

277

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

2771

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

2772

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2807

&mddev->bio_set);

drivers/md/raid10.c

2831

static void handle_read_error(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

2835

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

285

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

2850

if (mddev->ro)

drivers/md/raid10.c

2854

fix_read_error(conf, mddev, r10_bio);

drivers/md/raid10.c

2857

md_error(mddev, rdev);

drivers/md/raid10.c

2859

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

2861

raid10_read_request(mddev, r10_bio->master_bio, r10_bio, false);

drivers/md/raid10.c

2924

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

2928

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

2937

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

2950

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid10.c

2962

struct mddev *mddev = thread->mddev;

drivers/md/raid10.c

2965

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2969

md_check_recovery(mddev);

drivers/md/raid10.c

2972

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {

drivers/md/raid10.c

2975

if (!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {

drivers/md/raid10.c

3009

mddev = r10_bio->mddev;

drivers/md/raid10.c

301

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

3010

conf = mddev->private;

drivers/md/raid10.c

3015

reshape_request_write(mddev, r10_bio);

drivers/md/raid10.c

3017

sync_request_write(mddev, r10_bio);

drivers/md/raid10.c

3019

recovery_request_write(mddev, r10_bio);

drivers/md/raid10.c

302

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

3021

handle_read_error(mddev, r10_bio);

drivers/md/raid10.c

3026

if (mddev->sb_flags & ~(1<<MD_SB_CHANGE_PENDING))

drivers/md/raid10.c

3027

md_check_recovery(mddev);

drivers/md/raid10.c

3058

if (test_bit(MD_RECOVERY_SYNC, &conf->mddev->recovery) ||

drivers/md/raid10.c

3059

test_bit(MD_RECOVERY_RESHAPE, &conf->mddev->recovery))

drivers/md/raid10.c

3105

window_size = (chunks + extra_chunk) * conf->mddev->chunk_sectors;

drivers/md/raid10.c

312

md_wakeup_thread(mddev->thread);

drivers/md/raid10.c

3148

static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,

drivers/md/raid10.c

3151

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

3165

if (mddev->bitmap == NULL &&

drivers/md/raid10.c

3166

mddev->resync_offset == MaxSector &&

drivers/md/raid10.c

3167

mddev->reshape_position == MaxSector &&

drivers/md/raid10.c

3168

!test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&

drivers/md/raid10.c

3169

!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&

drivers/md/raid10.c

3170

!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&

drivers/md/raid10.c

3173

return mddev->dev_sectors - sector_nr;

drivers/md/raid10.c

3193

if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {

drivers/md/raid10.c

3199

if (mddev->curr_resync < max_sector) { /* aborted */

drivers/md/raid10.c

3200

if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))

drivers/md/raid10.c

3201

md_bitmap_end_sync(mddev, mddev->curr_resync,

drivers/md/raid10.c

3205

raid10_find_virt(conf, mddev->curr_resync, i);

drivers/md/raid10.c

3207

md_bitmap_end_sync(mddev, sect, &sync_blocks);

drivers/md/raid10.c

3211

if ((!mddev->bitmap || conf->fullsync)

drivers/md/raid10.c

3213

&& test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {

drivers/md/raid10.c

3227

if (md_bitmap_enabled(mddev, false))

drivers/md/raid10.c

3228

mddev->bitmap_ops->close_sync(mddev);

drivers/md/raid10.c

323

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

3234

if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))

drivers/md/raid10.c

3235

return reshape_request(mddev, sector_nr, skipped);

drivers/md/raid10.c

3237

if (max_sector > mddev->resync_max)

drivers/md/raid10.c

3238

max_sector = mddev->resync_max; /* Don't do IO beyond here */

drivers/md/raid10.c

3270

if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {

drivers/md/raid10.c

3300

if (sect >= mddev->resync_max_sectors)

drivers/md/raid10.c

3309

must_sync = md_bitmap_start_sync(mddev, sect,

drivers/md/raid10.c

3334

r10_bio->mddev = mddev;

drivers/md/raid10.c

3352

md_bitmap_start_sync(mddev, sect, &sync_blocks,

drivers/md/raid10.c

345

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

3461

mdname(mddev), r10_bio->devs[k].addr, max_sync);

drivers/md/raid10.c

3468

rdev_dec_pending(mrdev, mddev);

drivers/md/raid10.c

3470

rdev_dec_pending(mreplace, mddev);

drivers/md/raid10.c

3474

rdev_dec_pending(mrdev, mddev);

drivers/md/raid10.c

3476

rdev_dec_pending(mreplace, mddev);

drivers/md/raid10.c

3516

if (md_bitmap_enabled(mddev, false))

drivers/md/raid10.c

3517

mddev->bitmap_ops->cond_end_sync(mddev, sector_nr,

drivers/md/raid10.c

3518

mddev_is_clustered(mddev) &&

drivers/md/raid10.c

3521

if (!md_bitmap_start_sync(mddev, sector_nr, &sync_blocks,

drivers/md/raid10.c

3522

mddev->degraded) &&

drivers/md/raid10.c

3524

&mddev->recovery)) {

drivers/md/raid10.c

3534

r10_bio->mddev = mddev;

drivers/md/raid10.c

3611

mddev);

drivers/md/raid10.c

3616

mddev);

drivers/md/raid10.c

3649

if (mddev_is_clustered(mddev) &&

drivers/md/raid10.c

3650

test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {

drivers/md/raid10.c

3653

conf->cluster_sync_low = mddev->curr_resync_completed;

drivers/md/raid10.c

3656

mddev->cluster_ops->resync_info_update(mddev,

drivers/md/raid10.c

3660

} else if (mddev_is_clustered(mddev)) {

drivers/md/raid10.c

3680

mddev->curr_resync_completed, i);

drivers/md/raid10.c

3689

mddev->cluster_ops->resync_info_update(mddev,

drivers/md/raid10.c

3713

raid10_size(struct mddev *mddev, sector_t sectors, int raid_disks)

drivers/md/raid10.c

3716

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

3763

static int setup_geo(struct geom *geo, struct mddev *mddev, enum geo_type new)

drivers/md/raid10.c

3769

layout = mddev->layout;

drivers/md/raid10.c

3770

chunk = mddev->chunk_sectors;

drivers/md/raid10.c

3771

disks = mddev->raid_disks - mddev->delta_disks;

drivers/md/raid10.c

3774

layout = mddev->new_layout;

drivers/md/raid10.c

3775

chunk = mddev->new_chunk_sectors;

drivers/md/raid10.c

3776

disks = mddev->raid_disks;

drivers/md/raid10.c

3781

layout = mddev->new_layout;

drivers/md/raid10.c

3782

chunk = mddev->new_chunk_sectors;

drivers/md/raid10.c

3783

disks = mddev->raid_disks + mddev->delta_disks;

drivers/md/raid10.c

3833

static struct r10conf *setup_conf(struct mddev *mddev)

drivers/md/raid10.c

384

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

3840

copies = setup_geo(&geo, mddev, geo_new);

drivers/md/raid10.c

3844

mdname(mddev), PAGE_SIZE);

drivers/md/raid10.c

3848

if (copies < 2 || copies > mddev->raid_disks) {

drivers/md/raid10.c

3850

mdname(mddev), mddev->new_layout);

drivers/md/raid10.c

3861

mddev->raid_disks + max(0, -mddev->delta_disks));

drivers/md/raid10.c

3880

calc_sectors(conf, mddev->dev_sectors);

drivers/md/raid10.c

3881

if (mddev->reshape_position == MaxSector) {

drivers/md/raid10.c

3885

if (setup_geo(&conf->prev, mddev, geo_old) != conf->copies) {

drivers/md/raid10.c

3889

conf->reshape_progress = mddev->reshape_position;

drivers/md/raid10.c

3907

md_register_thread(raid10d, mddev, "raid10"));

drivers/md/raid10.c

3911

conf->mddev = mddev;

drivers/md/raid10.c

3928

static int raid10_set_queue_limits(struct mddev *mddev)

drivers/md/raid10.c

3930

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

3937

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid10.c

3938

lim.io_min = mddev->chunk_sectors << 9;

drivers/md/raid10.c

3939

lim.chunk_sectors = mddev->chunk_sectors;

drivers/md/raid10.c

3942

err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);

drivers/md/raid10.c

3945

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/md/raid10.c

3948

static int raid10_run(struct mddev *mddev)

drivers/md/raid10.c

3959

if (mddev->private == NULL) {

drivers/md/raid10.c

3960

conf = setup_conf(mddev);

drivers/md/raid10.c

3963

mddev->private = conf;

drivers/md/raid10.c

3965

conf = mddev->private;

drivers/md/raid10.c

3969

rcu_assign_pointer(mddev->thread, conf->thread);

drivers/md/raid10.c

3972

if (mddev_is_clustered(conf->mddev)) {

drivers/md/raid10.c

3975

fc = (mddev->layout >> 8) & 255;

drivers/md/raid10.c

3976

fo = mddev->layout & (1<<16);

drivers/md/raid10.c

3984

rdev_for_each(rdev, mddev) {

drivers/md/raid10.c

4005

if (!mddev->reshape_backwards)

drivers/md/raid10.c

4016

if (!mddev_is_dm(conf->mddev)) {

drivers/md/raid10.c

4017

int err = raid10_set_queue_limits(mddev);

drivers/md/raid10.c

4028

mdname(mddev));

drivers/md/raid10.c

4042

mddev->degraded = 0;

drivers/md/raid10.c

4060

mddev->degraded++;

drivers/md/raid10.c

4073

if (mddev->resync_offset != MaxSector)

drivers/md/raid10.c

4075

mdname(mddev));

drivers/md/raid10.c

4077

mdname(mddev), conf->geo.raid_disks - mddev->degraded,

drivers/md/raid10.c

4082

mddev->dev_sectors = conf->dev_sectors;

drivers/md/raid10.c

4083

size = raid10_size(mddev, 0, 0);

drivers/md/raid10.c

4084

md_set_array_sectors(mddev, size);

drivers/md/raid10.c

4085

mddev->resync_max_sectors = size;

drivers/md/raid10.c

4086

set_bit(MD_FAILFAST_SUPPORTED, &mddev->flags);

drivers/md/raid10.c

4088

if (md_integrity_register(mddev))

drivers/md/raid10.c

4106

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/raid10.c

4107

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/raid10.c

4108

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/raid10.c

4109

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid10.c

4115

md_unregister_thread(mddev, &mddev->thread);

drivers/md/raid10.c

4117

mddev->private = NULL;

drivers/md/raid10.c

4122

static void raid10_free(struct mddev *mddev, void *priv)

drivers/md/raid10.c

4127

static void raid10_quiesce(struct mddev *mddev, int quiesce)

drivers/md/raid10.c

4129

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4137

static int raid10_resize(struct mddev *mddev, sector_t sectors)

drivers/md/raid10.c

4151

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4154

if (mddev->reshape_position != MaxSector)

drivers/md/raid10.c

4160

oldsize = raid10_size(mddev, 0, 0);

drivers/md/raid10.c

4161

size = raid10_size(mddev, sectors, 0);

drivers/md/raid10.c

4162

if (mddev->external_size &&

drivers/md/raid10.c

4163

mddev->array_sectors > size)

drivers/md/raid10.c

4166

if (md_bitmap_enabled(mddev, false)) {

drivers/md/raid10.c

4167

int ret = mddev->bitmap_ops->resize(mddev, size, 0);

drivers/md/raid10.c

4173

md_set_array_sectors(mddev, size);

drivers/md/raid10.c

4174

if (sectors > mddev->dev_sectors &&

drivers/md/raid10.c

4175

mddev->resync_offset > oldsize) {

drivers/md/raid10.c

4176

mddev->resync_offset = oldsize;

drivers/md/raid10.c

4177

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid10.c

418

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

4180

mddev->dev_sectors = conf->dev_sectors;

drivers/md/raid10.c

4181

mddev->resync_max_sectors = size;

drivers/md/raid10.c

4185

static void *raid10_takeover_raid0(struct mddev *mddev, sector_t size, int devs)

drivers/md/raid10.c

4190

if (mddev->degraded > 0) {

drivers/md/raid10.c

4192

mdname(mddev));

drivers/md/raid10.c

4198

mddev->new_level = 10;

drivers/md/raid10.c

4200

mddev->new_layout = (1<<8) + 2;

drivers/md/raid10.c

4201

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid10.c

4202

mddev->delta_disks = mddev->raid_disks;

drivers/md/raid10.c

4203

mddev->raid_disks *= 2;

drivers/md/raid10.c

4205

mddev->resync_offset = MaxSector;

drivers/md/raid10.c

4206

mddev->dev_sectors = size;

drivers/md/raid10.c

4208

conf = setup_conf(mddev);

drivers/md/raid10.c

4210

rdev_for_each(rdev, mddev)

drivers/md/raid10.c

4220

static void *raid10_takeover(struct mddev *mddev)

drivers/md/raid10.c

4227

if (mddev->level == 0) {

drivers/md/raid10.c

4229

raid0_conf = mddev->private;

drivers/md/raid10.c

4232

mdname(mddev));

drivers/md/raid10.c

4235

return raid10_takeover_raid0(mddev,

drivers/md/raid10.c

424

mdname(conf->mddev),

drivers/md/raid10.c

4242

static int raid10_check_reshape(struct mddev *mddev)

drivers/md/raid10.c

4258

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4264

if (setup_geo(&geo, mddev, geo_start) != conf->copies)

drivers/md/raid10.c

4271

if (mddev->array_sectors & geo.chunk_mask)

drivers/md/raid10.c

4280

if (mddev->delta_disks > 0) {

drivers/md/raid10.c

4284

mddev->raid_disks + mddev->delta_disks);

drivers/md/raid10.c

434

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

4346

static int raid10_start_reshape(struct mddev *mddev)

drivers/md/raid10.c

436

md_write_end(mddev);

drivers/md/raid10.c

4362

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4367

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/raid10.c

4370

if (setup_geo(&new, mddev, geo_start) != conf->copies)

drivers/md/raid10.c

4378

rdev_for_each(rdev, mddev) {

drivers/md/raid10.c

4385

if (!mddev->reshape_backwards)

drivers/md/raid10.c

4398

if (spares < mddev->delta_disks)

drivers/md/raid10.c

4412

setup_geo(&conf->geo, mddev, geo_start);

drivers/md/raid10.c

4414

if (mddev->reshape_backwards) {

drivers/md/raid10.c

4415

sector_t size = raid10_size(mddev, 0, 0);

drivers/md/raid10.c

4416

if (size < mddev->array_sectors) {

drivers/md/raid10.c

4419

mdname(mddev));

drivers/md/raid10.c

4422

mddev->resync_max_sectors = size;

drivers/md/raid10.c

4429

if (mddev->delta_disks && mddev->bitmap) {

drivers/md/raid10.c

4433

oldsize = raid10_size(mddev, 0, 0);

drivers/md/raid10.c

4434

newsize = raid10_size(mddev, 0, conf->geo.raid_disks);

drivers/md/raid10.c

4436

if (!mddev_is_clustered(mddev) &&

drivers/md/raid10.c

4437

md_bitmap_enabled(mddev, false)) {

drivers/md/raid10.c

4438

ret = mddev->bitmap_ops->resize(mddev, newsize, 0);

drivers/md/raid10.c

4445

rdev_for_each(rdev, mddev) {

drivers/md/raid10.c

4461

ret = mddev->bitmap_ops->resize(mddev, newsize, 0);

drivers/md/raid10.c

4465

ret = mddev->cluster_ops->resize_bitmaps(mddev, newsize, oldsize);

drivers/md/raid10.c

4467

mddev->bitmap_ops->resize(mddev, oldsize, 0);

drivers/md/raid10.c

4472

if (mddev->delta_disks > 0) {

drivers/md/raid10.c

4473

rdev_for_each(rdev, mddev)

drivers/md/raid10.c

4476

if (raid10_add_disk(mddev, rdev) == 0) {

drivers/md/raid10.c

4484

sysfs_link_rdev(mddev, rdev);

drivers/md/raid10.c

4497

mddev->degraded = calc_degraded(conf);

drivers/md/raid10.c

4499

mddev->raid_disks = conf->geo.raid_disks;

drivers/md/raid10.c

4500

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid10.c

4501

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid10.c

4503

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/raid10.c

4504

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/raid10.c

4505

clear_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/raid10.c

4506

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/raid10.c

4507

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid10.c

4513

mddev->recovery = 0;

drivers/md/raid10.c

4516

mddev->raid_disks = conf->geo.raid_disks;

drivers/md/raid10.c

4517

rdev_for_each(rdev, mddev)

drivers/md/raid10.c

4522

mddev->reshape_position = MaxSector;

drivers/md/raid10.c

4558

static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr,

drivers/md/raid10.c

459

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

4598

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4613

if (mddev->reshape_backwards &&

drivers/md/raid10.c

4614

conf->reshape_progress < raid10_size(mddev, 0, 0)) {

drivers/md/raid10.c

4615

sector_nr = (raid10_size(mddev, 0, 0)

drivers/md/raid10.c

4617

} else if (!mddev->reshape_backwards &&

drivers/md/raid10.c

4621

mddev->curr_resync_completed = sector_nr;

drivers/md/raid10.c

4622

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/raid10.c

4632

if (mddev->reshape_backwards) {

drivers/md/raid10.c

4682

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid10.c

4683

if (mddev->reshape_backwards)

drivers/md/raid10.c

4684

mddev->curr_resync_completed = raid10_size(mddev, 0, 0)

drivers/md/raid10.c

4687

mddev->curr_resync_completed = conf->reshape_progress;

drivers/md/raid10.c

4689

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid10.c

4690

md_wakeup_thread(mddev->thread);

drivers/md/raid10.c

4691

wait_event(mddev->sb_wait, mddev->sb_flags == 0 ||

drivers/md/raid10.c

4692

test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid10.c

4693

if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {

drivers/md/raid10.c

4697

conf->reshape_safe = mddev->reshape_position;

drivers/md/raid10.c

4708

r10_bio->mddev = mddev;

drivers/md/raid10.c

4721

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid10.c

4726

GFP_KERNEL, &mddev->bio_set);

drivers/md/raid10.c

4738

if (mddev_is_clustered(mddev) && conf->cluster_sync_high <= sector_nr) {

drivers/md/raid10.c

4756

mddev->cluster_ops->resync_info_update(mddev, conf->cluster_sync_low,

drivers/md/raid10.c

4823

if (mddev->reshape_backwards)

drivers/md/raid10.c

483

md_error(rdev->mddev, rdev);

drivers/md/raid10.c

4832

static int handle_reshape_read_error(struct mddev *mddev,

drivers/md/raid10.c

4834

static void reshape_request_write(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

4841

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4845

if (handle_reshape_read_error(mddev, r10_bio) < 0) {

drivers/md/raid10.c

4847

md_done_sync(mddev, r10_bio->sectors);

drivers/md/raid10.c

4848

md_sync_error(mddev);

drivers/md/raid10.c

488

&rdev->mddev->recovery);

drivers/md/raid10.c

4880

if (test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery))

drivers/md/raid10.c

4885

md_finish_reshape(conf->mddev);

drivers/md/raid10.c

4891

mddev_update_io_opt(conf->mddev, raid10_nr_stripes(conf));

drivers/md/raid10.c

4895

static void raid10_update_reshape_pos(struct mddev *mddev)

drivers/md/raid10.c

4897

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4900

mddev->cluster_ops->resync_info_get(mddev, &lo, &hi);

drivers/md/raid10.c

4901

if (((mddev->reshape_position <= hi) && (mddev->reshape_position >= lo))

drivers/md/raid10.c

4902

|| mddev->reshape_position == MaxSector)

drivers/md/raid10.c

4903

conf->reshape_progress = mddev->reshape_position;

drivers/md/raid10.c

4908

static int handle_reshape_read_error(struct mddev *mddev,

drivers/md/raid10.c

4913

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4921

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid10.c

493

md_error(rdev->mddev, rdev);

drivers/md/raid10.c

4955

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

4968

&mddev->recovery);

drivers/md/raid10.c

4982

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

4983

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4995

md_error(mddev, rdev);

drivers/md/raid10.c

4998

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

5006

md_done_sync(r10_bio->mddev, r10_bio->sectors);

drivers/md/raid10.c

5011

static void raid10_finish_reshape(struct mddev *mddev)

drivers/md/raid10.c

5013

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

5015

if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/raid10.c

5018

if (mddev->delta_disks > 0) {

drivers/md/raid10.c

5019

if (mddev->resync_offset > mddev->resync_max_sectors) {

drivers/md/raid10.c

5020

mddev->resync_offset = mddev->resync_max_sectors;

drivers/md/raid10.c

5021

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid10.c

5023

mddev->resync_max_sectors = mddev->array_sectors;

drivers/md/raid10.c

5027

d < conf->geo.raid_disks - mddev->delta_disks;

drivers/md/raid10.c

5037

mddev->layout = mddev->new_layout;

drivers/md/raid10.c

5038

mddev->chunk_sectors = 1 << conf->geo.chunk_shift;

drivers/md/raid10.c

5039

mddev->reshape_position = MaxSector;

drivers/md/raid10.c

5040

mddev->delta_disks = 0;

drivers/md/raid10.c

5041

mddev->reshape_backwards = 0;

drivers/md/raid10.c

551

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

650

conf->mddev->reshape_backwards)) {

drivers/md/raid10.c

74

static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr,

drivers/md/raid10.c

749

if (raid1_should_read_first(conf->mddev, this_sector, sectors))

drivers/md/raid10.c

76

static void reshape_request_write(struct mddev *mddev, struct r10bio *r10_bio);

drivers/md/raid10.c

887

raid1_prepare_flush_writes(conf->mddev);

drivers/md/raid10.c

974

thread = rcu_dereference_protected(conf->mddev->thread, true);

drivers/md/raid10.h

121

struct mddev *mddev;

drivers/md/raid10.h

24

struct mddev *mddev;

drivers/md/raid5-cache.c

1174

struct r5conf *conf = log->rdev->mddev->private;

drivers/md/raid5-cache.c

1222

struct r5conf *conf = log->rdev->mddev->private;

drivers/md/raid5-cache.c

1260

md_error(log->rdev->mddev, log->rdev);

drivers/md/raid5-cache.c

1314

struct mddev *mddev;

drivers/md/raid5-cache.c

1321

mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

1333

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/raid5-cache.c

1335

if (!mddev_trylock(mddev))

drivers/md/raid5-cache.c

1337

md_update_sb(mddev, 1);

drivers/md/raid5-cache.c

1338

mddev_unlock(mddev);

drivers/md/raid5-cache.c

1491

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5-cache.c

1496

struct r5conf *conf = log->rdev->mddev->private;

drivers/md/raid5-cache.c

1519

md_wakeup_thread(log->rdev->mddev->thread);

drivers/md/raid5-cache.c

1548

struct mddev *mddev = thread->mddev;

drivers/md/raid5-cache.c

1549

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

1576

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

1578

log->reclaim_thread, lockdep_is_held(&mddev->reconfig_mutex));

drivers/md/raid5-cache.c

1582

wake_up(&mddev->sb_wait);

drivers/md/raid5-cache.c

1596

return test_bit(MD_HAS_JOURNAL, &conf->mddev->flags);

drivers/md/raid5-cache.c

1806

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

1807

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

1828

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

1829

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

1894

rdev_dec_pending(rdev, rdev->mddev);

drivers/md/raid5-cache.c

1902

rdev_dec_pending(rrdev, rrdev->mddev);

drivers/md/raid5-cache.c

1991

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

1992

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

2065

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2066

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

2143

mdname(mddev),

drivers/md/raid5-cache.c

2145

ret = raid5_set_cache_size(mddev, new_size);

drivers/md/raid5-cache.c

2148

mdname(mddev),

drivers/md/raid5-cache.c

2160

mdname(mddev));

drivers/md/raid5-cache.c

2341

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2348

mdname(mddev));

drivers/md/raid5-cache.c

2413

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2414

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

2421

if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {

drivers/md/raid5-cache.c

2423

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/raid5-cache.c

2440

set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/raid5-cache.c

2445

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2479

mdname(mddev));

drivers/md/raid5-cache.c

2482

mdname(mddev), ctx->data_only_stripes,

drivers/md/raid5-cache.c

2491

mdname(mddev));

drivers/md/raid5-cache.c

2514

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2517

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5-cache.c

2520

static ssize_t r5c_journal_mode_show(struct mddev *mddev, char *page)

drivers/md/raid5-cache.c

2525

ret = mddev_lock(mddev);

drivers/md/raid5-cache.c

2529

conf = mddev->private;

drivers/md/raid5-cache.c

2551

mddev_unlock(mddev);

drivers/md/raid5-cache.c

2561

int r5c_journal_mode_set(struct mddev *mddev, int mode)

drivers/md/raid5-cache.c

2569

conf = mddev->private;

drivers/md/raid5-cache.c

2580

mdname(mddev), mode, r5c_journal_mode_str[mode]);

drivers/md/raid5-cache.c

2585

static ssize_t r5c_journal_mode_store(struct mddev *mddev,

drivers/md/raid5-cache.c

2602

ret = mddev_suspend_and_lock(mddev);

drivers/md/raid5-cache.c

2605

ret = r5c_journal_mode_set(mddev, mode);

drivers/md/raid5-cache.c

2606

mddev_unlock_and_resume(mddev);

drivers/md/raid5-cache.c

2768

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5-cache.c

2823

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5-cache.c

301

md_write_end(conf->mddev);

drivers/md/raid5-cache.c

3025

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

3026

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

3033

void r5c_update_on_rdev_error(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid5-cache.c

3035

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

3054

mdname(conf->mddev), rdev->bdev);

drivers/md/raid5-cache.c

3070

mdname(conf->mddev), conf->raid_disks);

drivers/md/raid5-cache.c

3079

log->uuid_checksum = crc32c(~0, rdev->mddev->uuid,

drivers/md/raid5-cache.c

3080

sizeof(rdev->mddev->uuid));

drivers/md/raid5-cache.c

3109

thread = md_register_thread(r5l_reclaim_thread, log->rdev->mddev,

drivers/md/raid5-cache.c

3134

set_bit(MD_HAS_JOURNAL, &conf->mddev->flags);

drivers/md/raid5-cache.c

3154

md_unregister_thread(conf->mddev, &log->reclaim_thread);

drivers/md/raid5-cache.c

3161

wake_up(&conf->mddev->sb_wait);

drivers/md/raid5-cache.c

417

struct r5conf *conf = log->rdev->mddev->private;

drivers/md/raid5-cache.c

567

md_error(log->rdev->mddev, log->rdev);

drivers/md/raid5-cache.c

602

md_wakeup_thread(log->rdev->mddev->thread);

drivers/md/raid5-cache.c

683

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

684

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

689

mdname(mddev));

drivers/md/raid5-cache.c

692

wait_event(mddev->sb_wait,

drivers/md/raid5-cache.c

694

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/raid5-cache.c

698

mddev_suspend(mddev, false);

drivers/md/raid5-cache.c

700

mddev_resume(mddev);

drivers/md/raid5-cache.c

861

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

862

struct r5conf *conf = mddev->private;

drivers/md/raid5-log.h

30

void r5c_update_on_rdev_error(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/raid5-log.h

49

return test_bit(MD_HAS_JOURNAL, &conf->mddev->flags);

drivers/md/raid5-log.h

54

return test_bit(MD_HAS_PPL, &conf->mddev->flags);

drivers/md/raid5-ppl.c

1060

md_error(rdev->mddev, rdev);

drivers/md/raid5-ppl.c

1072

struct mddev *mddev = rdev->mddev;

drivers/md/raid5-ppl.c

1098

md_error(mddev, rdev);

drivers/md/raid5-ppl.c

1122

if (mddev->external) {

drivers/md/raid5-ppl.c

1166

if (pplhdr && !mddev->pers && mddev->resync_offset != MaxSector)

drivers/md/raid5-ppl.c

1170

if (!ret && !mddev->pers)

drivers/md/raid5-ppl.c

1205

if (ppl_conf->mddev->external) {

drivers/md/raid5-ppl.c

1211

mdname(ppl_conf->mddev));

drivers/md/raid5-ppl.c

1226

clear_bit(MD_HAS_PPL, &ppl_conf->mddev->flags);

drivers/md/raid5-ppl.c

1227

clear_bit(MD_HAS_MULTIPLE_PPLS, &ppl_conf->mddev->flags);

drivers/md/raid5-ppl.c

1264

RAID5_STRIPE_SECTORS((struct r5conf *)rdev->mddev->private));

drivers/md/raid5-ppl.c

1268

mdname(rdev->mddev), rdev->bdev);

drivers/md/raid5-ppl.c

1279

mdname(rdev->mddev), rdev->bdev);

drivers/md/raid5-ppl.c

1283

if (!rdev->mddev->external &&

drivers/md/raid5-ppl.c

1287

mdname(rdev->mddev), rdev->bdev);

drivers/md/raid5-ppl.c

1302

&log->ppl_conf->mddev->flags);

drivers/md/raid5-ppl.c

1318

struct mddev *mddev = conf->mddev;

drivers/md/raid5-ppl.c

1324

mdname(conf->mddev));

drivers/md/raid5-ppl.c

1329

if (mddev->level != 5) {

drivers/md/raid5-ppl.c

1331

mdname(mddev), mddev->level);

drivers/md/raid5-ppl.c

1335

if (mddev->bitmap_info.file || mddev->bitmap_info.offset) {

drivers/md/raid5-ppl.c

1337

mdname(mddev));

drivers/md/raid5-ppl.c

1341

if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {

drivers/md/raid5-ppl.c

1343

mdname(mddev));

drivers/md/raid5-ppl.c

1351

mdname(mddev), max_disks);

drivers/md/raid5-ppl.c

1359

ppl_conf->mddev = mddev;

drivers/md/raid5-ppl.c

1391

if (!mddev->external) {

drivers/md/raid5-ppl.c

1392

ppl_conf->signature = ~crc32c(~0, mddev->uuid, sizeof(mddev->uuid));

drivers/md/raid5-ppl.c

1396

queue_logical_block_size(mddev->gendisk->queue);

drivers/md/raid5-ppl.c

1424

} else if (!mddev->pers && mddev->resync_offset == 0 &&

drivers/md/raid5-ppl.c

1431

mddev->resync_offset = MaxSector;

drivers/md/raid5-ppl.c

1432

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/raid5-ppl.c

1433

} else if (mddev->pers && ppl_conf->mismatch_count > 0) {

drivers/md/raid5-ppl.c

1440

set_bit(MD_HAS_PPL, &ppl_conf->mddev->flags);

drivers/md/raid5-ppl.c

1486

ppl_write_hint_show(struct mddev *mddev, char *buf)

drivers/md/raid5-ppl.c

1492

ppl_write_hint_store(struct mddev *mddev, const char *page, size_t len)

drivers/md/raid5-ppl.c

1503

err = mddev_lock(mddev);

drivers/md/raid5-ppl.c

1507

conf = mddev->private;

drivers/md/raid5-ppl.c

1513

mddev_unlock(mddev);

drivers/md/raid5-ppl.c

408

md_error(ppl_conf->mddev, log->rdev);

drivers/md/raid5-ppl.c

551

struct r5conf *conf = ppl_conf->mddev->private;

drivers/md/raid5-ppl.c

586

struct r5conf *conf = ppl_conf->mddev->private;

drivers/md/raid5-ppl.c

594

rdev = md_find_rdev_rcu(conf->mddev, bio_dev(bio));

drivers/md/raid5-ppl.c

596

md_error(rdev->mddev, rdev);

drivers/md/raid5-ppl.c

604

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5-ppl.c

612

struct r5conf *conf = ppl_conf->mddev->private;

drivers/md/raid5-ppl.c

788

struct mddev *mddev = ppl_conf->mddev;

drivers/md/raid5-ppl.c

789

struct r5conf *conf = mddev->private;

drivers/md/raid5-ppl.c

88

struct mddev *mddev;

drivers/md/raid5-ppl.c

897

md_error(mddev, rdev);

drivers/md/raid5-ppl.c

922

md_error(mddev, log->rdev);

drivers/md/raid5-ppl.c

946

md_error(mddev, parity_rdev);

drivers/md/raid5-ppl.c

964

struct mddev *mddev = rdev->mddev;

drivers/md/raid5-ppl.c

996

md_error(mddev, rdev);

drivers/md/raid5.c

1224

if (!conf->mddev->external &&

drivers/md/raid5.c

1225

conf->mddev->sb_flags) {

drivers/md/raid5.c

1230

md_check_recovery(conf->mddev);

drivers/md/raid5.c

1238

md_wait_for_blocked_rdev(rdev, conf->mddev);

drivers/md/raid5.c

1241

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

1296

mddev_trace_remap(conf->mddev, bi, sh->dev[i].sector);

drivers/md/raid5.c

1336

mddev_trace_remap(conf->mddev, rbi, sh->dev[i].sector);

drivers/md/raid5.c

203

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

2411

if (mddev_is_dm(conf->mddev))

drivers/md/raid5.c

2413

"raid%d-%p", conf->level, conf->mddev);

drivers/md/raid5.c

2416

"raid%d-%s", conf->level, mdname(conf->mddev));

drivers/md/raid5.c

2485

raid5_quiesce(conf->mddev, true);

drivers/md/raid5.c

2499

raid5_quiesce(conf->mddev, false);

drivers/md/raid5.c

2541

md_allow_write(conf->mddev);

drivers/md/raid5.c

2752

mdname(conf->mddev), RAID5_STRIPE_SECTORS(conf),

drivers/md/raid5.c

276

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

2780

mdname(conf->mddev),

drivers/md/raid5.c

2783

else if (conf->mddev->degraded >= conf->max_degraded) {

drivers/md/raid5.c

2787

mdname(conf->mddev),

drivers/md/raid5.c

2795

mdname(conf->mddev),

drivers/md/raid5.c

2802

mdname(conf->mddev),

drivers/md/raid5.c

2806

mdname(conf->mddev), rdev->bdev);

drivers/md/raid5.c

282

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

2829

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

2872

md_error(conf->mddev, rdev);

drivers/md/raid5.c

2882

&rdev->mddev->recovery);

drivers/md/raid5.c

2894

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

2909

static void raid5_error(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid5.c

2911

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

2916

mdname(mddev), rdev->bdev);

drivers/md/raid5.c

2921

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

2924

set_bit(MD_BROKEN, &conf->mddev->flags);

drivers/md/raid5.c

2927

mdname(mddev), mddev->degraded, conf->raid_disks);

drivers/md/raid5.c

2930

mdname(mddev), conf->raid_disks - mddev->degraded);

drivers/md/raid5.c

2934

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid5.c

2937

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/raid5.c

2939

r5c_update_on_rdev_error(mddev, rdev);

drivers/md/raid5.c

3262

mdname(conf->mddev));

drivers/md/raid5.c

3519

md_write_inc(conf->mddev, bi);

drivers/md/raid5.c

3540

if (conf->mddev->bitmap && firstwrite && !sh->batch_head) {

drivers/md/raid5.c

3607

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

3626

md_write_end(conf->mddev);

drivers/md/raid5.c

364

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

3642

md_write_end(conf->mddev);

drivers/md/raid5.c

3681

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

3704

if (test_bit(MD_RECOVERY_RECOVER, &conf->mddev->recovery)) {

drivers/md/raid5.c

3727

md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf));

drivers/md/raid5.c

3730

md_sync_error(conf->mddev);

drivers/md/raid5.c

3743

|| rdev->mddev->resync_offset <= sh->sector))

drivers/md/raid5.c

3754

struct mddev *mddev = sh->raid_conf->mddev;

drivers/md/raid5.c

3759

(mddev->bitmap_ops && mddev->bitmap_ops->blocks_synced &&

drivers/md/raid5.c

3760

!mddev->bitmap_ops->blocks_synced(mddev, sh->sector)))

drivers/md/raid5.c

3840

sh->sector < sh->raid_conf->mddev->resync_offset)

drivers/md/raid5.c

4020

md_write_end(conf->mddev);

drivers/md/raid5.c

4078

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

410

if (unlikely(!conf->mddev->thread) ||

drivers/md/raid5.c

4105

struct mddev *mddev = conf->mddev;

drivers/md/raid5.c

4106

sector_t resync_offset = mddev->resync_offset;

drivers/md/raid5.c

4125

} else if (mddev->bitmap_ops && mddev->bitmap_ops->blocks_synced &&

drivers/md/raid5.c

4126

!mddev->bitmap_ops->blocks_synced(mddev, sh->sector)) {

drivers/md/raid5.c

415

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

4163

mddev_add_trace_msg(mddev, "raid5 rmw %llu %d",

drivers/md/raid5.c

4242

if (rcw && !mddev_is_dm(mddev))

drivers/md/raid5.c

4243

blk_add_trace_msg(mddev->gendisk->queue,

drivers/md/raid5.c

4331

atomic64_add(RAID5_STRIPE_SECTORS(conf), &conf->mddev->resync_mismatches);

drivers/md/raid5.c

4332

if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery)) {

drivers/md/raid5.c

4336

"%llu-%llu\n", mdname(conf->mddev),

drivers/md/raid5.c

4458

mdname(conf->mddev),

drivers/md/raid5.c

4495

atomic64_add(RAID5_STRIPE_SECTORS(conf), &conf->mddev->resync_mismatches);

drivers/md/raid5.c

4496

if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery)) {

drivers/md/raid5.c

4500

"%llu-%llu\n", mdname(conf->mddev),

drivers/md/raid5.c

4725

&conf->mddev->recovery))

drivers/md/raid5.c

4803

sh->sector >= conf->mddev->resync_offset ||

drivers/md/raid5.c

4804

test_bit(MD_RECOVERY_REQUESTED, &(conf->mddev->recovery)))

drivers/md/raid5.c

4964

(md_is_rdwr(conf->mddev) &&

drivers/md/raid5.c

4965

test_bit(MD_SB_CHANGE_PENDING, &conf->mddev->sb_flags))) {

drivers/md/raid5.c

4977

rdev_dec_pending(s.blocked_rdev, conf->mddev);

drivers/md/raid5.c

5165

md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf));

drivers/md/raid5.c

5174

if (s.failed <= conf->max_degraded && !conf->mddev->ro)

drivers/md/raid5.c

5232

md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf));

drivers/md/raid5.c

5242

if (conf->mddev->external)

drivers/md/raid5.c

5244

conf->mddev);

drivers/md/raid5.c

5251

conf->mddev);

drivers/md/raid5.c

5263

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

5269

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

5278

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

5295

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

5336

static int in_chunk_boundary(struct mddev *mddev, struct bio *bio)

drivers/md/raid5.c

5338

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5362

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

5396

struct mddev *mddev = rdev->mddev;

drivers/md/raid5.c

5397

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5402

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

5416

static int raid5_read_one_chunk(struct mddev *mddev, struct bio *raid_bio)

drivers/md/raid5.c

5418

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5425

if (!in_chunk_boundary(mddev, raid_bio)) {

drivers/md/raid5.c

5452

rdev_dec_pending(rdev, mddev);

drivers/md/raid5.c

5456

md_account_bio(mddev, &raid_bio);

drivers/md/raid5.c

5460

&mddev->bio_set);

drivers/md/raid5.c

5487

mddev_trace_remap(mddev, align_bio, raid_bio->bi_iter.bi_sector);

drivers/md/raid5.c

5492

static struct bio *chunk_aligned_read(struct mddev *mddev, struct bio *raid_bio)

drivers/md/raid5.c

5495

unsigned chunk_sects = mddev->chunk_sectors;

drivers/md/raid5.c

5499

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5507

if (!raid5_read_one_chunk(mddev, raid_bio))

drivers/md/raid5.c

5627

struct mddev *mddev = cb->cb.data;

drivers/md/raid5.c

5628

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5656

if (!mddev_is_dm(mddev))

drivers/md/raid5.c

5657

trace_block_unplug(mddev->gendisk->queue, cnt, !from_schedule);

drivers/md/raid5.c

5661

static void release_stripe_plug(struct mddev *mddev,

drivers/md/raid5.c

5665

raid5_unplug, mddev,

drivers/md/raid5.c

5689

static void make_discard_request(struct mddev *mddev, struct bio *bi)

drivers/md/raid5.c

5691

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5700

if (mddev->reshape_position != MaxSector)

drivers/md/raid5.c

5753

md_write_inc(mddev, bi);

drivers/md/raid5.c

5757

if (conf->mddev->bitmap) {

drivers/md/raid5.c

5766

release_stripe_plug(mddev, sh);

drivers/md/raid5.c

5772

static bool ahead_of_reshape(struct mddev *mddev, sector_t sector,

drivers/md/raid5.c

5775

return mddev->reshape_backwards ? sector < reshape_sector :

drivers/md/raid5.c

5779

static bool range_ahead_of_reshape(struct mddev *mddev, sector_t min,

drivers/md/raid5.c

5782

return mddev->reshape_backwards ? max < reshape_sector :

drivers/md/raid5.c

5786

static bool stripe_ahead_of_reshape(struct mddev *mddev, struct r5conf *conf,

drivers/md/raid5.c

5803

if (!range_ahead_of_reshape(mddev, min_sector, max_sector,

drivers/md/raid5.c

5840

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

5872

static enum reshape_loc get_reshape_loc(struct mddev *mddev,

drivers/md/raid5.c

5894

if (ahead_of_reshape(mddev, logical_sector, reshape_progress))

drivers/md/raid5.c

5896

if (ahead_of_reshape(mddev, logical_sector, reshape_safe))

drivers/md/raid5.c

5901

static void raid5_bitmap_sector(struct mddev *mddev, sector_t *offset,

drivers/md/raid5.c

5904

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5925

loc = get_reshape_loc(mddev, conf, prev_start);

drivers/md/raid5.c

5949

static enum stripe_result make_stripe_request(struct mddev *mddev,

drivers/md/raid5.c

5962

loc = get_reshape_loc(mddev, conf, logical_sector);

drivers/md/raid5.c

5987

stripe_ahead_of_reshape(mddev, conf, sh)) {

drivers/md/raid5.c

6007

md_wakeup_thread(mddev->thread);

drivers/md/raid5.c

6038

release_stripe_plug(mddev, sh);

drivers/md/raid5.c

6044

if (ret == STRIPE_SCHEDULE_AND_RETRY && reshape_interrupted(mddev)) {

drivers/md/raid5.c

6084

static bool raid5_make_request(struct mddev *mddev, struct bio * bi)

drivers/md/raid5.c

6087

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6101

if (md_flush_request(mddev, bi))

drivers/md/raid5.c

6107

md_write_start(mddev, bi);

drivers/md/raid5.c

6113

if (rw == READ && mddev->degraded == 0 &&

drivers/md/raid5.c

6114

mddev->reshape_position == MaxSector) {

drivers/md/raid5.c

6115

bi = chunk_aligned_read(mddev, bi);

drivers/md/raid5.c

6121

make_discard_request(mddev, bi);

drivers/md/raid5.c

6122

md_write_end(mddev);

drivers/md/raid5.c

6149

get_reshape_loc(mddev, conf, logical_sector) == LOC_INSIDE_RESHAPE) {

drivers/md/raid5.c

6152

md_write_end(mddev);

drivers/md/raid5.c

6156

md_account_bio(mddev, &bi);

drivers/md/raid5.c

6175

res = make_stripe_request(mddev, conf, ctx, logical_sector,

drivers/md/raid5.c

6216

md_write_end(mddev);

drivers/md/raid5.c

6228

static sector_t raid5_size(struct mddev *mddev, sector_t sectors, int raid_disks);

drivers/md/raid5.c

6230

static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr, int *skipped)

drivers/md/raid5.c

6241

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6258

if (mddev->reshape_backwards &&

drivers/md/raid5.c

6259

conf->reshape_progress < raid5_size(mddev, 0, 0)) {

drivers/md/raid5.c

6260

sector_nr = raid5_size(mddev, 0, 0)

drivers/md/raid5.c

6262

} else if (mddev->reshape_backwards &&

drivers/md/raid5.c

6266

} else if (!mddev->reshape_backwards &&

drivers/md/raid5.c

6271

mddev->curr_resync_completed = sector_nr;

drivers/md/raid5.c

6272

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/raid5.c

6298

if (mddev->reshape_backwards) {

drivers/md/raid5.c

6318

if (mddev->reshape_backwards) {

drivers/md/raid5.c

6323

if (WARN_ON((mddev->dev_sectors &

drivers/md/raid5.c

6360

if ((mddev->reshape_backwards

drivers/md/raid5.c

6367

|| test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid5.c

6370

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid5.c

6371

mddev->curr_resync_completed = sector_nr;

drivers/md/raid5.c

6372

if (!mddev->reshape_backwards)

drivers/md/raid5.c

6374

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

6382

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5.c

6383

md_wakeup_thread(mddev->thread);

drivers/md/raid5.c

6384

wait_event(mddev->sb_wait, mddev->sb_flags == 0 ||

drivers/md/raid5.c

6385

test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid5.c

6386

if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/raid5.c

6389

conf->reshape_safe = mddev->reshape_position;

drivers/md/raid5.c

6392

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/raid5.c

6414

if (s < raid5_size(mddev, 0, 0)) {

drivers/md/raid5.c

6429

if (mddev->reshape_backwards)

drivers/md/raid5.c

6446

if (last_sector >= mddev->dev_sectors)

drivers/md/raid5.c

6447

last_sector = mddev->dev_sectors - 1;

drivers/md/raid5.c

6470

if (mddev->curr_resync_completed > mddev->resync_max ||

drivers/md/raid5.c

6471

(sector_nr - mddev->curr_resync_completed) * 2

drivers/md/raid5.c

6472

>= mddev->resync_max - mddev->curr_resync_completed) {

drivers/md/raid5.c

6476

|| test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid5.c

6479

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid5.c

6480

mddev->curr_resync_completed = sector_nr;

drivers/md/raid5.c

6481

if (!mddev->reshape_backwards)

drivers/md/raid5.c

6483

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

6490

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5.c

6491

md_wakeup_thread(mddev->thread);

drivers/md/raid5.c

6492

wait_event(mddev->sb_wait,

drivers/md/raid5.c

6493

!test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)

drivers/md/raid5.c

6494

|| test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid5.c

6495

if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))

drivers/md/raid5.c

6498

conf->reshape_safe = mddev->reshape_position;

drivers/md/raid5.c

6501

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/raid5.c

6507

static inline sector_t raid5_sync_request(struct mddev *mddev, sector_t sector_nr,

drivers/md/raid5.c

6510

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6519

if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {

drivers/md/raid5.c

6524

if (mddev->curr_resync < max_sector) /* aborted */

drivers/md/raid5.c

6525

md_bitmap_end_sync(mddev, mddev->curr_resync,

drivers/md/raid5.c

6529

if (md_bitmap_enabled(mddev, false))

drivers/md/raid5.c

6530

mddev->bitmap_ops->close_sync(mddev);

drivers/md/raid5.c

6538

if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))

drivers/md/raid5.c

6539

return reshape_request(mddev, sector_nr, skipped);

drivers/md/raid5.c

6551

if (mddev->degraded >= conf->max_degraded &&

drivers/md/raid5.c

6552

test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {

drivers/md/raid5.c

6553

sector_t rv = mddev->dev_sectors - sector_nr;

drivers/md/raid5.c

6557

if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&

drivers/md/raid5.c

6559

!md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, true) &&

drivers/md/raid5.c

6568

if (md_bitmap_enabled(mddev, false))

drivers/md/raid5.c

6569

mddev->bitmap_ops->cond_end_sync(mddev, sector_nr, false);

drivers/md/raid5.c

6591

md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, still_degraded);

drivers/md/raid5.c

6718

struct mddev *mddev = conf->mddev;

drivers/md/raid5.c

6739

wait_event_lock_irq(mddev->sb_wait,

drivers/md/raid5.c

6740

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags),

drivers/md/raid5.c

6766

struct mddev *mddev = thread->mddev;

drivers/md/raid5.c

6767

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6773

md_check_recovery(mddev);

drivers/md/raid5.c

6783

if (md_is_rdwr(mddev) &&

drivers/md/raid5.c

6784

test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))

drivers/md/raid5.c

6796

if (md_bitmap_enabled(mddev, true))

drivers/md/raid5.c

6797

mddev->bitmap_ops->unplug(mddev, true);

drivers/md/raid5.c

6820

if (mddev->sb_flags & ~(1 << MD_SB_CHANGE_PENDING)) {

drivers/md/raid5.c

6822

md_check_recovery(mddev);

drivers/md/raid5.c

6850

raid5_show_stripe_cache_size(struct mddev *mddev, char *page)

drivers/md/raid5.c

6854

spin_lock(&mddev->lock);

drivers/md/raid5.c

6855

conf = mddev->private;

drivers/md/raid5.c

6858

spin_unlock(&mddev->lock);

drivers/md/raid5.c

6863

raid5_set_cache_size(struct mddev *mddev, int size)

drivers/md/raid5.c

6866

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6878

md_allow_write(mddev);

drivers/md/raid5.c

6894

raid5_store_stripe_cache_size(struct mddev *mddev, const char *page, size_t len)

drivers/md/raid5.c

6904

err = mddev_lock(mddev);

drivers/md/raid5.c

6907

conf = mddev->private;

drivers/md/raid5.c

6911

err = raid5_set_cache_size(mddev, new);

drivers/md/raid5.c

6912

mddev_unlock(mddev);

drivers/md/raid5.c

6923

raid5_show_rmw_level(struct mddev *mddev, char *page)

drivers/md/raid5.c

6925

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6933

raid5_store_rmw_level(struct mddev *mddev, const char *page, size_t len)

drivers/md/raid5.c

6935

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6965

raid5_show_stripe_size(struct mddev *mddev, char *page)

drivers/md/raid5.c

6970

spin_lock(&mddev->lock);

drivers/md/raid5.c

6971

conf = mddev->private;

drivers/md/raid5.c

6974

spin_unlock(&mddev->lock);

drivers/md/raid5.c

6980

raid5_store_stripe_size(struct mddev *mddev, const char *page, size_t len)

drivers/md/raid5.c

7002

err = mddev_suspend_and_lock(mddev);

drivers/md/raid5.c

7006

conf = mddev->private;

drivers/md/raid5.c

7018

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||

drivers/md/raid5.c

7019

mddev->reshape_position != MaxSector || mddev->sysfs_active) {

drivers/md/raid5.c

7034

mdname(mddev));

drivers/md/raid5.c

7040

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

7056

raid5_show_preread_threshold(struct mddev *mddev, char *page)

drivers/md/raid5.c

7060

spin_lock(&mddev->lock);

drivers/md/raid5.c

7061

conf = mddev->private;

drivers/md/raid5.c

7064

spin_unlock(&mddev->lock);

drivers/md/raid5.c

7069

raid5_store_preread_threshold(struct mddev *mddev, const char *page, size_t len)

drivers/md/raid5.c

7080

err = mddev_lock(mddev);

drivers/md/raid5.c

7083

conf = mddev->private;

drivers/md/raid5.c

7090

mddev_unlock(mddev);

drivers/md/raid5.c

7101

raid5_show_skip_copy(struct mddev *mddev, char *page)

drivers/md/raid5.c

7105

spin_lock(&mddev->lock);

drivers/md/raid5.c

7106

conf = mddev->private;

drivers/md/raid5.c

7109

spin_unlock(&mddev->lock);

drivers/md/raid5.c

7114

raid5_store_skip_copy(struct mddev *mddev, const char *page, size_t len)

drivers/md/raid5.c

7126

err = mddev_suspend_and_lock(mddev);

drivers/md/raid5.c

7129

conf = mddev->private;

drivers/md/raid5.c

7133

struct request_queue *q = mddev->gendisk->queue;

drivers/md/raid5.c

7143

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

7153

stripe_cache_active_show(struct mddev *mddev, char *page)

drivers/md/raid5.c

7155

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

7166

raid5_show_group_thread_cnt(struct mddev *mddev, char *page)

drivers/md/raid5.c

7170

spin_lock(&mddev->lock);

drivers/md/raid5.c

7171

conf = mddev->private;

drivers/md/raid5.c

7174

spin_unlock(&mddev->lock);

drivers/md/raid5.c

7182

raid5_store_group_thread_cnt(struct mddev *mddev, const char *page, size_t len)

drivers/md/raid5.c

7198

err = mddev_suspend_and_lock(mddev);

drivers/md/raid5.c

7201

conf = mddev->private;

drivers/md/raid5.c

7203

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

7206

raid5_quiesce(mddev, true);

drivers/md/raid5.c

7227

raid5_quiesce(mddev, false);

drivers/md/raid5.c

7228

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

7309

raid5_size(struct mddev *mddev, sector_t sectors, int raid_disks)

drivers/md/raid5.c

7311

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

7314

sectors = mddev->dev_sectors;

drivers/md/raid5.c

7459

static struct r5conf *setup_conf(struct mddev *mddev)

drivers/md/raid5.c

7471

if (mddev->new_level != 5

drivers/md/raid5.c

7472

&& mddev->new_level != 4

drivers/md/raid5.c

7473

&& mddev->new_level != 6) {

drivers/md/raid5.c

7475

mdname(mddev), mddev->new_level);

drivers/md/raid5.c

7478

if ((mddev->new_level == 5

drivers/md/raid5.c

7479

&& !algorithm_valid_raid5(mddev->new_layout)) ||

drivers/md/raid5.c

7480

(mddev->new_level == 6

drivers/md/raid5.c

7481

&& !algorithm_valid_raid6(mddev->new_layout))) {

drivers/md/raid5.c

7483

mdname(mddev), mddev->new_layout);

drivers/md/raid5.c

7486

if (mddev->new_level == 6 && mddev->raid_disks < 4) {

drivers/md/raid5.c

7488

mdname(mddev), mddev->raid_disks);

drivers/md/raid5.c

7492

if (!mddev->new_chunk_sectors ||

drivers/md/raid5.c

7493

(mddev->new_chunk_sectors << 9) % PAGE_SIZE ||

drivers/md/raid5.c

7494

!is_power_of_2(mddev->new_chunk_sectors)) {

drivers/md/raid5.c

7496

mdname(mddev), mddev->new_chunk_sectors << 9);

drivers/md/raid5.c

751

int degraded = conf->mddev->degraded;

drivers/md/raid5.c

753

if (test_bit(MD_BROKEN, &conf->mddev->flags))

drivers/md/raid5.c

7541

rdev_for_each(rdev, mddev) {

drivers/md/raid5.c

7551

conf->raid_disks = mddev->raid_disks;

drivers/md/raid5.c

7552

if (mddev->reshape_position == MaxSector)

drivers/md/raid5.c

7553

conf->previous_raid_disks = mddev->raid_disks;

drivers/md/raid5.c

7555

conf->previous_raid_disks = mddev->raid_disks - mddev->delta_disks;

drivers/md/raid5.c

756

if (conf->mddev->reshape_position != MaxSector)

drivers/md/raid5.c

7572

conf->mddev = mddev;

drivers/md/raid5.c

76

static void raid5_quiesce(struct mddev *mddev, int quiesce);

drivers/md/raid5.c

7601

conf->level = mddev->new_level;

drivers/md/raid5.c

7602

conf->chunk_sectors = mddev->new_chunk_sectors;

drivers/md/raid5.c

7607

pr_debug("raid456: run(%s) called.\n", mdname(mddev));

drivers/md/raid5.c

7610

rdev_for_each(rdev, mddev) {

drivers/md/raid5.c

7629

mdname(mddev), rdev->bdev, raid_disk);

drivers/md/raid5.c

7635

conf->level = mddev->new_level;

drivers/md/raid5.c

7646

conf->algorithm = mddev->new_layout;

drivers/md/raid5.c

7647

conf->reshape_progress = mddev->reshape_position;

drivers/md/raid5.c

7649

conf->prev_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid5.c

7650

conf->prev_algo = mddev->layout;

drivers/md/raid5.c

7657

if (mddev->reshape_position != MaxSector) {

drivers/md/raid5.c

7659

((mddev->chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4,

drivers/md/raid5.c

7660

((mddev->new_chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4);

drivers/md/raid5.c

7664

mdname(mddev), conf->min_nr_stripes);

drivers/md/raid5.c

7671

mdname(mddev), memory);

drivers/md/raid5.c

7675

pr_debug("md/raid:%s: allocated %dkB\n", mdname(mddev), memory);

drivers/md/raid5.c

7681

conf->shrinker = shrinker_alloc(0, "md-raid5:%s", mdname(mddev));

drivers/md/raid5.c

7685

mdname(mddev));

drivers/md/raid5.c

7697

sprintf(pers_name, "raid%d", mddev->new_level);

drivers/md/raid5.c

7699

md_register_thread(raid5d, mddev, pers_name));

drivers/md/raid5.c

7702

mdname(mddev));

drivers/md/raid5.c

7746

if (mddev_is_dm(conf->mddev))

drivers/md/raid5.c

7750

queue_max_hw_sectors(conf->mddev->gendisk->queue) >>

drivers/md/raid5.c

7760

static int raid5_set_limits(struct mddev *mddev)

drivers/md/raid5.c

7762

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

7777

stripe = roundup_pow_of_two(data_disks * (mddev->chunk_sectors << 9));

drivers/md/raid5.c

7780

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid5.c

7781

lim.io_min = mddev->chunk_sectors << 9;

drivers/md/raid5.c

7787

mddev_stack_rdev_limits(mddev, &lim, 0);

drivers/md/raid5.c

7788

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

7790

mddev->gendisk->disk_name);

drivers/md/raid5.c

7822

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/md/raid5.c

7825

static int raid5_run(struct mddev *mddev)

drivers/md/raid5.c

7837

if (mddev->resync_offset != MaxSector)

drivers/md/raid5.c

7839

mdname(mddev));

drivers/md/raid5.c

7841

rdev_for_each(rdev, mddev) {

drivers/md/raid5.c

7854

} else if (mddev->reshape_backwards &&

drivers/md/raid5.c

7857

else if (!mddev->reshape_backwards &&

drivers/md/raid5.c

7862

if ((test_bit(MD_HAS_JOURNAL, &mddev->flags) || journal_dev) &&

drivers/md/raid5.c

7863

(mddev->bitmap_info.offset || mddev->bitmap_info.file)) {

drivers/md/raid5.c

7865

mdname(mddev));

drivers/md/raid5.c

7869

if (mddev->reshape_position != MaxSector) {

drivers/md/raid5.c

7884

int max_degraded = (mddev->level == 6 ? 2 : 1);

drivers/md/raid5.c

7890

mdname(mddev));

drivers/md/raid5.c

7894

if (mddev->new_level != mddev->level) {

drivers/md/raid5.c

7896

mdname(mddev));

drivers/md/raid5.c

7899

old_disks = mddev->raid_disks - mddev->delta_disks;

drivers/md/raid5.c

7907

here_new = mddev->reshape_position;

drivers/md/raid5.c

7908

chunk_sectors = max(mddev->chunk_sectors, mddev->new_chunk_sectors);

drivers/md/raid5.c

7909

new_data_disks = mddev->raid_disks - max_degraded;

drivers/md/raid5.c

7912

mdname(mddev));

drivers/md/raid5.c

7917

here_old = mddev->reshape_position;

drivers/md/raid5.c

7921

if (mddev->delta_disks == 0) {

drivers/md/raid5.c

7929

if (abs(min_offset_diff) >= mddev->chunk_sectors &&

drivers/md/raid5.c

7930

abs(min_offset_diff) >= mddev->new_chunk_sectors)

drivers/md/raid5.c

7932

else if (mddev->ro == 0) {

drivers/md/raid5.c

7934

mdname(mddev));

drivers/md/raid5.c

7937

} else if (mddev->reshape_backwards

drivers/md/raid5.c

7944

mdname(mddev));

drivers/md/raid5.c

7947

pr_debug("md/raid:%s: reshape will continue\n", mdname(mddev));

drivers/md/raid5.c

7950

BUG_ON(mddev->level != mddev->new_level);

drivers/md/raid5.c

7951

BUG_ON(mddev->layout != mddev->new_layout);

drivers/md/raid5.c

7952

BUG_ON(mddev->chunk_sectors != mddev->new_chunk_sectors);

drivers/md/raid5.c

7953

BUG_ON(mddev->delta_disks != 0);

drivers/md/raid5.c

7956

if (test_bit(MD_HAS_JOURNAL, &mddev->flags) &&

drivers/md/raid5.c

7957

test_bit(MD_HAS_PPL, &mddev->flags)) {

drivers/md/raid5.c

7959

mdname(mddev));

drivers/md/raid5.c

7960

clear_bit(MD_HAS_PPL, &mddev->flags);

drivers/md/raid5.c

7961

clear_bit(MD_HAS_MULTIPLE_PPLS, &mddev->flags);

drivers/md/raid5.c

7964

if (mddev->private == NULL)

drivers/md/raid5.c

7965

conf = setup_conf(mddev);

drivers/md/raid5.c

7967

conf = mddev->private;

drivers/md/raid5.c

7972

if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {

drivers/md/raid5.c

7975

mdname(mddev));

drivers/md/raid5.c

7976

mddev->ro = 1;

drivers/md/raid5.c

7977

set_disk_ro(mddev->gendisk, 1);

drivers/md/raid5.c

7978

} else if (mddev->resync_offset == MaxSector)

drivers/md/raid5.c

7979

set_bit(MD_JOURNAL_CLEAN, &mddev->flags);

drivers/md/raid5.c

7983

rcu_assign_pointer(mddev->thread, conf->thread);

drivers/md/raid5.c

7985

mddev->private = conf;

drivers/md/raid5.c

8009

if (mddev->major_version == 0 &&

drivers/md/raid5.c

8010

mddev->minor_version > 90)

drivers/md/raid5.c

8032

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

8036

mdname(mddev), mddev->degraded, conf->raid_disks);

drivers/md/raid5.c

8041

mddev->dev_sectors &= ~((sector_t)mddev->chunk_sectors - 1);

drivers/md/raid5.c

8042

mddev->resync_max_sectors = mddev->dev_sectors;

drivers/md/raid5.c

8044

if (mddev->degraded > dirty_parity_disks &&

drivers/md/raid5.c

8045

mddev->resync_offset != MaxSector) {

drivers/md/raid5.c

8046

if (test_bit(MD_HAS_PPL, &mddev->flags))

drivers/md/raid5.c

8048

mdname(mddev));

drivers/md/raid5.c

8049

else if (mddev->ok_start_degraded)

drivers/md/raid5.c

8051

mdname(mddev));

drivers/md/raid5.c

8054

mdname(mddev));

drivers/md/raid5.c

8060

mdname(mddev), conf->level,

drivers/md/raid5.c

8061

mddev->raid_disks-mddev->degraded, mddev->raid_disks,

drivers/md/raid5.c

8062

mddev->new_layout);

drivers/md/raid5.c

8069

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/raid5.c

8070

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/raid5.c

8071

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/raid5.c

8072

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid5.c

8076

if (mddev->to_remove == &raid5_attrs_group)

drivers/md/raid5.c

8077

mddev->to_remove = NULL;

drivers/md/raid5.c

8078

else if (mddev->kobj.sd &&

drivers/md/raid5.c

8079

sysfs_create_group(&mddev->kobj, &raid5_attrs_group))

drivers/md/raid5.c

8081

mdname(mddev));

drivers/md/raid5.c

8082

md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));

drivers/md/raid5.c

8084

if (!mddev_is_dm(mddev)) {

drivers/md/raid5.c

8085

ret = raid5_set_limits(mddev);

drivers/md/raid5.c

8100

md_unregister_thread(mddev, &mddev->thread);

drivers/md/raid5.c

8103

mddev->private = NULL;

drivers/md/raid5.c

8104

pr_warn("md/raid:%s: failed to run raid set.\n", mdname(mddev));

drivers/md/raid5.c

8108

static void raid5_free(struct mddev *mddev, void *priv)

drivers/md/raid5.c

8113

mddev->to_remove = &raid5_attrs_group;

drivers/md/raid5.c

8116

static void raid5_status(struct seq_file *seq, struct mddev *mddev)

drivers/md/raid5.c

8118

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8121

lockdep_assert_held(&mddev->lock);

drivers/md/raid5.c

8123

seq_printf(seq, " level %d, %dk chunk, algorithm %d", mddev->level,

drivers/md/raid5.c

8124

conf->chunk_sectors / 2, mddev->layout);

drivers/md/raid5.c

8125

seq_printf (seq, " [%d/%d] [", conf->raid_disks, conf->raid_disks - mddev->degraded);

drivers/md/raid5.c

8146

conf->raid_disks - conf->mddev->degraded);

drivers/md/raid5.c

8157

static int raid5_spare_active(struct mddev *mddev)

drivers/md/raid5.c

8160

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8195

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

8201

static int raid5_remove_disk(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid5.c

8203

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8280

static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/raid5.c

8282

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8344

mddev->reshape_position == MaxSector &&

drivers/md/raid5.c

8360

static int raid5_resize(struct mddev *mddev, sector_t sectors)

drivers/md/raid5.c

8370

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8375

newsize = raid5_size(mddev, sectors, mddev->raid_disks);

drivers/md/raid5.c

8376

if (mddev->external_size &&

drivers/md/raid5.c

8377

mddev->array_sectors > newsize)

drivers/md/raid5.c

8380

if (md_bitmap_enabled(mddev, false)) {

drivers/md/raid5.c

8381

int ret = mddev->bitmap_ops->resize(mddev, sectors, 0);

drivers/md/raid5.c

8387

md_set_array_sectors(mddev, newsize);

drivers/md/raid5.c

8388

if (sectors > mddev->dev_sectors &&

drivers/md/raid5.c

8389

mddev->resync_offset > mddev->dev_sectors) {

drivers/md/raid5.c

8390

mddev->resync_offset = mddev->dev_sectors;

drivers/md/raid5.c

8391

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid5.c

8393

mddev->dev_sectors = sectors;

drivers/md/raid5.c

8394

mddev->resync_max_sectors = sectors;

drivers/md/raid5.c

8398

static int check_stripe_cache(struct mddev *mddev)

drivers/md/raid5.c

8408

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8409

if (((mddev->chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4

drivers/md/raid5.c

8411

((mddev->new_chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4

drivers/md/raid5.c

8414

mdname(mddev),

drivers/md/raid5.c

8415

((max(mddev->chunk_sectors, mddev->new_chunk_sectors) << 9)

drivers/md/raid5.c

8422

static int check_reshape(struct mddev *mddev)

drivers/md/raid5.c

8424

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8428

if (mddev->delta_disks == 0 &&

drivers/md/raid5.c

8429

mddev->new_layout == mddev->layout &&

drivers/md/raid5.c

8430

mddev->new_chunk_sectors == mddev->chunk_sectors)

drivers/md/raid5.c

8434

if (mddev->delta_disks < 0 && mddev->reshape_position == MaxSector) {

drivers/md/raid5.c

8441

if (mddev->level == 6)

drivers/md/raid5.c

8443

if (mddev->raid_disks + mddev->delta_disks < min)

drivers/md/raid5.c

8447

if (!check_stripe_cache(mddev))

drivers/md/raid5.c

8450

if (mddev->new_chunk_sectors > mddev->chunk_sectors ||

drivers/md/raid5.c

8451

mddev->delta_disks > 0)

drivers/md/raid5.c

8454

+ max(0, mddev->delta_disks),

drivers/md/raid5.c

8455

max(mddev->new_chunk_sectors,

drivers/md/raid5.c

8456

mddev->chunk_sectors)

drivers/md/raid5.c

8460

if (conf->previous_raid_disks + mddev->delta_disks <= conf->pool_size)

drivers/md/raid5.c

8463

+ mddev->delta_disks));

drivers/md/raid5.c

8466

static int raid5_start_reshape(struct mddev *mddev)

drivers/md/raid5.c

8468

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8474

if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/raid5.c

8477

if (!check_stripe_cache(mddev))

drivers/md/raid5.c

8484

if (mddev->resync_offset < MaxSector)

drivers/md/raid5.c

8490

rdev_for_each(rdev, mddev) {

drivers/md/raid5.c

8496

if (spares - mddev->degraded < mddev->delta_disks - conf->max_degraded)

drivers/md/raid5.c

8506

if (raid5_size(mddev, 0, conf->raid_disks + mddev->delta_disks)

drivers/md/raid5.c

8507

< mddev->array_sectors) {

drivers/md/raid5.c

8509

mdname(mddev));

drivers/md/raid5.c

8517

conf->raid_disks += mddev->delta_disks;

drivers/md/raid5.c

8519

conf->chunk_sectors = mddev->new_chunk_sectors;

drivers/md/raid5.c

8521

conf->algorithm = mddev->new_layout;

drivers/md/raid5.c

8527

if (mddev->reshape_backwards)

drivers/md/raid5.c

8528

conf->reshape_progress = raid5_size(mddev, 0, 0);

drivers/md/raid5.c

8539

raid5_quiesce(mddev, true);

drivers/md/raid5.c

8540

raid5_quiesce(mddev, false);

drivers/md/raid5.c

8549

if (mddev->delta_disks >= 0) {

drivers/md/raid5.c

8550

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

8553

if (raid5_add_disk(mddev, rdev) == 0) {

drivers/md/raid5.c

8561

sysfs_link_rdev(mddev, rdev);

drivers/md/raid5.c

8574

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

8577

mddev->raid_disks = conf->raid_disks;

drivers/md/raid5.c

8578

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid5.c

8579

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5.c

8581

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/raid5.c

8582

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/raid5.c

8583

clear_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/raid5.c

8584

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/raid5.c

8585

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid5.c

8597

if (!test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery)) {

drivers/md/raid5.c

8602

md_finish_reshape(conf->mddev);

drivers/md/raid5.c

8605

conf->mddev->reshape_position = MaxSector;

drivers/md/raid5.c

8606

rdev_for_each(rdev, conf->mddev)

drivers/md/raid5.c

8614

mddev_update_io_opt(conf->mddev,

drivers/md/raid5.c

8622

static void raid5_finish_reshape(struct mddev *mddev)

drivers/md/raid5.c

8624

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8627

if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {

drivers/md/raid5.c

8629

if (mddev->delta_disks <= 0) {

drivers/md/raid5.c

8632

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

8635

d < conf->raid_disks - mddev->delta_disks;

drivers/md/raid5.c

8645

mddev->layout = conf->algorithm;

drivers/md/raid5.c

8646

mddev->chunk_sectors = conf->chunk_sectors;

drivers/md/raid5.c

8647

mddev->reshape_position = MaxSector;

drivers/md/raid5.c

8648

mddev->delta_disks = 0;

drivers/md/raid5.c

8649

mddev->reshape_backwards = 0;

drivers/md/raid5.c

8653

static void raid5_quiesce(struct mddev *mddev, int quiesce)

drivers/md/raid5.c

8655

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8688

static void *raid45_takeover_raid0(struct mddev *mddev, int level)

drivers/md/raid5.c

8690

struct r0conf *raid0_conf = mddev->private;

drivers/md/raid5.c

8696

mdname(mddev));

drivers/md/raid5.c

8702

mddev->dev_sectors = sectors;

drivers/md/raid5.c

8703

mddev->new_level = level;

drivers/md/raid5.c

8704

mddev->new_layout = ALGORITHM_PARITY_N;

drivers/md/raid5.c

8705

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid5.c

8706

mddev->raid_disks += 1;

drivers/md/raid5.c

8707

mddev->delta_disks = 1;

drivers/md/raid5.c

8709

mddev->resync_offset = MaxSector;

drivers/md/raid5.c

8711

return setup_conf(mddev);

drivers/md/raid5.c

8714

static void *raid5_takeover_raid1(struct mddev *mddev)

drivers/md/raid5.c

8719

if (mddev->raid_disks != 2 ||

drivers/md/raid5.c

8720

mddev->degraded > 1)

drivers/md/raid5.c

8728

while (chunksect && (mddev->array_sectors & (chunksect-1)))

drivers/md/raid5.c

8731

if ((chunksect<<9) < RAID5_STRIPE_SIZE((struct r5conf *)mddev->private))

drivers/md/raid5.c

8735

mddev->new_level = 5;

drivers/md/raid5.c

8736

mddev->new_layout = ALGORITHM_LEFT_SYMMETRIC;

drivers/md/raid5.c

8737

mddev->new_chunk_sectors = chunksect;

drivers/md/raid5.c

8739

ret = setup_conf(mddev);

drivers/md/raid5.c

8741

mddev_clear_unsupported_flags(mddev,

drivers/md/raid5.c

8746

static void *raid5_takeover_raid6(struct mddev *mddev)

drivers/md/raid5.c

8750

switch (mddev->layout) {

drivers/md/raid5.c

8772

mddev->new_level = 5;

drivers/md/raid5.c

8773

mddev->new_layout = new_layout;

drivers/md/raid5.c

8774

mddev->delta_disks = -1;

drivers/md/raid5.c

8775

mddev->raid_disks -= 1;

drivers/md/raid5.c

8776

return setup_conf(mddev);

drivers/md/raid5.c

8779

static int raid5_check_reshape(struct mddev *mddev)

drivers/md/raid5.c

8786

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8787

int new_chunk = mddev->new_chunk_sectors;

drivers/md/raid5.c

8789

if (mddev->new_layout >= 0 && !algorithm_valid_raid5(mddev->new_layout))

drivers/md/raid5.c

8796

if (mddev->array_sectors & (new_chunk-1))

drivers/md/raid5.c

8803

if (mddev->raid_disks == 2) {

drivers/md/raid5.c

8805

if (mddev->new_layout >= 0) {

drivers/md/raid5.c

8806

conf->algorithm = mddev->new_layout;

drivers/md/raid5.c

8807

mddev->layout = mddev->new_layout;

drivers/md/raid5.c

8811

mddev->chunk_sectors = new_chunk;

drivers/md/raid5.c

8813

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5.c

8814

md_wakeup_thread(mddev->thread);

drivers/md/raid5.c

8816

return check_reshape(mddev);

drivers/md/raid5.c

8819

static int raid6_check_reshape(struct mddev *mddev)

drivers/md/raid5.c

8821

int new_chunk = mddev->new_chunk_sectors;

drivers/md/raid5.c

8823

if (mddev->new_layout >= 0 && !algorithm_valid_raid6(mddev->new_layout))

drivers/md/raid5.c

8830

if (mddev->array_sectors & (new_chunk-1))

drivers/md/raid5.c

8836

return check_reshape(mddev);

drivers/md/raid5.c

8839

static void *raid5_takeover(struct mddev *mddev)

drivers/md/raid5.c

8847

if (mddev->level == 0)

drivers/md/raid5.c

8848

return raid45_takeover_raid0(mddev, 5);

drivers/md/raid5.c

8849

if (mddev->level == 1)

drivers/md/raid5.c

8850

return raid5_takeover_raid1(mddev);

drivers/md/raid5.c

8851

if (mddev->level == 4) {

drivers/md/raid5.c

8852

mddev->new_layout = ALGORITHM_PARITY_N;

drivers/md/raid5.c

8853

mddev->new_level = 5;

drivers/md/raid5.c

8854

return setup_conf(mddev);

drivers/md/raid5.c

8856

if (mddev->level == 6)

drivers/md/raid5.c

8857

return raid5_takeover_raid6(mddev);

drivers/md/raid5.c

8862

static void *raid4_takeover(struct mddev *mddev)

drivers/md/raid5.c

8868

if (mddev->level == 0)

drivers/md/raid5.c

8869

return raid45_takeover_raid0(mddev, 4);

drivers/md/raid5.c

8870

if (mddev->level == 5 &&

drivers/md/raid5.c

8871

mddev->layout == ALGORITHM_PARITY_N) {

drivers/md/raid5.c

8872

mddev->new_layout = 0;

drivers/md/raid5.c

8873

mddev->new_level = 4;

drivers/md/raid5.c

8874

return setup_conf(mddev);

drivers/md/raid5.c

8881

static void *raid6_takeover(struct mddev *mddev)

drivers/md/raid5.c

8889

if (mddev->pers != &raid5_personality)

drivers/md/raid5.c

8891

if (mddev->degraded > 1)

drivers/md/raid5.c

8893

if (mddev->raid_disks > 253)

drivers/md/raid5.c

8895

if (mddev->raid_disks < 3)

drivers/md/raid5.c

8898

switch (mddev->layout) {

drivers/md/raid5.c

8920

mddev->new_level = 6;

drivers/md/raid5.c

8921

mddev->new_layout = new_layout;

drivers/md/raid5.c

8922

mddev->delta_disks = 1;

drivers/md/raid5.c

8923

mddev->raid_disks += 1;

drivers/md/raid5.c

8924

return setup_conf(mddev);

drivers/md/raid5.c

8927

static int raid5_change_consistency_policy(struct mddev *mddev, const char *buf)

drivers/md/raid5.c

8932

err = mddev_suspend_and_lock(mddev);

drivers/md/raid5.c

8935

conf = mddev->private;

drivers/md/raid5.c

8937

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

8956

} else if (test_bit(MD_HAS_JOURNAL, &conf->mddev->flags) &&

drivers/md/raid5.c

8961

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

8968

clear_bit(MD_HAS_JOURNAL, &mddev->flags);

drivers/md/raid5.c

8978

md_update_sb(mddev, 1);

drivers/md/raid5.c

8980

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

8985

static int raid5_start(struct mddev *mddev)

drivers/md/raid5.c

8987

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8997

static void raid5_prepare_suspend(struct mddev *mddev)

drivers/md/raid5.c

8999

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

994

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.h

574

struct mddev *mddev;

drivers/md/raid5.h

805

int raid5_set_cache_size(struct mddev *mddev, int size);

drivers/md/raid5.h

823

int r5c_journal_mode_set(struct mddev *mddev, int journal_mode);