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

3834

set_bit(MD_DM_SUSPENDING, &mddev->flags);

drivers/md/dm-raid.c

3836

if (!reshape_interrupted(mddev))

drivers/md/dm-raid.c

3844

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

drivers/md/dm-raid.c

3845

mddev->pers->prepare_suspend(mddev);

drivers/md/dm-raid.c

3851

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3853

clear_bit(MD_DM_SUSPENDING, &mddev->flags);

drivers/md/dm-raid.c

3860

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3871

clear_bit(MD_DM_SUSPENDING, &mddev->flags);

drivers/md/dm-raid.c

3882

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3886

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

drivers/md/dm-raid.c

3915

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

drivers/md/dm-raid.c

3926

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

drivers/md/dm-raid.c

3965

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3967

if (md_bitmap_enabled(mddev, false)) {

drivers/md/dm-raid.c

3968

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

drivers/md/dm-raid.c

3980

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

3981

int ro = mddev->ro;

drivers/md/dm-raid.c

3983

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/dm-raid.c

3984

mddev->ro = MD_RDWR;

drivers/md/dm-raid.c

3985

md_update_sb(mddev, 1);

drivers/md/dm-raid.c

3986

mddev->ro = ro;

drivers/md/dm-raid.c

3999

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

4000

struct md_personality *pers = mddev->pers;

drivers/md/dm-raid.c

4003

set_bit(MD_RECOVERY_WAIT, &mddev->recovery);

drivers/md/dm-raid.c

4014

r = pers->check_reshape(mddev);

drivers/md/dm-raid.c

4025

r = pers->start_reshape(mddev);

drivers/md/dm-raid.c

4046

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

4054

rs->array_sectors != mddev->array_sectors)

drivers/md/dm-raid.c

4073

mddev->array_sectors = rs->array_sectors;

drivers/md/dm-raid.c

4074

mddev->dev_sectors = rs->dev_sectors;

drivers/md/dm-raid.c

4080

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

drivers/md/dm-raid.c

4083

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

drivers/md/dm-raid.c

4084

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

drivers/md/dm-raid.c

4086

if (md_bitmap_enabled(mddev, false)) {

drivers/md/dm-raid.c

4087

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

drivers/md/dm-raid.c

4095

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

drivers/md/dm-raid.c

4096

set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/dm-raid.c

4097

mddev->resync_min = mddev->resync_offset;

drivers/md/dm-raid.c

4099

mddev->resync_max_sectors = mddev->dev_sectors;

drivers/md/dm-raid.c

4106

mddev_lock_nointr(mddev);

drivers/md/dm-raid.c

4108

mddev_unlock(mddev);

drivers/md/dm-raid.c

4120

struct mddev *mddev = &rs->md;

drivers/md/dm-raid.c

4128

mddev_lock_nointr(mddev);

drivers/md/dm-raid.c

4130

mddev_unlock(mddev);

drivers/md/dm-raid.c

4135

if (mddev->delta_disks < 0)

drivers/md/dm-raid.c

4138

mddev_lock_nointr(mddev);

drivers/md/dm-raid.c

4139

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

drivers/md/dm-raid.c

4140

WARN_ON_ONCE(rcu_dereference_protected(mddev->sync_thread,

drivers/md/dm-raid.c

4141

lockdep_is_held(&mddev->reconfig_mutex)));

drivers/md/dm-raid.c

4143

mddev->ro = MD_RDWR;

drivers/md/dm-raid.c

4144

mddev->in_sync = 0;

drivers/md/dm-raid.c

4145

md_unfrozen_sync_thread(mddev);

drivers/md/dm-raid.c

4146

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

1161

if (mddev_is_clustered(bitmap->mddev))

drivers/md/md-bitmap.c

1192

if (mddev_is_clustered(bitmap->mddev))

drivers/md/md-bitmap.c

1253

mddev_add_trace_msg(bitmap->mddev,

drivers/md/md-bitmap.c

1297

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

drivers/md/md-bitmap.c

1299

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1326

struct mddev *mddev = bitmap->mddev;

drivers/md/md-bitmap.c

1335

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

drivers/md/md-bitmap.c

1359

if (mddev_is_clustered(mddev))

drivers/md/md-bitmap.c

1375

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

drivers/md/md-bitmap.c

1390

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

drivers/md/md-bitmap.c

1446

static void bitmap_write_all(struct mddev *mddev)

drivers/md/md-bitmap.c

1449

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1486

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

drivers/md/md-bitmap.c

1492

thread = rcu_dereference(mddev->thread);

drivers/md/md-bitmap.c

1508

static void bitmap_daemon_work(struct mddev *mddev)

drivers/md/md-bitmap.c

1519

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

1520

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1522

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

1526

+ mddev->bitmap_info.daemon_sleep))

drivers/md/md-bitmap.c

1531

mddev_set_timeout(mddev, MAX_SCHEDULE_TIMEOUT, true);

drivers/md/md-bitmap.c

1536

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

drivers/md/md-bitmap.c

1549

mddev->bitmap_info.external == 0) {

drivers/md/md-bitmap.c

1625

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

drivers/md/md-bitmap.c

1626

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

1679

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

drivers/md/md-bitmap.c

1682

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1733

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

drivers/md/md-bitmap.c

1736

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1753

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

drivers/md/md-bitmap.c

1754

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

drivers/md/md-bitmap.c

1755

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

drivers/md/md-bitmap.c

1806

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

drivers/md/md-bitmap.c

1821

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

drivers/md/md-bitmap.c

1857

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

drivers/md/md-bitmap.c

1860

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

drivers/md/md-bitmap.c

1863

static void bitmap_close_sync(struct mddev *mddev)

drivers/md/md-bitmap.c

1871

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1876

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

drivers/md/md-bitmap.c

1882

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

drivers/md/md-bitmap.c

1887

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1896

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

drivers/md/md-bitmap.c

1898

wait_event(bitmap->mddev->recovery_wait,

drivers/md/md-bitmap.c

1899

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

drivers/md/md-bitmap.c

1901

bitmap->mddev->curr_resync_completed = sector;

drivers/md/md-bitmap.c

1902

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

drivers/md/md-bitmap.c

1905

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

drivers/md/md-bitmap.c

1910

sysfs_notify_dirent_safe(bitmap->mddev->sysfs_completed);

drivers/md/md-bitmap.c

1913

static void bitmap_sync_with_cluster(struct mddev *mddev,

drivers/md/md-bitmap.c

1917

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1927

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

drivers/md/md-bitmap.c

1960

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

drivers/md/md-bitmap.c

1964

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1974

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

drivers/md/md-bitmap.c

1979

bitmap->mddev->resync_offset = sec;

drivers/md/md-bitmap.c

1983

static void bitmap_flush(struct mddev *mddev)

drivers/md/md-bitmap.c

1985

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

1994

sleep = mddev->bitmap_info.daemon_sleep * 2;

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

2000

bitmap_daemon_work(mddev);

drivers/md/md-bitmap.c

2001

if (mddev->bitmap_info.external)

drivers/md/md-bitmap.c

2002

md_super_wait(mddev);

drivers/md/md-bitmap.c

2018

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

drivers/md/md-bitmap.c

2019

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

drivers/md/md-bitmap.c

2020

md_cluster_stop(bitmap->mddev);

drivers/md/md-bitmap.c

2042

static void bitmap_start_behind_write(struct mddev *mddev)

drivers/md/md-bitmap.c

2044

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2053

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

drivers/md/md-bitmap.c

2056

static void bitmap_end_behind_write(struct mddev *mddev)

drivers/md/md-bitmap.c

2058

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2064

bitmap->mddev->bitmap_info.max_write_behind);

drivers/md/md-bitmap.c

2067

static bool bitmap_wait_behind_writes(struct mddev *mddev, bool nowait)

drivers/md/md-bitmap.c

2069

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2077

mdname(mddev));

drivers/md/md-bitmap.c

2086

static void bitmap_destroy(struct mddev *mddev)

drivers/md/md-bitmap.c

2088

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2093

bitmap_wait_behind_writes(mddev, false);

drivers/md/md-bitmap.c

2094

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

drivers/md/md-bitmap.c

2095

mddev_destroy_serial_pool(mddev, NULL);

drivers/md/md-bitmap.c

2097

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2098

spin_lock(&mddev->lock);

drivers/md/md-bitmap.c

2099

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

drivers/md/md-bitmap.c

2100

spin_unlock(&mddev->lock);

drivers/md/md-bitmap.c

2101

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2102

mddev_set_timeout(mddev, MAX_SCHEDULE_TIMEOUT, true);

drivers/md/md-bitmap.c

2112

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

drivers/md/md-bitmap.c

2115

sector_t blocks = mddev->resync_max_sectors;

drivers/md/md-bitmap.c

2116

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

drivers/md/md-bitmap.c

2122

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

drivers/md/md-bitmap.c

2124

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

drivers/md/md-bitmap.c

2126

mdname(mddev));

drivers/md/md-bitmap.c

2140

bitmap->mddev = mddev;

drivers/md/md-bitmap.c

2143

if (mddev->kobj.sd)

drivers/md/md-bitmap.c

2144

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

drivers/md/md-bitmap.c

2161

if (!mddev->bitmap_info.external) {

drivers/md/md-bitmap.c

2166

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

drivers/md/md-bitmap.c

2172

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

drivers/md/md-bitmap.c

2173

mddev->bitmap_info.daemon_sleep == 0)

drivers/md/md-bitmap.c

2182

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

drivers/md/md-bitmap.c

2200

static int bitmap_create(struct mddev *mddev)

drivers/md/md-bitmap.c

2202

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

drivers/md/md-bitmap.c

2207

mddev->bitmap = bitmap;

drivers/md/md-bitmap.c

2211

static int bitmap_load(struct mddev *mddev)

drivers/md/md-bitmap.c

2216

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2222

rdev_for_each(rdev, mddev)

drivers/md/md-bitmap.c

2223

mddev_create_serial_pool(mddev, rdev);

drivers/md/md-bitmap.c

2225

if (mddev_is_clustered(mddev))

drivers/md/md-bitmap.c

2226

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

drivers/md/md-bitmap.c

2233

while (sector < mddev->resync_max_sectors) {

drivers/md/md-bitmap.c

2235

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

drivers/md/md-bitmap.c

2238

bitmap_close_sync(mddev);

drivers/md/md-bitmap.c

2240

if (mddev->degraded == 0

drivers/md/md-bitmap.c

2241

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

drivers/md/md-bitmap.c

2244

start = mddev->resync_offset;

drivers/md/md-bitmap.c

2246

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2248

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-bitmap.c

2255

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

drivers/md/md-bitmap.c

2257

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

drivers/md/md-bitmap.c

2258

md_wakeup_thread(mddev->thread);

drivers/md/md-bitmap.c

226

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

drivers/md/md-bitmap.c

2269

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

drivers/md/md-bitmap.c

2274

bitmap = __bitmap_create(mddev, slot);

drivers/md/md-bitmap.c

2292

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

drivers/md/md-bitmap.c

2300

bitmap = bitmap_get_from_slot(mddev, slot);

drivers/md/md-bitmap.c

2314

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

drivers/md/md-bitmap.c

2315

md_bitmap_file_set_bit(mddev->bitmap, block);

drivers/md/md-bitmap.c

2328

__bitmap_unplug(mddev->bitmap);

drivers/md/md-bitmap.c

2405

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

drivers/md/md-bitmap.c

2412

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

drivers/md/md-bitmap.c

2415

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

drivers/md/md-bitmap.c

2424

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

drivers/md/md-bitmap.c

2433

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

drivers/md/md-bitmap.c

2435

!bitmap->mddev->bitmap_info.external,

drivers/md/md-bitmap.c

2436

mddev_is_clustered(bitmap->mddev)

drivers/md/md-bitmap.c

2453

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

drivers/md/md-bitmap.c

2462

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

drivers/md/md-bitmap.c

2473

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

drivers/md/md-bitmap.c

2480

if (mddev_is_clustered(bitmap->mddev)) {

drivers/md/md-bitmap.c

2499

bitmap->mddev->bitmap_info.chunksize =

drivers/md/md-bitmap.c

2570

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

drivers/md/md-bitmap.c

2573

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

drivers/md/md-bitmap.c

2580

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

drivers/md/md-bitmap.c

2582

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2595

static int bitmap_none_create(struct mddev *mddev)

drivers/md/md-bitmap.c

2600

static int bitmap_none_load(struct mddev *mddev)

drivers/md/md-bitmap.c

2605

static void bitmap_none_destroy(struct mddev *mddev)

drivers/md/md-bitmap.c

2615

location_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2618

if (mddev->bitmap_info.file)

drivers/md/md-bitmap.c

2620

else if (mddev->bitmap_info.offset)

drivers/md/md-bitmap.c

2621

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

drivers/md/md-bitmap.c

2629

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

drivers/md/md-bitmap.c

2633

rv = mddev_suspend_and_lock(mddev);

drivers/md/md-bitmap.c

2637

if (mddev->pers) {

drivers/md/md-bitmap.c

2638

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

drivers/md/md-bitmap.c

2644

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

drivers/md/md-bitmap.c

2645

mddev->bitmap_info.offset) {

drivers/md/md-bitmap.c

2652

sysfs_unmerge_group(&mddev->kobj, &md_bitmap_internal_group);

drivers/md/md-bitmap.c

2653

md_bitmap_destroy_nosysfs(mddev);

drivers/md/md-bitmap.c

2654

mddev->bitmap_id = ID_BITMAP_NONE;

drivers/md/md-bitmap.c

2655

if (!mddev_set_bitmap_ops_nosysfs(mddev))

drivers/md/md-bitmap.c

2657

mddev->bitmap_info.offset = 0;

drivers/md/md-bitmap.c

2658

if (mddev->bitmap_info.file) {

drivers/md/md-bitmap.c

2659

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

drivers/md/md-bitmap.c

2660

mddev->bitmap_info.file = NULL;

drivers/md/md-bitmap.c

2684

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

drivers/md/md-bitmap.c

2685

mddev->major_version == 0 &&

drivers/md/md-bitmap.c

2686

offset != mddev->bitmap_info.default_offset) {

drivers/md/md-bitmap.c

2691

mddev->bitmap_info.offset = offset;

drivers/md/md-bitmap.c

2692

md_bitmap_destroy_nosysfs(mddev);

drivers/md/md-bitmap.c

2693

mddev->bitmap_id = ID_BITMAP;

drivers/md/md-bitmap.c

2694

if (!mddev_set_bitmap_ops_nosysfs(mddev))

drivers/md/md-bitmap.c

2697

rv = md_bitmap_create_nosysfs(mddev);

drivers/md/md-bitmap.c

2701

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

drivers/md/md-bitmap.c

2703

mddev->bitmap_info.offset = 0;

drivers/md/md-bitmap.c

2707

rv = sysfs_merge_group(&mddev->kobj,

drivers/md/md-bitmap.c

2713

if (!mddev->external) {

drivers/md/md-bitmap.c

2717

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md-bitmap.c

2718

md_wakeup_thread(mddev->thread);

drivers/md/md-bitmap.c

2722

mddev_unlock_and_resume(mddev);

drivers/md/md-bitmap.c

2728

mddev->bitmap_info.offset = 0;

drivers/md/md-bitmap.c

2730

md_bitmap_destroy_nosysfs(mddev);

drivers/md/md-bitmap.c

2732

mddev->bitmap_info.offset = 0;

drivers/md/md-bitmap.c

2733

mddev->bitmap_id = ID_BITMAP_NONE;

drivers/md/md-bitmap.c

2734

if (!mddev_set_bitmap_ops_nosysfs(mddev))

drivers/md/md-bitmap.c

2740

mddev->bitmap_info.offset = 0;

drivers/md/md-bitmap.c

2752

space_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2754

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

drivers/md/md-bitmap.c

2758

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

drivers/md/md-bitmap.c

2771

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2778

mddev->bitmap_info.space = sectors;

drivers/md/md-bitmap.c

2786

timeout_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2789

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

drivers/md/md-bitmap.c

2790

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

drivers/md/md-bitmap.c

2800

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

drivers/md/md-bitmap.c

2819

mddev->bitmap_info.daemon_sleep = timeout;

drivers/md/md-bitmap.c

2820

mddev_set_timeout(mddev, timeout, false);

drivers/md/md-bitmap.c

2821

md_wakeup_thread(mddev->thread);

drivers/md/md-bitmap.c

2830

backlog_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2832

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

drivers/md/md-bitmap.c

2836

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

drivers/md/md-bitmap.c

2839

unsigned long old_mwb = mddev->bitmap_info.max_write_behind;

drivers/md/md-bitmap.c

2848

rv = mddev_suspend_and_lock(mddev);

drivers/md/md-bitmap.c

2856

rdev_for_each(rdev, mddev) {

drivers/md/md-bitmap.c

2864

mdname(mddev));

drivers/md/md-bitmap.c

2865

mddev_unlock(mddev);

drivers/md/md-bitmap.c

2869

mddev->bitmap_info.max_write_behind = backlog;

drivers/md/md-bitmap.c

2870

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

drivers/md/md-bitmap.c

2872

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

drivers/md/md-bitmap.c

2873

mddev_destroy_serial_pool(mddev, NULL);

drivers/md/md-bitmap.c

2874

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

drivers/md/md-bitmap.c

2876

rdev_for_each(rdev, mddev)

drivers/md/md-bitmap.c

2877

mddev_create_serial_pool(mddev, rdev);

drivers/md/md-bitmap.c

2880

bitmap_update_sb(mddev->bitmap);

drivers/md/md-bitmap.c

2882

mddev_unlock_and_resume(mddev);

drivers/md/md-bitmap.c

2890

chunksize_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2892

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

drivers/md/md-bitmap.c

2896

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

drivers/md/md-bitmap.c

2901

if (mddev->bitmap)

drivers/md/md-bitmap.c

2912

mddev->bitmap_info.chunksize = csize;

drivers/md/md-bitmap.c

2919

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

drivers/md/md-bitmap.c

2921

if (mddev_is_clustered(mddev))

drivers/md/md-bitmap.c

2923

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

drivers/md/md-bitmap.c

2927

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

drivers/md/md-bitmap.c

2929

if (mddev->bitmap ||

drivers/md/md-bitmap.c

2930

mddev->bitmap_info.file ||

drivers/md/md-bitmap.c

2931

mddev->bitmap_info.offset)

drivers/md/md-bitmap.c

2934

mddev->bitmap_info.external = 1;

drivers/md/md-bitmap.c

2937

mddev->bitmap_info.external = 0;

drivers/md/md-bitmap.c

2946

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

drivers/md/md-bitmap.c

2951

spin_lock(&mddev->lock);

drivers/md/md-bitmap.c

2952

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2958

spin_unlock(&mddev->lock);

drivers/md/md-bitmap.c

2962

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

drivers/md/md-bitmap.c

2964

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2975

if (mddev->degraded)

drivers/md/md-bitmap.c

2988

behind_writes_used_show(struct mddev *mddev, char *page)

drivers/md/md-bitmap.c

2993

spin_lock(&mddev->lock);

drivers/md/md-bitmap.c

2994

bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

2999

spin_unlock(&mddev->lock);

drivers/md/md-bitmap.c

3005

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

drivers/md/md-bitmap.c

3007

struct bitmap *bitmap = mddev->bitmap;

drivers/md/md-bitmap.c

348

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

drivers/md/md-bitmap.c

352

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

drivers/md/md-bitmap.c

356

rdev_for_each(rdev, mddev) {

drivers/md/md-bitmap.c

370

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

drivers/md/md-bitmap.c

388

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

drivers/md/md-bitmap.c

391

rdev_dec_pending(rdev, mddev);

drivers/md/md-bitmap.c

393

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

drivers/md/md-bitmap.c

432

struct mddev *mddev = bitmap->mddev;

drivers/md/md-bitmap.c

436

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

drivers/md/md-bitmap.c

457

if (mddev->external) {

drivers/md/md-bitmap.c

460

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

drivers/md/md-bitmap.c

469

if (doff + mddev->dev_sectors > sboff)

drivers/md/md-bitmap.c

480

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

drivers/md/md-bitmap.c

488

struct mddev *mddev = bitmap->mddev;

drivers/md/md-bitmap.c

493

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

drivers/md/md-bitmap.c

499

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

drivers/md/md-bitmap.c

647

if (mddev_is_clustered(bitmap->mddev)) {

drivers/md/md-bitmap.c

676

md_super_wait(bitmap->mddev);

drivers/md/md-bitmap.c

686

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

drivers/md/md-bitmap.c

688

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

drivers/md/md-bitmap.c

693

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

drivers/md/md-bitmap.c

694

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

drivers/md/md-bitmap.c

696

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

drivers/md/md-bitmap.c

704

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

drivers/md/md-bitmap.c

705

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

drivers/md/md-bitmap.c

707

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

drivers/md/md-bitmap.c

708

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

drivers/md/md-bitmap.c

709

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

drivers/md/md-bitmap.c

710

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

drivers/md/md-bitmap.c

775

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

drivers/md/md-bitmap.c

784

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

drivers/md/md-bitmap.c

790

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

drivers/md/md-bitmap.c

796

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

drivers/md/md-bitmap.c

800

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

drivers/md/md-bitmap.c

803

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

drivers/md/md-bitmap.c

805

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

drivers/md/md-bitmap.c

809

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

drivers/md/md-bitmap.c

810

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

drivers/md/md-bitmap.c

811

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

drivers/md/md-bitmap.c

831

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

drivers/md/md-bitmap.c

848

sector_t bm_blocks = bitmap->mddev->resync_max_sectors;

drivers/md/md-bitmap.c

851

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

drivers/md/md-bitmap.c

868

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

drivers/md/md-bitmap.c

908

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

drivers/md/md-bitmap.c

913

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

drivers/md/md-bitmap.c

915

if (bitmap->mddev->persistent) {

drivers/md/md-bitmap.c

920

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

drivers/md/md-bitmap.c

926

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

drivers/md/md-bitmap.c

929

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

drivers/md/md-bitmap.c

945

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

drivers/md/md-bitmap.c

946

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

drivers/md/md-bitmap.c

952

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

drivers/md/md-bitmap.c

959

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

drivers/md/md-bitmap.c

960

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

drivers/md/md-bitmap.c

961

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

drivers/md/md-bitmap.c

962

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

drivers/md/md-bitmap.c

963

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

drivers/md/md-bitmap.c

964

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

drivers/md/md-bitmap.c

965

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

drivers/md/md-bitmap.c

966

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

drivers/md/md-bitmap.c

970

md_cluster_stop(bitmap->mddev);

drivers/md/md-bitmap.h

100

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

drivers/md/md-bitmap.h

101

bool (*wait_behind_writes)(struct mddev *mddev, bool nowait);

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

1000

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

drivers/md/md-llbitmap.c

1001

mddev->bitmap_info.space);

drivers/md/md-llbitmap.c

1008

mdname(mddev), daemon_sleep);

drivers/md/md-llbitmap.c

1013

if (events < mddev->events) {

drivers/md/md-llbitmap.c

1015

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

drivers/md/md-llbitmap.c

1019

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

drivers/md/md-llbitmap.c

1020

mddev->bitmap_info.chunksize = chunksize;

drivers/md/md-llbitmap.c

1021

mddev->bitmap_info.daemon_sleep = daemon_sleep;

drivers/md/md-llbitmap.c

1025

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

drivers/md/md-llbitmap.c

1042

mdname(llbitmap->mddev),

drivers/md/md-llbitmap.c

1043

llbitmap->mddev->bitmap_info.daemon_sleep);

drivers/md/md-llbitmap.c

1060

if (llbitmap->mddev->degraded)

drivers/md/md-llbitmap.c

1083

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

drivers/md/md-llbitmap.c

1101

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

drivers/md/md-llbitmap.c

1104

static int llbitmap_create(struct mddev *mddev)

drivers/md/md-llbitmap.c

1109

ret = llbitmap_check_support(mddev);

drivers/md/md-llbitmap.c

1117

llbitmap->mddev = mddev;

drivers/md/md-llbitmap.c

1118

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

drivers/md/md-llbitmap.c

1126

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1127

mddev->bitmap = llbitmap;

drivers/md/md-llbitmap.c

1129

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1132

mddev->bitmap = NULL;

drivers/md/md-llbitmap.c

1138

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

drivers/md/md-llbitmap.c

1140

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1148

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

drivers/md/md-llbitmap.c

1160

static int llbitmap_load(struct mddev *mddev)

drivers/md/md-llbitmap.c

1163

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1172

static void llbitmap_destroy(struct mddev *mddev)

drivers/md/md-llbitmap.c

1174

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1179

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1185

mddev->bitmap = NULL;

drivers/md/md-llbitmap.c

1188

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1191

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

drivers/md/md-llbitmap.c

1194

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1208

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

drivers/md/md-llbitmap.c

1211

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1223

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

drivers/md/md-llbitmap.c

1226

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1240

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

drivers/md/md-llbitmap.c

1243

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1274

md_super_wait(llbitmap->mddev);

drivers/md/md-llbitmap.c

1289

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

drivers/md/md-llbitmap.c

1292

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1318

static void __llbitmap_flush(struct mddev *mddev)

drivers/md/md-llbitmap.c

1320

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1334

md_super_wait(llbitmap->mddev);

drivers/md/md-llbitmap.c

1337

static void llbitmap_flush(struct mddev *mddev)

drivers/md/md-llbitmap.c

1339

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1349

__llbitmap_flush(mddev);

drivers/md/md-llbitmap.c

1353

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

drivers/md/md-llbitmap.c

1355

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1362

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

drivers/md/md-llbitmap.c

1364

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1378

if (mddev->degraded)

drivers/md/md-llbitmap.c

1383

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

drivers/md/md-llbitmap.c

1384

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

drivers/md/md-llbitmap.c

1390

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

drivers/md/md-llbitmap.c

1393

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1401

if (offset == 0 && test_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&

drivers/md/md-llbitmap.c

1402

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

drivers/md/md-llbitmap.c

1417

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

drivers/md/md-llbitmap.c

1420

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1429

static void llbitmap_close_sync(struct mddev *mddev)

drivers/md/md-llbitmap.c

1431

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1449

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

drivers/md/md-llbitmap.c

1452

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1460

HZ * mddev->bitmap_info.daemon_sleep))

drivers/md/md-llbitmap.c

1463

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

drivers/md/md-llbitmap.c

1465

mddev->curr_resync_completed = sector;

drivers/md/md-llbitmap.c

1466

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md-llbitmap.c

1469

__llbitmap_flush(mddev);

drivers/md/md-llbitmap.c

1472

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md-llbitmap.c

1482

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

drivers/md/md-llbitmap.c

1485

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

drivers/md/md-llbitmap.c

1494

md_super_wait(llbitmap->mddev);

drivers/md/md-llbitmap.c

1500

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

1510

mdname(mddev));

drivers/md/md-llbitmap.c

1515

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

drivers/md/md-llbitmap.c

1516

llbitmap->events_cleared = mddev->events;

drivers/md/md-llbitmap.c

1519

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

drivers/md/md-llbitmap.c

1522

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

drivers/md/md-llbitmap.c

1524

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

drivers/md/md-llbitmap.c

1525

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

drivers/md/md-llbitmap.c

1549

static void llbitmap_write_all(struct mddev *mddev)

drivers/md/md-llbitmap.c

1552

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1562

static void llbitmap_start_behind_write(struct mddev *mddev)

drivers/md/md-llbitmap.c

1564

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1569

static void llbitmap_end_behind_write(struct mddev *mddev)

drivers/md/md-llbitmap.c

1571

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1577

static bool llbitmap_wait_behind_writes(struct mddev *mddev, bool nowait)

drivers/md/md-llbitmap.c

1579

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1592

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

drivers/md/md-llbitmap.c

1598

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1599

llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1601

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1606

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1621

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1635

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

drivers/md/md-llbitmap.c

1640

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1641

llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1643

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1649

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

drivers/md/md-llbitmap.c

1650

llbitmap->mddev->bitmap_info.daemon_sleep);

drivers/md/md-llbitmap.c

1651

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1659

daemon_sleep_show(struct mddev *mddev, char *page)

drivers/md/md-llbitmap.c

1661

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

drivers/md/md-llbitmap.c

1665

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

drivers/md/md-llbitmap.c

1673

mddev->bitmap_info.daemon_sleep = timeout;

drivers/md/md-llbitmap.c

1680

barrier_idle_show(struct mddev *mddev, char *page)

drivers/md/md-llbitmap.c

1682

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1688

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

drivers/md/md-llbitmap.c

1690

struct llbitmap *llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1704

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

drivers/md/md-llbitmap.c

1709

if (!raid_is_456(mddev))

drivers/md/md-llbitmap.c

1712

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1713

llbitmap = mddev->bitmap;

drivers/md/md-llbitmap.c

1715

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

1723

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md-llbitmap.c

277

struct mddev *mddev;

drivers/md/md-llbitmap.c

416

static void __llbitmap_flush(struct mddev *mddev);

drivers/md/md-llbitmap.c

435

bool level_456 = raid_is_456(llbitmap->mddev);

drivers/md/md-llbitmap.c

468

if (llbitmap->mddev->degraded || !infect) {

drivers/md/md-llbitmap.c

515

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

528

rdev_for_each(rdev, mddev) {

drivers/md/md-llbitmap.c

535

sector = mddev->bitmap_info.offset +

drivers/md/md-llbitmap.c

542

md_error(mddev, rdev);

drivers/md/md-llbitmap.c

552

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

562

rdev_for_each(rdev, mddev) {

drivers/md/md-llbitmap.c

569

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

drivers/md/md-llbitmap.c

572

md_write_metadata(mddev, rdev, sector,

drivers/md/md-llbitmap.c

662

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

665

rdev_for_each(rdev, mddev) {

drivers/md/md-llbitmap.c

683

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

685

sector_t dev_sectors = mddev->dev_sectors;

drivers/md/md-llbitmap.c

688

rdev_for_each(rdev, mddev) {

drivers/md/md-llbitmap.c

708

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

714

} else if (raid_is_456(mddev) &&

drivers/md/md-llbitmap.c

735

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

737

bool level_456 = raid_is_456(llbitmap->mddev);

drivers/md/md-llbitmap.c

760

need_resync = !mddev->degraded;

drivers/md/md-llbitmap.c

764

if (unlikely(mddev->degraded)) {

drivers/md/md-llbitmap.c

790

need_resync = !mddev->degraded;

drivers/md/md-llbitmap.c

794

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

drivers/md/md-llbitmap.c

803

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md-llbitmap.c

804

set_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md-llbitmap.c

805

md_wakeup_thread(mddev->thread);

drivers/md/md-llbitmap.c

807

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md-llbitmap.c

808

set_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md-llbitmap.c

809

md_wakeup_thread(mddev->thread);

drivers/md/md-llbitmap.c

843

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

drivers/md/md-llbitmap.c

860

static int llbitmap_check_support(struct mddev *mddev)

drivers/md/md-llbitmap.c

862

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

drivers/md/md-llbitmap.c

864

mdname(mddev));

drivers/md/md-llbitmap.c

868

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

drivers/md/md-llbitmap.c

869

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

drivers/md/md-llbitmap.c

871

mdname(mddev));

drivers/md/md-llbitmap.c

876

if (!mddev->persistent) {

drivers/md/md-llbitmap.c

878

mdname(mddev));

drivers/md/md-llbitmap.c

882

if (mddev->bitmap_info.file) {

drivers/md/md-llbitmap.c

884

mdname(mddev));

drivers/md/md-llbitmap.c

888

if (mddev->bitmap_info.external) {

drivers/md/md-llbitmap.c

890

mdname(mddev));

drivers/md/md-llbitmap.c

894

if (mddev_is_dm(mddev)) {

drivers/md/md-llbitmap.c

896

mdname(mddev));

drivers/md/md-llbitmap.c

905

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

906

sector_t blocks = mddev->resync_max_sectors;

drivers/md/md-llbitmap.c

909

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

drivers/md/md-llbitmap.c

921

mddev->bitmap_info.daemon_sleep = DEFAULT_DAEMON_SLEEP;

drivers/md/md-llbitmap.c

930

__llbitmap_flush(mddev);

drivers/md/md-llbitmap.c

937

struct mddev *mddev = llbitmap->mddev;

drivers/md/md-llbitmap.c

945

if (!mddev->bitmap_info.offset) {

drivers/md/md-llbitmap.c

946

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

drivers/md/md-llbitmap.c

953

mdname(mddev));

drivers/md/md-llbitmap.c

960

mdname(mddev));

drivers/md/md-llbitmap.c

966

mdname(mddev));

drivers/md/md-llbitmap.c

970

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

drivers/md/md-llbitmap.c

972

mdname(mddev));

drivers/md/md-llbitmap.c

976

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

drivers/md/md-llbitmap.c

980

mddev->bitmap_info.space = room;

drivers/md/md-llbitmap.c

982

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

drivers/md/md-llbitmap.c

993

mdname(mddev));

drivers/md/md-llbitmap.c

997

if (chunksize < DIV_ROUND_UP_SECTOR_T(mddev->resync_max_sectors,

drivers/md/md-llbitmap.c

998

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

drivers/md/md.c

10022

struct mddev *mddev;

drivers/md/md.c

10024

mddev = READ_ONCE(rdev->mddev);

drivers/md/md.c

10025

if (!mddev)

drivers/md/md.c

10038

if (md_is_rdwr(mddev))

drivers/md/md.c

10051

static bool md_spares_need_change(struct mddev *mddev)

drivers/md/md.c

10056

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

10066

static int remove_spares(struct mddev *mddev, struct md_rdev *this)

drivers/md/md.c

1007

static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)

drivers/md/md.c

10071

rdev_for_each(rdev, mddev) {

drivers/md/md.c

10073

!mddev->pers->hot_remove_disk(mddev, rdev)) {

drivers/md/md.c

10074

sysfs_unlink_rdev(mddev, rdev);

drivers/md/md.c

10081

if (removed && mddev->kobj.sd)

drivers/md/md.c

10082

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

10087

static int remove_and_add_spares(struct mddev *mddev,

drivers/md/md.c

10094

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

drivers/md/md.c

10098

removed = remove_spares(mddev, this);

drivers/md/md.c

10102

rdev_for_each(rdev, mddev) {

drivers/md/md.c

1011

rdev_for_each(rdev, mddev)

drivers/md/md.c

10111

if (mddev->pers->hot_add_disk(mddev, rdev) == 0) {

drivers/md/md.c

10113

sysfs_link_rdev(mddev, rdev);

drivers/md/md.c

10117

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

10122

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

10126

static bool md_choose_sync_action(struct mddev *mddev, int *spares)

drivers/md/md.c

10129

if (mddev->reshape_position != MaxSector) {

drivers/md/md.c

10130

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

drivers/md/md.c

10131

mddev->pers->check_reshape(mddev) != 0)

drivers/md/md.c

10134

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/md.c

10135

clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

10136

clear_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md.c

10141

if (mddev->resync_offset < MaxSector) {

drivers/md/md.c

10142

remove_spares(mddev, NULL);

drivers/md/md.c

10143

set_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

10144

clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

10145

clear_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md.c

10154

*spares = remove_and_add_spares(mddev, NULL);

drivers/md/md.c

10155

if (*spares || test_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery)) {

drivers/md/md.c

10156

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

10157

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/md.c

10158

clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/md.c

10161

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

10166

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

drivers/md/md.c

10175

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

drivers/md/md.c

1018

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

drivers/md/md.c

10184

if (mddev->reshape_position == MaxSector &&

drivers/md/md.c

10185

md_spares_need_change(mddev)) {

drivers/md/md.c

10187

mddev_suspend(mddev, false);

drivers/md/md.c

10190

mddev_lock_nointr(mddev);

drivers/md/md.c

10191

if (!md_is_rdwr(mddev)) {

drivers/md/md.c

10199

remove_and_add_spares(mddev, NULL);

drivers/md/md.c

10203

if (!md_choose_sync_action(mddev, &spares))

drivers/md/md.c

10206

if (!mddev->pers->sync_request)

drivers/md/md.c

10213

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

drivers/md/md.c

10214

mddev->bitmap_ops->write_all(mddev);

drivers/md/md.c

10216

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

drivers/md/md.c

10218

rcu_assign_pointer(mddev->sync_thread,

drivers/md/md.c

10219

md_register_thread(md_do_sync, mddev, name));

drivers/md/md.c

1022

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.c

10220

if (!mddev->sync_thread) {

drivers/md/md.c

10222

mdname(mddev));

drivers/md/md.c

10227

mddev_unlock(mddev);

drivers/md/md.c

10235

__mddev_resume(mddev, false);

drivers/md/md.c

10236

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

10237

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

10242

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

10243

clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/md.c

10244

clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/md.c

10245

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/md.c

10246

clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10247

mddev_unlock(mddev);

drivers/md/md.c

10255

__mddev_resume(mddev, false);

drivers/md/md.c

10258

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

drivers/md/md.c

10259

mddev->sysfs_action)

drivers/md/md.c

10260

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

10263

static void unregister_sync_thread(struct mddev *mddev)

drivers/md/md.c

10265

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

drivers/md/md.c

10267

clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10271

if (WARN_ON_ONCE(!mddev->sync_thread))

drivers/md/md.c

10274

md_reap_sync_thread(mddev);

drivers/md/md.c

10277

static bool md_should_do_recovery(struct mddev *mddev)

drivers/md/md.c

10283

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

drivers/md/md.c

10284

test_bit(MD_RECOVERY_DONE, &mddev->recovery))

drivers/md/md.c

10291

if (!md_is_rdwr(mddev))

drivers/md/md.c

10299

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

drivers/md/md.c

10307

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

drivers/md/md.c

10316

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

drivers/md/md.c

10317

mddev->resync_offset == MaxSector)

drivers/md/md.c

10345

void md_check_recovery(struct mddev *mddev)

drivers/md/md.c

10347

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

drivers/md/md.c

10348

mddev->bitmap_ops->daemon_work(mddev);

drivers/md/md.c

10351

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

drivers/md/md.c

10353

mdname(mddev));

drivers/md/md.c

10354

mddev->safemode = 2;

drivers/md/md.c

10359

if (!md_should_do_recovery(mddev))

drivers/md/md.c

10362

if (mddev_trylock(mddev)) {

drivers/md/md.c

10363

bool try_set_sync = mddev->safemode != 0;

drivers/md/md.c

10365

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

drivers/md/md.c

10366

mddev->safemode = 0;

drivers/md/md.c

10368

if (!md_is_rdwr(mddev)) {

drivers/md/md.c

10371

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

drivers/md/md.c

10372

unregister_sync_thread(mddev);

drivers/md/md.c

10376

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

drivers/md/md.c

10383

rdev_for_each(rdev, mddev)

drivers/md/md.c

10390

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

10391

md_reap_sync_thread(mddev);

drivers/md/md.c

10397

if (md_spares_need_change(mddev)) {

drivers/md/md.c

10398

set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10399

queue_work(md_misc_wq, &mddev->sync_work);

drivers/md/md.c

10402

clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

10403

clear_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md.c

10404

clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10405

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

10410

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

10415

rdev_for_each_safe(rdev, tmp, mddev) {

drivers/md/md.c

10422

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

drivers/md/md.c

10423

spin_lock(&mddev->lock);

drivers/md/md.c

10424

set_in_sync(mddev);

drivers/md/md.c

10425

spin_unlock(&mddev->lock);

drivers/md/md.c

10428

if (mddev->sb_flags)

drivers/md/md.c

10429

md_update_sb(mddev, 0);

drivers/md/md.c

10435

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

drivers/md/md.c

10436

unregister_sync_thread(mddev);

drivers/md/md.c

10443

mddev->curr_resync_completed = 0;

drivers/md/md.c

10444

spin_lock(&mddev->lock);

drivers/md/md.c

10445

set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10446

spin_unlock(&mddev->lock);

drivers/md/md.c

10450

clear_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

10451

clear_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/md.c

10453

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

drivers/md/md.c

10454

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

drivers/md/md.c

10455

queue_work(md_misc_wq, &mddev->sync_work);

drivers/md/md.c

10457

clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10462

wake_up(&mddev->sb_wait);

drivers/md/md.c

10463

mddev_unlock(mddev);

drivers/md/md.c

10468

void md_reap_sync_thread(struct mddev *mddev)

drivers/md/md.c

10471

sector_t old_dev_sectors = mddev->dev_sectors;

drivers/md/md.c

10472

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

drivers/md/md.c

10475

md_unregister_thread(mddev, &mddev->sync_thread);

drivers/md/md.c

10476

atomic_inc(&mddev->sync_seq);

drivers/md/md.c

10478

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

drivers/md/md.c

10479

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

drivers/md/md.c

10480

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

drivers/md/md.c

10483

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

drivers/md/md.c

10484

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

10485

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

10492

if (!mddev->degraded)

drivers/md/md.c

10493

rdev_for_each(rdev, mddev)

drivers/md/md.c

10496

md_update_sb(mddev, 1);

drivers/md/md.c

10500

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

drivers/md/md.c

10501

mddev->cluster_ops->resync_finish(mddev);

drivers/md/md.c

10502

clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);

drivers/md/md.c

10503

clear_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/md.c

10504

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

10505

clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/md.c

10506

clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/md.c

10507

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/md.c

10508

clear_bit(MD_RECOVERY_LAZY_RECOVER, &mddev->recovery);

drivers/md/md.c

10514

if (mddev_is_clustered(mddev) && is_reshaped &&

drivers/md/md.c

10515

mddev->pers->finish_reshape &&

drivers/md/md.c

10516

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

drivers/md/md.c

10517

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

drivers/md/md.c

10519

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10520

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

10521

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

10523

if (mddev->event_work.func)

drivers/md/md.c

10524

queue_work(md_misc_wq, &mddev->event_work);

drivers/md/md.c

10529

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

drivers/md/md.c

10534

rdev_dec_pending(rdev, mddev);

drivers/md/md.c

10538

void md_finish_reshape(struct mddev *mddev)

drivers/md/md.c

10543

rdev_for_each(rdev, mddev) {

drivers/md/md.c

10559

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

10581

md_error(mddev, rdev);

drivers/md/md.c

10589

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/md.c

10591

md_wakeup_thread(rdev->mddev->thread);

drivers/md/md.c

10615

struct mddev *mddev;

drivers/md/md.c

10618

list_for_each_entry(mddev, &all_mddevs, all_mddevs) {

drivers/md/md.c

10619

if (!mddev_get(mddev))

drivers/md/md.c

10622

if (mddev_trylock(mddev)) {

drivers/md/md.c

10623

if (mddev->pers)

drivers/md/md.c

10624

__md_stop_writes(mddev);

drivers/md/md.c

10625

if (mddev->persistent)

drivers/md/md.c

10626

mddev->safemode = 2;

drivers/md/md.c

10627

mddev_unlock(mddev);

drivers/md/md.c

10630

mddev_put_locked(mddev);

drivers/md/md.c

10692

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

drivers/md/md.c

10702

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

drivers/md/md.c

10703

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

drivers/md/md.c

10706

else if (md_bitmap_enabled(mddev, false))

drivers/md/md.c

10707

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

drivers/md/md.c

10711

rdev_for_each_safe(rdev2, tmp, mddev) {

drivers/md/md.c

10714

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10739

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

drivers/md/md.c

10750

ret = remove_and_add_spares(mddev, rdev2);

drivers/md/md.c

10755

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

10756

md_wakeup_thread(mddev->thread);

drivers/md/md.c

10765

md_error(mddev, rdev2);

drivers/md/md.c

10771

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

drivers/md/md.c

10772

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

drivers/md/md.c

10781

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

drivers/md/md.c

10787

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

drivers/md/md.c

10788

if (mddev->pers->update_reshape_pos)

drivers/md/md.c

10789

mddev->pers->update_reshape_pos(mddev);

drivers/md/md.c

10790

if (mddev->pers->start_reshape)

drivers/md/md.c

10791

mddev->pers->start_reshape(mddev);

drivers/md/md.c

10792

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

drivers/md/md.c

10793

mddev->reshape_position != MaxSector &&

drivers/md/md.c

10796

mddev->reshape_position = MaxSector;

drivers/md/md.c

10797

if (mddev->pers->update_reshape_pos)

drivers/md/md.c

10798

mddev->pers->update_reshape_pos(mddev);

drivers/md/md.c

10802

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

drivers/md/md.c

10805

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

drivers/md/md.c

10819

err = super_types[mddev->major_version].

drivers/md/md.c

10820

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

drivers/md/md.c

10845

mddev->pers->spare_active(mddev))

drivers/md/md.c

10846

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

10852

void md_reload_sb(struct mddev *mddev, int nr)

drivers/md/md.c

10858

rdev_for_each_rcu(iter, mddev) {

drivers/md/md.c

10870

err = read_rdev(mddev, rdev);

drivers/md/md.c

10874

check_sb_changes(mddev, rdev);

drivers/md/md.c

10877

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

10879

read_rdev(mddev, rdev);

drivers/md/md.c

10955

struct mddev *mddev;

drivers/md/md.c

10976

list_for_each_entry(mddev, &all_mddevs, all_mddevs) {

drivers/md/md.c

10977

if (!mddev_get(mddev))

drivers/md/md.c

10980

export_array(mddev);

drivers/md/md.c

10981

mddev->ctime = 0;

drivers/md/md.c

10982

mddev->hold_active = 0;

drivers/md/md.c

10989

mddev_put_locked(mddev);

drivers/md/md.c

1100

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

1105

md_error(mddev, rdev);

drivers/md/md.c

1108

set_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags);

drivers/md/md.c

1116

rdev_dec_pending(rdev, mddev);

drivers/md/md.c

1118

if (atomic_dec_and_test(&mddev->pending_writes))

drivers/md/md.c

1119

wake_up(&mddev->sb_wait);

drivers/md/md.c

1138

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

drivers/md/md.c

1154

GFP_NOIO, &mddev->sync_set);

drivers/md/md.c

1163

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

drivers/md/md.c

1168

atomic_inc(&mddev->pending_writes);

drivers/md/md.c

1172

int md_super_wait(struct mddev *mddev)

drivers/md/md.c

1175

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

drivers/md/md.c

1176

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

drivers/md/md.c

1194

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

drivers/md/md.c

1195

(rdev->mddev->reshape_backwards ==

drivers/md/md.c

1196

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

drivers/md/md.c

1333

int (*validate_super)(struct mddev *mddev,

drivers/md/md.c

1336

void (*sync_super)(struct mddev *mddev,

drivers/md/md.c

1352

int md_check_no_bitmap(struct mddev *mddev)

drivers/md/md.c

1354

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

drivers/md/md.c

1357

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

drivers/md/md.c

136

static int speed_min(struct mddev *mddev)

drivers/md/md.c

138

return mddev->sync_speed_min ?

drivers/md/md.c

139

mddev->sync_speed_min : sysctl_speed_limit_min;

drivers/md/md.c

142

static int speed_max(struct mddev *mddev)

drivers/md/md.c

144

return mddev->sync_speed_max ?

drivers/md/md.c

145

mddev->sync_speed_max : sysctl_speed_limit_max;

drivers/md/md.c

1464

static u64 md_bitmap_events_cleared(struct mddev *mddev)

drivers/md/md.c

1469

if (!md_bitmap_enabled(mddev, false))

drivers/md/md.c

1472

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

drivers/md/md.c

148

static int sync_io_depth(struct mddev *mddev)

drivers/md/md.c

1483

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

drivers/md/md.c

1495

if (mddev->raid_disks == 0) {

drivers/md/md.c

1496

mddev->major_version = 0;

drivers/md/md.c

1497

mddev->minor_version = sb->minor_version;

drivers/md/md.c

1498

mddev->patch_version = sb->patch_version;

drivers/md/md.c

1499

mddev->external = 0;

drivers/md/md.c

150

return mddev->sync_io_depth ?

drivers/md/md.c

1500

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

drivers/md/md.c

1501

mddev->ctime = sb->ctime;

drivers/md/md.c

1502

mddev->utime = sb->utime;

drivers/md/md.c

1503

mddev->level = sb->level;

drivers/md/md.c

1504

mddev->clevel[0] = 0;

drivers/md/md.c

1505

mddev->layout = sb->layout;

drivers/md/md.c

1506

mddev->raid_disks = sb->raid_disks;

drivers/md/md.c

1507

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

drivers/md/md.c

1508

mddev->events = ev1;

drivers/md/md.c

1509

mddev->bitmap_info.offset = 0;

drivers/md/md.c

151

mddev->sync_io_depth : sysctl_sync_io_depth;

drivers/md/md.c

1510

mddev->bitmap_info.space = 0;

drivers/md/md.c

1512

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

drivers/md/md.c

1513

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

drivers/md/md.c

1514

mddev->reshape_backwards = 0;

drivers/md/md.c

1516

if (mddev->minor_version >= 91) {

drivers/md/md.c

1517

mddev->reshape_position = sb->reshape_position;

drivers/md/md.c

1518

mddev->delta_disks = sb->delta_disks;

drivers/md/md.c

1519

mddev->new_level = sb->new_level;

drivers/md/md.c

1520

mddev->new_layout = sb->new_layout;

drivers/md/md.c

1521

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

drivers/md/md.c

1522

if (mddev->delta_disks < 0)

drivers/md/md.c

1523

mddev->reshape_backwards = 1;

drivers/md/md.c

1525

mddev->reshape_position = MaxSector;

drivers/md/md.c

1526

mddev->delta_disks = 0;

drivers/md/md.c

1527

mddev->new_level = mddev->level;

drivers/md/md.c

1528

mddev->new_layout = mddev->layout;

drivers/md/md.c

1529

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

1531

if (mddev->level == 0)

drivers/md/md.c

1532

mddev->layout = -1;

drivers/md/md.c

1535

mddev->resync_offset = MaxSector;

drivers/md/md.c

1539

mddev->resync_offset = sb->recovery_cp;

drivers/md/md.c

1541

mddev->resync_offset = 0;

drivers/md/md.c

1544

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

drivers/md/md.c

1545

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

drivers/md/md.c

1546

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

drivers/md/md.c

1547

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

drivers/md/md.c

1549

mddev->max_disks = MD_SB_DISKS;

drivers/md/md.c

1552

mddev->bitmap_info.file == NULL) {

drivers/md/md.c

1553

mddev->bitmap_info.offset =

drivers/md/md.c

1554

mddev->bitmap_info.default_offset;

drivers/md/md.c

1555

mddev->bitmap_info.space =

drivers/md/md.c

1556

mddev->bitmap_info.default_space;

drivers/md/md.c

1559

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

drivers/md/md.c

1565

if (ev1 < mddev->events)

drivers/md/md.c

1567

} else if (mddev->bitmap) {

drivers/md/md.c

1571

if (ev1 < md_bitmap_events_cleared(mddev))

drivers/md/md.c

1573

if (ev1 < mddev->events)

drivers/md/md.c

1576

if (ev1 < mddev->events)

drivers/md/md.c

1594

if (mddev->minor_version >= 91) {

drivers/md/md.c

1609

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

drivers/md/md.c

1613

int next_spare = mddev->raid_disks;

drivers/md/md.c

163

static void rdevs_uninit_serial(struct mddev *mddev)

drivers/md/md.c

1635

sb->major_version = mddev->major_version;

drivers/md/md.c

1636

sb->patch_version = mddev->patch_version;

drivers/md/md.c

1638

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

drivers/md/md.c

1639

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

drivers/md/md.c

1640

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

drivers/md/md.c

1641

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

drivers/md/md.c

1643

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

drivers/md/md.c

1644

sb->level = mddev->level;

drivers/md/md.c

1645

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

drivers/md/md.c

1646

sb->raid_disks = mddev->raid_disks;

drivers/md/md.c

1647

sb->md_minor = mddev->md_minor;

drivers/md/md.c

1649

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

drivers/md/md.c

1651

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

drivers/md/md.c

1652

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

drivers/md/md.c

1654

if (mddev->reshape_position == MaxSector)

drivers/md/md.c

1658

sb->reshape_position = mddev->reshape_position;

drivers/md/md.c

1659

sb->new_level = mddev->new_level;

drivers/md/md.c

1660

sb->delta_disks = mddev->delta_disks;

drivers/md/md.c

1661

sb->new_layout = mddev->new_layout;

drivers/md/md.c

1662

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

drivers/md/md.c

1664

mddev->minor_version = sb->minor_version;

drivers/md/md.c

1665

if (mddev->in_sync)

drivers/md/md.c

1667

sb->recovery_cp = mddev->resync_offset;

drivers/md/md.c

1668

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

drivers/md/md.c

1669

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

drivers/md/md.c

167

rdev_for_each(rdev, mddev)

drivers/md/md.c

1670

if (mddev->resync_offset == MaxSector)

drivers/md/md.c

1675

sb->layout = mddev->layout;

drivers/md/md.c

1676

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

drivers/md/md.c

1678

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

drivers/md/md.c

1682

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

1730

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

drivers/md/md.c

1756

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

drivers/md/md.c

1758

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

drivers/md/md.c

1766

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

drivers/md/md.c

1769

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

drivers/md/md.c

1771

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

drivers/md/md.c

198

static int rdevs_init_serial(struct mddev *mddev)

drivers/md/md.c

1991

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

drivers/md/md.c

2003

if (mddev->raid_disks == 0) {

drivers/md/md.c

2004

mddev->major_version = 1;

drivers/md/md.c

2005

mddev->patch_version = 0;

drivers/md/md.c

2006

mddev->external = 0;

drivers/md/md.c

2007

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

drivers/md/md.c

2008

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

drivers/md/md.c

2009

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

drivers/md/md.c

2010

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

drivers/md/md.c

2011

mddev->clevel[0] = 0;

drivers/md/md.c

2012

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

drivers/md/md.c

2013

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

drivers/md/md.c

2014

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

drivers/md/md.c

2015

mddev->events = ev1;

drivers/md/md.c

2016

mddev->bitmap_info.offset = 0;

drivers/md/md.c

2017

mddev->bitmap_info.space = 0;

drivers/md/md.c

2021

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

drivers/md/md.c

2022

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

drivers/md/md.c

2023

mddev->reshape_backwards = 0;

drivers/md/md.c

2025

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

drivers/md/md.c

2026

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

drivers/md/md.c

2028

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

drivers/md/md.c

203

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2030

if (!mddev->logical_block_size)

drivers/md/md.c

2031

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

drivers/md/md.c

2034

mddev->bitmap_info.file == NULL) {

drivers/md/md.c

2035

mddev->bitmap_info.offset =

drivers/md/md.c

2042

if (mddev->minor_version > 0)

drivers/md/md.c

2043

mddev->bitmap_info.space = 0;

drivers/md/md.c

2044

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

drivers/md/md.c

2045

mddev->bitmap_info.space =

drivers/md/md.c

2046

8 - mddev->bitmap_info.offset;

drivers/md/md.c

2048

mddev->bitmap_info.space =

drivers/md/md.c

2049

-mddev->bitmap_info.offset;

drivers/md/md.c

2053

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

drivers/md/md.c

2054

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

drivers/md/md.c

2055

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

drivers/md/md.c

2056

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

drivers/md/md.c

2057

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

drivers/md/md.c

2058

if (mddev->delta_disks < 0 ||

drivers/md/md.c

2059

(mddev->delta_disks == 0 &&

drivers/md/md.c

2062

mddev->reshape_backwards = 1;

drivers/md/md.c

2064

mddev->reshape_position = MaxSector;

drivers/md/md.c

2065

mddev->delta_disks = 0;

drivers/md/md.c

2066

mddev->new_level = mddev->level;

drivers/md/md.c

2067

mddev->new_layout = mddev->layout;

drivers/md/md.c

2068

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

2071

if (mddev->level == 0 &&

drivers/md/md.c

2073

mddev->layout = -1;

drivers/md/md.c

2076

set_bit(MD_HAS_JOURNAL, &mddev->flags);

drivers/md/md.c

2087

set_bit(MD_HAS_PPL, &mddev->flags);

drivers/md/md.c

2089

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

drivers/md/md.c

2099

if (ev1 + 1 < mddev->events)

drivers/md/md.c

210

if (ret && !mddev->serial_info_pool)

drivers/md/md.c

2101

} else if (mddev->bitmap) {

drivers/md/md.c

2105

if (ev1 < md_bitmap_events_cleared(mddev))

drivers/md/md.c

2107

if (ev1 < mddev->events)

drivers/md/md.c

211

rdevs_uninit_serial(mddev);

drivers/md/md.c

2110

if (ev1 < mddev->events)

drivers/md/md.c

2119

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

drivers/md/md.c

2140

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

drivers/md/md.c

2147

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

drivers/md/md.c

2181

&mddev->recovery))

drivers/md/md.c

2197

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

drivers/md/md.c

2211

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

drivers/md/md.c

2212

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

drivers/md/md.c

2213

if (mddev->in_sync)

drivers/md/md.c

2214

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

drivers/md/md.c

2215

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

drivers/md/md.c

2222

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

drivers/md/md.c

2223

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

drivers/md/md.c

2224

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

drivers/md/md.c

2225

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

drivers/md/md.c

2226

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

drivers/md/md.c

2227

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

drivers/md/md.c

223

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

drivers/md/md.c

2240

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

drivers/md/md.c

2241

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

drivers/md/md.c

2251

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

drivers/md/md.c

2262

if (mddev->reshape_position != MaxSector) {

drivers/md/md.c

2264

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

drivers/md/md.c

2265

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

drivers/md/md.c

2266

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

drivers/md/md.c

2267

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

drivers/md/md.c

2268

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

drivers/md/md.c

2269

if (mddev->delta_disks == 0 &&

drivers/md/md.c

2270

mddev->reshape_backwards)

drivers/md/md.c

2281

if (mddev_is_clustered(mddev))

drivers/md/md.c

2288

md_error(mddev, rdev);

drivers/md/md.c

2319

rdev_for_each(rdev2, mddev)

drivers/md/md.c

233

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

drivers/md/md.c

2336

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

drivers/md/md.c

2339

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

drivers/md/md.c

2340

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

drivers/md/md.c

2349

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

2389

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

drivers/md/md.c

2398

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

drivers/md/md.c

242

ret = rdevs_init_serial(mddev);

drivers/md/md.c

2426

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

drivers/md/md.c

2428

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

drivers/md/md.c

2437

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

2445

if (mddev->minor_version == 0)

drivers/md/md.c

2457

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

drivers/md/md.c

2461

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

drivers/md/md.c

2462

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

drivers/md/md.c

248

if (mddev->serial_info_pool == NULL) {

drivers/md/md.c

2494

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

drivers/md/md.c

2496

if (mddev->sync_super) {

drivers/md/md.c

2497

mddev->sync_super(mddev, rdev);

drivers/md/md.c

2501

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

drivers/md/md.c

2503

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

drivers/md/md.c

2506

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

drivers/md/md.c

253

mddev->serial_info_pool =

drivers/md/md.c

2540

int md_integrity_register(struct mddev *mddev)

drivers/md/md.c

2542

if (list_empty(&mddev->disks))

drivers/md/md.c

2544

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

drivers/md/md.c

2547

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

drivers/md/md.c

2558

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

drivers/md/md.c

256

if (!mddev->serial_info_pool) {

drivers/md/md.c

2564

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

drivers/md/md.c

2567

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

drivers/md/md.c

257

rdevs_uninit_serial(mddev);

drivers/md/md.c

2573

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

drivers/md/md.c

2574

if (mddev->pers) {

drivers/md/md.c

2579

if (mddev->level > 0)

drivers/md/md.c

2582

mddev->dev_sectors = rdev->sectors;

drivers/md/md.c

2592

if (mddev->pers)

drivers/md/md.c

2593

choice = mddev->raid_disks;

drivers/md/md.c

2594

while (md_find_rdev_nr_rcu(mddev, choice))

drivers/md/md.c

2598

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

drivers/md/md.c

2605

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

drivers/md/md.c

2607

mdname(mddev), mddev->max_disks);

drivers/md/md.c

2613

rdev->mddev = mddev;

drivers/md/md.c

2616

if (mddev->raid_disks)

drivers/md/md.c

2617

mddev_create_serial_pool(mddev, rdev);

drivers/md/md.c

2619

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

drivers/md/md.c

2630

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

drivers/md/md.c

2631

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

drivers/md/md.c

2637

b, mdname(mddev));

drivers/md/md.c

2638

mddev_destroy_serial_pool(mddev, rdev);

drivers/md/md.c

2662

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

2664

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

drivers/md/md.c

2667

mddev_destroy_serial_pool(rdev->mddev, rdev);

drivers/md/md.c

2668

WRITE_ONCE(rdev->mddev, NULL);

drivers/md/md.c

2685

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

drivers/md/md.c

2688

static void export_array(struct mddev *mddev)

drivers/md/md.c

269

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

drivers/md/md.c

2692

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

drivers/md/md.c

2693

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

drivers/md/md.c

2697

mddev->raid_disks = 0;

drivers/md/md.c

2698

mddev->major_version = 0;

drivers/md/md.c

2701

static bool set_in_sync(struct mddev *mddev)

drivers/md/md.c

2703

lockdep_assert_held(&mddev->lock);

drivers/md/md.c

2704

if (!mddev->in_sync) {

drivers/md/md.c

2705

mddev->sync_checkers++;

drivers/md/md.c

2706

spin_unlock(&mddev->lock);

drivers/md/md.c

2707

percpu_ref_switch_to_atomic_sync(&mddev->writes_pending);

drivers/md/md.c

2708

spin_lock(&mddev->lock);

drivers/md/md.c

2709

if (!mddev->in_sync &&

drivers/md/md.c

2710

percpu_ref_is_zero(&mddev->writes_pending)) {

drivers/md/md.c

2711

mddev->in_sync = 1;

drivers/md/md.c

2717

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

2718

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

2720

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

drivers/md/md.c

2721

percpu_ref_switch_to_percpu(&mddev->writes_pending);

drivers/md/md.c

2723

if (mddev->safemode == 1)

drivers/md/md.c

2724

mddev->safemode = 0;

drivers/md/md.c

2725

return mddev->in_sync;

drivers/md/md.c

2728

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

drivers/md/md.c

2737

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2738

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

drivers/md/md.c

274

if (mddev->serial_info_pool) {

drivers/md/md.c

2741

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

drivers/md/md.c

2745

sync_super(mddev, rdev);

drivers/md/md.c

2751

static bool does_sb_need_changing(struct mddev *mddev)

drivers/md/md.c

2758

rdev_for_each(iter, mddev)

drivers/md/md.c

2770

rdev_for_each(rdev, mddev) {

drivers/md/md.c

278

rdev_for_each(temp, mddev) {

drivers/md/md.c

2782

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

drivers/md/md.c

2783

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

drivers/md/md.c

2784

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

drivers/md/md.c

2785

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

drivers/md/md.c

2786

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

drivers/md/md.c

2792

void md_update_sb(struct mddev *mddev, int force_change)

drivers/md/md.c

2800

if (!md_is_rdwr(mddev)) {

drivers/md/md.c

2802

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

2803

if (!mddev_is_dm(mddev))

drivers/md/md.c

2805

__func__, mdname(mddev));

drivers/md/md.c

281

&mddev->flags) ||

drivers/md/md.c

2810

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

2811

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

drivers/md/md.c

2813

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

drivers/md/md.c

2815

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

drivers/md/md.c

2817

if (!does_sb_need_changing(mddev)) {

drivers/md/md.c

2819

mddev->cluster_ops->metadata_update_cancel(mddev);

drivers/md/md.c

2820

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

drivers/md/md.c

2833

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2835

mddev->delta_disks >= 0 &&

drivers/md/md.c

2836

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

drivers/md/md.c

2837

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

drivers/md/md.c

2838

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

drivers/md/md.c

2841

mddev->curr_resync_completed > rdev->recovery_offset)

drivers/md/md.c

2842

rdev->recovery_offset = mddev->curr_resync_completed;

drivers/md/md.c

2845

if (!mddev->persistent) {

drivers/md/md.c

2846

clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

2847

clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

2848

if (!mddev->external) {

drivers/md/md.c

2849

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

2850

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2854

md_error(mddev, rdev);

drivers/md/md.c

2861

wake_up(&mddev->sb_wait);

drivers/md/md.c

2865

spin_lock(&mddev->lock);

drivers/md/md.c

2867

mddev->utime = ktime_get_real_seconds();

drivers/md/md.c

2869

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

drivers/md/md.c

2871

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

drivers/md/md.c

2879

if (mddev->degraded)

drivers/md/md.c

2891

sync_req = mddev->in_sync;

drivers/md/md.c

2896

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

drivers/md/md.c

2897

&& mddev->can_decrease_events

drivers/md/md.c

2898

&& mddev->events != 1) {

drivers/md/md.c

2899

mddev->events--;

drivers/md/md.c

2900

mddev->can_decrease_events = 0;

drivers/md/md.c

2903

mddev->events ++;

drivers/md/md.c

2904

mddev->can_decrease_events = nospares;

drivers/md/md.c

2912

WARN_ON(mddev->events == 0);

drivers/md/md.c

2914

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2921

sync_sbs(mddev, nospares);

drivers/md/md.c

2922

spin_unlock(&mddev->lock);

drivers/md/md.c

2925

mdname(mddev), mddev->in_sync);

drivers/md/md.c

2927

mddev_add_trace_msg(mddev, "md md_update_sb");

drivers/md/md.c

2929

if (md_bitmap_enabled(mddev, false))

drivers/md/md.c

2930

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

drivers/md/md.c

2931

rdev_for_each(rdev, mddev) {

drivers/md/md.c

2936

md_write_metadata(mddev, rdev, rdev->sb_start,

drivers/md/md.c

2941

rdev->sb_events = mddev->events;

drivers/md/md.c

2943

md_write_metadata(mddev, rdev,

drivers/md/md.c

2954

if (md_super_wait(mddev) < 0)

drivers/md/md.c

2958

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

drivers/md/md.c

2959

mddev->cluster_ops->metadata_update_finish(mddev);

drivers/md/md.c

2961

if (mddev->in_sync != sync_req ||

drivers/md/md.c

2962

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

drivers/md/md.c

2966

wake_up(&mddev->sb_wait);

drivers/md/md.c

2967

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

drivers/md/md.c

2968

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

297

mempool_destroy(mddev->serial_info_pool);

drivers/md/md.c

2970

rdev_for_each(rdev, mddev) {

drivers/md/md.c

298

mddev->serial_info_pool = NULL;

drivers/md/md.c

2984

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

2988

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

drivers/md/md.c

2993

super_types[mddev->major_version].

drivers/md/md.c

2994

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

drivers/md/md.c

2995

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

drivers/md/md.c

3003

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

3004

if (mddev->degraded)

drivers/md/md.c

3005

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

3006

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

3097

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

3101

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

drivers/md/md.c

3102

md_error(rdev->mddev, rdev);

drivers/md/md.c

3104

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

drivers/md/md.c

3109

if (rdev->mddev->pers) {

drivers/md/md.c

3111

remove_and_add_spares(rdev->mddev, rdev);

drivers/md/md.c

3117

if (mddev_is_clustered(mddev))

drivers/md/md.c

3118

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

drivers/md/md.c

3122

if (mddev->pers)

drivers/md/md.c

3123

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

3129

mddev_create_serial_pool(rdev->mddev, rdev);

drivers/md/md.c

3133

mddev_destroy_serial_pool(rdev->mddev, rdev);

drivers/md/md.c

3147

md_error(rdev->mddev, rdev);

drivers/md/md.c

3152

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

drivers/md/md.c

3168

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

drivers/md/md.c

3189

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

drivers/md/md.c

3202

if (rdev->mddev->pers)

drivers/md/md.c

3210

if (rdev->mddev->pers)

drivers/md/md.c

3217

if (!rdev->mddev->pers)

drivers/md/md.c

3227

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

drivers/md/md.c

3228

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

drivers/md/md.c

3234

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

drivers/md/md.c

3238

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

drivers/md/md.c

3243

md_update_sb(mddev, 1);

drivers/md/md.c

3301

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

drivers/md/md.c

3312

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

drivers/md/md.c

3315

remove_and_add_spares(rdev->mddev, rdev);

drivers/md/md.c

3318

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

drivers/md/md.c

3319

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

drivers/md/md.c

3328

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

drivers/md/md.c

3331

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

drivers/md/md.c

3334

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

drivers/md/md.c

3335

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

drivers/md/md.c

3345

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

drivers/md/md.c

3352

sysfs_link_rdev(rdev->mddev, rdev);

drivers/md/md.c

3355

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

drivers/md/md.c

3356

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

drivers/md/md.c

3383

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

drivers/md/md.c

3385

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

drivers/md/md.c

3407

struct mddev *mddev = rdev->mddev;

drivers/md/md.c

3412

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

drivers/md/md.c

3420

+ mddev->dev_sectors > rdev->sectors)

drivers/md/md.c

3429

mddev->reshape_backwards)

drivers/md/md.c

3436

!mddev->reshape_backwards)

drivers/md/md.c

3439

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

drivers/md/md.c

3440

!super_types[mddev->major_version]

drivers/md/md.c

3445

mddev->reshape_backwards = 1;

drivers/md/md.c

3447

mddev->reshape_backwards = 0;

drivers/md/md.c

3472

struct mddev *mddev;

drivers/md/md.c

3476

list_for_each_entry(mddev, &all_mddevs, all_mddevs) {

drivers/md/md.c

3477

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

drivers/md/md.c

3479

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

3513

struct mddev *my_mddev = rdev->mddev;

drivers/md/md.c

3582

if (rdev->mddev->pers &&

drivers/md/md.c

3650

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

drivers/md/md.c

3654

if (rdev->mddev->persistent) {

drivers/md/md.c

3655

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

drivers/md/md.c

3663

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

drivers/md/md.c

3687

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

drivers/md/md.c

369

static bool is_md_suspended(struct mddev *mddev)

drivers/md/md.c

3691

if (rdev->mddev->persistent) {

drivers/md/md.c

3692

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

drivers/md/md.c

3696

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

drivers/md/md.c

371

return percpu_ref_is_dying(&mddev->active_io);

drivers/md/md.c

3729

if (!rdev->mddev)

drivers/md/md.c

3743

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

drivers/md/md.c

3749

if (!mddev)

drivers/md/md.c

3761

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

drivers/md/md.c

3763

if (rdev->mddev == NULL)

drivers/md/md.c

3767

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

drivers/md/md.c

380

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

drivers/md/md.c

382

if (is_md_suspended(mddev))

drivers/md/md.c

386

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

drivers/md/md.c

388

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

drivers/md/md.c

3897

static int analyze_sbs(struct mddev *mddev)

drivers/md/md.c

390

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

drivers/md/md.c

3902

rdev_for_each_safe(rdev, tmp, mddev)

drivers/md/md.c

3903

switch (super_types[mddev->major_version].

drivers/md/md.c

3904

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

drivers/md/md.c

3922

super_types[mddev->major_version].

drivers/md/md.c

3923

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

drivers/md/md.c

3925

rdev_for_each_safe(rdev, tmp, mddev) {

drivers/md/md.c

3926

if (mddev->max_disks &&

drivers/md/md.c

3927

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

drivers/md/md.c

3929

mdname(mddev), rdev->bdev,

drivers/md/md.c

3930

mddev->max_disks);

drivers/md/md.c

3935

if (super_types[mddev->major_version].

drivers/md/md.c

3936

validate_super(mddev, freshest, rdev)) {

drivers/md/md.c

3943

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

drivers/md/md.c

395

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

drivers/md/md.c

398

if (unlikely(md_cloned_bio(mddev, bio))) {

drivers/md/md.c

3990

safe_delay_show(struct mddev *mddev, char *page)

drivers/md/md.c

3992

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

drivers/md/md.c

3997

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

drivers/md/md.c

4001

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

4009

mddev->safemode_delay = 0;

drivers/md/md.c

4011

unsigned long old_delay = mddev->safemode_delay;

drivers/md/md.c

4016

mddev->safemode_delay = new_delay;

drivers/md/md.c

4018

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

drivers/md/md.c

4026

level_show(struct mddev *mddev, char *page)

drivers/md/md.c

403

percpu_ref_get(&mddev->active_io);

drivers/md/md.c

4030

spin_lock(&mddev->lock);

drivers/md/md.c

4031

p = mddev->pers;

drivers/md/md.c

4034

else if (mddev->clevel[0])

drivers/md/md.c

4035

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

drivers/md/md.c

4036

else if (mddev->level != LEVEL_NONE)

drivers/md/md.c

4037

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

drivers/md/md.c

4040

spin_unlock(&mddev->lock);

drivers/md/md.c

4045

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

drivers/md/md.c

405

if (is_suspended(mddev, bio)) {

drivers/md/md.c

4058

rv = mddev_suspend_and_lock(mddev);

drivers/md/md.c

4062

if (mddev->pers == NULL) {

drivers/md/md.c

4063

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

drivers/md/md.c

4064

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

drivers/md/md.c

4066

mddev->clevel[slen] = 0;

drivers/md/md.c

4067

mddev->level = LEVEL_NONE;

drivers/md/md.c

4072

if (!md_is_rdwr(mddev))

drivers/md/md.c

4082

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

drivers/md/md.c

4083

mddev->reshape_position != MaxSector ||

drivers/md/md.c

4084

mddev->sysfs_active)

drivers/md/md.c

4088

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

drivers/md/md.c

4090

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

drivers/md/md.c

411

wait_event(mddev->sb_wait, !is_suspended(mddev, bio));

drivers/md/md.c

4110

if (pers == mddev->pers) {

drivers/md/md.c

4119

mdname(mddev), clevel);

drivers/md/md.c

4124

rdev_for_each(rdev, mddev)

drivers/md/md.c

413

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

drivers/md/md.c

4130

priv = pers->takeover(mddev);

drivers/md/md.c

4132

mddev->new_level = mddev->level;

drivers/md/md.c

4133

mddev->new_layout = mddev->layout;

drivers/md/md.c

4134

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

4135

mddev->raid_disks -= mddev->delta_disks;

drivers/md/md.c

4136

mddev->delta_disks = 0;

drivers/md/md.c

4137

mddev->reshape_backwards = 0;

drivers/md/md.c

4140

mdname(mddev), clevel);

drivers/md/md.c

4146

mddev_detach(mddev);

drivers/md/md.c

4148

spin_lock(&mddev->lock);

drivers/md/md.c

4149

oldpers = mddev->pers;

drivers/md/md.c

4150

oldpriv = mddev->private;

drivers/md/md.c

4151

mddev->pers = pers;

drivers/md/md.c

4152

mddev->private = priv;

drivers/md/md.c

4153

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

drivers/md/md.c

4154

mddev->level = mddev->new_level;

drivers/md/md.c

4155

mddev->layout = mddev->new_layout;

drivers/md/md.c

4156

mddev->chunk_sectors = mddev->new_chunk_sectors;

drivers/md/md.c

4157

mddev->delta_disks = 0;

drivers/md/md.c

4158

mddev->reshape_backwards = 0;

drivers/md/md.c

4159

mddev->degraded = 0;

drivers/md/md.c

416

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

drivers/md/md.c

4160

spin_unlock(&mddev->lock);

drivers/md/md.c

4163

mddev->external) {

drivers/md/md.c

417

percpu_ref_put(&mddev->active_io);

drivers/md/md.c

4171

mddev->in_sync = 0;

drivers/md/md.c

4172

mddev->safemode_delay = 0;

drivers/md/md.c

4173

mddev->safemode = 0;

drivers/md/md.c

4176

oldpers->free(mddev, oldpriv);

drivers/md/md.c

418

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

drivers/md/md.c

4181

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

drivers/md/md.c

4183

mdname(mddev));

drivers/md/md.c

4184

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

drivers/md/md.c

4185

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

drivers/md/md.c

4186

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

drivers/md/md.c

4191

if (mddev->to_remove == NULL)

drivers/md/md.c

4192

mddev->to_remove = &md_redundancy_group;

drivers/md/md.c

4197

rdev_for_each(rdev, mddev) {

drivers/md/md.c

4200

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

drivers/md/md.c

4204

sysfs_unlink_rdev(mddev, rdev);

drivers/md/md.c

4206

rdev_for_each(rdev, mddev) {

drivers/md/md.c

4215

if (sysfs_link_rdev(mddev, rdev))

drivers/md/md.c

4217

rdev->raid_disk, mdname(mddev));

drivers/md/md.c

4225

mddev->in_sync = 1;

drivers/md/md.c

4226

timer_delete_sync(&mddev->safemode_timer);

drivers/md/md.c

4228

pers->run(mddev);

drivers/md/md.c

4229

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

423

percpu_ref_put(&mddev->active_io);

drivers/md/md.c

4230

if (!mddev->thread)

drivers/md/md.c

4231

md_update_sb(mddev, 1);

drivers/md/md.c

4232

sysfs_notify_dirent_safe(mddev->sysfs_level);

drivers/md/md.c

4236

mddev_unlock_and_resume(mddev);

drivers/md/md.c

4244

new_level_show(struct mddev *mddev, char *page)

drivers/md/md.c

4246

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

drivers/md/md.c

4250

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

drivers/md/md.c

4258

err = mddev_lock(mddev);

drivers/md/md.c

4262

mddev->new_level = n;

drivers/md/md.c

4263

md_update_sb(mddev, 1);

drivers/md/md.c

4265

mddev_unlock(mddev);

drivers/md/md.c

4272

bitmap_type_show(struct mddev *mddev, char *page)

drivers/md/md.c

4278

if (mddev->bitmap_id == ID_BITMAP_NONE)

drivers/md/md.c

4288

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

drivers/md/md.c

4300

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

drivers/md/md.c

4309

if (mddev->bitmap_ops) {

drivers/md/md.c

431

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

drivers/md/md.c

4315

mddev->bitmap_id = ID_BITMAP_NONE;

drivers/md/md.c

4321

mddev->bitmap_id = head->id;

drivers/md/md.c

433

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

drivers/md/md.c

4331

mddev->bitmap_id = id;

drivers/md/md.c

4337

mddev->bitmap_id = id;

drivers/md/md.c

4352

layout_show(struct mddev *mddev, char *page)

drivers/md/md.c

4355

if (mddev->reshape_position != MaxSector &&

drivers/md/md.c

4356

mddev->layout != mddev->new_layout)

drivers/md/md.c

4358

mddev->new_layout, mddev->layout);

drivers/md/md.c

4359

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

drivers/md/md.c

4363

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

drivers/md/md.c

4371

err = mddev_lock(mddev);

drivers/md/md.c

4375

if (mddev->pers) {

drivers/md/md.c

4376

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

drivers/md/md.c

4378

else if (!md_is_rdwr(mddev))

drivers/md/md.c

438

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

drivers/md/md.c

4381

mddev->new_layout = n;

drivers/md/md.c

4382

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

drivers/md/md.c

4384

mddev->new_layout = mddev->layout;

drivers/md/md.c

4387

mddev->new_layout = n;

drivers/md/md.c

4388

if (mddev->reshape_position == MaxSector)

drivers/md/md.c

4389

mddev->layout = n;

drivers/md/md.c

4391

mddev_unlock(mddev);

drivers/md/md.c

4398

raid_disks_show(struct mddev *mddev, char *page)

drivers/md/md.c

4400

if (mddev->raid_disks == 0)

drivers/md/md.c

4402

if (mddev->reshape_position != MaxSector &&

drivers/md/md.c

4403

mddev->delta_disks != 0)

drivers/md/md.c

4404

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

drivers/md/md.c

4405

mddev->raid_disks - mddev->delta_disks);

drivers/md/md.c

4406

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

drivers/md/md.c

4409

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

drivers/md/md.c

4412

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

drivers/md/md.c

4421

err = mddev_suspend_and_lock(mddev);

drivers/md/md.c

4424

if (mddev->pers) {

drivers/md/md.c

4425

if (n != mddev->raid_disks)

drivers/md/md.c

4426

err = update_raid_disks(mddev, n);

drivers/md/md.c

4427

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

drivers/md/md.c

4429

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

drivers/md/md.c

4432

rdev_for_each(rdev, mddev) {

drivers/md/md.c

4441

mddev->delta_disks = n - olddisks;

drivers/md/md.c

4442

mddev->raid_disks = n;

drivers/md/md.c

4443

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

drivers/md/md.c

4445

mddev->raid_disks = n;

drivers/md/md.c

4447

mddev_unlock_and_resume(mddev);

drivers/md/md.c

4454

uuid_show(struct mddev *mddev, char *page)

drivers/md/md.c

4456

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

drivers/md/md.c

4462

chunk_size_show(struct mddev *mddev, char *page)

drivers/md/md.c

4464

if (mddev->reshape_position != MaxSector &&

drivers/md/md.c

4465

mddev->chunk_sectors != mddev->new_chunk_sectors)

drivers/md/md.c

4467

mddev->new_chunk_sectors << 9,

drivers/md/md.c

4468

mddev->chunk_sectors << 9);

drivers/md/md.c

4469

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

drivers/md/md.c

447

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

drivers/md/md.c

4473

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

drivers/md/md.c

4482

err = mddev_lock(mddev);

drivers/md/md.c

4485

if (mddev->pers) {

drivers/md/md.c

4486

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

drivers/md/md.c

4488

else if (!md_is_rdwr(mddev))

drivers/md/md.c

4491

mddev->new_chunk_sectors = n >> 9;

drivers/md/md.c

4492

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

drivers/md/md.c

4494

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

4497

mddev->new_chunk_sectors = n >> 9;

drivers/md/md.c

4498

if (mddev->reshape_position == MaxSector)

drivers/md/md.c

4499

mddev->chunk_sectors = n >> 9;

drivers/md/md.c

4501

mddev_unlock(mddev);

drivers/md/md.c

4508

resync_start_show(struct mddev *mddev, char *page)

drivers/md/md.c

4510

if (mddev->resync_offset == MaxSector)

drivers/md/md.c

4512

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

drivers/md/md.c

4516

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

drivers/md/md.c

4531

err = mddev_lock(mddev);

drivers/md/md.c

4534

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

drivers/md/md.c

4538

mddev->resync_offset = n;

drivers/md/md.c

4539

if (mddev->pers)

drivers/md/md.c

4540

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

4542

mddev_unlock(mddev);

drivers/md/md.c

457

md_handle_request(mddev, bio);

drivers/md/md.c

4605

array_state_show(struct mddev *mddev, char *page)

drivers/md/md.c

4609

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

drivers/md/md.c

4610

switch(mddev->ro) {

drivers/md/md.c

4618

spin_lock(&mddev->lock);

drivers/md/md.c

4619

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

drivers/md/md.c

4621

else if (mddev->in_sync)

drivers/md/md.c

4623

else if (mddev->safemode)

drivers/md/md.c

4627

spin_unlock(&mddev->lock);

drivers/md/md.c

4630

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

drivers/md/md.c

4633

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

drivers/md/md.c

4634

mddev->raid_disks == 0 &&

drivers/md/md.c

4635

mddev->dev_sectors == 0)

drivers/md/md.c

464

int mddev_suspend(struct mddev *mddev, bool interruptible)

drivers/md/md.c

4643

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

drivers/md/md.c

4644

static int md_set_readonly(struct mddev *mddev);

drivers/md/md.c

4645

static int restart_array(struct mddev *mddev);

drivers/md/md.c

4648

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

drivers/md/md.c

4665

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

drivers/md/md.c

4668

err = mddev_set_closing_and_sync_blockdev(mddev, 0);

drivers/md/md.c

4676

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

drivers/md/md.c

4677

mddev->ro != MD_RDONLY) {

drivers/md/md.c

4681

spin_lock(&mddev->lock);

drivers/md/md.c

4683

restart_array(mddev);

drivers/md/md.c

4684

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

4685

md_wakeup_thread(mddev->thread);

drivers/md/md.c

4686

wake_up(&mddev->sb_wait);

drivers/md/md.c

4688

restart_array(mddev);

drivers/md/md.c

4689

if (!set_in_sync(mddev))

drivers/md/md.c

4693

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

4694

spin_unlock(&mddev->lock);

drivers/md/md.c

4697

err = mddev_lock(mddev);

drivers/md/md.c

4704

if (mddev->pers)

drivers/md/md.c

4705

err = do_md_stop(mddev, 2);

drivers/md/md.c

4708

err = do_md_stop(mddev, 0);

drivers/md/md.c

4711

if (mddev->pers)

drivers/md/md.c

4712

err = md_set_readonly(mddev);

drivers/md/md.c

4714

mddev->ro = MD_RDONLY;

drivers/md/md.c

4715

set_disk_ro(mddev->gendisk, 1);

drivers/md/md.c

4716

err = do_md_run(mddev);

drivers/md/md.c

4720

if (mddev->pers) {

drivers/md/md.c

4721

if (md_is_rdwr(mddev))

drivers/md/md.c

4722

err = md_set_readonly(mddev);

drivers/md/md.c

4723

else if (mddev->ro == MD_RDONLY)

drivers/md/md.c

4724

err = restart_array(mddev);

drivers/md/md.c

4726

mddev->ro = MD_AUTO_READ;

drivers/md/md.c

4727

set_disk_ro(mddev->gendisk, 0);

drivers/md/md.c

473

lockdep_assert_not_held(&mddev->reconfig_mutex);

drivers/md/md.c

4730

mddev->ro = MD_AUTO_READ;

drivers/md/md.c

4731

err = do_md_run(mddev);

drivers/md/md.c

4735

if (mddev->pers) {

drivers/md/md.c

4736

err = restart_array(mddev);

drivers/md/md.c

4739

spin_lock(&mddev->lock);

drivers/md/md.c

4740

if (!set_in_sync(mddev))

drivers/md/md.c

4742

spin_unlock(&mddev->lock);

drivers/md/md.c

4747

if (mddev->pers) {

drivers/md/md.c

4748

err = restart_array(mddev);

drivers/md/md.c

4751

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

4752

wake_up(&mddev->sb_wait);

drivers/md/md.c

4755

mddev->ro = MD_RDWR;

drivers/md/md.c

4756

set_disk_ro(mddev->gendisk, 0);

drivers/md/md.c

4757

err = do_md_run(mddev);

drivers/md/md.c

476

err = mutex_lock_interruptible(&mddev->suspend_mutex);

drivers/md/md.c

4766

if (mddev->hold_active == UNTIL_IOCTL)

drivers/md/md.c

4767

mddev->hold_active = 0;

drivers/md/md.c

4768

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

4770

mddev_unlock(mddev);

drivers/md/md.c

4774

clear_bit(MD_CLOSING, &mddev->flags);

drivers/md/md.c

478

mutex_lock(&mddev->suspend_mutex);

drivers/md/md.c

4782

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

drivers/md/md.c

4784

atomic_read(&mddev->max_corr_read_errors));

drivers/md/md.c

4788

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

drivers/md/md.c

4798

atomic_set(&mddev->max_corr_read_errors, n);

drivers/md/md.c

4807

null_show(struct mddev *mddev, char *page)

drivers/md/md.c

4813

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

drivers/md/md.c

482

if (mddev->suspended) {

drivers/md/md.c

483

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

drivers/md/md.c

4839

err = mddev_suspend_and_lock(mddev);

drivers/md/md.c

484

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

4842

if (mddev->persistent) {

drivers/md/md.c

4843

rdev = md_import_device(dev, mddev->major_version,

drivers/md/md.c

4844

mddev->minor_version);

drivers/md/md.c

4845

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

drivers/md/md.c

4847

= list_entry(mddev->disks.next,

drivers/md/md.c

4849

err = super_types[mddev->major_version]

drivers/md/md.c

4850

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

drivers/md/md.c

4854

} else if (mddev->external)

drivers/md/md.c

4860

mddev_unlock_and_resume(mddev);

drivers/md/md.c

4863

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

4867

mddev_unlock_and_resume(mddev);

drivers/md/md.c

4877

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

drivers/md/md.c

488

percpu_ref_kill(&mddev->active_io);

drivers/md/md.c

4883

if (!md_bitmap_enabled(mddev, false))

drivers/md/md.c

4886

err = mddev_lock(mddev);

drivers/md/md.c

4889

if (!mddev->bitmap)

drivers/md/md.c

4907

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

drivers/md/md.c

4910

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

drivers/md/md.c

4912

mddev_unlock(mddev);

drivers/md/md.c

4920

size_show(struct mddev *mddev, char *page)

drivers/md/md.c

4923

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

drivers/md/md.c

4926

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

drivers/md/md.c

4929

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

drivers/md/md.c

4940

err = mddev_lock(mddev);

drivers/md/md.c

4943

if (mddev->pers) {

drivers/md/md.c

4944

err = update_size(mddev, sectors);

drivers/md/md.c

4946

md_update_sb(mddev, 1);

drivers/md/md.c

4948

if (mddev->dev_sectors == 0 ||

drivers/md/md.c

4949

mddev->dev_sectors > sectors)

drivers/md/md.c

4950

mddev->dev_sectors = sectors;

drivers/md/md.c

4954

mddev_unlock(mddev);

drivers/md/md.c

496

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

drivers/md/md.c

4968

metadata_show(struct mddev *mddev, char *page)

drivers/md/md.c

497

reshape_interrupted(mddev))

drivers/md/md.c

4970

if (mddev->persistent)

drivers/md/md.c

4972

mddev->major_version, mddev->minor_version);

drivers/md/md.c

4973

else if (mddev->external)

drivers/md/md.c

4974

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

drivers/md/md.c

498

mddev->pers->prepare_suspend(mddev);

drivers/md/md.c

4980

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

drivers/md/md.c

4990

err = mddev_lock(mddev);

drivers/md/md.c

4994

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

drivers/md/md.c

4996

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

drivers/md/md.c

5001

mddev->persistent = 0;

drivers/md/md.c

5002

mddev->external = 0;

drivers/md/md.c

5003

mddev->major_version = 0;

drivers/md/md.c

5004

mddev->minor_version = 90;

drivers/md/md.c

5009

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

drivers/md/md.c

501

err = wait_event_interruptible(mddev->sb_wait,

drivers/md/md.c

5010

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

drivers/md/md.c

5011

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

drivers/md/md.c

5012

mddev->metadata_type[namelen] = 0;

drivers/md/md.c

5013

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

drivers/md/md.c

5014

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

drivers/md/md.c

5015

mddev->persistent = 0;

drivers/md/md.c

5016

mddev->external = 1;

drivers/md/md.c

5017

mddev->major_version = 0;

drivers/md/md.c

5018

mddev->minor_version = 90;

drivers/md/md.c

502

percpu_ref_is_zero(&mddev->active_io));

drivers/md/md.c

5032

mddev->major_version = major;

drivers/md/md.c

5033

mddev->minor_version = minor;

drivers/md/md.c

5034

mddev->persistent = 1;

drivers/md/md.c

5035

mddev->external = 0;

drivers/md/md.c

5038

mddev_unlock(mddev);

drivers/md/md.c

504

wait_event(mddev->sb_wait,

drivers/md/md.c

505

percpu_ref_is_zero(&mddev->active_io));

drivers/md/md.c

5054

static enum sync_action md_get_active_sync_action(struct mddev *mddev)

drivers/md/md.c

5059

if (mddev->resync_offset < MaxSector)

drivers/md/md.c

5062

if (mddev->reshape_position != MaxSector)

drivers/md/md.c

5066

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

507

percpu_ref_resurrect(&mddev->active_io);

drivers/md/md.c

5077

enum sync_action md_sync_action(struct mddev *mddev)

drivers/md/md.c

5079

unsigned long recovery = mddev->recovery;

drivers/md/md.c

508

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

5093

if (!md_is_rdwr(mddev))

drivers/md/md.c

5110

active_action = md_get_active_sync_action(mddev);

drivers/md/md.c

5157

action_show(struct mddev *mddev, char *page)

drivers/md/md.c

5159

enum sync_action action = md_sync_action(mddev);

drivers/md/md.c

517

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

drivers/md/md.c

5171

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

drivers/md/md.c

5173

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

drivers/md/md.c

5175

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

drivers/md/md.c

5177

mddev_unlock(mddev);

drivers/md/md.c

5181

mddev_unlock(mddev);

drivers/md/md.c

5183

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

5188

md_wakeup_thread_directly(&mddev->sync_thread);

drivers/md/md.c

5189

if (work_pending(&mddev->sync_work))

drivers/md/md.c

5190

flush_work(&mddev->sync_work);

drivers/md/md.c

5193

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

drivers/md/md.c

5194

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

drivers/md/md.c

5195

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

drivers/md/md.c

5198

mddev_lock_nointr(mddev);

drivers/md/md.c

520

mddev->noio_flag = memalloc_noio_save();

drivers/md/md.c

5201

void md_idle_sync_thread(struct mddev *mddev)

drivers/md/md.c

5203

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

5205

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5206

stop_sync_thread(mddev, true);

drivers/md/md.c

5210

void md_frozen_sync_thread(struct mddev *mddev)

drivers/md/md.c

5212

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

5214

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5215

stop_sync_thread(mddev, true);

drivers/md/md.c

5219

void md_unfrozen_sync_thread(struct mddev *mddev)

drivers/md/md.c

522

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

5221

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

5223

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5224

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

5225

md_wakeup_thread(mddev->thread);

drivers/md/md.c

5226

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

5230

static int mddev_start_reshape(struct mddev *mddev)

drivers/md/md.c

5234

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

drivers/md/md.c

5237

if (mddev->reshape_position == MaxSector ||

drivers/md/md.c

5238

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

drivers/md/md.c

5239

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

drivers/md/md.c

5240

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5241

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

drivers/md/md.c

5250

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5253

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

5258

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

drivers/md/md.c

5263

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

drivers/md/md.c

5267

if (work_busy(&mddev->sync_work))

drivers/md/md.c

5268

flush_work(&mddev->sync_work);

drivers/md/md.c

527

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

drivers/md/md.c

5270

ret = mddev_lock(mddev);

drivers/md/md.c

5274

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

drivers/md/md.c

5275

mddev_unlock(mddev);

drivers/md/md.c

5282

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

drivers/md/md.c

5285

md_frozen_sync_thread(mddev);

drivers/md/md.c

5289

md_idle_sync_thread(mddev);

drivers/md/md.c

529

lockdep_assert_not_held(&mddev->reconfig_mutex);

drivers/md/md.c

5305

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5309

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

531

mutex_lock(&mddev->suspend_mutex);

drivers/md/md.c

5310

ret = mddev_start_reshape(mddev);

drivers/md/md.c

5315

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

5316

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

5319

set_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/md.c

532

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

drivers/md/md.c

5322

set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);

drivers/md/md.c

5323

set_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/md.c

5327

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

533

if (mddev->suspended) {

drivers/md/md.c

5335

if (mddev->ro == MD_AUTO_READ) {

drivers/md/md.c

5339

mddev->ro = MD_RDWR;

drivers/md/md.c

534

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

5340

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

5343

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

5344

md_wakeup_thread(mddev->thread);

drivers/md/md.c

5345

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

5349

mddev_unlock(mddev);

drivers/md/md.c

5357

last_sync_action_show(struct mddev *mddev, char *page)

drivers/md/md.c

5360

md_sync_action_name(mddev->last_sync_action));

drivers/md/md.c

5366

mismatch_cnt_show(struct mddev *mddev, char *page)

drivers/md/md.c

5370

atomic64_read(&mddev->resync_mismatches));

drivers/md/md.c

5376

sync_min_show(struct mddev *mddev, char *page)

drivers/md/md.c

5378

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

drivers/md/md.c

5379

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

drivers/md/md.c

5383

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

drivers/md/md.c

539

memalloc_noio_restore(mddev->noio_flag);

drivers/md/md.c

5397

mddev->sync_speed_min = min;

drivers/md/md.c

5405

sync_max_show(struct mddev *mddev, char *page)

drivers/md/md.c

5407

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

drivers/md/md.c

5408

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

drivers/md/md.c

541

percpu_ref_resurrect(&mddev->active_io);

drivers/md/md.c

5412

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

drivers/md/md.c

542

wake_up(&mddev->sb_wait);

drivers/md/md.c

5426

mddev->sync_speed_max = max;

drivers/md/md.c

5434

sync_io_depth_show(struct mddev *mddev, char *page)

drivers/md/md.c

5436

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

drivers/md/md.c

5437

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

drivers/md/md.c

5441

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

drivers/md/md.c

545

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

5455

mddev->sync_io_depth = max;

drivers/md/md.c

546

md_wakeup_thread(mddev->thread);

drivers/md/md.c

5463

degraded_show(struct mddev *mddev, char *page)

drivers/md/md.c

5465

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

drivers/md/md.c

547

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

drivers/md/md.c

5470

sync_force_parallel_show(struct mddev *mddev, char *page)

drivers/md/md.c

5472

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

drivers/md/md.c

5476

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

drivers/md/md.c

5486

mddev->parallel_resync = n;

drivers/md/md.c

5488

if (mddev->sync_thread)

drivers/md/md.c

549

mutex_unlock(&mddev->suspend_mutex);

drivers/md/md.c

5500

sync_speed_show(struct mddev *mddev, char *page)

drivers/md/md.c

5503

if (mddev->curr_resync == MD_RESYNC_NONE)

drivers/md/md.c

5505

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

drivers/md/md.c

5506

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

drivers/md/md.c

5508

db = resync - mddev->resync_mark_cnt;

drivers/md/md.c

5515

sync_completed_show(struct mddev *mddev, char *page)

drivers/md/md.c

5519

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

drivers/md/md.c

552

void mddev_resume(struct mddev *mddev)

drivers/md/md.c

5522

if (mddev->curr_resync == MD_RESYNC_YIELDED ||

drivers/md/md.c

5523

mddev->curr_resync == MD_RESYNC_DELAYED)

drivers/md/md.c

5526

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

drivers/md/md.c

5527

test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))

drivers/md/md.c

5528

max_sectors = mddev->resync_max_sectors;

drivers/md/md.c

5530

max_sectors = mddev->dev_sectors;

drivers/md/md.c

5532

resync = mddev->curr_resync_completed;

drivers/md/md.c

554

return __mddev_resume(mddev, true);

drivers/md/md.c

5540

min_sync_show(struct mddev *mddev, char *page)

drivers/md/md.c

5543

(unsigned long long)mddev->resync_min);

drivers/md/md.c

5546

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

drivers/md/md.c

5554

spin_lock(&mddev->lock);

drivers/md/md.c

5556

if (min > mddev->resync_max)

drivers/md/md.c

5560

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

drivers/md/md.c

5564

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

drivers/md/md.c

5568

spin_unlock(&mddev->lock);

drivers/md/md.c

5576

max_sync_show(struct mddev *mddev, char *page)

drivers/md/md.c

5578

if (mddev->resync_max == MaxSector)

drivers/md/md.c

5582

(unsigned long long)mddev->resync_max);

drivers/md/md.c

5585

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

drivers/md/md.c

5588

spin_lock(&mddev->lock);

drivers/md/md.c

559

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

drivers/md/md.c

5590

mddev->resync_max = MaxSector;

drivers/md/md.c

5598

if (max < mddev->resync_min)

drivers/md/md.c

5602

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

drivers/md/md.c

5603

test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))

drivers/md/md.c

5607

chunk = mddev->chunk_sectors;

drivers/md/md.c

561

mutex_lock(&mddev->open_mutex);

drivers/md/md.c

5615

mddev->resync_max = max;

drivers/md/md.c

5617

wake_up(&mddev->recovery_wait);

drivers/md/md.c

562

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

drivers/md/md.c

5620

spin_unlock(&mddev->lock);

drivers/md/md.c

5628

suspend_lo_show(struct mddev *mddev, char *page)

drivers/md/md.c

563

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

5631

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

drivers/md/md.c

5635

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

drivers/md/md.c

5646

err = mddev_suspend(mddev, true);

drivers/md/md.c

5650

WRITE_ONCE(mddev->suspend_lo, new);

drivers/md/md.c

5651

mddev_resume(mddev);

drivers/md/md.c

5659

suspend_hi_show(struct mddev *mddev, char *page)

drivers/md/md.c

566

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

drivers/md/md.c

5662

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

drivers/md/md.c

5666

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

drivers/md/md.c

567

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

5677

err = mddev_suspend(mddev, true);

drivers/md/md.c

5681

WRITE_ONCE(mddev->suspend_hi, new);

drivers/md/md.c

5682

mddev_resume(mddev);

drivers/md/md.c

5690

reshape_position_show(struct mddev *mddev, char *page)

drivers/md/md.c

5692

if (mddev->reshape_position != MaxSector)

drivers/md/md.c

5694

(unsigned long long)mddev->reshape_position);

drivers/md/md.c

570

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

5700

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

drivers/md/md.c

5711

err = mddev_lock(mddev);

drivers/md/md.c

5715

if (mddev->pers)

drivers/md/md.c

5717

mddev->reshape_position = new;

drivers/md/md.c

5718

mddev->delta_disks = 0;

drivers/md/md.c

5719

mddev->reshape_backwards = 0;

drivers/md/md.c

572

sync_blockdev(mddev->gendisk->part0);

drivers/md/md.c

5720

mddev->new_level = mddev->level;

drivers/md/md.c

5721

mddev->new_layout = mddev->layout;

drivers/md/md.c

5722

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

5723

rdev_for_each(rdev, mddev)

drivers/md/md.c

5727

mddev_unlock(mddev);

drivers/md/md.c

5736

reshape_direction_show(struct mddev *mddev, char *page)

drivers/md/md.c

5739

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

drivers/md/md.c

5743

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

drivers/md/md.c

5754

if (mddev->reshape_backwards == backwards)

drivers/md/md.c

5757

err = mddev_lock(mddev);

drivers/md/md.c

5761

if (mddev->delta_disks)

drivers/md/md.c

5763

else if (mddev->persistent &&

drivers/md/md.c

5764

mddev->major_version == 0)

drivers/md/md.c

5767

mddev->reshape_backwards = backwards;

drivers/md/md.c

5768

mddev_unlock(mddev);

drivers/md/md.c

5777

array_size_show(struct mddev *mddev, char *page)

drivers/md/md.c

5779

if (mddev->external_size)

drivers/md/md.c

5781

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

drivers/md/md.c

5787

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

drivers/md/md.c

5792

err = mddev_lock(mddev);

drivers/md/md.c

5797

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

5798

mddev_unlock(mddev);

drivers/md/md.c

5803

if (mddev->pers)

drivers/md/md.c

5804

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

drivers/md/md.c

5806

sectors = mddev->array_sectors;

drivers/md/md.c

5808

mddev->external_size = 0;

drivers/md/md.c

5812

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

drivers/md/md.c

5815

mddev->external_size = 1;

drivers/md/md.c

5819

mddev->array_sectors = sectors;

drivers/md/md.c

5820

if (mddev->pers)

drivers/md/md.c

5821

set_capacity_and_notify(mddev->gendisk,

drivers/md/md.c

5822

mddev->array_sectors);

drivers/md/md.c

5824

mddev_unlock(mddev);

drivers/md/md.c

5833

consistency_policy_show(struct mddev *mddev, char *page)

drivers/md/md.c

5837

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

drivers/md/md.c

5839

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

drivers/md/md.c

5841

} else if (mddev->bitmap) {

drivers/md/md.c

5843

} else if (mddev->pers) {

drivers/md/md.c

5844

if (mddev->pers->sync_request)

drivers/md/md.c

5856

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

drivers/md/md.c

5860

if (mddev->pers) {

drivers/md/md.c

5861

if (mddev->pers->change_consistency_policy)

drivers/md/md.c

5862

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

drivers/md/md.c

5865

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

drivers/md/md.c

5866

set_bit(MD_HAS_PPL, &mddev->flags);

drivers/md/md.c

5878

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

drivers/md/md.c

5880

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

drivers/md/md.c

5888

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

drivers/md/md.c

5898

set_bit(MD_FAILLAST_DEV, &mddev->flags);

drivers/md/md.c

5900

clear_bit(MD_FAILLAST_DEV, &mddev->flags);

drivers/md/md.c

5908

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

drivers/md/md.c

5910

if (mddev->pers == NULL || (mddev->pers->head.id != ID_RAID1))

drivers/md/md.c

5914

test_bit(MD_SERIALIZE_POLICY, &mddev->flags));

drivers/md/md.c

5922

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

drivers/md/md.c

5931

if (value == test_bit(MD_SERIALIZE_POLICY, &mddev->flags))

drivers/md/md.c

5934

err = mddev_suspend_and_lock(mddev);

drivers/md/md.c

5937

if (mddev->pers == NULL || (mddev->pers->head.id != ID_RAID1)) {

drivers/md/md.c

5944

mddev_create_serial_pool(mddev, NULL);

drivers/md/md.c

5945

set_bit(MD_SERIALIZE_POLICY, &mddev->flags);

drivers/md/md.c

5947

mddev_destroy_serial_pool(mddev, NULL);

drivers/md/md.c

5948

clear_bit(MD_SERIALIZE_POLICY, &mddev->flags);

drivers/md/md.c

5951

mddev_unlock_and_resume(mddev);

drivers/md/md.c

5959

static int mddev_set_logical_block_size(struct mddev *mddev,

drivers/md/md.c

596

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

drivers/md/md.c

5965

if (queue_logical_block_size(mddev->gendisk->queue) >= lbs) {

drivers/md/md.c

5967

mdname(mddev), lbs);

drivers/md/md.c

5971

lim = queue_limits_start_update(mddev->gendisk->queue);

drivers/md/md.c

5974

mdname(mddev));

drivers/md/md.c

5975

err = queue_limits_commit_update(mddev->gendisk->queue, &lim);

drivers/md/md.c

5979

mddev->logical_block_size = lbs;

drivers/md/md.c

5981

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

5986

lbs_show(struct mddev *mddev, char *page)

drivers/md/md.c

5988

return sprintf(page, "%u\n", mddev->logical_block_size);

drivers/md/md.c

5992

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

drivers/md/md.c

5998

if (mddev->major_version == 0)

drivers/md/md.c

6005

if (mddev->pers) {

drivers/md/md.c

6008

if (mddev->logical_block_size)

drivers/md/md.c

6017

curr_lbs = queue_logical_block_size(mddev->gendisk->queue);

drivers/md/md.c

6021

mddev->logical_block_size = curr_lbs;

drivers/md/md.c

6022

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

6024

mdname(mddev));

drivers/md/md.c

6028

err = mddev_lock(mddev);

drivers/md/md.c

6032

err = mddev_set_logical_block_size(mddev, lbs);

drivers/md/md.c

6035

mddev_unlock(mddev);

drivers/md/md.c

606

WARN_ON(percpu_ref_is_zero(&mddev->active_io));

drivers/md/md.c

608

rdev_for_each(rdev, mddev) {

drivers/md/md.c

6095

struct mddev *mddev = container_of(kobj, struct mddev, kobj);

drivers/md/md.c

6101

if (!mddev_get(mddev)) {

drivers/md/md.c

6107

rv = entry->show(mddev, page);

drivers/md/md.c

6108

mddev_put(mddev);

drivers/md/md.c

6117

struct mddev *mddev = container_of(kobj, struct mddev, kobj);

drivers/md/md.c

6130

if (!mddev_get(mddev)) {

drivers/md/md.c

6137

rv = entry->store(mddev, page, length);

drivers/md/md.c

614

&mddev->bio_set);

drivers/md/md.c

6147

mddev_put(mddev);

drivers/md/md.c

6154

struct mddev *mddev = container_of(ko, struct mddev, kobj);

drivers/md/md.c

6157

if (mddev->sysfs_state)

drivers/md/md.c

6158

sysfs_put(mddev->sysfs_state);

drivers/md/md.c

6159

if (mddev->sysfs_level)

drivers/md/md.c

6160

sysfs_put(mddev->sysfs_level);

drivers/md/md.c

6161

del_gendisk(mddev->gendisk);

drivers/md/md.c

6163

put_disk(mddev->gendisk);

drivers/md/md.c

6179

int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,

drivers/md/md.c

6184

rdev_for_each(rdev, mddev) {

drivers/md/md.c

6186

mddev->gendisk->disk_name);

drivers/md/md.c

6198

mdname(mddev));

drivers/md/md.c

6203

if (mddev->major_version == 0)

drivers/md/md.c

6212

if (!mddev->events) {

drivers/md/md.c

6214

mdname(mddev));

drivers/md/md.c

6215

mddev->logical_block_size = lim->logical_block_size;

drivers/md/md.c

6218

if (!mddev->logical_block_size)

drivers/md/md.c

6221

mdname(mddev));

drivers/md/md.c

6228

int mddev_stack_new_rdev(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.c

6232

if (mddev_is_dm(mddev))

drivers/md/md.c

6236

queue_logical_block_size(mddev->gendisk->queue)) {

drivers/md/md.c

6238

mdname(mddev));

drivers/md/md.c

6242

lim = queue_limits_start_update(mddev->gendisk->queue);

drivers/md/md.c

6244

mddev->gendisk->disk_name);

drivers/md/md.c

6248

mdname(mddev), rdev->bdev);

drivers/md/md.c

6249

queue_limits_cancel_update(mddev->gendisk->queue);

drivers/md/md.c

6253

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

drivers/md/md.c

6258

void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes)

drivers/md/md.c

6262

if (mddev_is_dm(mddev))

drivers/md/md.c

6266

if (mddev_suspend(mddev, false) < 0)

drivers/md/md.c

6268

lim = queue_limits_start_update(mddev->gendisk->queue);

drivers/md/md.c

6270

queue_limits_commit_update(mddev->gendisk->queue, &lim);

drivers/md/md.c

6271

mddev_resume(mddev);

drivers/md/md.c

6277

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

drivers/md/md.c

6279

kobject_put(&mddev->kobj);

drivers/md/md.c

6290

struct mddev *md_alloc(dev_t dev, char *name)

drivers/md/md.c

6302

struct mddev *mddev;

drivers/md/md.c

631

static inline struct mddev *mddev_get(struct mddev *mddev)

drivers/md/md.c

6316

mddev = mddev_alloc(dev);

drivers/md/md.c

6317

if (IS_ERR(mddev)) {

drivers/md/md.c

6318

error = PTR_ERR(mddev);

drivers/md/md.c

6322

partitioned = (MAJOR(mddev->unit) != MD_MAJOR);

drivers/md/md.c

6324

unit = MINOR(mddev->unit) >> shift;

drivers/md/md.c

6329

struct mddev *mddev2;

drivers/md/md.c

6345

mddev->hold_active = UNTIL_STOP;

drivers/md/md.c

635

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

drivers/md/md.c

6353

disk->major = MAJOR(mddev->unit);

drivers/md/md.c

6363

disk->private_data = mddev;

drivers/md/md.c

6366

mddev->gendisk = disk;

drivers/md/md.c

637

atomic_inc(&mddev->active);

drivers/md/md.c

6371

kobject_init(&mddev->kobj, &md_ktype);

drivers/md/md.c

6372

error = kobject_add(&mddev->kobj, &disk_to_dev(disk)->kobj, "%s", "md");

drivers/md/md.c

6379

mddev->hold_active = 0;

drivers/md/md.c

638

return mddev;

drivers/md/md.c

6381

mddev_put(mddev);

drivers/md/md.c

6385

kobject_uevent(&mddev->kobj, KOBJ_ADD);

drivers/md/md.c

6386

mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");

drivers/md/md.c

6387

mddev->sysfs_level = sysfs_get_dirent_safe(mddev->kobj.sd, "level");

drivers/md/md.c

6389

return mddev;

drivers/md/md.c

6394

mddev_free(mddev);

drivers/md/md.c

6402

struct mddev *mddev = md_alloc(dev, name);

drivers/md/md.c

6407

if (IS_ERR(mddev))

drivers/md/md.c

6408

return PTR_ERR(mddev);

drivers/md/md.c

6409

mddev_put(mddev);

drivers/md/md.c

643

static void __mddev_put(struct mddev *mddev)

drivers/md/md.c

645

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

drivers/md/md.c

6452

struct mddev *mddev = timer_container_of(mddev, t, safemode_timer);

drivers/md/md.c

6454

mddev->safemode = 1;

drivers/md/md.c

6455

if (mddev->external)

drivers/md/md.c

6456

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

6458

md_wakeup_thread(mddev->thread);

drivers/md/md.c

646

mddev->ctime || mddev->hold_active)

drivers/md/md.c

6468

static enum md_submodule_id md_bitmap_get_id_from_sb(struct mddev *mddev)

drivers/md/md.c

6477

if (!mddev->bitmap_info.offset)

drivers/md/md.c

6483

mdname(mddev));

drivers/md/md.c

6487

sector = mddev->bitmap_info.offset;

drivers/md/md.c

6489

rdev_for_each(rdev, mddev) {

drivers/md/md.c

6504

mdname(mddev));

drivers/md/md.c

6511

mdname(mddev), le32_to_cpu(sb->magic));

drivers/md/md.c

6527

mdname(mddev), version);

drivers/md/md.c

6538

int md_bitmap_create_nosysfs(struct mddev *mddev)

drivers/md/md.c

654

set_bit(MD_DELETED, &mddev->flags);

drivers/md/md.c

6540

enum md_submodule_id orig_id = mddev->bitmap_id;

drivers/md/md.c

6544

if (mddev->bitmap_id == ID_BITMAP_NONE)

drivers/md/md.c

6547

if (!mddev_set_bitmap_ops_nosysfs(mddev)) {

drivers/md/md.c

6548

mddev->bitmap_id = orig_id;

drivers/md/md.c

6552

err = mddev->bitmap_ops->create(mddev);

drivers/md/md.c

6561

mddev->bitmap_ops = NULL;

drivers/md/md.c

6563

sb_id = md_bitmap_get_id_from_sb(mddev);

drivers/md/md.c

6565

mddev->bitmap_id = orig_id;

drivers/md/md.c

6570

mdname(mddev), orig_id, sb_id);

drivers/md/md.c

6572

mddev->bitmap_id = sb_id;

drivers/md/md.c

6573

if (!mddev_set_bitmap_ops_nosysfs(mddev)) {

drivers/md/md.c

6574

mddev->bitmap_id = orig_id;

drivers/md/md.c

6578

err = mddev->bitmap_ops->create(mddev);

drivers/md/md.c

6580

mddev->bitmap_ops = NULL;

drivers/md/md.c

6581

mddev->bitmap_id = orig_id;

drivers/md/md.c

6587

static int md_bitmap_create(struct mddev *mddev)

drivers/md/md.c

659

queue_work(md_misc_wq, &mddev->del_work);

drivers/md/md.c

6591

err = md_bitmap_create_nosysfs(mddev);

drivers/md/md.c

6595

if (!mddev_is_dm(mddev) && mddev->bitmap_ops->groups)

drivers/md/md.c

6596

md_bitmap_sysfs_add(mddev);

drivers/md/md.c

6601

void md_bitmap_destroy_nosysfs(struct mddev *mddev)

drivers/md/md.c

6603

if (!md_bitmap_registered(mddev))

drivers/md/md.c

6606

mddev->bitmap_ops->destroy(mddev);

drivers/md/md.c

6607

mddev->bitmap_ops = NULL;

drivers/md/md.c

6610

static void md_bitmap_destroy(struct mddev *mddev)

drivers/md/md.c

6612

if (!mddev_is_dm(mddev) && mddev->bitmap_ops &&

drivers/md/md.c

6613

mddev->bitmap_ops->groups)

drivers/md/md.c

6614

md_bitmap_sysfs_del(mddev);

drivers/md/md.c

6616

md_bitmap_destroy_nosysfs(mddev);

drivers/md/md.c

6619

static void md_bitmap_set_none(struct mddev *mddev)

drivers/md/md.c

662

static void mddev_put_locked(struct mddev *mddev)

drivers/md/md.c

6621

mddev->bitmap_id = ID_BITMAP_NONE;

drivers/md/md.c

6622

if (!mddev_set_bitmap_ops_nosysfs(mddev))

drivers/md/md.c

6625

if (!mddev_is_dm(mddev) && mddev->bitmap_ops->groups)

drivers/md/md.c

6626

md_bitmap_sysfs_add(mddev);

drivers/md/md.c

6629

int md_run(struct mddev *mddev)

drivers/md/md.c

6636

if (list_empty(&mddev->disks))

drivers/md/md.c

664

if (atomic_dec_and_test(&mddev->active))

drivers/md/md.c

6640

if (mddev->pers)

drivers/md/md.c

6643

if (mddev->sysfs_active)

drivers/md/md.c

6649

if (!mddev->raid_disks) {

drivers/md/md.c

665

__mddev_put(mddev);

drivers/md/md.c

6650

if (!mddev->persistent)

drivers/md/md.c

6652

err = analyze_sbs(mddev);

drivers/md/md.c

6657

if (mddev->level != LEVEL_NONE)

drivers/md/md.c

6658

request_module("md-level-%d", mddev->level);

drivers/md/md.c

6659

else if (mddev->clevel[0])

drivers/md/md.c

6660

request_module("md-%s", mddev->clevel);

drivers/md/md.c

6667

clear_bit(MD_HAS_SUPERBLOCK, &mddev->flags);

drivers/md/md.c

6668

rdev_for_each(rdev, mddev) {

drivers/md/md.c

6673

if (mddev->ro != MD_RDONLY && rdev_read_only(rdev)) {

drivers/md/md.c

6674

mddev->ro = MD_RDONLY;

drivers/md/md.c

6675

if (!mddev_is_dm(mddev))

drivers/md/md.c

6676

set_disk_ro(mddev->gendisk, 1);

drivers/md/md.c

668

void mddev_put(struct mddev *mddev)

drivers/md/md.c

6680

set_bit(MD_HAS_SUPERBLOCK, &mddev->flags);

drivers/md/md.c

6689

if (mddev->dev_sectors &&

drivers/md/md.c

6690

rdev->data_offset + mddev->dev_sectors

drivers/md/md.c

6693

mdname(mddev));

drivers/md/md.c

670

if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))

drivers/md/md.c

6700

mdname(mddev));

drivers/md/md.c

6708

pers = get_pers(mddev->level, mddev->clevel);

drivers/md/md.c

6711

if (mddev->level != pers->head.id) {

drivers/md/md.c

6712

mddev->level = pers->head.id;

drivers/md/md.c

6713

mddev->new_level = pers->head.id;

drivers/md/md.c

6715

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

drivers/md/md.c

6717

if (mddev->reshape_position != MaxSector &&

drivers/md/md.c

673

__mddev_put(mddev);

drivers/md/md.c

6731

rdev_for_each(rdev, mddev)

drivers/md/md.c

6732

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

6737

mdname(mddev),

drivers/md/md.c

6749

if (!mddev_is_dm(mddev))

drivers/md/md.c

6750

mddev->recovery = 0;

drivers/md/md.c

6753

mddev->resync_max_sectors = mddev->dev_sectors;

drivers/md/md.c

6755

mddev->ok_start_degraded = start_dirty_degraded;

drivers/md/md.c

6757

if (start_readonly && md_is_rdwr(mddev))

drivers/md/md.c

6758

mddev->ro = MD_AUTO_READ; /* read-only, but switch on first write */

drivers/md/md.c

6760

err = pers->run(mddev);

drivers/md/md.c

6763

else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {

drivers/md/md.c

6764

WARN_ONCE(!mddev->external_size,

drivers/md/md.c

6768

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

drivers/md/md.c

6769

(unsigned long long)pers->size(mddev, 0, 0) / 2);

drivers/md/md.c

6773

(mddev->bitmap_info.file || mddev->bitmap_info.offset)) {

drivers/md/md.c

6774

err = md_bitmap_create(mddev);

drivers/md/md.c

6777

mdname(mddev), err);

drivers/md/md.c

6782

if (mddev->bitmap_info.max_write_behind > 0) {

drivers/md/md.c

6785

rdev_for_each(rdev, mddev) {

drivers/md/md.c

6790

if (create_pool && mddev->serial_info_pool == NULL) {

drivers/md/md.c

6791

mddev->serial_info_pool =

drivers/md/md.c

6794

if (!mddev->serial_info_pool) {

drivers/md/md.c

6802

if (mddev->kobj.sd &&

drivers/md/md.c

6803

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

drivers/md/md.c

6805

mdname(mddev));

drivers/md/md.c

6806

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

drivers/md/md.c

6807

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

drivers/md/md.c

6808

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

drivers/md/md.c

6809

} else if (mddev->ro == MD_AUTO_READ)

drivers/md/md.c

6810

mddev->ro = MD_RDWR;

drivers/md/md.c

6812

atomic_set(&mddev->max_corr_read_errors,

drivers/md/md.c

6814

mddev->safemode = 0;

drivers/md/md.c

6815

if (mddev_is_clustered(mddev))

drivers/md/md.c

6816

mddev->safemode_delay = 0;

drivers/md/md.c

6818

mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;

drivers/md/md.c

6819

mddev->in_sync = 1;

drivers/md/md.c

682

struct mddev *mddev = container_of(ref, struct mddev, active_io);

drivers/md/md.c

6821

spin_lock(&mddev->lock);

drivers/md/md.c

6822

mddev->pers = pers;

drivers/md/md.c

6823

spin_unlock(&mddev->lock);

drivers/md/md.c

6824

rdev_for_each(rdev, mddev)

drivers/md/md.c

6826

sysfs_link_rdev(mddev, rdev); /* failure here is OK */

drivers/md/md.c

6828

if (mddev->degraded && md_is_rdwr(mddev))

drivers/md/md.c

6832

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

6833

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

6835

if (mddev->sb_flags)

drivers/md/md.c

6836

md_update_sb(mddev, 0);

drivers/md/md.c

6838

if (IS_ENABLED(CONFIG_MD_BITMAP) && !mddev->bitmap_info.file &&

drivers/md/md.c

6839

!mddev->bitmap_info.offset)

drivers/md/md.c

684

wake_up(&mddev->sb_wait);

drivers/md/md.c

6840

md_bitmap_set_none(mddev);

drivers/md/md.c

6846

mddev_detach(mddev);

drivers/md/md.c

6847

if (mddev->private)

drivers/md/md.c

6848

pers->free(mddev, mddev->private);

drivers/md/md.c

6849

mddev->private = NULL;

drivers/md/md.c

6851

md_bitmap_destroy(mddev);

drivers/md/md.c

6856

int do_md_run(struct mddev *mddev)

drivers/md/md.c

6860

set_bit(MD_NOT_READY, &mddev->flags);

drivers/md/md.c

6861

err = md_run(mddev);

drivers/md/md.c

6865

if (md_bitmap_registered(mddev)) {

drivers/md/md.c

6866

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

drivers/md/md.c

6868

md_bitmap_destroy(mddev);

drivers/md/md.c

6873

if (mddev_is_clustered(mddev))

drivers/md/md.c

6874

md_allow_write(mddev);

drivers/md/md.c

6877

md_start(mddev);

drivers/md/md.c

6879

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

drivers/md/md.c

6881

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

drivers/md/md.c

6882

clear_bit(MD_NOT_READY, &mddev->flags);

drivers/md/md.c

6883

mddev->changed = 1;

drivers/md/md.c

6884

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

drivers/md/md.c

6885

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

6886

sysfs_notify_dirent_safe(mddev->sysfs_action);

drivers/md/md.c

6887

sysfs_notify_dirent_safe(mddev->sysfs_degraded);

drivers/md/md.c

6889

clear_bit(MD_NOT_READY, &mddev->flags);

drivers/md/md.c

689

static void md_bitmap_sysfs_add(struct mddev *mddev)

drivers/md/md.c

6893

int md_start(struct mddev *mddev)

drivers/md/md.c

6897

if (mddev->pers->start) {

drivers/md/md.c

6898

set_bit(MD_RECOVERY_WAIT, &mddev->recovery);

drivers/md/md.c

6899

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

drivers/md/md.c

6900

clear_bit(MD_RECOVERY_WAIT, &mddev->recovery);

drivers/md/md.c

6901

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

6907

static int restart_array(struct mddev *mddev)

drivers/md/md.c

6909

struct gendisk *disk = mddev->gendisk;

drivers/md/md.c

691

if (sysfs_update_groups(&mddev->kobj, mddev->bitmap_ops->groups))

drivers/md/md.c

6915

if (list_empty(&mddev->disks))

drivers/md/md.c

6917

if (!mddev->pers)

drivers/md/md.c

6919

if (md_is_rdwr(mddev))

drivers/md/md.c

6923

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

693

mdname(mddev));

drivers/md/md.c

6931

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

drivers/md/md.c

6937

mddev->safemode = 0;

drivers/md/md.c

6938

mddev->ro = MD_RDWR;

drivers/md/md.c

6940

pr_debug("md: %s switched to read-write mode.\n", mdname(mddev));

drivers/md/md.c

6942

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

6943

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

6944

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

6948

static void md_clean(struct mddev *mddev)

drivers/md/md.c

6950

mddev->array_sectors = 0;

drivers/md/md.c

6951

mddev->external_size = 0;

drivers/md/md.c

6952

mddev->dev_sectors = 0;

drivers/md/md.c

6953

mddev->raid_disks = 0;

drivers/md/md.c

6954

mddev->resync_offset = 0;

drivers/md/md.c

6955

mddev->resync_min = 0;

drivers/md/md.c

6956

mddev->resync_max = MaxSector;

drivers/md/md.c

6957

mddev->reshape_position = MaxSector;

drivers/md/md.c

6959

mddev->persistent = 0;

drivers/md/md.c

6960

mddev->level = LEVEL_NONE;

drivers/md/md.c

6961

mddev->clevel[0] = 0;

drivers/md/md.c

6970

if (legacy_async_del_gendisk && mddev->hold_active) {

drivers/md/md.c

6971

clear_bit(MD_CLOSING, &mddev->flags);

drivers/md/md.c

6974

mddev->hold_active = 0;

drivers/md/md.c

6976

mddev->flags &= BIT_ULL_MASK(MD_CLOSING);

drivers/md/md.c

6978

mddev->sb_flags = 0;

drivers/md/md.c

6979

mddev->ro = MD_RDWR;

drivers/md/md.c

6980

mddev->metadata_type[0] = 0;

drivers/md/md.c

6981

mddev->chunk_sectors = 0;

drivers/md/md.c

6982

mddev->ctime = mddev->utime = 0;

drivers/md/md.c

6983

mddev->layout = 0;

drivers/md/md.c

6984

mddev->logical_block_size = 0;

drivers/md/md.c

6985

mddev->max_disks = 0;

drivers/md/md.c

6986

mddev->events = 0;

drivers/md/md.c

6987

mddev->can_decrease_events = 0;

drivers/md/md.c

6988

mddev->delta_disks = 0;

drivers/md/md.c

6989

mddev->reshape_backwards = 0;

drivers/md/md.c

699

kobject_uevent(&mddev->kobj, KOBJ_CHANGE);

drivers/md/md.c

6990

mddev->new_level = LEVEL_NONE;

drivers/md/md.c

6991

mddev->new_layout = 0;

drivers/md/md.c

6992

mddev->new_chunk_sectors = 0;

drivers/md/md.c

6993

mddev->curr_resync = MD_RESYNC_NONE;

drivers/md/md.c

6994

atomic64_set(&mddev->resync_mismatches, 0);

drivers/md/md.c

6995

mddev->suspend_lo = mddev->suspend_hi = 0;

drivers/md/md.c

6996

mddev->sync_speed_min = mddev->sync_speed_max = 0;

drivers/md/md.c

6997

mddev->recovery = 0;

drivers/md/md.c

6998

mddev->in_sync = 0;

drivers/md/md.c

6999

mddev->changed = 0;

drivers/md/md.c

7000

mddev->degraded = 0;

drivers/md/md.c

7001

mddev->safemode = 0;

drivers/md/md.c

7002

mddev->private = NULL;

drivers/md/md.c

7003

mddev->cluster_info = NULL;

drivers/md/md.c

7004

mddev->bitmap_info.offset = 0;

drivers/md/md.c

7005

mddev->bitmap_info.default_offset = 0;

drivers/md/md.c

7006

mddev->bitmap_info.default_space = 0;

drivers/md/md.c

7007

mddev->bitmap_info.chunksize = 0;

drivers/md/md.c

7008

mddev->bitmap_info.daemon_sleep = 0;

drivers/md/md.c

7009

mddev->bitmap_info.max_write_behind = 0;

drivers/md/md.c

7010

mddev->bitmap_info.nodes = 0;

drivers/md/md.c

7013

static void __md_stop_writes(struct mddev *mddev)

drivers/md/md.c

7015

timer_delete_sync(&mddev->safemode_timer);

drivers/md/md.c

7017

if (md_is_rdwr(mddev) || !mddev_is_dm(mddev)) {

drivers/md/md.c

7018

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

drivers/md/md.c

7019

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

drivers/md/md.c

702

static void md_bitmap_sysfs_del(struct mddev *mddev)

drivers/md/md.c

7020

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

drivers/md/md.c

7023

if (md_bitmap_enabled(mddev, true))

drivers/md/md.c

7024

mddev->bitmap_ops->flush(mddev);

drivers/md/md.c

7027

if (md_is_rdwr(mddev) &&

drivers/md/md.c

7028

((!mddev->in_sync && !mddev_is_clustered(mddev)) ||

drivers/md/md.c

7029

mddev->sb_flags)) {

drivers/md/md.c

7031

if (!mddev_is_clustered(mddev))

drivers/md/md.c

7032

mddev->in_sync = 1;

drivers/md/md.c

7033

md_update_sb(mddev, 1);

drivers/md/md.c

7036

clear_bit(MD_SERIALIZE_POLICY, &mddev->flags);

drivers/md/md.c

7037

mddev_destroy_serial_pool(mddev, NULL);

drivers/md/md.c

7040

void md_stop_writes(struct mddev *mddev)

drivers/md/md.c

7042

mddev_lock_nointr(mddev);

drivers/md/md.c

7043

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

7044

stop_sync_thread(mddev, true);

drivers/md/md.c

7045

__md_stop_writes(mddev);

drivers/md/md.c

7046

mddev_unlock(mddev);

drivers/md/md.c

7050

static void mddev_detach(struct mddev *mddev)

drivers/md/md.c

7052

if (md_bitmap_enabled(mddev, false))

drivers/md/md.c

7053

mddev->bitmap_ops->wait_behind_writes(mddev, false);

drivers/md/md.c

7054

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

drivers/md/md.c

7055

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

drivers/md/md.c

7056

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

drivers/md/md.c

7058

md_unregister_thread(mddev, &mddev->thread);

drivers/md/md.c

706

for (nr_groups = 0; mddev->bitmap_ops->groups[nr_groups]; nr_groups++)

drivers/md/md.c

7061

if (!mddev_is_dm(mddev))

drivers/md/md.c

7062

blk_sync_queue(mddev->gendisk->queue);

drivers/md/md.c

7065

static void __md_stop(struct mddev *mddev)

drivers/md/md.c

7067

struct md_personality *pers = mddev->pers;

drivers/md/md.c

7069

md_bitmap_destroy(mddev);

drivers/md/md.c

7070

mddev_detach(mddev);

drivers/md/md.c

7071

spin_lock(&mddev->lock);

drivers/md/md.c

7072

mddev->pers = NULL;

drivers/md/md.c

7073

spin_unlock(&mddev->lock);

drivers/md/md.c

7074

if (mddev->private)

drivers/md/md.c

7075

pers->free(mddev, mddev->private);

drivers/md/md.c

7076

mddev->private = NULL;

drivers/md/md.c

7078

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

7081

void md_stop(struct mddev *mddev)

drivers/md/md.c

7083

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

7088

__md_stop_writes(mddev);

drivers/md/md.c

7089

__md_stop(mddev);

drivers/md/md.c

7095

static int md_set_readonly(struct mddev *mddev)

drivers/md/md.c

710

sysfs_unmerge_group(&mddev->kobj,

drivers/md/md.c

7100

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

drivers/md/md.c

7103

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

drivers/md/md.c

7105

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

7108

stop_sync_thread(mddev, false);

drivers/md/md.c

7109

wait_event(mddev->sb_wait,

drivers/md/md.c

711

mddev->bitmap_ops->groups[nr_groups]);

drivers/md/md.c

7110

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/md.c

7111

mddev_lock_nointr(mddev);

drivers/md/md.c

7113

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

drivers/md/md.c

7114

pr_warn("md: %s still in use.\n",mdname(mddev));

drivers/md/md.c

7119

__md_stop_writes(mddev);

drivers/md/md.c

712

sysfs_remove_group(&mddev->kobj, mddev->bitmap_ops->groups[0]);

drivers/md/md.c

7121

if (mddev->ro == MD_RDONLY) {

drivers/md/md.c

7126

mddev->ro = MD_RDONLY;

drivers/md/md.c

7127

set_disk_ro(mddev->gendisk, 1);

drivers/md/md.c

7131

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

7132

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

7133

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

7143

static int do_md_stop(struct mddev *mddev, int mode)

drivers/md/md.c

7145

struct gendisk *disk = mddev->gendisk;

drivers/md/md.c

7149

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

drivers/md/md.c

715

bool mddev_set_bitmap_ops_nosysfs(struct mddev *mddev)

drivers/md/md.c

7151

set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

7154

stop_sync_thread(mddev, true);

drivers/md/md.c

7156

if (mddev->sysfs_active ||

drivers/md/md.c

7157

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

drivers/md/md.c

7158

pr_warn("md: %s still in use.\n",mdname(mddev));

drivers/md/md.c

7160

clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);

drivers/md/md.c

7161

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

7165

if (mddev->pers) {

drivers/md/md.c

7166

if (!md_is_rdwr(mddev))

drivers/md/md.c

7169

if (mode == 2 && mddev->pers->sync_request &&

drivers/md/md.c

7170

mddev->to_remove == NULL)

drivers/md/md.c

7171

mddev->to_remove = &md_redundancy_group;

drivers/md/md.c

7173

__md_stop_writes(mddev);

drivers/md/md.c

7174

__md_stop(mddev);

drivers/md/md.c

7177

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

7179

rdev_for_each(rdev, mddev)

drivers/md/md.c

7181

sysfs_unlink_rdev(mddev, rdev);

drivers/md/md.c

7184

mddev->changed = 1;

drivers/md/md.c

7186

if (!md_is_rdwr(mddev))

drivers/md/md.c

7187

mddev->ro = MD_RDWR;

drivers/md/md.c

719

if (mddev->bitmap_ops &&

drivers/md/md.c

7193

pr_info("md: %s stopped.\n", mdname(mddev));

drivers/md/md.c

7195

if (mddev->bitmap_info.file) {

drivers/md/md.c

7196

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

drivers/md/md.c

7197

spin_lock(&mddev->lock);

drivers/md/md.c

7198

mddev->bitmap_info.file = NULL;

drivers/md/md.c

7199

spin_unlock(&mddev->lock);

drivers/md/md.c

720

mddev->bitmap_ops->head.id == mddev->bitmap_id)

drivers/md/md.c

7202

mddev->bitmap_info.offset = 0;

drivers/md/md.c

7204

export_array(mddev);

drivers/md/md.c

7205

md_clean(mddev);

drivers/md/md.c

7207

set_bit(MD_DELETED, &mddev->flags);

drivers/md/md.c

7210

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

7215

static void autorun_array(struct mddev *mddev)

drivers/md/md.c

7220

if (list_empty(&mddev->disks))

drivers/md/md.c

7225

rdev_for_each(rdev, mddev) {

drivers/md/md.c

7230

err = do_md_run(mddev);

drivers/md/md.c

7233

do_md_stop(mddev, 0);

drivers/md/md.c

724

head = xa_load(&md_submodule, mddev->bitmap_id);

drivers/md/md.c

7252

struct mddev *mddev;

drivers/md/md.c

727

pr_warn("md: can't find bitmap id %d\n", mddev->bitmap_id);

drivers/md/md.c

7289

mddev = md_alloc(dev, NULL);

drivers/md/md.c

7290

if (IS_ERR(mddev))

drivers/md/md.c

7293

if (mddev_suspend_and_lock(mddev))

drivers/md/md.c

7294

pr_warn("md: %s locked, cannot run\n", mdname(mddev));

drivers/md/md.c

7295

else if (mddev->raid_disks || mddev->major_version

drivers/md/md.c

7296

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

drivers/md/md.c

7298

mdname(mddev), rdev0->bdev);

drivers/md/md.c

7299

mddev_unlock_and_resume(mddev);

drivers/md/md.c

7301

pr_debug("md: created %s\n", mdname(mddev));

drivers/md/md.c

7302

mddev->persistent = 1;

drivers/md/md.c

7305

if (bind_rdev_to_array(rdev, mddev))

drivers/md/md.c

7308

autorun_array(mddev);

drivers/md/md.c

7309

mddev_unlock_and_resume(mddev);

drivers/md/md.c

7318

mddev_put(mddev);

drivers/md/md.c

732

pr_warn("md: invalid bitmap id %d\n", mddev->bitmap_id);

drivers/md/md.c

7338

static int get_array_info(struct mddev *mddev, void __user *arg)

drivers/md/md.c

7346

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

736

mddev->bitmap_ops = (void *)head;

drivers/md/md.c

7363

info.major_version = mddev->major_version;

drivers/md/md.c

7364

info.minor_version = mddev->minor_version;

drivers/md/md.c

7366

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

drivers/md/md.c

7367

info.level = mddev->level;

drivers/md/md.c

7368

info.size = mddev->dev_sectors / 2;

drivers/md/md.c

7369

if (info.size != mddev->dev_sectors / 2) /* overflow */

drivers/md/md.c

7372

info.raid_disks = mddev->raid_disks;

drivers/md/md.c

7373

info.md_minor = mddev->md_minor;

drivers/md/md.c

7374

info.not_persistent= !mddev->persistent;

drivers/md/md.c

7376

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

drivers/md/md.c

7378

if (mddev->in_sync)

drivers/md/md.c

7380

if (mddev->bitmap && mddev->bitmap_info.offset)

drivers/md/md.c

7382

if (mddev_is_clustered(mddev))

drivers/md/md.c

7389

info.layout = mddev->layout;

drivers/md/md.c

7390

info.chunk_size = mddev->chunk_sectors << 9;

drivers/md/md.c

7398

static int get_bitmap_file(struct mddev *mddev, void __user * arg)

drivers/md/md.c

7409

spin_lock(&mddev->lock);

drivers/md/md.c

7411

if (mddev->bitmap_info.file) {

drivers/md/md.c

7412

ptr = file_path(mddev->bitmap_info.file, file->pathname,

drivers/md/md.c

7420

spin_unlock(&mddev->lock);

drivers/md/md.c

7430

static int get_disk_info(struct mddev *mddev, void __user * arg)

drivers/md/md.c

7439

rdev = md_find_rdev_nr_rcu(mddev, info.number);

drivers/md/md.c

745

int mddev_init(struct mddev *mddev)

drivers/md/md.c

7470

int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info)

drivers/md/md.c

7475

if (mddev_is_clustered(mddev) &&

drivers/md/md.c

7478

mdname(mddev));

drivers/md/md.c

7485

if (!mddev->raid_disks) {

drivers/md/md.c

7488

rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);

drivers/md/md.c

7494

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

drivers/md/md.c

7496

= list_entry(mddev->disks.next,

drivers/md/md.c

7498

err = super_types[mddev->major_version]

drivers/md/md.c

7499

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

drivers/md/md.c

750

mddev->bitmap_id = ID_BITMAP_NONE;

drivers/md/md.c

7508

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

7519

if (mddev->pers) {

drivers/md/md.c

752

mddev->bitmap_id = ID_BITMAP;

drivers/md/md.c

7521

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

drivers/md/md.c

7523

mdname(mddev));

drivers/md/md.c

7526

if (mddev->persistent)

drivers/md/md.c

7527

rdev = md_import_device(dev, mddev->major_version,

drivers/md/md.c

7528

mddev->minor_version);

drivers/md/md.c

7537

if (!mddev->persistent) {

drivers/md/md.c

7539

info->raid_disk < mddev->raid_disks) {

drivers/md/md.c

754

if (percpu_ref_init(&mddev->active_io, active_io_release,

drivers/md/md.c

7546

super_types[mddev->major_version].

drivers/md/md.c

7547

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

drivers/md/md.c

7572

rdev_for_each(rdev2, mddev) {

drivers/md/md.c

7578

if (has_journal || mddev->bitmap) {

drivers/md/md.c

758

if (percpu_ref_init(&mddev->writes_pending, no_op,

drivers/md/md.c

7587

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

7592

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

drivers/md/md.c

7601

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

7606

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

7609

err = mddev->cluster_ops->new_disk_ack(

drivers/md/md.c

7610

mddev, err == 0);

drivers/md/md.c

7616

mddev->cluster_ops->add_new_disk_cancel(mddev);

drivers/md/md.c

7630

if (mddev->major_version != 0) {

drivers/md/md.c

7631

pr_warn("%s: ADD_NEW_DISK not supported\n", mdname(mddev));

drivers/md/md.c

764

err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);

drivers/md/md.c

7644

if (info->raid_disk < mddev->raid_disks)

drivers/md/md.c

7649

if (rdev->raid_disk < mddev->raid_disks)

drivers/md/md.c

7658

if (!mddev->persistent) {

drivers/md/md.c

7665

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

7675

static int hot_remove_disk(struct mddev *mddev, dev_t dev)

drivers/md/md.c

7679

if (!mddev->pers)

drivers/md/md.c

768

err = bioset_init(&mddev->sync_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);

drivers/md/md.c

7682

rdev = find_rdev(mddev, dev);

drivers/md/md.c

7690

remove_and_add_spares(mddev, rdev);

drivers/md/md.c

7696

if (mddev_is_clustered(mddev) &&

drivers/md/md.c

7697

mddev->cluster_ops->remove_disk(mddev, rdev))

drivers/md/md.c

7701

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

7702

if (!mddev->thread)

drivers/md/md.c

7703

md_update_sb(mddev, 1);

drivers/md/md.c

7709

rdev->bdev, mdname(mddev));

drivers/md/md.c

7713

static int hot_add_disk(struct mddev *mddev, dev_t dev)

drivers/md/md.c

7718

if (!mddev->pers)

drivers/md/md.c

772

err = bioset_init(&mddev->io_clone_set, BIO_POOL_SIZE,

drivers/md/md.c

7721

if (mddev->major_version != 0) {

drivers/md/md.c

7723

mdname(mddev));

drivers/md/md.c

7726

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

drivers/md/md.c

7728

mdname(mddev));

drivers/md/md.c

7739

if (mddev->persistent)

drivers/md/md.c

7748

rdev->bdev, mdname(mddev));

drivers/md/md.c

7756

err = bind_rdev_to_array(rdev, mddev);

drivers/md/md.c

7767

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

7768

if (!mddev->thread)

drivers/md/md.c

7769

md_update_sb(mddev, 1);

drivers/md/md.c

7774

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

778

percpu_ref_put(&mddev->writes_pending);

drivers/md/md.c

7783

static int set_bitmap_file(struct mddev *mddev, int fd)

drivers/md/md.c

7787

if (!md_bitmap_registered(mddev) ||

drivers/md/md.c

7788

mddev->bitmap_id == ID_BITMAP_NONE)

drivers/md/md.c

7791

if (mddev->pers) {

drivers/md/md.c

7792

if (!mddev->pers->quiesce || !mddev->thread)

drivers/md/md.c

7794

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

drivers/md/md.c

780

mutex_init(&mddev->open_mutex);

drivers/md/md.c

7803

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

drivers/md/md.c

7808

mdname(mddev));

drivers/md/md.c

781

mutex_init(&mddev->reconfig_mutex);

drivers/md/md.c

7812

mdname(mddev));

drivers/md/md.c

7818

mdname(mddev));

drivers/md/md.c

782

mutex_init(&mddev->suspend_mutex);

drivers/md/md.c

7825

mdname(mddev));

drivers/md/md.c

7829

mdname(mddev));

drivers/md/md.c

783

mutex_init(&mddev->bitmap_info.mutex);

drivers/md/md.c

7833

mdname(mddev));

drivers/md/md.c

784

INIT_LIST_HEAD(&mddev->disks);

drivers/md/md.c

7840

mddev->bitmap_info.file = f;

drivers/md/md.c

7841

mddev->bitmap_info.offset = 0; /* file overrides offset */

drivers/md/md.c

7842

} else if (mddev->bitmap == NULL)

drivers/md/md.c

7845

if (mddev->pers) {

drivers/md/md.c

7847

err = md_bitmap_create(mddev);

drivers/md/md.c

7849

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

drivers/md/md.c

785

INIT_LIST_HEAD(&mddev->all_mddevs);

drivers/md/md.c

7852

md_bitmap_destroy(mddev);

drivers/md/md.c

7853

md_bitmap_set_none(mddev);

drivers/md/md.c

7857

md_bitmap_destroy(mddev);

drivers/md/md.c

7858

md_bitmap_set_none(mddev);

drivers/md/md.c

786

INIT_LIST_HEAD(&mddev->deleting);

drivers/md/md.c

7863

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

drivers/md/md.c

7865

spin_lock(&mddev->lock);

drivers/md/md.c

7866

mddev->bitmap_info.file = NULL;

drivers/md/md.c

7867

spin_unlock(&mddev->lock);

drivers/md/md.c

787

timer_setup(&mddev->safemode_timer, md_safemode_timeout, 0);

drivers/md/md.c

788

atomic_set(&mddev->active, 1);

drivers/md/md.c

7888

int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info)

drivers/md/md.c

789

atomic_set(&mddev->openers, 0);

drivers/md/md.c

790

atomic_set(&mddev->sync_seq, 0);

drivers/md/md.c

7900

mddev->major_version = info->major_version;

drivers/md/md.c

7901

mddev->minor_version = info->minor_version;

drivers/md/md.c

7902

mddev->patch_version = info->patch_version;

drivers/md/md.c

7903

mddev->persistent = !info->not_persistent;

drivers/md/md.c

7907

mddev->ctime = ktime_get_real_seconds();

drivers/md/md.c

791

spin_lock_init(&mddev->lock);

drivers/md/md.c

7910

mddev->major_version = MD_MAJOR_VERSION;

drivers/md/md.c

7911

mddev->minor_version = MD_MINOR_VERSION;

drivers/md/md.c

7912

mddev->patch_version = MD_PATCHLEVEL_VERSION;

drivers/md/md.c

7913

mddev->ctime = ktime_get_real_seconds();

drivers/md/md.c

7915

mddev->level = info->level;

drivers/md/md.c

7916

mddev->clevel[0] = 0;

drivers/md/md.c

7917

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

drivers/md/md.c

7918

mddev->raid_disks = info->raid_disks;

drivers/md/md.c

792

init_waitqueue_head(&mddev->sb_wait);

drivers/md/md.c

7923

mddev->resync_offset = MaxSector;

drivers/md/md.c

7925

mddev->resync_offset = 0;

drivers/md/md.c

7926

mddev->persistent = ! info->not_persistent;

drivers/md/md.c

7927

mddev->external = 0;

drivers/md/md.c

7929

mddev->layout = info->layout;

drivers/md/md.c

793

init_waitqueue_head(&mddev->recovery_wait);

drivers/md/md.c

7930

if (mddev->level == 0)

drivers/md/md.c

7932

mddev->layout = -1;

drivers/md/md.c

7933

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

drivers/md/md.c

7935

if (mddev->persistent) {

drivers/md/md.c

7936

mddev->max_disks = MD_SB_DISKS;

drivers/md/md.c

7937

mddev->flags = 0;

drivers/md/md.c

7938

mddev->sb_flags = 0;

drivers/md/md.c

794

mddev->reshape_position = MaxSector;

drivers/md/md.c

7940

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/md.c

7942

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

drivers/md/md.c

7943

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

drivers/md/md.c

7944

mddev->bitmap_info.offset = 0;

drivers/md/md.c

7946

mddev->reshape_position = MaxSector;

drivers/md/md.c

795

mddev->reshape_backwards = 0;

drivers/md/md.c

7951

get_random_bytes(mddev->uuid, 16);

drivers/md/md.c

7953

mddev->new_level = mddev->level;

drivers/md/md.c

7954

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/md.c

7955

mddev->new_layout = mddev->layout;

drivers/md/md.c

7956

mddev->delta_disks = 0;

drivers/md/md.c

7957

mddev->reshape_backwards = 0;

drivers/md/md.c

796

mddev->last_sync_action = ACTION_IDLE;

drivers/md/md.c

7962

void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)

drivers/md/md.c

7964

lockdep_assert_held(&mddev->reconfig_mutex);

drivers/md/md.c

7966

if (mddev->external_size)

drivers/md/md.c

7969

mddev->array_sectors = array_sectors;

drivers/md/md.c

797

mddev->resync_min = 0;

drivers/md/md.c

7973

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

drivers/md/md.c

7978

sector_t old_dev_sectors = mddev->dev_sectors;

drivers/md/md.c

798

mddev->resync_max = MaxSector;

drivers/md/md.c

7980

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

drivers/md/md.c

799

mddev->level = LEVEL_NONE;

drivers/md/md.c

7991

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

drivers/md/md.c

7993

if (!md_is_rdwr(mddev))

drivers/md/md.c

7996

rdev_for_each(rdev, mddev) {

drivers/md/md.c

8004

rv = mddev->pers->resize(mddev, num_sectors);

drivers/md/md.c

8006

if (mddev_is_clustered(mddev))

drivers/md/md.c

8007

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

drivers/md/md.c

8008

else if (!mddev_is_dm(mddev))

drivers/md/md.c

8009

set_capacity_and_notify(mddev->gendisk,

drivers/md/md.c

801

INIT_WORK(&mddev->sync_work, md_start_sync);

drivers/md/md.c

8010

mddev->array_sectors);

drivers/md/md.c

8015

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

drivers/md/md.c

802

INIT_WORK(&mddev->del_work, mddev_delayed_delete);

drivers/md/md.c

8020

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

drivers/md/md.c

8022

if (!md_is_rdwr(mddev))

drivers/md/md.c

8025

(mddev->max_disks && raid_disks >= mddev->max_disks))

drivers/md/md.c

8027

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

drivers/md/md.c

8028

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

drivers/md/md.c

8029

mddev->reshape_position != MaxSector)

drivers/md/md.c

8032

rdev_for_each(rdev, mddev) {

drivers/md/md.c

8033

if (mddev->raid_disks < raid_disks &&

drivers/md/md.c

8036

if (mddev->raid_disks > raid_disks &&

drivers/md/md.c

8041

mddev->delta_disks = raid_disks - mddev->raid_disks;

drivers/md/md.c

8042

if (mddev->delta_disks < 0)

drivers/md/md.c

8043

mddev->reshape_backwards = 1;

drivers/md/md.c

8044

else if (mddev->delta_disks > 0)

drivers/md/md.c

8045

mddev->reshape_backwards = 0;

drivers/md/md.c

8047

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

drivers/md/md.c

8049

mddev->delta_disks = 0;

drivers/md/md.c

8050

mddev->reshape_backwards = 0;

drivers/md/md.c

8055

static int get_cluster_ops(struct mddev *mddev)

drivers/md/md.c

8058

mddev->cluster_ops = xa_load(&md_submodule, ID_CLUSTER);

drivers/md/md.c

8059

if (mddev->cluster_ops &&

drivers/md/md.c

8060

!try_module_get(mddev->cluster_ops->head.owner))

drivers/md/md.c

8061

mddev->cluster_ops = NULL;

drivers/md/md.c

8064

return mddev->cluster_ops == NULL ? -ENOENT : 0;

drivers/md/md.c

8067

static void put_cluster_ops(struct mddev *mddev)

drivers/md/md.c

8069

if (!mddev->cluster_ops)

drivers/md/md.c

807

bioset_exit(&mddev->sync_set);

drivers/md/md.c

8072

mddev->cluster_ops->leave(mddev);

drivers/md/md.c

8073

module_put(mddev->cluster_ops->head.owner);

drivers/md/md.c

8074

mddev->cluster_ops = NULL;

drivers/md/md.c

8085

static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)

drivers/md/md.c

809

bioset_exit(&mddev->bio_set);

drivers/md/md.c

8092

if (mddev->bitmap && mddev->bitmap_info.offset)

drivers/md/md.c

8095

if (mddev->major_version != info->major_version ||

drivers/md/md.c

8096

mddev->minor_version != info->minor_version ||

drivers/md/md.c

8098

mddev->ctime != info->ctime ||

drivers/md/md.c

8099

mddev->level != info->level ||

drivers/md/md.c

8101

mddev->persistent != !info->not_persistent ||

drivers/md/md.c

8102

mddev->chunk_sectors != info->chunk_size >> 9 ||

drivers/md/md.c

8108

if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)

drivers/md/md.c

811

percpu_ref_exit(&mddev->writes_pending);

drivers/md/md.c

8110

if (mddev->raid_disks != info->raid_disks)

drivers/md/md.c

8112

if (mddev->layout != info->layout)

drivers/md/md.c

8121

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

drivers/md/md.c

8126

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

drivers/md/md.c

8129

mddev->new_layout = info->layout;

drivers/md/md.c

813

percpu_ref_exit(&mddev->active_io);

drivers/md/md.c

8130

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

drivers/md/md.c

8132

mddev->new_layout = mddev->layout;

drivers/md/md.c

8136

if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)

drivers/md/md.c

8137

rv = update_size(mddev, (sector_t)info->size * 2);

drivers/md/md.c

8139

if (mddev->raid_disks != info->raid_disks)

drivers/md/md.c

8140

rv = update_raid_disks(mddev, info->raid_disks);

drivers/md/md.c

8143

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

drivers/md/md.c

8147

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

drivers/md/md.c

8153

if (mddev->bitmap) {

drivers/md/md.c

8157

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

drivers/md/md.c

8161

mddev->bitmap_info.offset =

drivers/md/md.c

8162

mddev->bitmap_info.default_offset;

drivers/md/md.c

8163

mddev->bitmap_info.space =

drivers/md/md.c

8164

mddev->bitmap_info.default_space;

drivers/md/md.c

8165

mddev->bitmap_id = ID_BITMAP;

drivers/md/md.c

8166

rv = md_bitmap_create(mddev);

drivers/md/md.c

8168

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

drivers/md/md.c

8171

md_bitmap_destroy(mddev);

drivers/md/md.c

8172

mddev->bitmap_info.offset = 0;

drivers/md/md.c

8173

md_bitmap_set_none(mddev);

drivers/md/md.c

8178

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

drivers/md/md.c

818

void mddev_destroy(struct mddev *mddev)

drivers/md/md.c

8187

if (mddev->bitmap_info.nodes) {

drivers/md/md.c

8189

if (mddev->cluster_ops->lock_all_bitmaps(mddev) <= 0) {

drivers/md/md.c

8192

mddev->cluster_ops->unlock_all_bitmaps(mddev);

drivers/md/md.c

8196

mddev->bitmap_info.nodes = 0;

drivers/md/md.c

8197

put_cluster_ops(mddev);

drivers/md/md.c

8198

mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;

drivers/md/md.c

820

bioset_exit(&mddev->bio_set);

drivers/md/md.c

8200

md_bitmap_destroy(mddev);

drivers/md/md.c

8201

mddev->bitmap_info.offset = 0;

drivers/md/md.c

8202

md_bitmap_set_none(mddev);

drivers/md/md.c

8205

md_update_sb(mddev, 1);

drivers/md/md.c

821

bioset_exit(&mddev->sync_set);

drivers/md/md.c

8211

static int set_disk_faulty(struct mddev *mddev, dev_t dev)

drivers/md/md.c

8216

if (mddev->pers == NULL)

drivers/md/md.c

822

bioset_exit(&mddev->io_clone_set);

drivers/md/md.c

8220

rdev = md_find_rdev_rcu(mddev, dev);

drivers/md/md.c

8224

md_error(mddev, rdev);

drivers/md/md.c

8225

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

drivers/md/md.c

823

percpu_ref_exit(&mddev->active_io);

drivers/md/md.c

824

percpu_ref_exit(&mddev->writes_pending);

drivers/md/md.c

8240

struct mddev *mddev = disk->private_data;

drivers/md/md.c

8244

geo->cylinders = mddev->array_sectors / 8;

drivers/md/md.c

828

static struct mddev *mddev_find_locked(dev_t unit)

drivers/md/md.c

8289

static int __md_set_array_info(struct mddev *mddev, void __user *argp)

drivers/md/md.c

8299

if (mddev->pers) {

drivers/md/md.c

830

struct mddev *mddev;

drivers/md/md.c

8300

err = update_array_info(mddev, &info);

drivers/md/md.c

8306

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

drivers/md/md.c

8307

pr_warn("md: array %s already has disks!\n", mdname(mddev));

drivers/md/md.c

8311

if (mddev->raid_disks) {

drivers/md/md.c

8312

pr_warn("md: array %s already initialised!\n", mdname(mddev));

drivers/md/md.c

8316

err = md_set_array_info(mddev, &info);

drivers/md/md.c

832

list_for_each_entry(mddev, &all_mddevs, all_mddevs)

drivers/md/md.c

8328

struct mddev *mddev = NULL;

drivers/md/md.c

833

if (mddev->unit == unit)

drivers/md/md.c

834

return mddev;

drivers/md/md.c

8345

mddev = bdev->bd_disk->private_data;

drivers/md/md.c

8350

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

drivers/md/md.c

8352

return get_array_info(mddev, argp);

drivers/md/md.c

8355

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

drivers/md/md.c

8357

return get_disk_info(mddev, argp);

drivers/md/md.c

8360

return set_disk_faulty(mddev, new_decode_dev(arg));

drivers/md/md.c

8363

return get_bitmap_file(mddev, argp);

drivers/md/md.c

8370

err = mddev_set_closing_and_sync_blockdev(mddev, 1);

drivers/md/md.c

8375

if (!md_is_rdwr(mddev))

drivers/md/md.c

8376

flush_work(&mddev->sync_work);

drivers/md/md.c

8378

err = md_ioctl_need_suspend(cmd) ? mddev_suspend_and_lock(mddev) :

drivers/md/md.c

8379

mddev_lock(mddev);

drivers/md/md.c

8387

err = __md_set_array_info(mddev, argp);

drivers/md/md.c

8396

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

drivers/md/md.c

8409

err = restart_array(mddev);

drivers/md/md.c

8413

err = do_md_stop(mddev, 0);

drivers/md/md.c

8417

if (mddev->pers)

drivers/md/md.c

8418

err = md_set_readonly(mddev);

drivers/md/md.c

8422

err = hot_remove_disk(mddev, new_decode_dev(arg));

drivers/md/md.c

8430

if (mddev->pers) {

drivers/md/md.c

8438

err = md_add_new_disk(mddev, &info);

drivers/md/md.c

8448

if (!md_is_rdwr(mddev) && mddev->pers) {

drivers/md/md.c

8449

if (mddev->ro != MD_AUTO_READ) {

drivers/md/md.c

8453

mddev->ro = MD_RDWR;

drivers/md/md.c

8454

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

8455

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

8460

if (test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)) {

drivers/md/md.c

8461

mddev_unlock(mddev);

drivers/md/md.c

8462

wait_event(mddev->sb_wait,

drivers/md/md.c

8463

!test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags) &&

drivers/md/md.c

8464

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/md.c

8465

mddev_lock_nointr(mddev);

drivers/md/md.c

8476

err = md_add_new_disk(mddev, &info);

drivers/md/md.c

8481

if (mddev_is_clustered(mddev))

drivers/md/md.c

8482

mddev->cluster_ops->new_disk_ack(mddev, false);

drivers/md/md.c

8488

err = hot_add_disk(mddev, new_decode_dev(arg));

drivers/md/md.c

8492

err = do_md_run(mddev);

drivers/md/md.c

8496

err = set_bitmap_file(mddev, (int)arg);

drivers/md/md.c

8505

if (mddev->hold_active == UNTIL_IOCTL &&

drivers/md/md.c

8507

mddev->hold_active = 0;

drivers/md/md.c

8509

md_ioctl_need_suspend(cmd) ? mddev_unlock_and_resume(mddev) :

drivers/md/md.c

8510

mddev_unlock(mddev);

drivers/md/md.c

8514

clear_bit(MD_CLOSING, &mddev->flags);

drivers/md/md.c

8539

struct mddev *mddev = bdev->bd_disk->private_data;

drivers/md/md.c

8542

err = mddev_lock(mddev);

drivers/md/md.c

8546

if (!mddev->raid_disks && !mddev->external) {

drivers/md/md.c

8555

if (!ro && mddev->ro == MD_RDONLY && mddev->pers) {

drivers/md/md.c

8556

err = restart_array(mddev);

drivers/md/md.c

8559

mddev->ro = MD_AUTO_READ;

drivers/md/md.c

8563

mddev_unlock(mddev);

drivers/md/md.c

8569

struct mddev *mddev;

drivers/md/md.c

8573

mddev = mddev_get(disk->private_data);

drivers/md/md.c

8575

if (!mddev)

drivers/md/md.c

8578

err = mutex_lock_interruptible(&mddev->open_mutex);

drivers/md/md.c

8583

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

drivers/md/md.c

8586

atomic_inc(&mddev->openers);

drivers/md/md.c

8587

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

8593

mutex_unlock(&mddev->open_mutex);

drivers/md/md.c

8595

mddev_put(mddev);

drivers/md/md.c

860

static struct mddev *mddev_alloc(dev_t unit)

drivers/md/md.c

8601

struct mddev *mddev = disk->private_data;

drivers/md/md.c

8603

BUG_ON(!mddev);

drivers/md/md.c

8604

atomic_dec(&mddev->openers);

drivers/md/md.c

8605

mddev_put(mddev);

drivers/md/md.c

8610

struct mddev *mddev = disk->private_data;

drivers/md/md.c

8613

if (mddev->changed)

drivers/md/md.c

8615

mddev->changed = 0;

drivers/md/md.c

862

struct mddev *new;

drivers/md/md.c

8621

struct mddev *mddev = disk->private_data;

drivers/md/md.c

8623

mddev_free(mddev);

drivers/md/md.c

8711

struct mddev *mddev, const char *name)

drivers/md/md.c

8722

thread->mddev = mddev;

drivers/md/md.c

8726

mdname(thread->mddev),

drivers/md/md.c

8736

void md_unregister_thread(struct mddev *mddev, struct md_thread __rcu **threadp)

drivers/md/md.c

8739

lockdep_is_held(&mddev->reconfig_mutex));

drivers/md/md.c

8753

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

drivers/md/md.c

8758

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

drivers/md/md.c

8760

mddev->pers->error_handler(mddev, rdev);

drivers/md/md.c

8762

if (mddev->pers->head.id == ID_RAID0 ||

drivers/md/md.c

8763

mddev->pers->head.id == ID_LINEAR)

drivers/md/md.c

8766

if (mddev->degraded && !test_bit(MD_BROKEN, &mddev->flags))

drivers/md/md.c

8767

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/md.c

8769

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

8770

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

drivers/md/md.c

8771

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

8772

md_wakeup_thread(mddev->thread);

drivers/md/md.c

8774

if (mddev->event_work.func)

drivers/md/md.c

8775

queue_work(md_misc_wq, &mddev->event_work);

drivers/md/md.c

8815

static int status_resync(struct seq_file *seq, struct mddev *mddev)

drivers/md/md.c

8823

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

drivers/md/md.c

8824

test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))

drivers/md/md.c

8825

max_sectors = mddev->resync_max_sectors;

drivers/md/md.c

8827

max_sectors = mddev->dev_sectors;

drivers/md/md.c

8829

resync = mddev->curr_resync;

drivers/md/md.c

8831

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

drivers/md/md.c

8837

res = atomic_read(&mddev->recovery_active);

drivers/md/md.c

8850

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

drivers/md/md.c

8853

rdev_for_each(rdev, mddev)

drivers/md/md.c

8861

if (mddev->reshape_position != MaxSector)

drivers/md/md.c

8867

if (mddev->resync_offset < MaxSector) {

drivers/md/md.c

8904

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

drivers/md/md.c

8906

(test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?

drivers/md/md.c

8908

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

drivers/md/md.c

8931

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

drivers/md/md.c

8934

curr_mark_cnt = mddev->curr_mark_cnt;

drivers/md/md.c

8935

recovery_active = atomic_read(&mddev->recovery_active);

drivers/md/md.c

8936

resync_mark_cnt = mddev->resync_mark_cnt;

drivers/md/md.c

8973

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

drivers/md/md.c

8980

if (!md_bitmap_enabled(mddev, false))

drivers/md/md.c

8983

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

drivers/md/md.c

8987

chunk_kb = mddev->bitmap_info.chunksize >> 10;

drivers/md/md.c

8992

chunk_kb ? chunk_kb : mddev->bitmap_info.chunksize,

drivers/md/md.c

9005

struct mddev *mddev;

drivers/md/md.c

9016

mddev = list_entry(v, struct mddev, all_mddevs);

drivers/md/md.c

9017

if (!mddev_get(mddev))

drivers/md/md.c

9023

mutex_lock(&mddev->bitmap_info.mutex);

drivers/md/md.c

9025

spin_lock(&mddev->lock);

drivers/md/md.c

9026

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

drivers/md/md.c

9027

seq_printf(seq, "%s : ", mdname(mddev));

drivers/md/md.c

9028

if (mddev->pers) {

drivers/md/md.c

9029

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

drivers/md/md.c

9033

if (mddev->ro == MD_RDONLY)

drivers/md/md.c

9035

if (mddev->ro == MD_AUTO_READ)

drivers/md/md.c

9037

seq_printf(seq, " %s", mddev->pers->head.name);

drivers/md/md.c

9044

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

9063

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

drivers/md/md.c

9064

if (mddev->pers)

drivers/md/md.c

9067

mddev->array_sectors / 2);

drivers/md/md.c

9072

if (mddev->persistent) {

drivers/md/md.c

9073

if (mddev->major_version != 0 ||

drivers/md/md.c

9074

mddev->minor_version != 90) {

drivers/md/md.c

9076

mddev->major_version,

drivers/md/md.c

9077

mddev->minor_version);

drivers/md/md.c

9079

} else if (mddev->external)

drivers/md/md.c

908

static void mddev_free(struct mddev *mddev)

drivers/md/md.c

9081

mddev->metadata_type);

drivers/md/md.c

9085

if (mddev->pers) {

drivers/md/md.c

9086

mddev->pers->status(seq, mddev);

drivers/md/md.c

9088

if (mddev->pers->sync_request) {

drivers/md/md.c

9089

if (status_resync(seq, mddev))

drivers/md/md.c

9095

md_bitmap_status(seq, mddev);

drivers/md/md.c

9099

spin_unlock(&mddev->lock);

drivers/md/md.c

9100

mutex_unlock(&mddev->bitmap_info.mutex);

drivers/md/md.c

9103

if (mddev == list_last_entry(&all_mddevs, struct mddev, all_mddevs))

drivers/md/md.c

9106

mddev_put_locked(mddev);

drivers/md/md.c

911

list_del(&mddev->all_mddevs);

drivers/md/md.c

914

mddev_destroy(mddev);

drivers/md/md.c

915

kfree(mddev);

drivers/md/md.c

9169

int md_setup_cluster(struct mddev *mddev, int nodes)

drivers/md/md.c

9171

int ret = get_cluster_ops(mddev);

drivers/md/md.c

9175

ret = get_cluster_ops(mddev);

drivers/md/md.c

9184

ret = mddev->cluster_ops->join(mddev, nodes);

drivers/md/md.c

9186

mddev->safemode_delay = 0;

drivers/md/md.c

9190

void md_cluster_stop(struct mddev *mddev)

drivers/md/md.c

9192

put_cluster_ops(mddev);

drivers/md/md.c

920

void mddev_unlock(struct mddev *mddev)

drivers/md/md.c

9222

static bool is_mddev_idle(struct mddev *mddev, int init)

drivers/md/md.c

9224

unsigned long last_events = mddev->normal_io_events;

drivers/md/md.c

9229

disk = mddev_is_dm(mddev) ? mddev->dm_gendisk : mddev->gendisk;

drivers/md/md.c

9233

mddev->normal_io_events = part_stat_read_accum(disk->part0, sectors);

drivers/md/md.c

9234

if (!init && (mddev->normal_io_events > last_events ||

drivers/md/md.c

9239

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.c

9247

void md_done_sync(struct mddev *mddev, int blocks)

drivers/md/md.c

9250

atomic_sub(blocks, &mddev->recovery_active);

drivers/md/md.c

9251

wake_up(&mddev->recovery_wait);

drivers/md/md.c

9255

void md_sync_error(struct mddev *mddev)

drivers/md/md.c

9258

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

9259

md_wakeup_thread(mddev->thread);

drivers/md/md.c

926

if (!list_empty(&mddev->deleting))

drivers/md/md.c

927

list_splice_init(&mddev->deleting, &delete);

drivers/md/md.c

9270

void md_write_start(struct mddev *mddev, struct bio *bi)

drivers/md/md.c

9277

BUG_ON(mddev->ro == MD_RDONLY);

drivers/md/md.c

9278

if (mddev->ro == MD_AUTO_READ) {

drivers/md/md.c

9280

mddev->ro = MD_RDWR;

drivers/md/md.c

9281

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.c

9282

md_wakeup_thread(mddev->thread);

drivers/md/md.c

9283

md_wakeup_thread(mddev->sync_thread);

drivers/md/md.c

9287

percpu_ref_get(&mddev->writes_pending);

drivers/md/md.c

9289

if (mddev->safemode == 1)

drivers/md/md.c

929

if (mddev->to_remove) {

drivers/md/md.c

9290

mddev->safemode = 0;

drivers/md/md.c

9292

if (mddev->in_sync || mddev->sync_checkers) {

drivers/md/md.c

9293

spin_lock(&mddev->lock);

drivers/md/md.c

9294

if (mddev->in_sync) {

drivers/md/md.c

9295

mddev->in_sync = 0;

drivers/md/md.c

9296

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

9297

set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

9298

md_wakeup_thread(mddev->thread);

drivers/md/md.c

9301

spin_unlock(&mddev->lock);

drivers/md/md.c

9305

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

9306

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

drivers/md/md.c

9308

wait_event(mddev->sb_wait,

drivers/md/md.c

9309

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/md.c

9321

void md_write_inc(struct mddev *mddev, struct bio *bi)

drivers/md/md.c

9325

WARN_ON_ONCE(mddev->in_sync || !md_is_rdwr(mddev));

drivers/md/md.c

9326

percpu_ref_get(&mddev->writes_pending);

drivers/md/md.c

9330

void md_write_end(struct mddev *mddev)

drivers/md/md.c

9332

percpu_ref_put(&mddev->writes_pending);

drivers/md/md.c

9334

if (mddev->safemode == 2)

drivers/md/md.c

9335

md_wakeup_thread(mddev->thread);

drivers/md/md.c

9336

else if (mddev->safemode_delay)

drivers/md/md.c

9340

mod_timer(&mddev->safemode_timer,

drivers/md/md.c

9341

roundup(jiffies, mddev->safemode_delay) +

drivers/md/md.c

9342

mddev->safemode_delay);

drivers/md/md.c

9348

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

drivers/md/md.c

9359

mddev_trace_remap(mddev, discard_bio, bio->bi_iter.bi_sector);

drivers/md/md.c

9364

static void md_bitmap_start(struct mddev *mddev,

drivers/md/md.c

9368

mddev->bitmap_ops->start_discard :

drivers/md/md.c

9369

mddev->bitmap_ops->start_write;

drivers/md/md.c

9371

if (mddev->pers->bitmap_sector)

drivers/md/md.c

9372

mddev->pers->bitmap_sector(mddev, &md_io_clone->offset,

drivers/md/md.c

9375

fn(mddev, md_io_clone->offset, md_io_clone->sectors);

drivers/md/md.c

9378

static void md_bitmap_end(struct mddev *mddev, struct md_io_clone *md_io_clone)

drivers/md/md.c

9381

mddev->bitmap_ops->end_discard :

drivers/md/md.c

9382

mddev->bitmap_ops->end_write;

drivers/md/md.c

9384

fn(mddev, md_io_clone->offset, md_io_clone->sectors);

drivers/md/md.c

9392

struct mddev *mddev = md_io_clone->mddev;

drivers/md/md.c

9395

if (bio_data_dir(orig_bio) == WRITE && md_bitmap_enabled(mddev, false))

drivers/md/md.c

9396

md_bitmap_end(mddev, md_io_clone);

drivers/md/md.c

9409

percpu_ref_put(&mddev->active_io);

drivers/md/md.c

9412

static void md_clone_bio(struct mddev *mddev, struct bio **bio)

drivers/md/md.c

9417

bio_alloc_clone(bdev, *bio, GFP_NOIO, &mddev->io_clone_set);

drivers/md/md.c

942

const struct attribute_group *to_remove = mddev->to_remove;

drivers/md/md.c

9421

md_io_clone->mddev = mddev;

drivers/md/md.c

9425

if (bio_data_dir(*bio) == WRITE && md_bitmap_enabled(mddev, false)) {

drivers/md/md.c

9429

md_bitmap_start(mddev, md_io_clone);

drivers/md/md.c

943

mddev->to_remove = NULL;

drivers/md/md.c

9437

void md_account_bio(struct mddev *mddev, struct bio **bio)

drivers/md/md.c

9439

percpu_ref_get(&mddev->active_io);

drivers/md/md.c

944

mddev->sysfs_active = 1;

drivers/md/md.c

9440

md_clone_bio(mddev, bio);

drivers/md/md.c

945

mutex_unlock(&mddev->reconfig_mutex);

drivers/md/md.c

9450

void md_allow_write(struct mddev *mddev)

drivers/md/md.c

9452

if (!mddev->pers)

drivers/md/md.c

9454

if (!md_is_rdwr(mddev))

drivers/md/md.c

9456

if (!mddev->pers->sync_request)

drivers/md/md.c

9459

spin_lock(&mddev->lock);

drivers/md/md.c

9460

if (mddev->in_sync) {

drivers/md/md.c

9461

mddev->in_sync = 0;

drivers/md/md.c

9462

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

9463

set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/md.c

9464

if (mddev->safemode_delay &&

drivers/md/md.c

9465

mddev->safemode == 0)

drivers/md/md.c

9466

mddev->safemode = 1;

drivers/md/md.c

9467

spin_unlock(&mddev->lock);

drivers/md/md.c

9468

md_update_sb(mddev, 0);

drivers/md/md.c

9469

sysfs_notify_dirent_safe(mddev->sysfs_state);

drivers/md/md.c

947

if (mddev->kobj.sd) {

drivers/md/md.c

9471

wait_event(mddev->sb_wait,

drivers/md/md.c

9472

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/md.c

9474

spin_unlock(&mddev->lock);

drivers/md/md.c

9478

static sector_t md_sync_max_sectors(struct mddev *mddev,

drivers/md/md.c

9485

atomic64_set(&mddev->resync_mismatches, 0);

drivers/md/md.c

9488

return mddev->resync_max_sectors;

drivers/md/md.c

949

sysfs_remove_group(&mddev->kobj, to_remove);

drivers/md/md.c

9490

return mddev->dev_sectors;

drivers/md/md.c

950

if (mddev->pers == NULL ||

drivers/md/md.c

9501

static bool mddev_select_lazy_recover_rdev(struct mddev *mddev)

drivers/md/md.c

9508

rdev_for_each_rcu(rdev, mddev) {

drivers/md/md.c

951

mddev->pers->sync_request == NULL) {

drivers/md/md.c

952

sysfs_remove_group(&mddev->kobj, &md_redundancy_group);

drivers/md/md.c

9529

static sector_t md_sync_position(struct mddev *mddev, enum sync_action action)

drivers/md/md.c

953

if (mddev->sysfs_action)

drivers/md/md.c

9537

return mddev->resync_min;

drivers/md/md.c

9539

if (!mddev->bitmap)

drivers/md/md.c

954

sysfs_put(mddev->sysfs_action);

drivers/md/md.c

9540

return mddev->resync_offset;

drivers/md/md.c

9548

if (mddev_is_clustered(mddev) &&

drivers/md/md.c

9549

mddev->reshape_position != MaxSector)

drivers/md/md.c

955

if (mddev->sysfs_completed)

drivers/md/md.c

9550

return mddev->reshape_position;

drivers/md/md.c

9555

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.c

956

sysfs_put(mddev->sysfs_completed);

drivers/md/md.c

9564

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

drivers/md/md.c

9565

start == MaxSector && mddev_select_lazy_recover_rdev(mddev))

drivers/md/md.c

957

if (mddev->sysfs_degraded)

drivers/md/md.c

9576

if (mddev->bitmap) {

drivers/md/md.c

9577

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

drivers/md/md.c

9578

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

drivers/md/md.c

958

sysfs_put(mddev->sysfs_degraded);

drivers/md/md.c

9586

static bool sync_io_within_limit(struct mddev *mddev)

drivers/md/md.c

959

mddev->sysfs_action = NULL;

drivers/md/md.c

9592

return atomic_read(&mddev->recovery_active) <

drivers/md/md.c

9593

(raid_is_456(mddev) ? 8 : 128) * sync_io_depth(mddev);

drivers/md/md.c

9599

static void md_finish_sync(struct mddev *mddev, enum sync_action action)

drivers/md/md.c

960

mddev->sysfs_completed = NULL;

drivers/md/md.c

9606

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

drivers/md/md.c

9607

mddev->curr_resync = MaxSector;

drivers/md/md.c

9608

mddev->resync_offset = mddev->curr_resync;

drivers/md/md.c

961

mddev->sysfs_degraded = NULL;

drivers/md/md.c

9611

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

drivers/md/md.c

9612

mddev->curr_resync = MaxSector;

drivers/md/md.c

9614

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.c

9615

if (mddev->delta_disks >= 0 &&

drivers/md/md.c

9616

rdev_needs_recovery(rdev, mddev->curr_resync))

drivers/md/md.c

9617

rdev->recovery_offset = mddev->curr_resync;

drivers/md/md.c

9621

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

drivers/md/md.c

9622

mddev->delta_disks > 0 &&

drivers/md/md.c

9623

mddev->pers->finish_reshape &&

drivers/md/md.c

9624

mddev->pers->size &&

drivers/md/md.c

9625

!mddev_is_dm(mddev)) {

drivers/md/md.c

9626

mddev_lock_nointr(mddev);

drivers/md/md.c

9627

md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0));

drivers/md/md.c

9628

mddev_unlock(mddev);

drivers/md/md.c

9629

if (!mddev_is_clustered(mddev))

drivers/md/md.c

9630

set_capacity_and_notify(mddev->gendisk,

drivers/md/md.c

9631

mddev->array_sectors);

drivers/md/md.c

9633

if (mddev->pers->finish_reshape)

drivers/md/md.c

9634

mddev->pers->finish_reshape(mddev);

drivers/md/md.c

964

mddev->sysfs_active = 0;

drivers/md/md.c

9648

struct mddev *mddev = thread->mddev;

drivers/md/md.c

9649

struct mddev *mddev2;

drivers/md/md.c

966

mutex_unlock(&mddev->reconfig_mutex);

drivers/md/md.c

9664

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

drivers/md/md.c

9667

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

drivers/md/md.c

9670

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

drivers/md/md.c

9671

!md_is_rdwr(mddev)) {/* never try to sync a read-only array */

drivers/md/md.c

9672

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

9676

if (mddev_is_clustered(mddev)) {

drivers/md/md.c

9677

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

drivers/md/md.c

968

md_wakeup_thread(mddev->thread);

drivers/md/md.c

9681

set_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags);

drivers/md/md.c

9682

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

drivers/md/md.c

9683

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

drivers/md/md.c

9684

test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))

drivers/md/md.c

9685

&& ((unsigned long long)mddev->curr_resync_completed

drivers/md/md.c

9686

< (unsigned long long)mddev->resync_max_sectors))

drivers/md/md.c

969

wake_up(&mddev->sb_wait);

drivers/md/md.c

9690

action = md_sync_action(mddev);

drivers/md/md.c

9692

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

9697

mddev->last_sync_action = action;

drivers/md/md.c

97

static int remove_and_add_spares(struct mddev *mddev,

drivers/md/md.c

9708

if (mddev_is_clustered(mddev))

drivers/md/md.c

9709

mddev->cluster_ops->resync_start_notify(mddev);

drivers/md/md.c

9712

mddev->curr_resync = MD_RESYNC_DELAYED;

drivers/md/md.c

9715

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

drivers/md/md.c

9721

if (mddev2 == mddev)

drivers/md/md.c

9723

if (!mddev->parallel_resync

drivers/md/md.c

9725

&& match_mddev_units(mddev, mddev2)) {

drivers/md/md.c

9727

if (mddev < mddev2 &&

drivers/md/md.c

9728

mddev->curr_resync == MD_RESYNC_DELAYED) {

drivers/md/md.c

9730

mddev->curr_resync = MD_RESYNC_YIELDED;

drivers/md/md.c

9733

if (mddev > mddev2 &&

drivers/md/md.c

9734

mddev->curr_resync == MD_RESYNC_YIELDED)

drivers/md/md.c

9744

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

drivers/md/md.c

9745

mddev2->curr_resync >= mddev->curr_resync) {

drivers/md/md.c

9749

desc, mdname(mddev),

drivers/md/md.c

9764

} while (mddev->curr_resync < MD_RESYNC_DELAYED);

drivers/md/md.c

9766

max_sectors = md_sync_max_sectors(mddev, action);

drivers/md/md.c

9767

j = md_sync_position(mddev, action);

drivers/md/md.c

9769

pr_info("md: %s of RAID array %s\n", desc, mdname(mddev));

drivers/md/md.c

9770

pr_debug("md: minimum _guaranteed_ speed: %d KB/sec/disk.\n", speed_min(mddev));

drivers/md/md.c

9772

speed_max(mddev), desc);

drivers/md/md.c

9774

is_mddev_idle(mddev, 1); /* this initializes IO event counters */

drivers/md/md.c

9782

mddev->resync_mark = mark[last_mark];

drivers/md/md.c

9783

mddev->resync_mark_cnt = mark_cnt[last_mark];

drivers/md/md.c

9792

atomic_set(&mddev->recovery_active, 0);

drivers/md/md.c

9797

desc, mdname(mddev));

drivers/md/md.c

9798

mddev->curr_resync = j;

drivers/md/md.c

9800

mddev->curr_resync = MD_RESYNC_ACTIVE; /* no longer delayed */

drivers/md/md.c

9801

mddev->curr_resync_completed = j;

drivers/md/md.c

9802

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

9812

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

drivers/md/md.c

9813

((mddev->curr_resync > mddev->curr_resync_completed &&

drivers/md/md.c

9814

(mddev->curr_resync - mddev->curr_resync_completed)

drivers/md/md.c

9817

(j - mddev->curr_resync_completed)*2

drivers/md/md.c

9818

>= mddev->resync_max - mddev->curr_resync_completed ||

drivers/md/md.c

9819

mddev->curr_resync_completed > mddev->resync_max

drivers/md/md.c

9822

wait_event(mddev->recovery_wait,

drivers/md/md.c

9823

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

drivers/md/md.c

9824

mddev->curr_resync_completed = j;

drivers/md/md.c

9825

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

drivers/md/md.c

9826

j > mddev->resync_offset)

drivers/md/md.c

9827

mddev->resync_offset = j;

drivers/md/md.c

9829

set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);

drivers/md/md.c

9830

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

9833

while (j >= mddev->resync_max &&

drivers/md/md.c

9834

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

drivers/md/md.c

9840

wait_event_interruptible(mddev->recovery_wait,

drivers/md/md.c

9841

mddev->resync_max > j

drivers/md/md.c

9843

&mddev->recovery));

drivers/md/md.c

9846

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

drivers/md/md.c

9849

if (mddev->bitmap_ops && mddev->bitmap_ops->skip_sync_blocks) {

drivers/md/md.c

9850

sectors = mddev->bitmap_ops->skip_sync_blocks(mddev, j);

drivers/md/md.c

9855

sectors = mddev->pers->sync_request(mddev, j, max_sectors,

drivers/md/md.c

9858

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/md.c

986

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

drivers/md/md.c

9864

atomic_add(sectors, &mddev->recovery_active);

drivers/md/md.c

9867

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

drivers/md/md.c

987

!test_and_set_bit(MD_DO_DELETE, &mddev->flags)) {

drivers/md/md.c

9876

mddev->curr_resync = j;

drivers/md/md.c

9877

mddev->curr_mark_cnt = io_sectors;

drivers/md/md.c

988

kobject_del(&mddev->kobj);

drivers/md/md.c

989

del_gendisk(mddev->gendisk);

drivers/md/md.c

9893

mddev->resync_mark = mark[next];

drivers/md/md.c

9894

mddev->resync_mark_cnt = mark_cnt[next];

drivers/md/md.c

9896

mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);

drivers/md/md.c

99

static void mddev_detach(struct mddev *mddev);

drivers/md/md.c

9900

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

drivers/md/md.c

9913

recovery_done = io_sectors - atomic_read(&mddev->recovery_active);

drivers/md/md.c

9914

currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2

drivers/md/md.c

9915

/((jiffies-mddev->resync_mark)/HZ +1) +1;

drivers/md/md.c

9917

if (currspeed > speed_min(mddev)) {

drivers/md/md.c

9918

if (currspeed > speed_max(mddev)) {

drivers/md/md.c

9922

if (!sync_io_within_limit(mddev) &&

drivers/md/md.c

9923

!is_mddev_idle(mddev, 0)) {

drivers/md/md.c

9928

wait_event(mddev->recovery_wait,

drivers/md/md.c

9929

!atomic_read(&mddev->recovery_active));

drivers/md/md.c

9933

pr_info("md: %s: %s %s.\n",mdname(mddev), desc,

drivers/md/md.c

9934

test_bit(MD_RECOVERY_INTR, &mddev->recovery)

drivers/md/md.c

9940

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

drivers/md/md.c

9942

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

drivers/md/md.c

9943

mddev->curr_resync >= MD_RESYNC_ACTIVE) {

drivers/md/md.c

9945

mddev->curr_resync_completed = mddev->curr_resync;

drivers/md/md.c

9946

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/md.c

9948

mddev->pers->sync_request(mddev, max_sectors, max_sectors, &skipped);

drivers/md/md.c

995

struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)

drivers/md/md.c

9950

if (mddev->curr_resync > MD_RESYNC_ACTIVE)

drivers/md/md.c

9951

md_finish_sync(mddev, action);

drivers/md/md.c

9956

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/md.c

9958

spin_lock(&mddev->lock);

drivers/md/md.c

9959

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

drivers/md/md.c

9961

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

drivers/md/md.c

9962

mddev->resync_min = 0;

drivers/md/md.c

9963

mddev->resync_max = MaxSector;

drivers/md/md.c

9964

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

drivers/md/md.c

9965

mddev->resync_min = mddev->curr_resync_completed;

drivers/md/md.c

9966

set_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/md.c

9967

mddev->curr_resync = MD_RESYNC_NONE;

drivers/md/md.c

9968

spin_unlock(&mddev->lock);

drivers/md/md.c

9971

md_wakeup_thread(mddev->thread);

drivers/md/md.c

999

rdev_for_each_rcu(rdev, mddev)

drivers/md/md.h

1001

mddev->gendisk->queue->limits.max_write_zeroes_sectors = 0;

drivers/md/md.h

1004

static inline int mddev_suspend_and_lock(struct mddev *mddev)

drivers/md/md.h

1008

ret = mddev_suspend(mddev, true);

drivers/md/md.h

1012

ret = mddev_lock(mddev);

drivers/md/md.h

1014

mddev_resume(mddev);

drivers/md/md.h

1019

static inline void mddev_suspend_and_lock_nointr(struct mddev *mddev)

drivers/md/md.h

1021

mddev_suspend(mddev, false);

drivers/md/md.h

1022

mddev_lock_nointr(mddev);

drivers/md/md.h

1025

static inline void mddev_unlock_and_resume(struct mddev *mddev)

drivers/md/md.h

1027

mddev_unlock(mddev);

drivers/md/md.h

1028

mddev_resume(mddev);

drivers/md/md.h

1036

int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info);

drivers/md/md.h

1037

int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info);

drivers/md/md.h

1038

int do_md_run(struct mddev *mddev);

drivers/md/md.h

1040

int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,

drivers/md/md.h

1042

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

drivers/md/md.h

1043

void mddev_update_io_opt(struct mddev *mddev, unsigned int nr_stripes);

drivers/md/md.h

1047

static inline bool md_cloned_bio(struct mddev *mddev, struct bio *bio)

drivers/md/md.h

1049

return bio->bi_pool == &mddev->io_clone_set;

drivers/md/md.h

1055

static inline bool mddev_is_dm(struct mddev *mddev)

drivers/md/md.h

1057

return !mddev->gendisk;

drivers/md/md.h

1060

static inline bool raid_is_456(struct mddev *mddev)

drivers/md/md.h

1062

return mddev->level == ID_RAID4 || mddev->level == ID_RAID5 ||

drivers/md/md.h

1063

mddev->level == ID_RAID6;

drivers/md/md.h

1066

static inline void mddev_trace_remap(struct mddev *mddev, struct bio *bio,

drivers/md/md.h

1069

if (!mddev_is_dm(mddev))

drivers/md/md.h

1070

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

drivers/md/md.h

1097

#define mddev_add_trace_msg(mddev, fmt, args...) \

drivers/md/md.h

1099

if (!mddev_is_dm(mddev)) \

drivers/md/md.h

1100

blk_add_trace_msg((mddev)->gendisk->queue, fmt, ##args); \

drivers/md/md.h

138

struct mddev *mddev; /* RAID array if running */

drivers/md/md.h

620

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

drivers/md/md.h

686

static inline bool md_is_rdwr(struct mddev *mddev)

drivers/md/md.h

688

return (mddev->ro == MD_RDWR);

drivers/md/md.h

691

static inline bool reshape_interrupted(struct mddev *mddev)

drivers/md/md.h

694

if (mddev->reshape_position == MaxSector)

drivers/md/md.h

698

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

drivers/md/md.h

702

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

drivers/md/md.h

703

test_bit(MD_RECOVERY_INTR, &mddev->recovery) ||

drivers/md/md.h

704

test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))

drivers/md/md.h

710

static inline int __must_check mddev_lock(struct mddev *mddev)

drivers/md/md.h

714

ret = mutex_lock_interruptible(&mddev->reconfig_mutex);

drivers/md/md.h

719

if (!ret && test_bit(MD_DELETED, &mddev->flags)) {

drivers/md/md.h

721

mutex_unlock(&mddev->reconfig_mutex);

drivers/md/md.h

733

static inline void mddev_lock_nointr(struct mddev *mddev)

drivers/md/md.h

735

mutex_lock(&mddev->reconfig_mutex);

drivers/md/md.h

738

static inline int mddev_trylock(struct mddev *mddev)

drivers/md/md.h

742

ret = mutex_trylock(&mddev->reconfig_mutex);

drivers/md/md.h

743

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

drivers/md/md.h

745

mutex_unlock(&mddev->reconfig_mutex);

drivers/md/md.h

749

extern void mddev_unlock(struct mddev *mddev);

drivers/md/md.h

755

bool __must_check (*make_request)(struct mddev *mddev, struct bio *bio);

drivers/md/md.h

760

int (*run)(struct mddev *mddev);

drivers/md/md.h

762

int (*start)(struct mddev *mddev);

drivers/md/md.h

763

void (*free)(struct mddev *mddev, void *priv);

drivers/md/md.h

764

void (*status)(struct seq_file *seq, struct mddev *mddev);

drivers/md/md.h

768

void (*error_handler)(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md.h

769

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

drivers/md/md.h

770

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

drivers/md/md.h

771

int (*spare_active) (struct mddev *mddev);

drivers/md/md.h

772

sector_t (*sync_request)(struct mddev *mddev, sector_t sector_nr,

drivers/md/md.h

774

int (*resize) (struct mddev *mddev, sector_t sectors);

drivers/md/md.h

775

sector_t (*size) (struct mddev *mddev, sector_t sectors, int raid_disks);

drivers/md/md.h

776

int (*check_reshape) (struct mddev *mddev);

drivers/md/md.h

777

int (*start_reshape) (struct mddev *mddev);

drivers/md/md.h

778

void (*finish_reshape) (struct mddev *mddev);

drivers/md/md.h

779

void (*update_reshape_pos) (struct mddev *mddev);

drivers/md/md.h

780

void (*prepare_suspend) (struct mddev *mddev);

drivers/md/md.h

785

void (*quiesce) (struct mddev *mddev, int quiesce);

drivers/md/md.h

795

void *(*takeover) (struct mddev *mddev);

drivers/md/md.h

797

int (*change_consistency_policy)(struct mddev *mddev, const char *buf);

drivers/md/md.h

799

void (*bitmap_sector)(struct mddev *mddev, sector_t *offset,

drivers/md/md.h

805

ssize_t (*show)(struct mddev *, char *);

drivers/md/md.h

806

ssize_t (*store)(struct mddev *, const char *, size_t);

drivers/md/md.h

821

static inline char * mdname (struct mddev * mddev)

drivers/md/md.h

823

return mddev->gendisk ? mddev->gendisk->disk_name : "mdX";

drivers/md/md.h

826

static inline int sysfs_link_rdev(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.h

831

mddev->kobj.sd) {

drivers/md/md.h

833

return sysfs_create_link(&mddev->kobj, &rdev->kobj, nm);

drivers/md/md.h

838

static inline void sysfs_unlink_rdev(struct mddev *mddev, struct md_rdev *rdev)

drivers/md/md.h

843

mddev->kobj.sd) {

drivers/md/md.h

845

sysfs_remove_link(&mddev->kobj, nm);

drivers/md/md.h

859

#define rdev_for_each(rdev, mddev) \

drivers/md/md.h

860

list_for_each_entry(rdev, &((mddev)->disks), same_set)

drivers/md/md.h

862

#define rdev_for_each_safe(rdev, tmp, mddev) \

drivers/md/md.h

863

list_for_each_entry_safe(rdev, tmp, &((mddev)->disks), same_set)

drivers/md/md.h

865

#define rdev_for_each_rcu(rdev, mddev) \

drivers/md/md.h

866

list_for_each_entry_rcu(rdev, &((mddev)->disks), same_set)

drivers/md/md.h

870

struct mddev *mddev;

drivers/md/md.h

879

struct mddev *mddev;

drivers/md/md.h

906

struct mddev *mddev,

drivers/md/md.h

908

extern void md_unregister_thread(struct mddev *mddev, struct md_thread __rcu **threadp);

drivers/md/md.h

910

extern void md_check_recovery(struct mddev *mddev);

drivers/md/md.h

911

extern void md_reap_sync_thread(struct mddev *mddev);

drivers/md/md.h

912

extern enum sync_action md_sync_action(struct mddev *mddev);

drivers/md/md.h

915

extern void md_write_start(struct mddev *mddev, struct bio *bi);

drivers/md/md.h

916

extern void md_write_inc(struct mddev *mddev, struct bio *bi);

drivers/md/md.h

917

extern void md_write_end(struct mddev *mddev);

drivers/md/md.h

918

extern void md_done_sync(struct mddev *mddev, int blocks);

drivers/md/md.h

919

extern void md_sync_error(struct mddev *mddev);

drivers/md/md.h

920

extern void md_error(struct mddev *mddev, struct md_rdev *rdev);

drivers/md/md.h

921

extern void md_finish_reshape(struct mddev *mddev);

drivers/md/md.h

922

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

drivers/md/md.h

924

void md_account_bio(struct mddev *mddev, struct bio **bio);

drivers/md/md.h

926

extern bool __must_check md_flush_request(struct mddev *mddev, struct bio *bio);

drivers/md/md.h

927

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

drivers/md/md.h

930

extern int md_super_wait(struct mddev *mddev);

drivers/md/md.h

935

extern void md_allow_write(struct mddev *mddev);

drivers/md/md.h

936

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

drivers/md/md.h

937

extern void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors);

drivers/md/md.h

938

extern int md_check_no_bitmap(struct mddev *mddev);

drivers/md/md.h

939

bool mddev_set_bitmap_ops_nosysfs(struct mddev *mddev);

drivers/md/md.h

940

int md_bitmap_create_nosysfs(struct mddev *mddev);

drivers/md/md.h

941

void md_bitmap_destroy_nosysfs(struct mddev *mddev);

drivers/md/md.h

942

extern int md_integrity_register(struct mddev *mddev);

drivers/md/md.h

945

extern int mddev_init(struct mddev *mddev);

drivers/md/md.h

946

extern void mddev_destroy(struct mddev *mddev);

drivers/md/md.h

948

struct mddev *md_alloc(dev_t dev, char *name);

drivers/md/md.h

949

void mddev_put(struct mddev *mddev);

drivers/md/md.h

950

extern int md_run(struct mddev *mddev);

drivers/md/md.h

951

extern int md_start(struct mddev *mddev);

drivers/md/md.h

952

extern void md_stop(struct mddev *mddev);

drivers/md/md.h

953

extern void md_stop_writes(struct mddev *mddev);

drivers/md/md.h

957

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

drivers/md/md.h

958

extern int mddev_suspend(struct mddev *mddev, bool interruptible);

drivers/md/md.h

959

extern void mddev_resume(struct mddev *mddev);

drivers/md/md.h

960

extern void md_idle_sync_thread(struct mddev *mddev);

drivers/md/md.h

961

extern void md_frozen_sync_thread(struct mddev *mddev);

drivers/md/md.h

962

extern void md_unfrozen_sync_thread(struct mddev *mddev);

drivers/md/md.h

964

extern void md_update_sb(struct mddev *mddev, int force);

drivers/md/md.h

965

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

drivers/md/md.h

966

extern void mddev_destroy_serial_pool(struct mddev *mddev,

drivers/md/md.h

968

struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr);

drivers/md/md.h

969

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

drivers/md/md.h

976

static inline void rdev_dec_pending(struct md_rdev *rdev, struct mddev *mddev)

drivers/md/md.h

980

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/md.h

981

md_wakeup_thread(mddev->thread);

drivers/md/md.h

985

static inline int mddev_is_clustered(struct mddev *mddev)

drivers/md/md.h

987

return mddev->cluster_info && mddev->bitmap_info.nodes > 1;

drivers/md/md.h

991

static inline void mddev_clear_unsupported_flags(struct mddev *mddev,

drivers/md/md.h

994

mddev->flags &= ~unsupported_flags;

drivers/md/md.h

997

static inline void mddev_check_write_zeroes(struct mddev *mddev, struct bio *bio)

drivers/md/raid0.c

100

mdname(mddev),

drivers/md/raid0.c

107

mdname(mddev));

drivers/md/raid0.c

116

mdname(mddev));

drivers/md/raid0.c

121

mdname(mddev));

drivers/md/raid0.c

125

mdname(mddev));

drivers/md/raid0.c

128

mdname(mddev), conf->nr_strip_zones);

drivers/md/raid0.c

132

mdname(mddev), conf->nr_strip_zones);

drivers/md/raid0.c

138

if ((mddev->chunk_sectors << 9) % blksize) {

drivers/md/raid0.c

140

mdname(mddev),

drivers/md/raid0.c

141

mddev->chunk_sectors << 9, blksize);

drivers/md/raid0.c

152

mddev->raid_disks),

drivers/md/raid0.c

165

rdev_for_each(rdev1, mddev) {

drivers/md/raid0.c

168

if (mddev->level == 10) {

drivers/md/raid0.c

174

if (mddev->level == 1) {

drivers/md/raid0.c

184

mdname(mddev));

drivers/md/raid0.c

187

if (j >= mddev->raid_disks) {

drivers/md/raid0.c

189

mdname(mddev), j);

drivers/md/raid0.c

194

mdname(mddev), j);

drivers/md/raid0.c

203

if (cnt != mddev->raid_disks) {

drivers/md/raid0.c

205

mdname(mddev), cnt, mddev->raid_disks);

drivers/md/raid0.c

219

dev = conf->devlist + i * mddev->raid_disks;

drivers/md/raid0.c

221

pr_debug("md/raid0:%s: zone %d\n", mdname(mddev), i);

drivers/md/raid0.c

230

mdname(mddev),

drivers/md/raid0.c

236

mdname(mddev),

drivers/md/raid0.c

243

mdname(mddev),

drivers/md/raid0.c

251

mdname(mddev),

drivers/md/raid0.c

258

mdname(mddev),

drivers/md/raid0.c

264

} else if (mddev->layout == RAID0_ORIG_LAYOUT ||

drivers/md/raid0.c

265

mddev->layout == RAID0_ALT_MULTIZONE_LAYOUT) {

drivers/md/raid0.c

266

conf->layout = mddev->layout;

drivers/md/raid0.c

272

mdname(mddev));

drivers/md/raid0.c

282

sector_div(first_sector, mddev->chunk_sectors);

drivers/md/raid0.c

290

pr_debug("md/raid0:%s: done.\n", mdname(mddev));

drivers/md/raid0.c

325

static struct md_rdev *map_sector(struct mddev *mddev, struct strip_zone *zone,

drivers/md/raid0.c

330

struct r0conf *conf = mddev->private;

drivers/md/raid0.c

332

unsigned int chunk_sects = mddev->chunk_sectors;

drivers/md/raid0.c

358

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

drivers/md/raid0.c

366

rdev_for_each(rdev, mddev)

drivers/md/raid0.c

368

~(sector_t)(mddev->chunk_sectors-1));

drivers/md/raid0.c

373

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

drivers/md/raid0.c

38

static void dump_zones(struct mddev *mddev)

drivers/md/raid0.c

382

static int raid0_set_limits(struct mddev *mddev)

drivers/md/raid0.c

388

lim.max_hw_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

389

lim.max_write_zeroes_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

390

lim.max_hw_wzeroes_unmap_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

391

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid0.c

392

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

drivers/md/raid0.c

393

lim.io_opt = lim.io_min * mddev->raid_disks;

drivers/md/raid0.c

394

lim.chunk_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

397

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

drivers/md/raid0.c

400

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

drivers/md/raid0.c

403

static int raid0_run(struct mddev *mddev)

drivers/md/raid0.c

408

if (mddev->chunk_sectors == 0) {

drivers/md/raid0.c

409

pr_warn("md/raid0:%s: chunk size must be set.\n", mdname(mddev));

drivers/md/raid0.c

412

if (md_check_no_bitmap(mddev))

drivers/md/raid0.c

415

if (!mddev_is_dm(mddev)) {

drivers/md/raid0.c

416

ret = raid0_set_limits(mddev);

drivers/md/raid0.c

422

if (mddev->private == NULL) {

drivers/md/raid0.c

423

ret = create_strip_zones(mddev, &conf);

drivers/md/raid0.c

426

mddev->private = conf;

drivers/md/raid0.c

428

conf = mddev->private;

drivers/md/raid0.c

43

struct r0conf *conf = mddev->private;

drivers/md/raid0.c

431

md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));

drivers/md/raid0.c

434

mdname(mddev),

drivers/md/raid0.c

435

(unsigned long long)mddev->array_sectors);

drivers/md/raid0.c

437

dump_zones(mddev);

drivers/md/raid0.c

439

return md_integrity_register(mddev);

drivers/md/raid0.c

456

static void raid0_handle_discard(struct mddev *mddev, struct bio *bio)

drivers/md/raid0.c

458

struct r0conf *conf = mddev->private;

drivers/md/raid0.c

46

mdname(mddev),

drivers/md/raid0.c

477

&mddev->bio_set);

drivers/md/raid0.c

491

stripe_size = zone->nb_dev * mddev->chunk_sectors;

drivers/md/raid0.c

500

sector_div(orig_start, mddev->chunk_sectors);

drivers/md/raid0.c

505

sector_div(orig_end, mddev->chunk_sectors);

drivers/md/raid0.c

511

mddev->chunk_sectors;

drivers/md/raid0.c

513

mddev->chunk_sectors;

drivers/md/raid0.c

516

mddev->chunk_sectors) +

drivers/md/raid0.c

517

first_stripe_index * mddev->chunk_sectors;

drivers/md/raid0.c

519

mddev->chunk_sectors) +

drivers/md/raid0.c

520

last_stripe_index * mddev->chunk_sectors;

drivers/md/raid0.c

532

mddev->chunk_sectors;

drivers/md/raid0.c

534

dev_start = first_stripe_index * mddev->chunk_sectors;

drivers/md/raid0.c

539

dev_end = (last_stripe_index + 1) * mddev->chunk_sectors;

drivers/md/raid0.c

541

dev_end = last_stripe_index * mddev->chunk_sectors;

drivers/md/raid0.c

550

md_submit_discard_bio(mddev, rdev, bio,

drivers/md/raid0.c

557

static void raid0_map_submit_bio(struct mddev *mddev, struct bio *bio)

drivers/md/raid0.c

559

struct r0conf *conf = mddev->private;

drivers/md/raid0.c

565

md_account_bio(mddev, &bio);

drivers/md/raid0.c

567

zone = find_zone(mddev->private, &sector);

drivers/md/raid0.c

570

tmp_dev = map_sector(mddev, zone, bio_sector, &sector);

drivers/md/raid0.c

573

tmp_dev = map_sector(mddev, zone, sector, &sector);

drivers/md/raid0.c

576

WARN(1, "md/raid0:%s: Invalid layout\n", mdname(mddev));

drivers/md/raid0.c

583

md_error(mddev, tmp_dev);

drivers/md/raid0.c

590

mddev_trace_remap(mddev, bio, bio_sector);

drivers/md/raid0.c

591

mddev_check_write_zeroes(mddev, bio);

drivers/md/raid0.c

595

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

drivers/md/raid0.c

602

&& md_flush_request(mddev, bio))

drivers/md/raid0.c

606

raid0_handle_discard(mddev, bio);

drivers/md/raid0.c

611

chunk_sects = mddev->chunk_sectors;

drivers/md/raid0.c

620

&mddev->bio_set);

drivers/md/raid0.c

625

raid0_map_submit_bio(mddev, bio);

drivers/md/raid0.c

629

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

drivers/md/raid0.c

631

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

drivers/md/raid0.c

635

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

drivers/md/raid0.c

637

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

drivers/md/raid0.c

638

char *md_name = mdname(mddev);

drivers/md/raid0.c

645

static void *raid0_takeover_raid45(struct mddev *mddev)

drivers/md/raid0.c

650

if (mddev->degraded != 1) {

drivers/md/raid0.c

652

mdname(mddev),

drivers/md/raid0.c

653

mddev->degraded);

drivers/md/raid0.c

657

rdev_for_each(rdev, mddev) {

drivers/md/raid0.c

659

if (rdev->raid_disk == mddev->raid_disks-1) {

drivers/md/raid0.c

66

static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)

drivers/md/raid0.c

661

mdname(mddev));

drivers/md/raid0.c

664

rdev->sectors = mddev->dev_sectors;

drivers/md/raid0.c

668

mddev->new_level = 0;

drivers/md/raid0.c

669

mddev->new_layout = 0;

drivers/md/raid0.c

670

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

671

mddev->raid_disks--;

drivers/md/raid0.c

672

mddev->delta_disks = -1;

drivers/md/raid0.c

674

mddev->resync_offset = MaxSector;

drivers/md/raid0.c

675

mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);

drivers/md/raid0.c

677

create_strip_zones(mddev, &priv_conf);

drivers/md/raid0.c

682

static void *raid0_takeover_raid10(struct mddev *mddev)

drivers/md/raid0.c

692

if (mddev->layout != ((1 << 8) + 2)) {

drivers/md/raid0.c

694

mdname(mddev),

drivers/md/raid0.c

695

mddev->layout);

drivers/md/raid0.c

698

if (mddev->raid_disks & 1) {

drivers/md/raid0.c

700

mdname(mddev));

drivers/md/raid0.c

703

if (mddev->degraded != (mddev->raid_disks>>1)) {

drivers/md/raid0.c

705

mdname(mddev));

drivers/md/raid0.c

710

mddev->new_level = 0;

drivers/md/raid0.c

711

mddev->new_layout = 0;

drivers/md/raid0.c

712

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

713

mddev->delta_disks = - mddev->raid_disks / 2;

drivers/md/raid0.c

714

mddev->raid_disks += mddev->delta_disks;

drivers/md/raid0.c

715

mddev->degraded = 0;

drivers/md/raid0.c

717

mddev->resync_offset = MaxSector;

drivers/md/raid0.c

718

mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);

drivers/md/raid0.c

720

create_strip_zones(mddev, &priv_conf);

drivers/md/raid0.c

724

static void *raid0_takeover_raid1(struct mddev *mddev)

drivers/md/raid0.c

732

if ((mddev->raid_disks - 1) != mddev->degraded) {

drivers/md/raid0.c

734

mdname(mddev));

drivers/md/raid0.c

745

while (chunksect && (mddev->array_sectors & (chunksect - 1)))

drivers/md/raid0.c

753

mddev->new_level = 0;

drivers/md/raid0.c

754

mddev->new_layout = 0;

drivers/md/raid0.c

755

mddev->new_chunk_sectors = chunksect;

drivers/md/raid0.c

756

mddev->chunk_sectors = chunksect;

drivers/md/raid0.c

757

mddev->delta_disks = 1 - mddev->raid_disks;

drivers/md/raid0.c

758

mddev->raid_disks = 1;

drivers/md/raid0.c

76

if (!mddev_is_dm(mddev))

drivers/md/raid0.c

760

mddev->resync_offset = MaxSector;

drivers/md/raid0.c

761

mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);

drivers/md/raid0.c

763

create_strip_zones(mddev, &priv_conf);

drivers/md/raid0.c

767

static void *raid0_takeover(struct mddev *mddev)

drivers/md/raid0.c

77

blksize = queue_logical_block_size(mddev->gendisk->queue);

drivers/md/raid0.c

776

if (mddev->bitmap) {

drivers/md/raid0.c

778

mdname(mddev));

drivers/md/raid0.c

781

if (mddev->level == 4)

drivers/md/raid0.c

782

return raid0_takeover_raid45(mddev);

drivers/md/raid0.c

784

if (mddev->level == 5) {

drivers/md/raid0.c

785

if (mddev->layout == ALGORITHM_PARITY_N)

drivers/md/raid0.c

786

return raid0_takeover_raid45(mddev);

drivers/md/raid0.c

789

mdname(mddev), ALGORITHM_PARITY_N);

drivers/md/raid0.c

792

if (mddev->level == 10)

drivers/md/raid0.c

793

return raid0_takeover_raid10(mddev);

drivers/md/raid0.c

795

if (mddev->level == 1)

drivers/md/raid0.c

796

return raid0_takeover_raid1(mddev);

drivers/md/raid0.c

799

mddev->level);

drivers/md/raid0.c

804

static void raid0_quiesce(struct mddev *mddev, int quiesce)

drivers/md/raid0.c

82

rdev_for_each(rdev1, mddev) {

drivers/md/raid0.c

84

mdname(mddev),

drivers/md/raid0.c

90

sector_div(sectors, mddev->chunk_sectors);

drivers/md/raid0.c

91

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

drivers/md/raid0.c

93

if (mddev_is_dm(mddev))

drivers/md/raid0.c

97

rdev_for_each(rdev2, 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

1027

test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery),

drivers/md/raid1.c

1030

if (test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery)) {

drivers/md/raid1.c

112

struct mddev *mddev = rdev->mddev;

drivers/md/raid1.c

1226

mddev_add_trace_msg(conf->mddev, "raid1 wait freeze");

drivers/md/raid1.c

1252

&r1_bio->mddev->bio_set);

drivers/md/raid1.c

1295

struct mddev *mddev = plug->cb.data;

drivers/md/raid1.c

1296

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1304

md_wakeup_thread(mddev->thread);

drivers/md/raid1.c

1315

static void init_r1bio(struct r1bio *r1_bio, struct mddev *mddev, struct bio *bio)

drivers/md/raid1.c

1320

r1_bio->mddev = mddev;

drivers/md/raid1.c

1325

alloc_r1bio(struct mddev *mddev, struct bio *bio)

drivers/md/raid1.c

1327

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1332

init_r1bio(r1_bio, mddev, bio);

drivers/md/raid1.c

1336

static void raid1_read_request(struct mddev *mddev, struct bio *bio,

drivers/md/raid1.c

1339

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1352

bool err_path = md_cloned_bio(mddev, bio);

drivers/md/raid1.c

137

mempool_free(si, mddev->serial_info_pool);

drivers/md/raid1.c

1377

r1_bio = alloc_r1bio(mddev, bio);

drivers/md/raid1.c

1379

init_r1bio(r1_bio, mddev, bio);

drivers/md/raid1.c

1391

mdname(mddev),

drivers/md/raid1.c

1401

mdname(mddev),

drivers/md/raid1.c

1406

md_bitmap_enabled(mddev, false)) {

drivers/md/raid1.c

1411

mddev_add_trace_msg(mddev, "raid1 wait behind writes");

drivers/md/raid1.c

1412

if (!mddev->bitmap_ops->wait_behind_writes(mddev, nowait)) {

drivers/md/raid1.c

1432

if (likely(!md_cloned_bio(mddev, bio))) {

drivers/md/raid1.c

1433

md_account_bio(mddev, &bio);

drivers/md/raid1.c

1437

&mddev->bio_set);

drivers/md/raid1.c

1448

mddev_trace_remap(mddev, read_bio, r1_bio->sector);

drivers/md/raid1.c

1457

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

drivers/md/raid1.c

1459

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1480

mddev_add_trace_msg(rdev->mddev, "raid1 wait rdev %d blocked",

drivers/md/raid1.c

1483

md_wait_for_blocked_rdev(rdev, rdev->mddev);

drivers/md/raid1.c

1491

static void raid1_start_write_behind(struct mddev *mddev, struct r1bio *r1_bio,

drivers/md/raid1.c

1494

unsigned long max_write_behind = mddev->bitmap_info.max_write_behind;

drivers/md/raid1.c

1499

if (!md_bitmap_enabled(mddev, false))

drivers/md/raid1.c

1502

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

drivers/md/raid1.c

1511

mddev->bitmap_ops->start_behind_write(mddev);

drivers/md/raid1.c

1515

static bool raid1_write_request(struct mddev *mddev, struct bio *bio,

drivers/md/raid1.c

1518

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1528

if (mddev_is_clustered(mddev) &&

drivers/md/raid1.c

1529

mddev->cluster_ops->area_resyncing(mddev, WRITE, sector,

drivers/md/raid1.c

1537

!mddev->cluster_ops->area_resyncing(mddev, WRITE,

drivers/md/raid1.c

1552

if (!wait_blocked_rdev(mddev, bio)) {

drivers/md/raid1.c

1557

r1_bio = alloc_r1bio(mddev, bio);

drivers/md/raid1.c

1636

if (write_behind && mddev->bitmap)

drivers/md/raid1.c

1649

md_account_bio(mddev, &bio);

drivers/md/raid1.c

1664

raid1_start_write_behind(mddev, r1_bio, bio);

drivers/md/raid1.c

1671

GFP_NOIO, &mddev->bio_set);

drivers/md/raid1.c

1678

&mddev->bio_set);

drivers/md/raid1.c

1680

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

drivers/md/raid1.c

1691

conf->raid_disks - mddev->degraded > 1)

drivers/md/raid1.c

1696

mddev_trace_remap(mddev, mbio, sector);

drivers/md/raid1.c

1699

if (!raid1_add_bio_to_plug(mddev, mbio, raid1_unplug, disks)) {

drivers/md/raid1.c

1703

md_wakeup_thread(mddev->thread);

drivers/md/raid1.c

1717

rdev_dec_pending(conf->mirrors[k].rdev, mddev);

drivers/md/raid1.c

1730

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

drivers/md/raid1.c

1735

&& md_flush_request(mddev, bio))

drivers/md/raid1.c

1749

raid1_read_request(mddev, bio, sectors, NULL);

drivers/md/raid1.c

1751

md_write_start(mddev, bio);

drivers/md/raid1.c

1752

if (!raid1_write_request(mddev, bio, sectors))

drivers/md/raid1.c

1753

md_write_end(mddev);

drivers/md/raid1.c

1758

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

drivers/md/raid1.c

1760

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1763

lockdep_assert_held(&mddev->lock);

drivers/md/raid1.c

1766

conf->raid_disks - mddev->degraded);

drivers/md/raid1.c

1792

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

drivers/md/raid1.c

1794

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1800

(conf->raid_disks - mddev->degraded) == 1) {

drivers/md/raid1.c

1801

set_bit(MD_BROKEN, &mddev->flags);

drivers/md/raid1.c

1803

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

drivers/md/raid1.c

1810

mddev->degraded++;

drivers/md/raid1.c

1816

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid1.c

1817

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/raid1.c

1821

mdname(mddev), rdev->bdev,

drivers/md/raid1.c

1822

mdname(mddev), conf->raid_disks - mddev->degraded);

drivers/md/raid1.c

1834

pr_debug(" --- wd:%d rd:%d\n", conf->raid_disks - conf->mddev->degraded,

drivers/md/raid1.c

1837

lockdep_assert_held(&conf->mddev->reconfig_mutex);

drivers/md/raid1.c

1860

static int raid1_spare_active(struct mddev *mddev)

drivers/md/raid1.c

1863

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1905

mddev->degraded -= count;

drivers/md/raid1.c

1947

rdev->mddev->degraded < conf->raid_disks)

drivers/md/raid1.c

1957

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

drivers/md/raid1.c

1959

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

1982

err = mddev_stack_new_rdev(mddev, rdev);

drivers/md/raid1.c

201

if (test_bit(MD_RECOVERY_REQUESTED, &conf->mddev->recovery))

drivers/md/raid1.c

2012

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

drivers/md/raid1.c

2014

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2061

err = md_integrity_register(mddev);

drivers/md/raid1.c

2087

static void abort_sync_write(struct mddev *mddev, struct r1bio *r1_bio)

drivers/md/raid1.c

2095

md_bitmap_end_sync(mddev, s, &sync_blocks);

drivers/md/raid1.c

2104

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2112

md_done_sync(mddev, s);

drivers/md/raid1.c

2120

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2121

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2125

abort_sync_write(mddev, r1_bio);

drivers/md/raid1.c

2129

mddev->recovery);

drivers/md/raid1.c

2151

rdev->mddev->recovery);

drivers/md/raid1.c

2171

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2172

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2184

md_error(mddev, rdev);

drivers/md/raid1.c

2227

mdname(mddev), bio->bi_bdev,

drivers/md/raid1.c

2259

rdev_dec_pending(rdev, mddev);

drivers/md/raid1.c

2293

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2294

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2324

rdev_dec_pending(conf->mirrors[primary].rdev, mddev);

drivers/md/raid1.c

2357

atomic64_add(r1_bio->sectors, &mddev->resync_mismatches);

drivers/md/raid1.c

2358

if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)

drivers/md/raid1.c

2362

rdev_dec_pending(conf->mirrors[i].rdev, mddev);

drivers/md/raid1.c

2370

static void sync_request_write(struct mddev *mddev, struct r1bio *r1_bio)

drivers/md/raid1.c

2372

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2383

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

drivers/md/raid1.c

2385

md_done_sync(mddev, r1_bio->sectors);

drivers/md/raid1.c

2386

md_sync_error(mddev);

drivers/md/raid1.c

2392

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

drivers/md/raid1.c

2404

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

drivers/md/raid1.c

2407

abort_sync_write(mddev, r1_bio);

drivers/md/raid1.c

2437

struct mddev *mddev = conf->mddev;

drivers/md/raid1.c

2460

rdev_dec_pending(rdev, mddev);

drivers/md/raid1.c

2488

rdev_dec_pending(rdev, mddev);

drivers/md/raid1.c

2504

mdname(mddev), s,

drivers/md/raid1.c

2509

rdev_dec_pending(rdev, mddev);

drivers/md/raid1.c

2519

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

2520

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2558

GFP_NOIO, &mddev->bio_set);

drivers/md/raid1.c

2561

GFP_NOIO, &mddev->bio_set);

drivers/md/raid1.c

2605

md_done_sync(conf->mddev, s);

drivers/md/raid1.c

2619

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid1.c

2628

conf->mddev);

drivers/md/raid1.c

2641

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid1.c

2653

struct mddev *mddev = conf->mddev;

drivers/md/raid1.c

2670

if (mddev->ro) {

drivers/md/raid1.c

2673

md_error(mddev, rdev);

drivers/md/raid1.c

2676

if (exceed_read_errors(mddev, rdev))

drivers/md/raid1.c

2683

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid1.c

2689

raid1_read_request(mddev, bio, r1_bio->sectors, r1_bio);

drivers/md/raid1.c

2695

struct mddev *mddev = thread->mddev;

drivers/md/raid1.c

2698

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2703

md_check_recovery(mddev);

drivers/md/raid1.c

2706

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {

drivers/md/raid1.c

2709

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

drivers/md/raid1.c

2740

mddev = r1_bio->mddev;

drivers/md/raid1.c

2741

conf = mddev->private;

drivers/md/raid1.c

2747

sync_request_write(mddev, r1_bio);

drivers/md/raid1.c

2757

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

drivers/md/raid1.c

2758

md_check_recovery(mddev);

drivers/md/raid1.c

276

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

2801

static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,

drivers/md/raid1.c

2804

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

2829

if (mddev->curr_resync < max_sector) /* aborted */

drivers/md/raid1.c

2830

md_bitmap_end_sync(mddev, mddev->curr_resync,

drivers/md/raid1.c

2835

if (md_bitmap_enabled(mddev, false))

drivers/md/raid1.c

2836

mddev->bitmap_ops->close_sync(mddev);

drivers/md/raid1.c

2839

if (mddev_is_clustered(mddev)) {

drivers/md/raid1.c

284

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

2846

if (mddev->bitmap == NULL &&

drivers/md/raid1.c

2847

mddev->resync_offset == MaxSector &&

drivers/md/raid1.c

2848

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

drivers/md/raid1.c

2856

if (!md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, true) &&

drivers/md/raid1.c

2857

!conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {

drivers/md/raid1.c

2873

if (md_bitmap_enabled(mddev, false))

drivers/md/raid1.c

2874

mddev->bitmap_ops->cond_end_sync(mddev, sector_nr,

drivers/md/raid1.c

2875

mddev_is_clustered(mddev) &&

drivers/md/raid1.c

2893

r1_bio->mddev = mddev;

drivers/md/raid1.c

291

rdev_dec_pending(conf->mirrors[i].rdev, r1_bio->mddev);

drivers/md/raid1.c

2941

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

drivers/md/raid1.c

2942

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

drivers/md/raid1.c

2978

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid1.c

2997

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

drivers/md/raid1.c

3014

if (max_sector > mddev->resync_max)

drivers/md/raid1.c

3015

max_sector = mddev->resync_max; /* Don't do IO beyond here */

drivers/md/raid1.c

302

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

3028

if (!md_bitmap_start_sync(mddev, sector_nr,

drivers/md/raid1.c

303

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

3031

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

drivers/md/raid1.c

3059

if (mddev_is_clustered(mddev) &&

drivers/md/raid1.c

3061

conf->cluster_sync_low = mddev->curr_resync_completed;

drivers/md/raid1.c

3064

mddev->cluster_ops->resync_info_update(mddev,

drivers/md/raid1.c

3072

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

drivers/md/raid1.c

3093

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

drivers/md/raid1.c

3098

return mddev->dev_sectors;

drivers/md/raid1.c

3101

static struct r1conf *setup_conf(struct mddev *mddev)

drivers/md/raid1.c

313

md_wakeup_thread(mddev->thread);

drivers/md/raid1.c

3131

mddev->raid_disks, 2),

drivers/md/raid1.c

3140

r1bio_size = offsetof(struct r1bio, bios[mddev->raid_disks * 2]);

drivers/md/raid1.c

3151

conf->raid_disks = mddev->raid_disks;

drivers/md/raid1.c

3152

rdev_for_each(rdev, mddev) {

drivers/md/raid1.c

3162

conf->mddev = mddev;

drivers/md/raid1.c

3202

md_register_thread(raid1d, mddev, "raid1"));

drivers/md/raid1.c

3223

static int raid1_set_limits(struct mddev *mddev)

drivers/md/raid1.c

3231

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid1.c

3234

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

drivers/md/raid1.c

3237

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

drivers/md/raid1.c

3240

static int raid1_run(struct mddev *mddev)

drivers/md/raid1.c

3246

if (mddev->level != 1) {

drivers/md/raid1.c

3248

mdname(mddev), mddev->level);

drivers/md/raid1.c

3251

if (mddev->reshape_position != MaxSector) {

drivers/md/raid1.c

3253

mdname(mddev));

drivers/md/raid1.c

3262

if (mddev->private == NULL)

drivers/md/raid1.c

3263

conf = setup_conf(mddev);

drivers/md/raid1.c

3265

conf = mddev->private;

drivers/md/raid1.c

3270

if (!mddev_is_dm(mddev)) {

drivers/md/raid1.c

3271

ret = raid1_set_limits(mddev);

drivers/md/raid1.c

3273

md_unregister_thread(mddev, &conf->thread);

drivers/md/raid1.c

3274

if (!mddev->private)

drivers/md/raid1.c

3275

raid1_free(mddev, conf);

drivers/md/raid1.c

3280

mddev->degraded = 0;

drivers/md/raid1.c

3285

mddev->degraded++;

drivers/md/raid1.c

3289

if (conf->raid_disks - mddev->degraded < 1) {

drivers/md/raid1.c

3290

md_unregister_thread(mddev, &conf->thread);

drivers/md/raid1.c

3291

if (!mddev->private)

drivers/md/raid1.c

3292

raid1_free(mddev, conf);

drivers/md/raid1.c

3296

if (conf->raid_disks - mddev->degraded == 1)

drivers/md/raid1.c

3297

mddev->resync_offset = MaxSector;

drivers/md/raid1.c

3299

if (mddev->resync_offset != MaxSector)

drivers/md/raid1.c

3301

mdname(mddev));

drivers/md/raid1.c

3303

mdname(mddev), mddev->raid_disks - mddev->degraded,

drivers/md/raid1.c

3304

mddev->raid_disks);

drivers/md/raid1.c

3309

rcu_assign_pointer(mddev->thread, conf->thread);

drivers/md/raid1.c

3311

mddev->private = conf;

drivers/md/raid1.c

3312

set_bit(MD_FAILFAST_SUPPORTED, &mddev->flags);

drivers/md/raid1.c

3314

md_set_array_sectors(mddev, raid1_size(mddev, 0, 0));

drivers/md/raid1.c

3316

ret = md_integrity_register(mddev);

drivers/md/raid1.c

3318

md_unregister_thread(mddev, &mddev->thread);

drivers/md/raid1.c

3322

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

drivers/md/raid1.c

3337

static int raid1_resize(struct mddev *mddev, sector_t sectors)

drivers/md/raid1.c

334

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

3346

sector_t newsize = raid1_size(mddev, sectors, 0);

drivers/md/raid1.c

3348

if (mddev->external_size &&

drivers/md/raid1.c

3349

mddev->array_sectors > newsize)

drivers/md/raid1.c

3352

if (md_bitmap_enabled(mddev, false)) {

drivers/md/raid1.c

3353

int ret = mddev->bitmap_ops->resize(mddev, newsize, 0);

drivers/md/raid1.c

3359

md_set_array_sectors(mddev, newsize);

drivers/md/raid1.c

3360

if (sectors > mddev->dev_sectors &&

drivers/md/raid1.c

3361

mddev->resync_offset > mddev->dev_sectors) {

drivers/md/raid1.c

3362

mddev->resync_offset = mddev->dev_sectors;

drivers/md/raid1.c

3363

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid1.c

3365

mddev->dev_sectors = sectors;

drivers/md/raid1.c

3366

mddev->resync_max_sectors = sectors;

drivers/md/raid1.c

3370

static int raid1_reshape(struct mddev *mddev)

drivers/md/raid1.c

3386

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

3392

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

drivers/md/raid1.c

3393

mddev->layout != mddev->new_layout ||

drivers/md/raid1.c

3394

mddev->level != mddev->new_level) {

drivers/md/raid1.c

3395

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid1.c

3396

mddev->new_layout = mddev->layout;

drivers/md/raid1.c

3397

mddev->new_level = mddev->level;

drivers/md/raid1.c

3401

if (!mddev_is_clustered(mddev))

drivers/md/raid1.c

3402

md_allow_write(mddev);

drivers/md/raid1.c

3404

raid_disks = mddev->raid_disks + mddev->delta_disks;

drivers/md/raid1.c

3437

sysfs_unlink_rdev(mddev, rdev);

drivers/md/raid1.c

3439

sysfs_unlink_rdev(mddev, rdev);

drivers/md/raid1.c

3440

if (sysfs_link_rdev(mddev, rdev))

drivers/md/raid1.c

3442

mdname(mddev), rdev->raid_disk);

drivers/md/raid1.c

3451

mddev->degraded += (raid_disks - conf->raid_disks);

drivers/md/raid1.c

3453

conf->raid_disks = mddev->raid_disks = raid_disks;

drivers/md/raid1.c

3454

mddev->delta_disks = 0;

drivers/md/raid1.c

3458

set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);

drivers/md/raid1.c

3459

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid1.c

3460

md_wakeup_thread(mddev->thread);

drivers/md/raid1.c

3466

static void raid1_quiesce(struct mddev *mddev, int quiesce)

drivers/md/raid1.c

3468

struct r1conf *conf = mddev->private;

drivers/md/raid1.c

3476

static void *raid1_takeover(struct mddev *mddev)

drivers/md/raid1.c

3481

if (mddev->level == 5 && mddev->raid_disks == 2) {

drivers/md/raid1.c

3483

mddev->new_level = 1;

drivers/md/raid1.c

3484

mddev->new_layout = 0;

drivers/md/raid1.c

3485

mddev->new_chunk_sectors = 0;

drivers/md/raid1.c

3486

conf = setup_conf(mddev);

drivers/md/raid1.c

3490

mddev_clear_unsupported_flags(mddev,

drivers/md/raid1.c

360

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

372

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

389

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

413

if (r1_bio->mddev->degraded == conf->raid_disks ||

drivers/md/raid1.c

414

(r1_bio->mddev->degraded == conf->raid_disks-1 &&

drivers/md/raid1.c

422

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid1.c

428

mdname(conf->mddev),

drivers/md/raid1.c

439

struct mddev *mddev = r1_bio->mddev;

drivers/md/raid1.c

449

mddev->bitmap_ops->end_behind_write(mddev);

drivers/md/raid1.c

450

md_write_end(mddev);

drivers/md/raid1.c

473

struct r1conf *conf = r1_bio->mddev->private;

drivers/md/raid1.c

489

conf->mddev->recovery);

drivers/md/raid1.c

49

static void raid1_free(struct mddev *mddev, void *priv);

drivers/md/raid1.c

495

md_error(r1_bio->mddev, rdev);

drivers/md/raid1.c

567

} else if (test_bit(MD_SERIALIZE_POLICY, &rdev->mddev->flags))

drivers/md/raid1.c

570

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid1.c

893

if (raid1_should_read_first(conf->mddev, r1_bio->sector,

drivers/md/raid1.c

92

struct mddev *mddev = rdev->mddev;

drivers/md/raid1.c

926

raid1_prepare_flush_writes(conf->mddev);

drivers/md/raid1.c

95

if (WARN_ON(!mddev->serial_info_pool))

drivers/md/raid1.c

97

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

1164

bool err_path = md_cloned_bio(mddev, bio);

drivers/md/raid10.c

1194

if (!regular_request_wait(mddev, conf, bio, r10_bio->sectors)) {

drivers/md/raid10.c

1203

mdname(mddev), b,

drivers/md/raid10.c

1211

mdname(mddev),

drivers/md/raid10.c

1229

if (likely(!md_cloned_bio(mddev, bio))) {

drivers/md/raid10.c

1230

md_account_bio(mddev, &bio);

drivers/md/raid10.c

1233

read_bio = bio_alloc_clone(rdev->bdev, bio, gfp, &mddev->bio_set);

drivers/md/raid10.c

1246

mddev_trace_remap(mddev, read_bio, r10_bio->sector);

drivers/md/raid10.c

1254

static void raid10_write_one_disk(struct mddev *mddev, struct r10bio *r10_bio,

drivers/md/raid10.c

1259

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1267

mbio = bio_alloc_clone(rdev->bdev, bio, GFP_NOIO, &mddev->bio_set);

drivers/md/raid10.c

1282

mddev_trace_remap(mddev, mbio, r10_bio->sector);

drivers/md/raid10.c

1288

if (!raid1_add_bio_to_plug(mddev, mbio, raid10_unplug, conf->copies)) {

drivers/md/raid10.c

1292

md_wakeup_thread(mddev->thread);

drivers/md/raid10.c

1296

static void wait_blocked_dev(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

1298

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1343

mddev_add_trace_msg(conf->mddev,

drivers/md/raid10.c

1346

md_wait_for_blocked_rdev(blocked_rdev, mddev);

drivers/md/raid10.c

1352

static bool raid10_write_request(struct mddev *mddev, struct bio *bio,

drivers/md/raid10.c

1355

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1360

if ((mddev_is_clustered(mddev) &&

drivers/md/raid10.c

1361

mddev->cluster_ops->area_resyncing(mddev, WRITE,

drivers/md/raid10.c

1373

if (!mddev->cluster_ops->area_resyncing(mddev, WRITE,

drivers/md/raid10.c

1382

if (!regular_request_wait(mddev, conf, bio, sectors)) {

drivers/md/raid10.c

1387

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

drivers/md/raid10.c

1388

(mddev->reshape_backwards

drivers/md/raid10.c

1394

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid10.c

1395

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/raid10.c

1397

md_wakeup_thread(mddev->thread);

drivers/md/raid10.c

1403

mddev_add_trace_msg(conf->mddev,

drivers/md/raid10.c

1405

wait_event(mddev->sb_wait,

drivers/md/raid10.c

1406

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));

drivers/md/raid10.c

1408

conf->reshape_safe = mddev->reshape_position;

drivers/md/raid10.c

1424

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

1506

md_account_bio(mddev, &bio);

drivers/md/raid10.c

1512

raid10_write_one_disk(mddev, r10_bio, bio, false, i);

drivers/md/raid10.c

1514

raid10_write_one_disk(mddev, r10_bio, bio, true, i);

drivers/md/raid10.c

1526

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

1530

rdev_dec_pending(rrdev, mddev);

drivers/md/raid10.c

1539

static bool __make_request(struct mddev *mddev, struct bio *bio, int sectors)

drivers/md/raid10.c

1542

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1550

r10_bio->mddev = mddev;

drivers/md/raid10.c

1559

raid10_read_request(mddev, bio, r10_bio);

drivers/md/raid10.c

1561

ret = raid10_write_request(mddev, bio, r10_bio);

drivers/md/raid10.c

1568

struct r10conf *conf = r10bio->mddev->private;

drivers/md/raid10.c

1580

md_write_end(r10bio->mddev);

drivers/md/raid10.c

1591

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

1607

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

1616

static int raid10_handle_discard(struct mddev *mddev, struct bio *bio)

drivers/md/raid10.c

1618

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1637

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

drivers/md/raid10.c

1642

md_write_end(mddev);

drivers/md/raid10.c

1650

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

drivers/md/raid10.c

1685

md_write_end(mddev);

drivers/md/raid10.c

1704

md_write_end(mddev);

drivers/md/raid10.c

1746

r10_bio->mddev = mddev;

drivers/md/raid10.c

1751

wait_blocked_dev(mddev, r10_bio);

drivers/md/raid10.c

1761

md_account_bio(mddev, &bio);

drivers/md/raid10.c

1817

dev_start = (first_stripe_index + 1) * mddev->chunk_sectors;

drivers/md/raid10.c

1819

dev_start = first_stripe_index * mddev->chunk_sectors;

drivers/md/raid10.c

1824

dev_end = (last_stripe_index + 1) * mddev->chunk_sectors;

drivers/md/raid10.c

1826

dev_end = last_stripe_index * mddev->chunk_sectors;

drivers/md/raid10.c

1839

&mddev->bio_set);

drivers/md/raid10.c

1845

md_submit_discard_bio(mddev, rdev, mbio,

drivers/md/raid10.c

1853

&mddev->bio_set);

drivers/md/raid10.c

1859

md_submit_discard_bio(mddev, rrdev, rbio,

drivers/md/raid10.c

1885

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

drivers/md/raid10.c

1887

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1893

&& md_flush_request(mddev, bio))

drivers/md/raid10.c

1896

md_write_start(mddev, bio);

drivers/md/raid10.c

1899

if (!raid10_handle_discard(mddev, bio))

drivers/md/raid10.c

191

&conf->mddev->recovery)) {

drivers/md/raid10.c

1914

if (!__make_request(mddev, bio, sectors))

drivers/md/raid10.c

1915

md_write_end(mddev);

drivers/md/raid10.c

1922

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

drivers/md/raid10.c

1924

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

1927

lockdep_assert_held(&mddev->lock);

drivers/md/raid10.c

1930

seq_printf(seq, " %dK chunks", mddev->chunk_sectors / 2);

drivers/md/raid10.c

1942

conf->geo.raid_disks - mddev->degraded);

drivers/md/raid10.c

2016

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

drivers/md/raid10.c

2018

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2024

set_bit(MD_BROKEN, &mddev->flags);

drivers/md/raid10.c

2026

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

drivers/md/raid10.c

2032

mddev->degraded++;

drivers/md/raid10.c

2034

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid10.c

2037

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/raid10.c

2042

mdname(mddev), rdev->bdev,

drivers/md/raid10.c

2043

mdname(mddev), conf->geo.raid_disks - mddev->degraded);

drivers/md/raid10.c

2056

pr_debug(" --- wd:%d rd:%d\n", conf->geo.raid_disks - conf->mddev->degraded,

drivers/md/raid10.c

2059

lockdep_assert_held(&conf->mddev->reconfig_mutex);

drivers/md/raid10.c

2078

static int raid10_spare_active(struct mddev *mddev)

drivers/md/raid10.c

2081

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2119

mddev->degraded -= count;

drivers/md/raid10.c

2126

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

drivers/md/raid10.c

2128

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2135

if (mddev->resync_offset < MaxSector)

drivers/md/raid10.c

2161

err = mddev_stack_new_rdev(mddev, rdev);

drivers/md/raid10.c

2178

err = mddev_stack_new_rdev(mddev, rdev);

drivers/md/raid10.c

2189

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

drivers/md/raid10.c

2191

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2198

if (unlikely(number >= mddev->raid_disks))

drivers/md/raid10.c

2232

err = md_integrity_register(mddev);

drivers/md/raid10.c

2242

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

2256

rdev_dec_pending(conf->mirrors[d].rdev, conf->mddev);

drivers/md/raid10.c

2269

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

2285

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

2296

md_done_sync(mddev, s);

drivers/md/raid10.c

2313

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

2314

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2328

md_error(mddev, rdev);

drivers/md/raid10.c

2333

&rdev->mddev->recovery);

drivers/md/raid10.c

2341

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

2362

static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

2364

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2421

atomic64_add(r10_bio->sectors, &mddev->resync_mismatches);

drivers/md/raid10.c

2422

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

drivers/md/raid10.c

2427

md_error(rdev->mddev, rdev);

drivers/md/raid10.c

2472

md_done_sync(mddev, r10_bio->sectors);

drivers/md/raid10.c

2496

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

2497

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2535

&rdev->mddev->recovery);

drivers/md/raid10.c

2553

mdname(mddev));

drivers/md/raid10.c

2556

&mddev->recovery);

drivers/md/raid10.c

2568

static void recovery_request_write(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

2570

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2619

&rdev->mddev->recovery);

drivers/md/raid10.c

2634

static void fix_read_error(struct r10conf *conf, struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

2651

if (exceed_read_errors(mddev, rdev)) {

drivers/md/raid10.c

2681

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

2730

mdname(mddev), s,

drivers/md/raid10.c

2737

mdname(mddev),

drivers/md/raid10.c

2740

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

2762

mdname(mddev), s,

drivers/md/raid10.c

2768

mdname(mddev),

drivers/md/raid10.c

277

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

2773

mdname(mddev), s,

drivers/md/raid10.c

2781

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

2792

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

2793

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2828

&mddev->bio_set);

drivers/md/raid10.c

285

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

2852

static void handle_read_error(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

2856

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2871

if (mddev->ro)

drivers/md/raid10.c

2875

fix_read_error(conf, mddev, r10_bio);

drivers/md/raid10.c

2878

md_error(mddev, rdev);

drivers/md/raid10.c

2880

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

2882

raid10_read_request(mddev, r10_bio->master_bio, r10_bio);

drivers/md/raid10.c

2945

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

2949

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

2958

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

2971

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid10.c

2983

struct mddev *mddev = thread->mddev;

drivers/md/raid10.c

2986

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

2990

md_check_recovery(mddev);

drivers/md/raid10.c

2993

!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {

drivers/md/raid10.c

2996

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

drivers/md/raid10.c

301

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

302

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

3030

mddev = r10_bio->mddev;

drivers/md/raid10.c

3031

conf = mddev->private;

drivers/md/raid10.c

3036

reshape_request_write(mddev, r10_bio);

drivers/md/raid10.c

3038

sync_request_write(mddev, r10_bio);

drivers/md/raid10.c

3040

recovery_request_write(mddev, r10_bio);

drivers/md/raid10.c

3042

handle_read_error(mddev, r10_bio);

drivers/md/raid10.c

3047

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

drivers/md/raid10.c

3048

md_check_recovery(mddev);

drivers/md/raid10.c

3079

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

drivers/md/raid10.c

3080

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

drivers/md/raid10.c

312

md_wakeup_thread(mddev->thread);

drivers/md/raid10.c

3126

window_size = (chunks + extra_chunk) * conf->mddev->chunk_sectors;

drivers/md/raid10.c

3169

static sector_t raid10_sync_request(struct mddev *mddev, sector_t sector_nr,

drivers/md/raid10.c

3172

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

3186

if (mddev->bitmap == NULL &&

drivers/md/raid10.c

3187

mddev->resync_offset == MaxSector &&

drivers/md/raid10.c

3188

mddev->reshape_position == MaxSector &&

drivers/md/raid10.c

3189

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

drivers/md/raid10.c

3190

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

drivers/md/raid10.c

3191

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

drivers/md/raid10.c

3194

return mddev->dev_sectors - sector_nr;

drivers/md/raid10.c

3214

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

drivers/md/raid10.c

3220

if (mddev->curr_resync < max_sector) { /* aborted */

drivers/md/raid10.c

3221

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

drivers/md/raid10.c

3222

md_bitmap_end_sync(mddev, mddev->curr_resync,

drivers/md/raid10.c

3226

raid10_find_virt(conf, mddev->curr_resync, i);

drivers/md/raid10.c

3228

md_bitmap_end_sync(mddev, sect, &sync_blocks);

drivers/md/raid10.c

323

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

3232

if ((!mddev->bitmap || conf->fullsync)

drivers/md/raid10.c

3234

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

drivers/md/raid10.c

3248

if (md_bitmap_enabled(mddev, false))

drivers/md/raid10.c

3249

mddev->bitmap_ops->close_sync(mddev);

drivers/md/raid10.c

3255

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

drivers/md/raid10.c

3256

return reshape_request(mddev, sector_nr, skipped);

drivers/md/raid10.c

3258

if (max_sector > mddev->resync_max)

drivers/md/raid10.c

3259

max_sector = mddev->resync_max; /* Don't do IO beyond here */

drivers/md/raid10.c

3291

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

drivers/md/raid10.c

3321

if (sect >= mddev->resync_max_sectors)

drivers/md/raid10.c

3330

must_sync = md_bitmap_start_sync(mddev, sect,

drivers/md/raid10.c

3355

r10_bio->mddev = mddev;

drivers/md/raid10.c

3373

md_bitmap_start_sync(mddev, sect, &sync_blocks,

drivers/md/raid10.c

345

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

3482

mdname(mddev), r10_bio->devs[k].addr, max_sync);

drivers/md/raid10.c

3489

rdev_dec_pending(mrdev, mddev);

drivers/md/raid10.c

3491

rdev_dec_pending(mreplace, mddev);

drivers/md/raid10.c

3495

rdev_dec_pending(mrdev, mddev);

drivers/md/raid10.c

3497

rdev_dec_pending(mreplace, mddev);

drivers/md/raid10.c

3537

if (md_bitmap_enabled(mddev, false))

drivers/md/raid10.c

3538

mddev->bitmap_ops->cond_end_sync(mddev, sector_nr,

drivers/md/raid10.c

3539

mddev_is_clustered(mddev) &&

drivers/md/raid10.c

3542

if (!md_bitmap_start_sync(mddev, sector_nr, &sync_blocks,

drivers/md/raid10.c

3543

mddev->degraded) &&

drivers/md/raid10.c

3545

&mddev->recovery)) {

drivers/md/raid10.c

3555

r10_bio->mddev = mddev;

drivers/md/raid10.c

3632

mddev);

drivers/md/raid10.c

3637

mddev);

drivers/md/raid10.c

3670

if (mddev_is_clustered(mddev) &&

drivers/md/raid10.c

3671

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

drivers/md/raid10.c

3674

conf->cluster_sync_low = mddev->curr_resync_completed;

drivers/md/raid10.c

3677

mddev->cluster_ops->resync_info_update(mddev,

drivers/md/raid10.c

3681

} else if (mddev_is_clustered(mddev)) {

drivers/md/raid10.c

3701

mddev->curr_resync_completed, i);

drivers/md/raid10.c

3710

mddev->cluster_ops->resync_info_update(mddev,

drivers/md/raid10.c

3734

raid10_size(struct mddev *mddev, sector_t sectors, int raid_disks)

drivers/md/raid10.c

3737

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

3784

static int setup_geo(struct geom *geo, struct mddev *mddev, enum geo_type new)

drivers/md/raid10.c

3790

layout = mddev->layout;

drivers/md/raid10.c

3791

chunk = mddev->chunk_sectors;

drivers/md/raid10.c

3792

disks = mddev->raid_disks - mddev->delta_disks;

drivers/md/raid10.c

3795

layout = mddev->new_layout;

drivers/md/raid10.c

3796

chunk = mddev->new_chunk_sectors;

drivers/md/raid10.c

3797

disks = mddev->raid_disks;

drivers/md/raid10.c

3802

layout = mddev->new_layout;

drivers/md/raid10.c

3803

chunk = mddev->new_chunk_sectors;

drivers/md/raid10.c

3804

disks = mddev->raid_disks + mddev->delta_disks;

drivers/md/raid10.c

384

struct r10conf *conf = r10_bio->mddev->private;

drivers/md/raid10.c

3856

static struct r10conf *setup_conf(struct mddev *mddev)

drivers/md/raid10.c

3863

copies = setup_geo(&geo, mddev, geo_new);

drivers/md/raid10.c

3867

mdname(mddev), PAGE_SIZE);

drivers/md/raid10.c

3871

if (copies < 2 || copies > mddev->raid_disks) {

drivers/md/raid10.c

3873

mdname(mddev), mddev->new_layout);

drivers/md/raid10.c

3884

mddev->raid_disks + max(0, -mddev->delta_disks));

drivers/md/raid10.c

3903

calc_sectors(conf, mddev->dev_sectors);

drivers/md/raid10.c

3904

if (mddev->reshape_position == MaxSector) {

drivers/md/raid10.c

3908

if (setup_geo(&conf->prev, mddev, geo_old) != conf->copies) {

drivers/md/raid10.c

3912

conf->reshape_progress = mddev->reshape_position;

drivers/md/raid10.c

3930

md_register_thread(raid10d, mddev, "raid10"));

drivers/md/raid10.c

3934

conf->mddev = mddev;

drivers/md/raid10.c

3951

static int raid10_set_queue_limits(struct mddev *mddev)

drivers/md/raid10.c

3953

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

3960

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid10.c

3961

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

drivers/md/raid10.c

3962

lim.chunk_sectors = mddev->chunk_sectors;

drivers/md/raid10.c

3966

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

drivers/md/raid10.c

3969

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

drivers/md/raid10.c

3972

static int raid10_run(struct mddev *mddev)

drivers/md/raid10.c

3983

if (mddev->private == NULL) {

drivers/md/raid10.c

3984

conf = setup_conf(mddev);

drivers/md/raid10.c

3987

mddev->private = conf;

drivers/md/raid10.c

3989

conf = mddev->private;

drivers/md/raid10.c

3993

rcu_assign_pointer(mddev->thread, conf->thread);

drivers/md/raid10.c

3996

if (mddev_is_clustered(conf->mddev)) {

drivers/md/raid10.c

3999

fc = (mddev->layout >> 8) & 255;

drivers/md/raid10.c

4000

fo = mddev->layout & (1<<16);

drivers/md/raid10.c

4008

rdev_for_each(rdev, mddev) {

drivers/md/raid10.c

4029

if (!mddev->reshape_backwards)

drivers/md/raid10.c

4040

if (!mddev_is_dm(conf->mddev)) {

drivers/md/raid10.c

4041

int err = raid10_set_queue_limits(mddev);

drivers/md/raid10.c

4052

mdname(mddev));

drivers/md/raid10.c

4066

mddev->degraded = 0;

drivers/md/raid10.c

4084

mddev->degraded++;

drivers/md/raid10.c

4097

if (mddev->resync_offset != MaxSector)

drivers/md/raid10.c

4099

mdname(mddev));

drivers/md/raid10.c

4101

mdname(mddev), conf->geo.raid_disks - mddev->degraded,

drivers/md/raid10.c

4106

mddev->dev_sectors = conf->dev_sectors;

drivers/md/raid10.c

4107

size = raid10_size(mddev, 0, 0);

drivers/md/raid10.c

4108

md_set_array_sectors(mddev, size);

drivers/md/raid10.c

4109

mddev->resync_max_sectors = size;

drivers/md/raid10.c

4110

set_bit(MD_FAILFAST_SUPPORTED, &mddev->flags);

drivers/md/raid10.c

4112

if (md_integrity_register(mddev))

drivers/md/raid10.c

4130

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/raid10.c

4131

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/raid10.c

4132

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/raid10.c

4133

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid10.c

4139

md_unregister_thread(mddev, &mddev->thread);

drivers/md/raid10.c

4141

mddev->private = NULL;

drivers/md/raid10.c

4146

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

drivers/md/raid10.c

4151

static void raid10_quiesce(struct mddev *mddev, int quiesce)

drivers/md/raid10.c

4153

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4161

static int raid10_resize(struct mddev *mddev, sector_t sectors)

drivers/md/raid10.c

4175

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4178

if (mddev->reshape_position != MaxSector)

drivers/md/raid10.c

418

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid10.c

4184

oldsize = raid10_size(mddev, 0, 0);

drivers/md/raid10.c

4185

size = raid10_size(mddev, sectors, 0);

drivers/md/raid10.c

4186

if (mddev->external_size &&

drivers/md/raid10.c

4187

mddev->array_sectors > size)

drivers/md/raid10.c

4190

if (md_bitmap_enabled(mddev, false)) {

drivers/md/raid10.c

4191

int ret = mddev->bitmap_ops->resize(mddev, size, 0);

drivers/md/raid10.c

4197

md_set_array_sectors(mddev, size);

drivers/md/raid10.c

4198

if (sectors > mddev->dev_sectors &&

drivers/md/raid10.c

4199

mddev->resync_offset > oldsize) {

drivers/md/raid10.c

4200

mddev->resync_offset = oldsize;

drivers/md/raid10.c

4201

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid10.c

4204

mddev->dev_sectors = conf->dev_sectors;

drivers/md/raid10.c

4205

mddev->resync_max_sectors = size;

drivers/md/raid10.c

4209

static void *raid10_takeover_raid0(struct mddev *mddev, sector_t size, int devs)

drivers/md/raid10.c

4214

if (mddev->degraded > 0) {

drivers/md/raid10.c

4216

mdname(mddev));

drivers/md/raid10.c

4222

mddev->new_level = 10;

drivers/md/raid10.c

4224

mddev->new_layout = (1<<8) + 2;

drivers/md/raid10.c

4225

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid10.c

4226

mddev->delta_disks = mddev->raid_disks;

drivers/md/raid10.c

4227

mddev->raid_disks *= 2;

drivers/md/raid10.c

4229

mddev->resync_offset = MaxSector;

drivers/md/raid10.c

4230

mddev->dev_sectors = size;

drivers/md/raid10.c

4232

conf = setup_conf(mddev);

drivers/md/raid10.c

4234

rdev_for_each(rdev, mddev)

drivers/md/raid10.c

424

mdname(conf->mddev),

drivers/md/raid10.c

4244

static void *raid10_takeover(struct mddev *mddev)

drivers/md/raid10.c

4251

if (mddev->level == 0) {

drivers/md/raid10.c

4253

raid0_conf = mddev->private;

drivers/md/raid10.c

4256

mdname(mddev));

drivers/md/raid10.c

4259

return raid10_takeover_raid0(mddev,

drivers/md/raid10.c

4266

static int raid10_check_reshape(struct mddev *mddev)

drivers/md/raid10.c

4282

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4288

if (setup_geo(&geo, mddev, geo_start) != conf->copies)

drivers/md/raid10.c

4295

if (mddev->array_sectors & geo.chunk_mask)

drivers/md/raid10.c

4304

if (mddev->delta_disks > 0) {

drivers/md/raid10.c

4308

mddev->raid_disks + mddev->delta_disks);

drivers/md/raid10.c

434

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

436

md_write_end(mddev);

drivers/md/raid10.c

4370

static int raid10_start_reshape(struct mddev *mddev)

drivers/md/raid10.c

4386

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4391

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

drivers/md/raid10.c

4394

if (setup_geo(&new, mddev, geo_start) != conf->copies)

drivers/md/raid10.c

4402

rdev_for_each(rdev, mddev) {

drivers/md/raid10.c

4409

if (!mddev->reshape_backwards)

drivers/md/raid10.c

4422

if (spares < mddev->delta_disks)

drivers/md/raid10.c

4436

setup_geo(&conf->geo, mddev, geo_start);

drivers/md/raid10.c

4438

if (mddev->reshape_backwards) {

drivers/md/raid10.c

4439

sector_t size = raid10_size(mddev, 0, 0);

drivers/md/raid10.c

4440

if (size < mddev->array_sectors) {

drivers/md/raid10.c

4443

mdname(mddev));

drivers/md/raid10.c

4446

mddev->resync_max_sectors = size;

drivers/md/raid10.c

4453

if (mddev->delta_disks && mddev->bitmap) {

drivers/md/raid10.c

4457

oldsize = raid10_size(mddev, 0, 0);

drivers/md/raid10.c

4458

newsize = raid10_size(mddev, 0, conf->geo.raid_disks);

drivers/md/raid10.c

4460

if (!mddev_is_clustered(mddev) &&

drivers/md/raid10.c

4461

md_bitmap_enabled(mddev, false)) {

drivers/md/raid10.c

4462

ret = mddev->bitmap_ops->resize(mddev, newsize, 0);

drivers/md/raid10.c

4469

rdev_for_each(rdev, mddev) {

drivers/md/raid10.c

4485

ret = mddev->bitmap_ops->resize(mddev, newsize, 0);

drivers/md/raid10.c

4489

ret = mddev->cluster_ops->resize_bitmaps(mddev, newsize, oldsize);

drivers/md/raid10.c

4491

mddev->bitmap_ops->resize(mddev, oldsize, 0);

drivers/md/raid10.c

4496

if (mddev->delta_disks > 0) {

drivers/md/raid10.c

4497

rdev_for_each(rdev, mddev)

drivers/md/raid10.c

4500

if (raid10_add_disk(mddev, rdev) == 0) {

drivers/md/raid10.c

4508

sysfs_link_rdev(mddev, rdev);

drivers/md/raid10.c

4521

mddev->degraded = calc_degraded(conf);

drivers/md/raid10.c

4523

mddev->raid_disks = conf->geo.raid_disks;

drivers/md/raid10.c

4524

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid10.c

4525

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid10.c

4527

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/raid10.c

4528

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/raid10.c

4529

clear_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/raid10.c

4530

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/raid10.c

4531

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid10.c

4537

mddev->recovery = 0;

drivers/md/raid10.c

4540

mddev->raid_disks = conf->geo.raid_disks;

drivers/md/raid10.c

4541

rdev_for_each(rdev, mddev)

drivers/md/raid10.c

4546

mddev->reshape_position = MaxSector;

drivers/md/raid10.c

4582

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

4622

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4637

if (mddev->reshape_backwards &&

drivers/md/raid10.c

4638

conf->reshape_progress < raid10_size(mddev, 0, 0)) {

drivers/md/raid10.c

4639

sector_nr = (raid10_size(mddev, 0, 0)

drivers/md/raid10.c

4641

} else if (!mddev->reshape_backwards &&

drivers/md/raid10.c

4645

mddev->curr_resync_completed = sector_nr;

drivers/md/raid10.c

4646

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/raid10.c

4656

if (mddev->reshape_backwards) {

drivers/md/raid10.c

4706

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid10.c

4707

if (mddev->reshape_backwards)

drivers/md/raid10.c

4708

mddev->curr_resync_completed = raid10_size(mddev, 0, 0)

drivers/md/raid10.c

4711

mddev->curr_resync_completed = conf->reshape_progress;

drivers/md/raid10.c

4713

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid10.c

4714

md_wakeup_thread(mddev->thread);

drivers/md/raid10.c

4715

wait_event(mddev->sb_wait, mddev->sb_flags == 0 ||

drivers/md/raid10.c

4716

test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid10.c

4717

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

drivers/md/raid10.c

4721

conf->reshape_safe = mddev->reshape_position;

drivers/md/raid10.c

4732

r10_bio->mddev = mddev;

drivers/md/raid10.c

4745

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid10.c

4750

GFP_KERNEL, &mddev->bio_set);

drivers/md/raid10.c

4762

if (mddev_is_clustered(mddev) && conf->cluster_sync_high <= sector_nr) {

drivers/md/raid10.c

4780

mddev->cluster_ops->resync_info_update(mddev, conf->cluster_sync_low,

drivers/md/raid10.c

483

md_error(rdev->mddev, rdev);

drivers/md/raid10.c

4847

if (mddev->reshape_backwards)

drivers/md/raid10.c

4856

static int handle_reshape_read_error(struct mddev *mddev,

drivers/md/raid10.c

4858

static void reshape_request_write(struct mddev *mddev, struct r10bio *r10_bio)

drivers/md/raid10.c

4865

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4869

if (handle_reshape_read_error(mddev, r10_bio) < 0) {

drivers/md/raid10.c

4871

md_done_sync(mddev, r10_bio->sectors);

drivers/md/raid10.c

4872

md_sync_error(mddev);

drivers/md/raid10.c

488

&rdev->mddev->recovery);

drivers/md/raid10.c

4904

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

drivers/md/raid10.c

4909

md_finish_reshape(conf->mddev);

drivers/md/raid10.c

4915

mddev_update_io_opt(conf->mddev, raid10_nr_stripes(conf));

drivers/md/raid10.c

4919

static void raid10_update_reshape_pos(struct mddev *mddev)

drivers/md/raid10.c

4921

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4924

mddev->cluster_ops->resync_info_get(mddev, &lo, &hi);

drivers/md/raid10.c

4925

if (((mddev->reshape_position <= hi) && (mddev->reshape_position >= lo))

drivers/md/raid10.c

4926

|| mddev->reshape_position == MaxSector)

drivers/md/raid10.c

4927

conf->reshape_progress = mddev->reshape_position;

drivers/md/raid10.c

493

md_error(rdev->mddev, rdev);

drivers/md/raid10.c

4932

static int handle_reshape_read_error(struct mddev *mddev,

drivers/md/raid10.c

4937

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

4945

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid10.c

4979

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

4992

&mddev->recovery);

drivers/md/raid10.c

5006

struct mddev *mddev = r10_bio->mddev;

drivers/md/raid10.c

5007

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

5019

md_error(mddev, rdev);

drivers/md/raid10.c

5022

rdev_dec_pending(rdev, mddev);

drivers/md/raid10.c

5030

md_done_sync(r10_bio->mddev, r10_bio->sectors);

drivers/md/raid10.c

5035

static void raid10_finish_reshape(struct mddev *mddev)

drivers/md/raid10.c

5037

struct r10conf *conf = mddev->private;

drivers/md/raid10.c

5039

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

drivers/md/raid10.c

5042

if (mddev->delta_disks > 0) {

drivers/md/raid10.c

5043

if (mddev->resync_offset > mddev->resync_max_sectors) {

drivers/md/raid10.c

5044

mddev->resync_offset = mddev->resync_max_sectors;

drivers/md/raid10.c

5045

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid10.c

5047

mddev->resync_max_sectors = mddev->array_sectors;

drivers/md/raid10.c

5051

d < conf->geo.raid_disks - mddev->delta_disks;

drivers/md/raid10.c

5061

mddev->layout = mddev->new_layout;

drivers/md/raid10.c

5062

mddev->chunk_sectors = 1 << conf->geo.chunk_shift;

drivers/md/raid10.c

5063

mddev->reshape_position = MaxSector;

drivers/md/raid10.c

5064

mddev->delta_disks = 0;

drivers/md/raid10.c

5065

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

2073

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2074

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

2163

mdname(mddev),

drivers/md/raid5-cache.c

2165

ret = raid5_set_cache_size(mddev, new_size);

drivers/md/raid5-cache.c

2168

mdname(mddev),

drivers/md/raid5-cache.c

2180

mdname(mddev));

drivers/md/raid5-cache.c

2359

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2366

mdname(mddev));

drivers/md/raid5-cache.c

2431

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2432

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

2439

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

drivers/md/raid5-cache.c

2441

clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/raid5-cache.c

2458

set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);

drivers/md/raid5-cache.c

2463

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2497

mdname(mddev));

drivers/md/raid5-cache.c

2500

mdname(mddev), ctx->data_only_stripes,

drivers/md/raid5-cache.c

2509

mdname(mddev));

drivers/md/raid5-cache.c

2532

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

2535

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5-cache.c

2538

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

drivers/md/raid5-cache.c

2543

ret = mddev_lock(mddev);

drivers/md/raid5-cache.c

2547

conf = mddev->private;

drivers/md/raid5-cache.c

2569

mddev_unlock(mddev);

drivers/md/raid5-cache.c

2579

int r5c_journal_mode_set(struct mddev *mddev, int mode)

drivers/md/raid5-cache.c

2587

conf = mddev->private;

drivers/md/raid5-cache.c

2598

mdname(mddev), mode, r5c_journal_mode_str[mode]);

drivers/md/raid5-cache.c

2603

static ssize_t r5c_journal_mode_store(struct mddev *mddev,

drivers/md/raid5-cache.c

2620

ret = mddev_suspend_and_lock(mddev);

drivers/md/raid5-cache.c

2623

ret = r5c_journal_mode_set(mddev, mode);

drivers/md/raid5-cache.c

2624

mddev_unlock_and_resume(mddev);

drivers/md/raid5-cache.c

2786

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5-cache.c

2841

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5-cache.c

301

md_write_end(conf->mddev);

drivers/md/raid5-cache.c

3043

struct mddev *mddev = log->rdev->mddev;

drivers/md/raid5-cache.c

3044

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

3051

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

drivers/md/raid5-cache.c

3053

struct r5conf *conf = mddev->private;

drivers/md/raid5-cache.c

3072

mdname(conf->mddev), rdev->bdev);

drivers/md/raid5-cache.c

3088

mdname(conf->mddev), conf->raid_disks);

drivers/md/raid5-cache.c

3097

log->uuid_checksum = crc32c(~0, rdev->mddev->uuid,

drivers/md/raid5-cache.c

3098

sizeof(rdev->mddev->uuid));

drivers/md/raid5-cache.c

3127

thread = md_register_thread(r5l_reclaim_thread, log->rdev->mddev,

drivers/md/raid5-cache.c

3152

set_bit(MD_HAS_JOURNAL, &conf->mddev->flags);

drivers/md/raid5-cache.c

3172

md_unregister_thread(conf->mddev, &log->reclaim_thread);

drivers/md/raid5-cache.c

3179

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

1137

static bool raid5_discard_limits(struct mddev *mddev, struct bio *bi)

drivers/md/raid5.c

1139

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

1141

if (mddev->bitmap_id == ID_LLBITMAP)

drivers/md/raid5.c

1239

if (!conf->mddev->external &&

drivers/md/raid5.c

1240

conf->mddev->sb_flags) {

drivers/md/raid5.c

1245

md_check_recovery(conf->mddev);

drivers/md/raid5.c

1253

md_wait_for_blocked_rdev(rdev, conf->mddev);

drivers/md/raid5.c

1256

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

1311

mddev_trace_remap(conf->mddev, bi, sh->dev[i].sector);

drivers/md/raid5.c

1351

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

2426

if (mddev_is_dm(conf->mddev))

drivers/md/raid5.c

2428

"raid%d-%p", conf->level, conf->mddev);

drivers/md/raid5.c

2431

"raid%d-%s", conf->level, mdname(conf->mddev));

drivers/md/raid5.c

2500

raid5_quiesce(conf->mddev, true);

drivers/md/raid5.c

2514

raid5_quiesce(conf->mddev, false);

drivers/md/raid5.c

2556

md_allow_write(conf->mddev);

drivers/md/raid5.c

276

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

2767

mdname(conf->mddev), RAID5_STRIPE_SECTORS(conf),

drivers/md/raid5.c

2795

mdname(conf->mddev),

drivers/md/raid5.c

2798

else if (conf->mddev->degraded >= conf->max_degraded) {

drivers/md/raid5.c

2802

mdname(conf->mddev),

drivers/md/raid5.c

2810

mdname(conf->mddev),

drivers/md/raid5.c

2817

mdname(conf->mddev),

drivers/md/raid5.c

282

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

2821

mdname(conf->mddev), rdev->bdev);

drivers/md/raid5.c

2844

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

2887

md_error(conf->mddev, rdev);

drivers/md/raid5.c

2897

&rdev->mddev->recovery);

drivers/md/raid5.c

2909

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

2924

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

drivers/md/raid5.c

2926

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

2931

mdname(mddev), rdev->bdev);

drivers/md/raid5.c

2936

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

2939

set_bit(MD_BROKEN, &conf->mddev->flags);

drivers/md/raid5.c

2942

mdname(mddev), mddev->degraded, conf->raid_disks);

drivers/md/raid5.c

2945

mdname(mddev), conf->raid_disks - mddev->degraded);

drivers/md/raid5.c

2949

set_bit(MD_RECOVERY_INTR, &mddev->recovery);

drivers/md/raid5.c

2952

set_mask_bits(&mddev->sb_flags, 0,

drivers/md/raid5.c

2954

r5c_update_on_rdev_error(mddev, rdev);

drivers/md/raid5.c

3277

mdname(conf->mddev));

drivers/md/raid5.c

3534

md_write_inc(conf->mddev, bi);

drivers/md/raid5.c

3555

if (conf->mddev->bitmap && firstwrite && !sh->batch_head) {

drivers/md/raid5.c

3622

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

364

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

3641

md_write_end(conf->mddev);

drivers/md/raid5.c

3657

md_write_end(conf->mddev);

drivers/md/raid5.c

3696

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

3719

if (test_bit(MD_RECOVERY_RECOVER, &conf->mddev->recovery)) {

drivers/md/raid5.c

3742

md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf));

drivers/md/raid5.c

3745

md_sync_error(conf->mddev);

drivers/md/raid5.c

3758

|| rdev->mddev->resync_offset <= sh->sector))

drivers/md/raid5.c

3769

struct mddev *mddev = sh->raid_conf->mddev;

drivers/md/raid5.c

3774

(mddev->bitmap_ops && mddev->bitmap_ops->blocks_synced &&

drivers/md/raid5.c

3775

!mddev->bitmap_ops->blocks_synced(mddev, sh->sector)))

drivers/md/raid5.c

3855

sh->sector < sh->raid_conf->mddev->resync_offset)

drivers/md/raid5.c

4037

md_write_end(conf->mddev);

drivers/md/raid5.c

4095

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

410

if (unlikely(!conf->mddev->thread) ||

drivers/md/raid5.c

4122

struct mddev *mddev = conf->mddev;

drivers/md/raid5.c

4123

sector_t resync_offset = mddev->resync_offset;

drivers/md/raid5.c

4142

} else if (mddev->bitmap_ops && mddev->bitmap_ops->blocks_synced &&

drivers/md/raid5.c

4143

!mddev->bitmap_ops->blocks_synced(mddev, sh->sector)) {

drivers/md/raid5.c

415

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

4180

mddev_add_trace_msg(mddev, "raid5 rmw %llu %d",

drivers/md/raid5.c

4259

if (rcw && !mddev_is_dm(mddev))

drivers/md/raid5.c

4260

blk_add_trace_msg(mddev->gendisk->queue,

drivers/md/raid5.c

4348

atomic64_add(RAID5_STRIPE_SECTORS(conf), &conf->mddev->resync_mismatches);

drivers/md/raid5.c

4349

if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery)) {

drivers/md/raid5.c

4353

"%llu-%llu\n", mdname(conf->mddev),

drivers/md/raid5.c

4475

mdname(conf->mddev),

drivers/md/raid5.c

4512

atomic64_add(RAID5_STRIPE_SECTORS(conf), &conf->mddev->resync_mismatches);

drivers/md/raid5.c

4513

if (test_bit(MD_RECOVERY_CHECK, &conf->mddev->recovery)) {

drivers/md/raid5.c

4517

"%llu-%llu\n", mdname(conf->mddev),

drivers/md/raid5.c

4728

&conf->mddev->recovery))

drivers/md/raid5.c

4806

sh->sector >= conf->mddev->resync_offset ||

drivers/md/raid5.c

4807

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

drivers/md/raid5.c

4986

(md_is_rdwr(conf->mddev) &&

drivers/md/raid5.c

4987

test_bit(MD_SB_CHANGE_PENDING, &conf->mddev->sb_flags))) {

drivers/md/raid5.c

4999

rdev_dec_pending(s.blocked_rdev, conf->mddev);

drivers/md/raid5.c

5187

md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf));

drivers/md/raid5.c

5196

if (s.failed <= conf->max_degraded && !conf->mddev->ro)

drivers/md/raid5.c

5254

md_done_sync(conf->mddev, RAID5_STRIPE_SECTORS(conf));

drivers/md/raid5.c

5264

if (conf->mddev->external)

drivers/md/raid5.c

5266

conf->mddev);

drivers/md/raid5.c

5273

conf->mddev);

drivers/md/raid5.c

5285

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

5291

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

5300

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

5317

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

5358

static int in_chunk_boundary(struct mddev *mddev, struct bio *bio)

drivers/md/raid5.c

5360

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5384

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

5418

struct mddev *mddev = rdev->mddev;

drivers/md/raid5.c

5419

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5424

rdev_dec_pending(rdev, conf->mddev);

drivers/md/raid5.c

5438

static int raid5_read_one_chunk(struct mddev *mddev, struct bio *raid_bio)

drivers/md/raid5.c

5440

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5447

if (!in_chunk_boundary(mddev, raid_bio)) {

drivers/md/raid5.c

5474

rdev_dec_pending(rdev, mddev);

drivers/md/raid5.c

5478

md_account_bio(mddev, &raid_bio);

drivers/md/raid5.c

5482

&mddev->bio_set);

drivers/md/raid5.c

5509

mddev_trace_remap(mddev, align_bio, raid_bio->bi_iter.bi_sector);

drivers/md/raid5.c

5514

static struct bio *chunk_aligned_read(struct mddev *mddev, struct bio *raid_bio)

drivers/md/raid5.c

5517

unsigned chunk_sects = mddev->chunk_sectors;

drivers/md/raid5.c

5521

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5529

if (!raid5_read_one_chunk(mddev, raid_bio))

drivers/md/raid5.c

5649

struct mddev *mddev = cb->cb.data;

drivers/md/raid5.c

5650

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5678

if (!mddev_is_dm(mddev))

drivers/md/raid5.c

5679

trace_block_unplug(mddev->gendisk->queue, cnt, !from_schedule);

drivers/md/raid5.c

5683

static void release_stripe_plug(struct mddev *mddev,

drivers/md/raid5.c

5687

raid5_unplug, mddev,

drivers/md/raid5.c

5711

static void make_discard_request(struct mddev *mddev, struct bio *bi)

drivers/md/raid5.c

5713

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5725

if (mddev->reshape_position != MaxSector)

drivers/md/raid5.c

5729

if (!raid5_discard_limits(mddev, bi))

drivers/md/raid5.c

5748

md_account_bio(mddev, &bi);

drivers/md/raid5.c

5753

if (mddev->bitmap_id == ID_LLBITMAP &&

drivers/md/raid5.c

5797

md_write_inc(mddev, bi);

drivers/md/raid5.c

5801

if (conf->mddev->bitmap) {

drivers/md/raid5.c

5810

release_stripe_plug(mddev, sh);

drivers/md/raid5.c

5816

static bool ahead_of_reshape(struct mddev *mddev, sector_t sector,

drivers/md/raid5.c

5819

return mddev->reshape_backwards ? sector < reshape_sector :

drivers/md/raid5.c

5823

static bool range_ahead_of_reshape(struct mddev *mddev, sector_t min,

drivers/md/raid5.c

5826

return mddev->reshape_backwards ? max < reshape_sector :

drivers/md/raid5.c

5830

static bool stripe_ahead_of_reshape(struct mddev *mddev, struct r5conf *conf,

drivers/md/raid5.c

5847

if (!range_ahead_of_reshape(mddev, min_sector, max_sector,

drivers/md/raid5.c

5884

md_wakeup_thread(conf->mddev->thread);

drivers/md/raid5.c

5916

static enum reshape_loc get_reshape_loc(struct mddev *mddev,

drivers/md/raid5.c

5938

if (ahead_of_reshape(mddev, logical_sector, reshape_progress))

drivers/md/raid5.c

5940

if (ahead_of_reshape(mddev, logical_sector, reshape_safe))

drivers/md/raid5.c

5945

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

drivers/md/raid5.c

5948

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

5969

loc = get_reshape_loc(mddev, conf, prev_start);

drivers/md/raid5.c

5993

static enum stripe_result make_stripe_request(struct mddev *mddev,

drivers/md/raid5.c

6006

loc = get_reshape_loc(mddev, conf, logical_sector);

drivers/md/raid5.c

6031

stripe_ahead_of_reshape(mddev, conf, sh)) {

drivers/md/raid5.c

6051

md_wakeup_thread(mddev->thread);

drivers/md/raid5.c

6082

release_stripe_plug(mddev, sh);

drivers/md/raid5.c

6088

if (ret == STRIPE_SCHEDULE_AND_RETRY && reshape_interrupted(mddev)) {

drivers/md/raid5.c

6089

if (!mddev_is_dm(mddev) ||

drivers/md/raid5.c

6090

test_bit(MD_DM_SUSPENDING, &mddev->flags)) {

drivers/md/raid5.c

6131

static bool raid5_make_request(struct mddev *mddev, struct bio * bi)

drivers/md/raid5.c

6134

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6148

if (md_flush_request(mddev, bi))

drivers/md/raid5.c

6154

md_write_start(mddev, bi);

drivers/md/raid5.c

6160

if (rw == READ && mddev->degraded == 0 &&

drivers/md/raid5.c

6161

mddev->reshape_position == MaxSector) {

drivers/md/raid5.c

6162

bi = chunk_aligned_read(mddev, bi);

drivers/md/raid5.c

6168

make_discard_request(mddev, bi);

drivers/md/raid5.c

6169

md_write_end(mddev);

drivers/md/raid5.c

6196

get_reshape_loc(mddev, conf, logical_sector) == LOC_INSIDE_RESHAPE) {

drivers/md/raid5.c

6199

md_write_end(mddev);

drivers/md/raid5.c

6203

md_account_bio(mddev, &bi);

drivers/md/raid5.c

6222

res = make_stripe_request(mddev, conf, ctx, logical_sector,

drivers/md/raid5.c

6263

md_write_end(mddev);

drivers/md/raid5.c

6280

static sector_t raid5_size(struct mddev *mddev, sector_t sectors, int raid_disks);

drivers/md/raid5.c

6282

static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr, int *skipped)

drivers/md/raid5.c

6293

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6310

if (mddev->reshape_backwards &&

drivers/md/raid5.c

6311

conf->reshape_progress < raid5_size(mddev, 0, 0)) {

drivers/md/raid5.c

6312

sector_nr = raid5_size(mddev, 0, 0)

drivers/md/raid5.c

6314

} else if (mddev->reshape_backwards &&

drivers/md/raid5.c

6318

} else if (!mddev->reshape_backwards &&

drivers/md/raid5.c

6323

mddev->curr_resync_completed = sector_nr;

drivers/md/raid5.c

6324

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/raid5.c

6350

if (mddev->reshape_backwards) {

drivers/md/raid5.c

6370

if (mddev->reshape_backwards) {

drivers/md/raid5.c

6375

if (WARN_ON((mddev->dev_sectors &

drivers/md/raid5.c

6412

if ((mddev->reshape_backwards

drivers/md/raid5.c

6419

|| test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid5.c

6422

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid5.c

6423

mddev->curr_resync_completed = sector_nr;

drivers/md/raid5.c

6424

if (!mddev->reshape_backwards)

drivers/md/raid5.c

6426

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

6434

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5.c

6435

md_wakeup_thread(mddev->thread);

drivers/md/raid5.c

6436

wait_event(mddev->sb_wait, mddev->sb_flags == 0 ||

drivers/md/raid5.c

6437

test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid5.c

6438

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

drivers/md/raid5.c

6441

conf->reshape_safe = mddev->reshape_position;

drivers/md/raid5.c

6444

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/raid5.c

6466

if (s < raid5_size(mddev, 0, 0)) {

drivers/md/raid5.c

6481

if (mddev->reshape_backwards)

drivers/md/raid5.c

6498

if (last_sector >= mddev->dev_sectors)

drivers/md/raid5.c

6499

last_sector = mddev->dev_sectors - 1;

drivers/md/raid5.c

6522

if (mddev->curr_resync_completed > mddev->resync_max ||

drivers/md/raid5.c

6523

(sector_nr - mddev->curr_resync_completed) * 2

drivers/md/raid5.c

6524

>= mddev->resync_max - mddev->curr_resync_completed) {

drivers/md/raid5.c

6528

|| test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid5.c

6531

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid5.c

6532

mddev->curr_resync_completed = sector_nr;

drivers/md/raid5.c

6533

if (!mddev->reshape_backwards)

drivers/md/raid5.c

6535

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

6542

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5.c

6543

md_wakeup_thread(mddev->thread);

drivers/md/raid5.c

6544

wait_event(mddev->sb_wait,

drivers/md/raid5.c

6545

!test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)

drivers/md/raid5.c

6546

|| test_bit(MD_RECOVERY_INTR, &mddev->recovery));

drivers/md/raid5.c

6547

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

drivers/md/raid5.c

6550

conf->reshape_safe = mddev->reshape_position;

drivers/md/raid5.c

6553

sysfs_notify_dirent_safe(mddev->sysfs_completed);

drivers/md/raid5.c

6559

static inline sector_t raid5_sync_request(struct mddev *mddev, sector_t sector_nr,

drivers/md/raid5.c

6562

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6571

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

drivers/md/raid5.c

6576

if (mddev->curr_resync < max_sector) /* aborted */

drivers/md/raid5.c

6577

md_bitmap_end_sync(mddev, mddev->curr_resync,

drivers/md/raid5.c

6581

if (md_bitmap_enabled(mddev, false))

drivers/md/raid5.c

6582

mddev->bitmap_ops->close_sync(mddev);

drivers/md/raid5.c

6590

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

drivers/md/raid5.c

6591

return reshape_request(mddev, sector_nr, skipped);

drivers/md/raid5.c

6603

if (mddev->degraded >= conf->max_degraded &&

drivers/md/raid5.c

6604

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

drivers/md/raid5.c

6605

sector_t rv = mddev->dev_sectors - sector_nr;

drivers/md/raid5.c

6609

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

drivers/md/raid5.c

6611

!md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, true) &&

drivers/md/raid5.c

6620

if (md_bitmap_enabled(mddev, false))

drivers/md/raid5.c

6621

mddev->bitmap_ops->cond_end_sync(mddev, sector_nr, false);

drivers/md/raid5.c

6643

md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, still_degraded);

drivers/md/raid5.c

6776

struct mddev *mddev = conf->mddev;

drivers/md/raid5.c

6797

wait_event_lock_irq(mddev->sb_wait,

drivers/md/raid5.c

6798

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

drivers/md/raid5.c

6824

struct mddev *mddev = thread->mddev;

drivers/md/raid5.c

6825

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6831

md_check_recovery(mddev);

drivers/md/raid5.c

6841

if (md_is_rdwr(mddev) &&

drivers/md/raid5.c

6842

test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))

drivers/md/raid5.c

6854

if (md_bitmap_enabled(mddev, true))

drivers/md/raid5.c

6855

mddev->bitmap_ops->unplug(mddev, true);

drivers/md/raid5.c

6878

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

drivers/md/raid5.c

6880

md_check_recovery(mddev);

drivers/md/raid5.c

6908

raid5_show_stripe_cache_size(struct mddev *mddev, char *page)

drivers/md/raid5.c

6912

spin_lock(&mddev->lock);

drivers/md/raid5.c

6913

conf = mddev->private;

drivers/md/raid5.c

6916

spin_unlock(&mddev->lock);

drivers/md/raid5.c

6921

raid5_set_cache_size(struct mddev *mddev, int size)

drivers/md/raid5.c

6924

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6936

md_allow_write(mddev);

drivers/md/raid5.c

6952

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

drivers/md/raid5.c

6962

err = mddev_lock(mddev);

drivers/md/raid5.c

6965

conf = mddev->private;

drivers/md/raid5.c

6969

err = raid5_set_cache_size(mddev, new);

drivers/md/raid5.c

6970

mddev_unlock(mddev);

drivers/md/raid5.c

6981

raid5_show_rmw_level(struct mddev *mddev, char *page)

drivers/md/raid5.c

6983

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

6991

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

drivers/md/raid5.c

6993

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

7023

raid5_show_stripe_size(struct mddev *mddev, char *page)

drivers/md/raid5.c

7028

spin_lock(&mddev->lock);

drivers/md/raid5.c

7029

conf = mddev->private;

drivers/md/raid5.c

7032

spin_unlock(&mddev->lock);

drivers/md/raid5.c

7038

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

drivers/md/raid5.c

7060

err = mddev_suspend_and_lock(mddev);

drivers/md/raid5.c

7064

conf = mddev->private;

drivers/md/raid5.c

7076

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

drivers/md/raid5.c

7077

mddev->reshape_position != MaxSector || mddev->sysfs_active) {

drivers/md/raid5.c

7092

mdname(mddev));

drivers/md/raid5.c

7098

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

7114

raid5_show_preread_threshold(struct mddev *mddev, char *page)

drivers/md/raid5.c

7118

spin_lock(&mddev->lock);

drivers/md/raid5.c

7119

conf = mddev->private;

drivers/md/raid5.c

7122

spin_unlock(&mddev->lock);

drivers/md/raid5.c

7127

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

drivers/md/raid5.c

7138

err = mddev_lock(mddev);

drivers/md/raid5.c

7141

conf = mddev->private;

drivers/md/raid5.c

7148

mddev_unlock(mddev);

drivers/md/raid5.c

7159

raid5_show_skip_copy(struct mddev *mddev, char *page)

drivers/md/raid5.c

7163

spin_lock(&mddev->lock);

drivers/md/raid5.c

7164

conf = mddev->private;

drivers/md/raid5.c

7167

spin_unlock(&mddev->lock);

drivers/md/raid5.c

7172

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

drivers/md/raid5.c

7184

err = mddev_suspend_and_lock(mddev);

drivers/md/raid5.c

7187

conf = mddev->private;

drivers/md/raid5.c

7191

struct request_queue *q = mddev->gendisk->queue;

drivers/md/raid5.c

7201

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

7211

stripe_cache_active_show(struct mddev *mddev, char *page)

drivers/md/raid5.c

7213

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

7224

raid5_show_group_thread_cnt(struct mddev *mddev, char *page)

drivers/md/raid5.c

7228

spin_lock(&mddev->lock);

drivers/md/raid5.c

7229

conf = mddev->private;

drivers/md/raid5.c

7232

spin_unlock(&mddev->lock);

drivers/md/raid5.c

7240

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

drivers/md/raid5.c

7256

err = mddev_suspend_and_lock(mddev);

drivers/md/raid5.c

7259

conf = mddev->private;

drivers/md/raid5.c

7261

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

7264

raid5_quiesce(mddev, true);

drivers/md/raid5.c

7285

raid5_quiesce(mddev, false);

drivers/md/raid5.c

7286

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

7367

raid5_size(struct mddev *mddev, sector_t sectors, int raid_disks)

drivers/md/raid5.c

7369

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

7372

sectors = mddev->dev_sectors;

drivers/md/raid5.c

751

int degraded = conf->mddev->degraded;

drivers/md/raid5.c

7517

static struct r5conf *setup_conf(struct mddev *mddev)

drivers/md/raid5.c

7529

if (mddev->new_level != 5

drivers/md/raid5.c

753

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

drivers/md/raid5.c

7530

&& mddev->new_level != 4

drivers/md/raid5.c

7531

&& mddev->new_level != 6) {

drivers/md/raid5.c

7533

mdname(mddev), mddev->new_level);

drivers/md/raid5.c

7536

if ((mddev->new_level == 5

drivers/md/raid5.c

7537

&& !algorithm_valid_raid5(mddev->new_layout)) ||

drivers/md/raid5.c

7538

(mddev->new_level == 6

drivers/md/raid5.c

7539

&& !algorithm_valid_raid6(mddev->new_layout))) {

drivers/md/raid5.c

7541

mdname(mddev), mddev->new_layout);

drivers/md/raid5.c

7544

if (mddev->new_level == 6 && mddev->raid_disks < 4) {

drivers/md/raid5.c

7546

mdname(mddev), mddev->raid_disks);

drivers/md/raid5.c

7550

if (!mddev->new_chunk_sectors ||

drivers/md/raid5.c

7551

(mddev->new_chunk_sectors << 9) % PAGE_SIZE ||

drivers/md/raid5.c

7552

!is_power_of_2(mddev->new_chunk_sectors)) {

drivers/md/raid5.c

7554

mdname(mddev), mddev->new_chunk_sectors << 9);

drivers/md/raid5.c

756

if (conf->mddev->reshape_position != MaxSector)

drivers/md/raid5.c

7599

rdev_for_each(rdev, mddev) {

drivers/md/raid5.c

76

static void raid5_quiesce(struct mddev *mddev, int quiesce);

drivers/md/raid5.c

7609

conf->raid_disks = mddev->raid_disks;

drivers/md/raid5.c

7610

if (mddev->reshape_position == MaxSector)

drivers/md/raid5.c

7611

conf->previous_raid_disks = mddev->raid_disks;

drivers/md/raid5.c

7613

conf->previous_raid_disks = mddev->raid_disks - mddev->delta_disks;

drivers/md/raid5.c

7630

conf->mddev = mddev;

drivers/md/raid5.c

7659

conf->level = mddev->new_level;

drivers/md/raid5.c

7660

conf->chunk_sectors = mddev->new_chunk_sectors;

drivers/md/raid5.c

7665

pr_debug("raid456: run(%s) called.\n", mdname(mddev));

drivers/md/raid5.c

7668

rdev_for_each(rdev, mddev) {

drivers/md/raid5.c

7687

mdname(mddev), rdev->bdev, raid_disk);

drivers/md/raid5.c

7693

conf->level = mddev->new_level;

drivers/md/raid5.c

7704

conf->algorithm = mddev->new_layout;

drivers/md/raid5.c

7705

conf->reshape_progress = mddev->reshape_position;

drivers/md/raid5.c

7707

conf->prev_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid5.c

7708

conf->prev_algo = mddev->layout;

drivers/md/raid5.c

7715

if (mddev->reshape_position != MaxSector) {

drivers/md/raid5.c

7717

((mddev->chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4,

drivers/md/raid5.c

7718

((mddev->new_chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4);

drivers/md/raid5.c

7722

mdname(mddev), conf->min_nr_stripes);

drivers/md/raid5.c

7729

mdname(mddev), memory);

drivers/md/raid5.c

7733

pr_debug("md/raid:%s: allocated %dkB\n", mdname(mddev), memory);

drivers/md/raid5.c

7739

conf->shrinker = shrinker_alloc(0, "md-raid5:%s", mdname(mddev));

drivers/md/raid5.c

7743

mdname(mddev));

drivers/md/raid5.c

7755

sprintf(pers_name, "raid%d", mddev->new_level);

drivers/md/raid5.c

7757

md_register_thread(raid5d, mddev, pers_name));

drivers/md/raid5.c

7760

mdname(mddev));

drivers/md/raid5.c

7804

if (mddev_is_dm(conf->mddev))

drivers/md/raid5.c

7808

queue_max_hw_sectors(conf->mddev->gendisk->queue) >>

drivers/md/raid5.c

7818

static int raid5_set_limits(struct mddev *mddev)

drivers/md/raid5.c

7820

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

7835

stripe = roundup_pow_of_two(data_disks * (mddev->chunk_sectors << 9));

drivers/md/raid5.c

7838

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid5.c

7839

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

drivers/md/raid5.c

7846

mddev_stack_rdev_limits(mddev, &lim, 0);

drivers/md/raid5.c

7847

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

7849

mddev->gendisk->disk_name);

drivers/md/raid5.c

7870

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

drivers/md/raid5.c

7873

static int raid5_run(struct mddev *mddev)

drivers/md/raid5.c

7885

if (mddev->resync_offset != MaxSector)

drivers/md/raid5.c

7887

mdname(mddev));

drivers/md/raid5.c

7889

rdev_for_each(rdev, mddev) {

drivers/md/raid5.c

7902

} else if (mddev->reshape_backwards &&

drivers/md/raid5.c

7905

else if (!mddev->reshape_backwards &&

drivers/md/raid5.c

7910

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

drivers/md/raid5.c

7911

(mddev->bitmap_info.offset || mddev->bitmap_info.file)) {

drivers/md/raid5.c

7913

mdname(mddev));

drivers/md/raid5.c

7917

if (mddev->reshape_position != MaxSector) {

drivers/md/raid5.c

7932

int max_degraded = (mddev->level == 6 ? 2 : 1);

drivers/md/raid5.c

7938

mdname(mddev));

drivers/md/raid5.c

7942

if (mddev->new_level != mddev->level) {

drivers/md/raid5.c

7944

mdname(mddev));

drivers/md/raid5.c

7947

old_disks = mddev->raid_disks - mddev->delta_disks;

drivers/md/raid5.c

7955

here_new = mddev->reshape_position;

drivers/md/raid5.c

7956

chunk_sectors = max(mddev->chunk_sectors, mddev->new_chunk_sectors);

drivers/md/raid5.c

7957

new_data_disks = mddev->raid_disks - max_degraded;

drivers/md/raid5.c

7960

mdname(mddev));

drivers/md/raid5.c

7965

here_old = mddev->reshape_position;

drivers/md/raid5.c

7969

if (mddev->delta_disks == 0) {

drivers/md/raid5.c

7977

if (abs(min_offset_diff) >= mddev->chunk_sectors &&

drivers/md/raid5.c

7978

abs(min_offset_diff) >= mddev->new_chunk_sectors)

drivers/md/raid5.c

7980

else if (mddev->ro == 0) {

drivers/md/raid5.c

7982

mdname(mddev));

drivers/md/raid5.c

7985

} else if (mddev->reshape_backwards

drivers/md/raid5.c

7992

mdname(mddev));

drivers/md/raid5.c

7995

pr_debug("md/raid:%s: reshape will continue\n", mdname(mddev));

drivers/md/raid5.c

7998

BUG_ON(mddev->level != mddev->new_level);

drivers/md/raid5.c

7999

BUG_ON(mddev->layout != mddev->new_layout);

drivers/md/raid5.c

8000

BUG_ON(mddev->chunk_sectors != mddev->new_chunk_sectors);

drivers/md/raid5.c

8001

BUG_ON(mddev->delta_disks != 0);

drivers/md/raid5.c

8004

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

drivers/md/raid5.c

8005

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

drivers/md/raid5.c

8007

mdname(mddev));

drivers/md/raid5.c

8008

clear_bit(MD_HAS_PPL, &mddev->flags);

drivers/md/raid5.c

8009

clear_bit(MD_HAS_MULTIPLE_PPLS, &mddev->flags);

drivers/md/raid5.c

8012

if (mddev->private == NULL)

drivers/md/raid5.c

8013

conf = setup_conf(mddev);

drivers/md/raid5.c

8015

conf = mddev->private;

drivers/md/raid5.c

8020

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

drivers/md/raid5.c

8023

mdname(mddev));

drivers/md/raid5.c

8024

mddev->ro = 1;

drivers/md/raid5.c

8025

set_disk_ro(mddev->gendisk, 1);

drivers/md/raid5.c

8026

} else if (mddev->resync_offset == MaxSector)

drivers/md/raid5.c

8027

set_bit(MD_JOURNAL_CLEAN, &mddev->flags);

drivers/md/raid5.c

8031

rcu_assign_pointer(mddev->thread, conf->thread);

drivers/md/raid5.c

8033

mddev->private = conf;

drivers/md/raid5.c

8057

if (mddev->major_version == 0 &&

drivers/md/raid5.c

8058

mddev->minor_version > 90)

drivers/md/raid5.c

8080

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

8084

mdname(mddev), mddev->degraded, conf->raid_disks);

drivers/md/raid5.c

8089

mddev->dev_sectors &= ~((sector_t)mddev->chunk_sectors - 1);

drivers/md/raid5.c

8090

mddev->resync_max_sectors = mddev->dev_sectors;

drivers/md/raid5.c

8092

if (mddev->degraded > dirty_parity_disks &&

drivers/md/raid5.c

8093

mddev->resync_offset != MaxSector) {

drivers/md/raid5.c

8094

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

drivers/md/raid5.c

8096

mdname(mddev));

drivers/md/raid5.c

8097

else if (mddev->ok_start_degraded)

drivers/md/raid5.c

8099

mdname(mddev));

drivers/md/raid5.c

8102

mdname(mddev));

drivers/md/raid5.c

8108

mdname(mddev), conf->level,

drivers/md/raid5.c

8109

mddev->raid_disks-mddev->degraded, mddev->raid_disks,

drivers/md/raid5.c

8110

mddev->new_layout);

drivers/md/raid5.c

8117

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/raid5.c

8118

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/raid5.c

8119

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/raid5.c

8120

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid5.c

8124

if (mddev->to_remove == &raid5_attrs_group)

drivers/md/raid5.c

8125

mddev->to_remove = NULL;

drivers/md/raid5.c

8126

else if (mddev->kobj.sd &&

drivers/md/raid5.c

8127

sysfs_create_group(&mddev->kobj, &raid5_attrs_group))

drivers/md/raid5.c

8129

mdname(mddev));

drivers/md/raid5.c

8130

md_set_array_sectors(mddev, raid5_size(mddev, 0, 0));

drivers/md/raid5.c

8132

if (!mddev_is_dm(mddev)) {

drivers/md/raid5.c

8133

ret = raid5_set_limits(mddev);

drivers/md/raid5.c

8148

md_unregister_thread(mddev, &mddev->thread);

drivers/md/raid5.c

8151

mddev->private = NULL;

drivers/md/raid5.c

8152

pr_warn("md/raid:%s: failed to run raid set.\n", mdname(mddev));

drivers/md/raid5.c

8156

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

drivers/md/raid5.c

8161

mddev->to_remove = &raid5_attrs_group;

drivers/md/raid5.c

8164

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

drivers/md/raid5.c

8166

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8169

lockdep_assert_held(&mddev->lock);

drivers/md/raid5.c

8171

seq_printf(seq, " level %d, %dk chunk, algorithm %d", mddev->level,

drivers/md/raid5.c

8172

conf->chunk_sectors / 2, mddev->layout);

drivers/md/raid5.c

8173

seq_printf (seq, " [%d/%d] [", conf->raid_disks, conf->raid_disks - mddev->degraded);

drivers/md/raid5.c

8194

conf->raid_disks - conf->mddev->degraded);

drivers/md/raid5.c

8205

static int raid5_spare_active(struct mddev *mddev)

drivers/md/raid5.c

8208

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8243

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

8249

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

drivers/md/raid5.c

8251

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8328

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

drivers/md/raid5.c

8330

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8392

mddev->reshape_position == MaxSector &&

drivers/md/raid5.c

8408

static int raid5_resize(struct mddev *mddev, sector_t sectors)

drivers/md/raid5.c

8418

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8423

newsize = raid5_size(mddev, sectors, mddev->raid_disks);

drivers/md/raid5.c

8424

if (mddev->external_size &&

drivers/md/raid5.c

8425

mddev->array_sectors > newsize)

drivers/md/raid5.c

8428

if (md_bitmap_enabled(mddev, false)) {

drivers/md/raid5.c

8429

int ret = mddev->bitmap_ops->resize(mddev, sectors, 0);

drivers/md/raid5.c

8435

md_set_array_sectors(mddev, newsize);

drivers/md/raid5.c

8436

if (sectors > mddev->dev_sectors &&

drivers/md/raid5.c

8437

mddev->resync_offset > mddev->dev_sectors) {

drivers/md/raid5.c

8438

mddev->resync_offset = mddev->dev_sectors;

drivers/md/raid5.c

8439

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid5.c

8441

mddev->dev_sectors = sectors;

drivers/md/raid5.c

8442

mddev->resync_max_sectors = sectors;

drivers/md/raid5.c

8446

static int check_stripe_cache(struct mddev *mddev)

drivers/md/raid5.c

8456

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8457

if (((mddev->chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4

drivers/md/raid5.c

8459

((mddev->new_chunk_sectors << 9) / RAID5_STRIPE_SIZE(conf)) * 4

drivers/md/raid5.c

8462

mdname(mddev),

drivers/md/raid5.c

8463

((max(mddev->chunk_sectors, mddev->new_chunk_sectors) << 9)

drivers/md/raid5.c

8470

static int check_reshape(struct mddev *mddev)

drivers/md/raid5.c

8472

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8476

if (mddev->delta_disks == 0 &&

drivers/md/raid5.c

8477

mddev->new_layout == mddev->layout &&

drivers/md/raid5.c

8478

mddev->new_chunk_sectors == mddev->chunk_sectors)

drivers/md/raid5.c

8482

if (mddev->delta_disks < 0 && mddev->reshape_position == MaxSector) {

drivers/md/raid5.c

8489

if (mddev->level == 6)

drivers/md/raid5.c

8491

if (mddev->raid_disks + mddev->delta_disks < min)

drivers/md/raid5.c

8495

if (!check_stripe_cache(mddev))

drivers/md/raid5.c

8498

if (mddev->new_chunk_sectors > mddev->chunk_sectors ||

drivers/md/raid5.c

8499

mddev->delta_disks > 0)

drivers/md/raid5.c

8502

+ max(0, mddev->delta_disks),

drivers/md/raid5.c

8503

max(mddev->new_chunk_sectors,

drivers/md/raid5.c

8504

mddev->chunk_sectors)

drivers/md/raid5.c

8508

if (conf->previous_raid_disks + mddev->delta_disks <= conf->pool_size)

drivers/md/raid5.c

8511

+ mddev->delta_disks));

drivers/md/raid5.c

8514

static int raid5_start_reshape(struct mddev *mddev)

drivers/md/raid5.c

8516

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8522

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

drivers/md/raid5.c

8525

if (!check_stripe_cache(mddev))

drivers/md/raid5.c

8532

if (mddev->resync_offset < MaxSector)

drivers/md/raid5.c

8538

rdev_for_each(rdev, mddev) {

drivers/md/raid5.c

8544

if (spares - mddev->degraded < mddev->delta_disks - conf->max_degraded)

drivers/md/raid5.c

8554

if (raid5_size(mddev, 0, conf->raid_disks + mddev->delta_disks)

drivers/md/raid5.c

8555

< mddev->array_sectors) {

drivers/md/raid5.c

8557

mdname(mddev));

drivers/md/raid5.c

8565

conf->raid_disks += mddev->delta_disks;

drivers/md/raid5.c

8567

conf->chunk_sectors = mddev->new_chunk_sectors;

drivers/md/raid5.c

8569

conf->algorithm = mddev->new_layout;

drivers/md/raid5.c

8575

if (mddev->reshape_backwards)

drivers/md/raid5.c

8576

conf->reshape_progress = raid5_size(mddev, 0, 0);

drivers/md/raid5.c

8587

raid5_quiesce(mddev, true);

drivers/md/raid5.c

8588

raid5_quiesce(mddev, false);

drivers/md/raid5.c

8597

if (mddev->delta_disks >= 0) {

drivers/md/raid5.c

8598

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

8601

if (raid5_add_disk(mddev, rdev) == 0) {

drivers/md/raid5.c

8609

sysfs_link_rdev(mddev, rdev);

drivers/md/raid5.c

8622

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

8625

mddev->raid_disks = conf->raid_disks;

drivers/md/raid5.c

8626

mddev->reshape_position = conf->reshape_progress;

drivers/md/raid5.c

8627

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5.c

8629

clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);

drivers/md/raid5.c

8630

clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);

drivers/md/raid5.c

8631

clear_bit(MD_RECOVERY_DONE, &mddev->recovery);

drivers/md/raid5.c

8632

set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);

drivers/md/raid5.c

8633

set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);

drivers/md/raid5.c

8645

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

drivers/md/raid5.c

8650

md_finish_reshape(conf->mddev);

drivers/md/raid5.c

8653

conf->mddev->reshape_position = MaxSector;

drivers/md/raid5.c

8654

rdev_for_each(rdev, conf->mddev)

drivers/md/raid5.c

8662

mddev_update_io_opt(conf->mddev,

drivers/md/raid5.c

8670

static void raid5_finish_reshape(struct mddev *mddev)

drivers/md/raid5.c

8672

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8675

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

drivers/md/raid5.c

8677

if (mddev->delta_disks <= 0) {

drivers/md/raid5.c

8680

mddev->degraded = raid5_calc_degraded(conf);

drivers/md/raid5.c

8683

d < conf->raid_disks - mddev->delta_disks;

drivers/md/raid5.c

8693

mddev->layout = conf->algorithm;

drivers/md/raid5.c

8694

mddev->chunk_sectors = conf->chunk_sectors;

drivers/md/raid5.c

8695

mddev->reshape_position = MaxSector;

drivers/md/raid5.c

8696

mddev->delta_disks = 0;

drivers/md/raid5.c

8697

mddev->reshape_backwards = 0;

drivers/md/raid5.c

8701

static void raid5_quiesce(struct mddev *mddev, int quiesce)

drivers/md/raid5.c

8703

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8736

static void *raid45_takeover_raid0(struct mddev *mddev, int level)

drivers/md/raid5.c

8738

struct r0conf *raid0_conf = mddev->private;

drivers/md/raid5.c

8744

mdname(mddev));

drivers/md/raid5.c

8750

mddev->dev_sectors = sectors;

drivers/md/raid5.c

8751

mddev->new_level = level;

drivers/md/raid5.c

8752

mddev->new_layout = ALGORITHM_PARITY_N;

drivers/md/raid5.c

8753

mddev->new_chunk_sectors = mddev->chunk_sectors;

drivers/md/raid5.c

8754

mddev->raid_disks += 1;

drivers/md/raid5.c

8755

mddev->delta_disks = 1;

drivers/md/raid5.c

8757

mddev->resync_offset = MaxSector;

drivers/md/raid5.c

8759

return setup_conf(mddev);

drivers/md/raid5.c

8762

static void *raid5_takeover_raid1(struct mddev *mddev)

drivers/md/raid5.c

8767

if (mddev->raid_disks != 2 ||

drivers/md/raid5.c

8768

mddev->degraded > 1)

drivers/md/raid5.c

8776

while (chunksect && (mddev->array_sectors & (chunksect-1)))

drivers/md/raid5.c

8779

if ((chunksect<<9) < RAID5_STRIPE_SIZE((struct r5conf *)mddev->private))

drivers/md/raid5.c

8783

mddev->new_level = 5;

drivers/md/raid5.c

8784

mddev->new_layout = ALGORITHM_LEFT_SYMMETRIC;

drivers/md/raid5.c

8785

mddev->new_chunk_sectors = chunksect;

drivers/md/raid5.c

8787

ret = setup_conf(mddev);

drivers/md/raid5.c

8789

mddev_clear_unsupported_flags(mddev,

drivers/md/raid5.c

8794

static void *raid5_takeover_raid6(struct mddev *mddev)

drivers/md/raid5.c

8798

switch (mddev->layout) {

drivers/md/raid5.c

8820

mddev->new_level = 5;

drivers/md/raid5.c

8821

mddev->new_layout = new_layout;

drivers/md/raid5.c

8822

mddev->delta_disks = -1;

drivers/md/raid5.c

8823

mddev->raid_disks -= 1;

drivers/md/raid5.c

8824

return setup_conf(mddev);

drivers/md/raid5.c

8827

static int raid5_check_reshape(struct mddev *mddev)

drivers/md/raid5.c

8834

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

8835

int new_chunk = mddev->new_chunk_sectors;

drivers/md/raid5.c

8837

if (mddev->new_layout >= 0 && !algorithm_valid_raid5(mddev->new_layout))

drivers/md/raid5.c

8844

if (mddev->array_sectors & (new_chunk-1))

drivers/md/raid5.c

8851

if (mddev->raid_disks == 2) {

drivers/md/raid5.c

8853

if (mddev->new_layout >= 0) {

drivers/md/raid5.c

8854

conf->algorithm = mddev->new_layout;

drivers/md/raid5.c

8855

mddev->layout = mddev->new_layout;

drivers/md/raid5.c

8859

mddev->chunk_sectors = new_chunk;

drivers/md/raid5.c

8861

set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);

drivers/md/raid5.c

8862

md_wakeup_thread(mddev->thread);

drivers/md/raid5.c

8864

return check_reshape(mddev);

drivers/md/raid5.c

8867

static int raid6_check_reshape(struct mddev *mddev)

drivers/md/raid5.c

8869

int new_chunk = mddev->new_chunk_sectors;

drivers/md/raid5.c

8871

if (mddev->new_layout >= 0 && !algorithm_valid_raid6(mddev->new_layout))

drivers/md/raid5.c

8878

if (mddev->array_sectors & (new_chunk-1))

drivers/md/raid5.c

8884

return check_reshape(mddev);

drivers/md/raid5.c

8887

static void *raid5_takeover(struct mddev *mddev)

drivers/md/raid5.c

8895

if (mddev->level == 0)

drivers/md/raid5.c

8896

return raid45_takeover_raid0(mddev, 5);

drivers/md/raid5.c

8897

if (mddev->level == 1)

drivers/md/raid5.c

8898

return raid5_takeover_raid1(mddev);

drivers/md/raid5.c

8899

if (mddev->level == 4) {

drivers/md/raid5.c

8900

mddev->new_layout = ALGORITHM_PARITY_N;

drivers/md/raid5.c

8901

mddev->new_level = 5;

drivers/md/raid5.c

8902

return setup_conf(mddev);

drivers/md/raid5.c

8904

if (mddev->level == 6)

drivers/md/raid5.c

8905

return raid5_takeover_raid6(mddev);

drivers/md/raid5.c

8910

static void *raid4_takeover(struct mddev *mddev)

drivers/md/raid5.c

8916

if (mddev->level == 0)

drivers/md/raid5.c

8917

return raid45_takeover_raid0(mddev, 4);

drivers/md/raid5.c

8918

if (mddev->level == 5 &&

drivers/md/raid5.c

8919

mddev->layout == ALGORITHM_PARITY_N) {

drivers/md/raid5.c

8920

mddev->new_layout = 0;

drivers/md/raid5.c

8921

mddev->new_level = 4;

drivers/md/raid5.c

8922

return setup_conf(mddev);

drivers/md/raid5.c

8929

static void *raid6_takeover(struct mddev *mddev)

drivers/md/raid5.c

8937

if (mddev->pers != &raid5_personality)

drivers/md/raid5.c

8939

if (mddev->degraded > 1)

drivers/md/raid5.c

8941

if (mddev->raid_disks > 253)

drivers/md/raid5.c

8943

if (mddev->raid_disks < 3)

drivers/md/raid5.c

8946

switch (mddev->layout) {

drivers/md/raid5.c

8968

mddev->new_level = 6;

drivers/md/raid5.c

8969

mddev->new_layout = new_layout;

drivers/md/raid5.c

8970

mddev->delta_disks = 1;

drivers/md/raid5.c

8971

mddev->raid_disks += 1;

drivers/md/raid5.c

8972

return setup_conf(mddev);

drivers/md/raid5.c

8975

static int raid5_change_consistency_policy(struct mddev *mddev, const char *buf)

drivers/md/raid5.c

8980

err = mddev_suspend_and_lock(mddev);

drivers/md/raid5.c

8983

conf = mddev->private;

drivers/md/raid5.c

8985

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

9004

} else if (test_bit(MD_HAS_JOURNAL, &conf->mddev->flags) &&

drivers/md/raid5.c

9009

rdev_for_each(rdev, mddev)

drivers/md/raid5.c

9016

clear_bit(MD_HAS_JOURNAL, &mddev->flags);

drivers/md/raid5.c

9026

md_update_sb(mddev, 1);

drivers/md/raid5.c

9028

mddev_unlock_and_resume(mddev);

drivers/md/raid5.c

9033

static int raid5_start(struct mddev *mddev)

drivers/md/raid5.c

9035

struct r5conf *conf = mddev->private;

drivers/md/raid5.c

9045

static void raid5_prepare_suspend(struct mddev *mddev)

drivers/md/raid5.c

9047

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);