~ubuntu-branches/ubuntu/oneiric/drbd8/oneiric : revision 25

33

#include <asm/types.h>

34

#include <net/sock.h>

35

#include <linux/ctype.h>

36

#include <linux/smp_lock.h>

37

36

#include <linux/fs.h>

38

37

#include <linux/file.h>

39

38

#include <linux/proc_fs.h>

108

107

MODULE_DESCRIPTION("drbd - Distributed Replicated Block Device v" REL_VERSION);

109

108

MODULE_VERSION(REL_VERSION);

110

109

MODULE_LICENSE("GPL");

111

MODULE_PARM_DESC(minor_count, "Maximum number of drbd devices (1-255)");

110

MODULE_PARM_DESC(minor_count, "Maximum number of drbd devices ("

111

__stringify(DRBD_MINOR_COUNT_MIN) "-" __stringify(DRBD_MINOR_COUNT_MAX) ")");

112

MODULE_ALIAS_BLOCKDEV_MAJOR(DRBD_MAJOR);

113

114

#include <linux/moduleparam.h>

138

#endif

139

140

/* module parameter, defined */

141

unsigned int minor_count = 32;

141

unsigned int minor_count = DRBD_MINOR_COUNT_DEF;

142

int disable_sendpage;

143

int allow_oos;

144

unsigned int cn_idx = CN_IDX_DRBD;

356

drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR));

357

}

358

359

360

/**

360

361

* _tl_restart() - Walks the transfer log, and applies an action to all requests

361

362

* @mdev: DRBD device.

477

478

}

478

479

480

/**

480

* cl_wide_st_chg() - TRUE if the state change is a cluster wide one

481

* cl_wide_st_chg() - true if the state change is a cluster wide one

481

482

* @mdev: DRBD device.

482

483

* @os: old (current) state.

483

484

* @ns: new (wanted) state.

494

495

(os.conn == C_CONNECTED && ns.conn == C_VERIFY_S);

495

496

}

496

497

int drbd_change_state(struct drbd_conf *mdev, enum chg_state_flags f,

498

union drbd_state mask, union drbd_state val)

498

enum drbd_state_rv

499

drbd_change_state(struct drbd_conf *mdev, enum chg_state_flags f,

500

union drbd_state mask, union drbd_state val)

499

501

{

500

502

#if DRBD_DEBUG_STATE_CHANGES

501

503

static unsigned long long sseq = 0x00f00000LLU;

503

505

504

506

unsigned long flags;

505

507

union drbd_state os, ns;

506

int rv;

508

enum drbd_state_rv rv;

507

509

508

510

ns = val; /* assign debug info, if any. */

509

511

spin_lock_irqsave(&mdev->req_lock, flags);

536

538

drbd_change_state(mdev, CS_HARD, mask, val);

537

539

}

538

540

539

STATIC int is_valid_state(struct drbd_conf *mdev, union drbd_state ns);

540

STATIC int is_valid_state_transition(struct drbd_conf *,

541

union drbd_state, union drbd_state);

541

STATIC enum drbd_state_rv is_valid_state(struct drbd_conf *, union drbd_state);

542

STATIC enum drbd_state_rv is_valid_state_transition(struct drbd_conf *,

543

union drbd_state,

544

union drbd_state);

545

enum sanitize_state_warnings {

546

NO_WARNING,

547

ABORTED_ONLINE_VERIFY,

548

ABORTED_RESYNC,

549

CONNECTION_LOST_NEGOTIATING,

550

IMPLICITLY_UPGRADED_DISK,

551

IMPLICITLY_UPGRADED_PDSK,

552

};

542

553

STATIC union drbd_state sanitize_state(struct drbd_conf *mdev, union drbd_state os,

543

union drbd_state ns, const char **warn_sync_abort);

554

union drbd_state ns, enum sanitize_state_warnings *warn);

544

555

int drbd_send_state_req(struct drbd_conf *,

545

556

union drbd_state, union drbd_state);

546

557

547

STATIC enum drbd_state_ret_codes _req_st_cond(struct drbd_conf *mdev,

548

union drbd_state mask, union drbd_state val)

558

STATIC enum drbd_state_rv

559

_req_st_cond(struct drbd_conf *mdev, union drbd_state mask,

560

union drbd_state val)

549

561

{

550

562

union drbd_state os, ns;

551

563

unsigned long flags;

552

int rv;

564

enum drbd_state_rv rv;

553

565

554

566

if (test_and_clear_bit(CL_ST_CHG_SUCCESS, &mdev->flags))

555

567

return SS_CW_SUCCESS;

570

582

if (rv == SS_SUCCESS) {

571

583

rv = is_valid_state_transition(mdev, ns, os);

572

584

if (rv == SS_SUCCESS)

573

rv = 0; /* cont waiting, otherwise fail. */

585

rv = SS_UNKNOWN_ERROR; /* cont waiting, otherwise fail. */

574

586

}

575

587

}

576

588

spin_unlock_irqrestore(&mdev->req_lock, flags);

588

600

* Should not be called directly, use drbd_request_state() or

589

601

* _drbd_request_state().

590

602

*/

591

STATIC int drbd_req_state(struct drbd_conf *mdev,

592

union drbd_state mask, union drbd_state val,

593

enum chg_state_flags f)

603

STATIC enum drbd_state_rv

604

drbd_req_state(struct drbd_conf *mdev, union drbd_state mask,

605

union drbd_state val, enum chg_state_flags f)

594

606

{

595

607

#if DRBD_DEBUG_STATE_CHANGES

596

608

static unsigned long long sseq = 0;

599

611

struct completion done;

600

612

unsigned long flags;

601

613

union drbd_state os, ns;

602

int rv;

614

enum drbd_state_rv rv;

603

615

604

616

init_completion(&done);

605

617

690

702

* Cousin of drbd_request_state(), useful with the CS_WAIT_COMPLETE

691

703

* flag, or when logging of failed state change requests is not desired.

692

704

*/

693

int _drbd_request_state(struct drbd_conf *mdev, union drbd_state mask,

694

union drbd_state val, enum chg_state_flags f)

705

enum drbd_state_rv

706

_drbd_request_state(struct drbd_conf *mdev, union drbd_state mask,

707

union drbd_state val, enum chg_state_flags f)

695

708

{

696

int rv;

709

enum drbd_state_rv rv;

697

710

698

711

wait_event(mdev->state_wait,

699

712

(rv = drbd_req_state(mdev, mask, val, f)) != SS_IN_TRANSIENT_STATE);

754

767

}

755

768

756

769

757

void print_st_err(struct drbd_conf *mdev,

758

union drbd_state os, union drbd_state ns, int err)

770

void print_st_err(struct drbd_conf *mdev, union drbd_state os,

771

union drbd_state ns, enum drbd_state_rv err)

759

772

{

760

773

if (err == SS_IN_TRANSIENT_STATE)

761

774

return;

767

780

#undef STATE_FMT

768

781

#undef STATE_ARGS

769

782

770

#define drbd_peer_str drbd_role_str

771

#define drbd_pdsk_str drbd_disk_str

772

773

#define drbd_susp_str(A) ((A) ? "1" : "0")

774

#define drbd_aftr_isp_str(A) ((A) ? "1" : "0")

775

#define drbd_peer_isp_str(A) ((A) ? "1" : "0")

776

#define drbd_user_isp_str(A) ((A) ? "1" : "0")

777

778

#define PSC(A) \

779

({ if (ns.A != os.A) { \

780

pbp += sprintf(pbp, #A "( %s -> %s ) ", \

781

drbd_##A##_str(os.A), \

782

drbd_##A##_str(ns.A)); \

783

} })

784

785

783

/**

786

784

* is_valid_state() - Returns an SS_ error code if ns is not valid

787

785

* @mdev: DRBD device.

788

786

* @ns: State to consider.

789

787

*/

790

STATIC int is_valid_state(struct drbd_conf *mdev, union drbd_state ns)

788

STATIC enum drbd_state_rv

789

is_valid_state(struct drbd_conf *mdev, union drbd_state ns)

791

790

{

792

791

/* See drbd_state_sw_errors in drbd_strings.c */

793

792

794

793

enum drbd_fencing_p fp;

795

int rv = SS_SUCCESS;

794

enum drbd_state_rv rv = SS_SUCCESS;

796

795

797

796

fp = FP_DONT_CARE;

798

797

if (get_ldev(mdev)) {

846

845

mdev->agreed_pro_version < 88)

847

846

rv = SS_NOT_SUPPORTED;

848

847

848

else if (ns.conn >= C_CONNECTED && ns.pdsk == D_UNKNOWN)

849

rv = SS_CONNECTED_OUTDATES;

850

849

851

return rv;

850

852

}

851

853

855

857

* @ns: new state.

856

858

* @os: old state.

857

859

*/

858

STATIC int is_valid_state_transition(struct drbd_conf *mdev,

859

union drbd_state ns, union drbd_state os)

860

STATIC enum drbd_state_rv

861

is_valid_state_transition(struct drbd_conf *mdev, union drbd_state ns,

862

union drbd_state os)

860

863

{

861

int rv = SS_SUCCESS;

864

enum drbd_state_rv rv = SS_SUCCESS;

862

865

863

866

if ((ns.conn == C_STARTING_SYNC_T || ns.conn == C_STARTING_SYNC_S) &&

864

867

os.conn > C_CONNECTED)

893

896

os.conn < C_CONNECTED)

894

897

rv = SS_NEED_CONNECTION;

895

898

899

if ((ns.conn == C_SYNC_TARGET || ns.conn == C_SYNC_SOURCE)

900

&& os.conn < C_WF_REPORT_PARAMS)

901

rv = SS_NEED_CONNECTION; /* No NetworkFailure -> SyncTarget etc... */

902

896

903

return rv;

897

904

}

898

905

906

static void print_sanitize_warnings(struct drbd_conf *mdev, enum sanitize_state_warnings warn)

907

{

908

static const char *msg_table[] = {

909

[NO_WARNING] = "",

910

[ABORTED_ONLINE_VERIFY] = "Online-verify aborted.",

911

[ABORTED_RESYNC] = "Resync aborted.",

912

[CONNECTION_LOST_NEGOTIATING] = "Connection lost while negotiating, no data!",

913

[IMPLICITLY_UPGRADED_DISK] = "Implicitly upgraded disk",

914

[IMPLICITLY_UPGRADED_PDSK] = "Implicitly upgraded pdsk",

915

};

916

917

if (warn != NO_WARNING)

918

dev_warn(DEV, "%s\n", msg_table[warn]);

919

}

920

899

921

/**

900

922

* sanitize_state() - Resolves implicitly necessary additional changes to a state transition

901

923

* @mdev: DRBD device.

907

929

* to D_UNKNOWN. This rule and many more along those lines are in this function.

908

930

*/

909

931

STATIC union drbd_state sanitize_state(struct drbd_conf *mdev, union drbd_state os,

910

union drbd_state ns, const char **warn_sync_abort)

932

union drbd_state ns, enum sanitize_state_warnings *warn)

911

933

{

912

934

enum drbd_fencing_p fp;

935

enum drbd_disk_state disk_min, disk_max, pdsk_min, pdsk_max;

936

937

if (warn)

938

*warn = NO_WARNING;

913

939

914

940

fp = FP_DONT_CARE;

915

941

if (get_ldev(mdev)) {

955

981

/* Abort resync if a disk fails/detaches */

956

982

if (os.conn > C_CONNECTED && ns.conn > C_CONNECTED &&

957

983

(ns.disk <= D_FAILED || ns.pdsk <= D_FAILED)) {

958

if (warn_sync_abort)

959

*warn_sync_abort =

960

os.conn == C_VERIFY_S || os.conn == C_VERIFY_T ?

961

"Online-verify" : "Resync";

984

if (warn)

985

*warn = os.conn == C_VERIFY_S || os.conn == C_VERIFY_T ?

986

ABORTED_ONLINE_VERIFY : ABORTED_RESYNC;

962

987

ns.conn = C_CONNECTED;

963

988

}

964

989

965

if (ns.conn >= C_CONNECTED &&

966

((ns.disk == D_CONSISTENT || ns.disk == D_OUTDATED) ||

967

(ns.disk == D_NEGOTIATING && ns.conn == C_WF_BITMAP_T))) {

968

switch (ns.conn) {

969

case C_WF_BITMAP_T:

970

case C_PAUSED_SYNC_T:

971

ns.disk = D_OUTDATED;

972

break;

973

case C_CONNECTED:

974

case C_WF_BITMAP_S:

975

case C_SYNC_SOURCE:

976

case C_PAUSED_SYNC_S:

977

ns.disk = D_UP_TO_DATE;

978

break;

979

case C_SYNC_TARGET:

980

ns.disk = D_INCONSISTENT;

981

dev_warn(DEV, "Implicitly set disk state Inconsistent!\n");

982

break;

983

}

984

if (os.disk == D_OUTDATED && ns.disk == D_UP_TO_DATE)

985

dev_warn(DEV, "Implicitly set disk from Outdated to UpToDate\n");

986

}

987

988

if (ns.conn >= C_CONNECTED &&

989

(ns.pdsk == D_CONSISTENT || ns.pdsk == D_OUTDATED)) {

990

switch (ns.conn) {

991

case C_CONNECTED:

992

case C_WF_BITMAP_T:

993

case C_PAUSED_SYNC_T:

994

case C_SYNC_TARGET:

995

ns.pdsk = D_UP_TO_DATE;

996

break;

997

case C_WF_BITMAP_S:

998

case C_PAUSED_SYNC_S:

999

/* remap any consistent state to D_OUTDATED,

1000

* but disallow "upgrade" of not even consistent states.

1001

*/

1002

ns.pdsk =

1003

(D_DISKLESS < os.pdsk && os.pdsk < D_OUTDATED)

1004

? os.pdsk : D_OUTDATED;

1005

break;

1006

case C_SYNC_SOURCE:

1007

ns.pdsk = D_INCONSISTENT;

1008

dev_warn(DEV, "Implicitly set pdsk Inconsistent!\n");

1009

break;

1010

}

1011

if (os.pdsk == D_OUTDATED && ns.pdsk == D_UP_TO_DATE)

1012

dev_warn(DEV, "Implicitly set pdsk from Outdated to UpToDate\n");

1013

}

1014

1015

990

/* Connection breaks down before we finished "Negotiating" */

1016

991

if (ns.conn < C_CONNECTED && ns.disk == D_NEGOTIATING &&

1017

992

get_ldev_if_state(mdev, D_NEGOTIATING)) {

1019

994

ns.disk = mdev->new_state_tmp.disk;

1020

995

ns.pdsk = mdev->new_state_tmp.pdsk;

1021

996

} else {

1022

dev_alert(DEV, "Connection lost while negotiating, no data!\n");

997

if (warn)

998

*warn = CONNECTION_LOST_NEGOTIATING;

1023

999

ns.disk = D_DISKLESS;

1024

1000

ns.pdsk = D_UNKNOWN;

1025

1001

}

1026

1002

put_ldev(mdev);

1027

1003

}

1028

1004

1005

/* D_CONSISTENT and D_OUTDATED vanish when we get connected */

1006

if (ns.conn >= C_CONNECTED && ns.conn < C_AHEAD) {

1007

if (ns.disk == D_CONSISTENT || ns.disk == D_OUTDATED)

1008

ns.disk = D_UP_TO_DATE;

1009

if (ns.pdsk == D_CONSISTENT || ns.pdsk == D_OUTDATED)

1010

ns.pdsk = D_UP_TO_DATE;

1011

}

1012

1013

/* Implications of the connection stat on the disk states */

1014

disk_min = D_DISKLESS;

1015

disk_max = D_UP_TO_DATE;

1016

pdsk_min = D_INCONSISTENT;

1017

pdsk_max = D_UNKNOWN;

1018

switch ((enum drbd_conns)ns.conn) {

1019

case C_WF_BITMAP_T:

1020

case C_PAUSED_SYNC_T:

1021

case C_STARTING_SYNC_T:

1022

case C_WF_SYNC_UUID:

1023

case C_BEHIND:

1024

disk_min = D_INCONSISTENT;

1025

disk_max = D_OUTDATED;

1026

pdsk_min = D_UP_TO_DATE;

1027

pdsk_max = D_UP_TO_DATE;

1028

break;

1029

case C_VERIFY_S:

1030

case C_VERIFY_T:

1031

disk_min = D_UP_TO_DATE;

1032

disk_max = D_UP_TO_DATE;

1033

pdsk_min = D_UP_TO_DATE;

1034

pdsk_max = D_UP_TO_DATE;

1035

break;

1036

case C_CONNECTED:

1037

disk_min = D_DISKLESS;

1038

disk_max = D_UP_TO_DATE;

1039

pdsk_min = D_DISKLESS;

1040

pdsk_max = D_UP_TO_DATE;

1041

break;

1042

case C_WF_BITMAP_S:

1043

case C_PAUSED_SYNC_S:

1044

case C_STARTING_SYNC_S:

1045

case C_AHEAD:

1046

disk_min = D_UP_TO_DATE;

1047

disk_max = D_UP_TO_DATE;

1048

pdsk_min = D_INCONSISTENT;

1049

pdsk_max = D_CONSISTENT; /* D_OUTDATED would be nice. But explicit outdate necessary*/

1050

break;

1051

case C_SYNC_TARGET:

1052

disk_min = D_INCONSISTENT;

1053

disk_max = D_INCONSISTENT;

1054

pdsk_min = D_UP_TO_DATE;

1055

pdsk_max = D_UP_TO_DATE;

1056

break;

1057

case C_SYNC_SOURCE:

1058

disk_min = D_UP_TO_DATE;

1059

disk_max = D_UP_TO_DATE;

1060

pdsk_min = D_INCONSISTENT;

1061

pdsk_max = D_INCONSISTENT;

1062

break;

1063

case C_STANDALONE:

1064

case C_DISCONNECTING:

1065

case C_UNCONNECTED:

1066

case C_TIMEOUT:

1067

case C_BROKEN_PIPE:

1068

case C_NETWORK_FAILURE:

1069

case C_PROTOCOL_ERROR:

1070

case C_TEAR_DOWN:

1071

case C_WF_CONNECTION:

1072

case C_WF_REPORT_PARAMS:

1073

case C_MASK:

1074

break;

1075

}

1076

if (ns.disk > disk_max)

1077

ns.disk = disk_max;

1078

1079

if (ns.disk < disk_min) {

1080

if (warn)

1081

*warn = IMPLICITLY_UPGRADED_DISK;

1082

ns.disk = disk_min;

1083

}

1084

if (ns.pdsk > pdsk_max)

1085

ns.pdsk = pdsk_max;

1086

1087

if (ns.pdsk < pdsk_min) {

1088

if (warn)

1089

*warn = IMPLICITLY_UPGRADED_PDSK;

1090

ns.pdsk = pdsk_min;

1091

}

1092

1029

1093

if (fp == FP_STONITH &&

1030

1094

(ns.role == R_PRIMARY && ns.conn < C_CONNECTED && ns.pdsk > D_OUTDATED) &&

1031

1095

!(os.role == R_PRIMARY && os.conn < C_CONNECTED && os.pdsk > D_OUTDATED))

1054

1118

/* helper for __drbd_set_state */

1055

1119

static void set_ov_position(struct drbd_conf *mdev, enum drbd_conns cs)

1056

1120

{

1121

if (mdev->agreed_pro_version < 90)

1122

mdev->ov_start_sector = 0;

1123

mdev->rs_total = drbd_bm_bits(mdev);

1124

mdev->ov_position = 0;

1057

1125

if (cs == C_VERIFY_T) {

1058

1126

/* starting online verify from an arbitrary position

1059

1127

* does not fit well into the existing protocol.

1063

1131

mdev->ov_start_sector = ~(sector_t)0;

1064

1132

} else {

1065

1133

unsigned long bit = BM_SECT_TO_BIT(mdev->ov_start_sector);

1066

if (bit >= mdev->rs_total)

1134

if (bit >= mdev->rs_total) {

1067

1135

mdev->ov_start_sector =

1068

1136

BM_BIT_TO_SECT(mdev->rs_total - 1);

1137

mdev->rs_total = 1;

1138

} else

1139

mdev->rs_total -= bit;

1069

1140

mdev->ov_position = mdev->ov_start_sector;

1070

1141

}

1142

mdev->ov_left = mdev->rs_total;

1071

1143

}

1072

1144

1073

1145

static void drbd_resume_al(struct drbd_conf *mdev)

1085

1157

*

1086

1158

* Caller needs to hold req_lock, and global_state_lock. Do not call directly.

1087

1159

*/

1088

int __drbd_set_state(struct drbd_conf *mdev,

1089

union drbd_state ns, enum chg_state_flags flags,

1090

struct completion *done)

1160

enum drbd_state_rv

1161

__drbd_set_state(struct drbd_conf *mdev, union drbd_state ns,

1162

enum chg_state_flags flags, struct completion *done)

1091

1163

{

1092

1164

#if DRBD_DEBUG_STATE_CHANGES

1093

1165

static unsigned long long sseq = 0xff000000LLU;

1094

1166

#endif

1095

1167

union drbd_state os;

1096

int rv = SS_SUCCESS;

1097

const char *warn_sync_abort = NULL;

1168

enum drbd_state_rv rv = SS_SUCCESS;

1169

enum sanitize_state_warnings ssw;

1098

1170

struct after_state_chg_work *ascw;

1099

1171

1100

1172

1108

1180

}

1109

1181

#endif

1110

1182

1111

ns = sanitize_state(mdev, os, ns, &warn_sync_abort);

1183

ns = sanitize_state(mdev, os, ns, &ssw);

1112

1184

1113

1185

#if DRBD_DEBUG_STATE_CHANGES

1114

1186

drbd_state_dbg(mdev, ns.seq, ns.func, ns.line, "=>ns", ns);

1138

1210

return rv;

1139

1211

}

1140

1212

1141

if (warn_sync_abort)

1142

dev_warn(DEV, "%s aborted.\n", warn_sync_abort);

1213

print_sanitize_warnings(mdev, ssw);

1143

1214

1144

1215

#if DUMP_MD >= 2

1145

1216

{

1146

1217

char *pbp, pb[300];

1147

1218

pbp = pb;

1148

1219

*pbp = 0;

1149

PSC(role);

1150

PSC(peer);

1151

PSC(conn);

1152

PSC(disk);

1153

PSC(pdsk);

1220

if (ns.role != os.role)

1221

pbp += sprintf(pbp, "role( %s -> %s ) ",

1222

drbd_role_str(os.role),

1223

drbd_role_str(ns.role));

1224

if (ns.peer != os.peer)

1225

pbp += sprintf(pbp, "peer( %s -> %s ) ",

1226

drbd_role_str(os.peer),

1227

drbd_role_str(ns.peer));

1228

if (ns.conn != os.conn)

1229

pbp += sprintf(pbp, "conn( %s -> %s ) ",

1230

drbd_conn_str(os.conn),

1231

drbd_conn_str(ns.conn));

1232

if (ns.disk != os.disk)

1233

pbp += sprintf(pbp, "disk( %s -> %s ) ",

1234

drbd_disk_str(os.disk),

1235

drbd_disk_str(ns.disk));

1236

if (ns.pdsk != os.pdsk)

1237

pbp += sprintf(pbp, "pdsk( %s -> %s ) ",

1238

drbd_disk_str(os.pdsk),

1239

drbd_disk_str(ns.pdsk));

1154

1240

if (is_susp(ns) != is_susp(os))

1155

pbp += sprintf(pbp, "susp( %s -> %s ) ",

1156

drbd_susp_str(is_susp(os)),

1157

drbd_susp_str(is_susp(ns)));

1158

PSC(aftr_isp);

1159

PSC(peer_isp);

1160

PSC(user_isp);

1241

pbp += sprintf(pbp, "susp( %d -> %d ) ",

1242

is_susp(os),

1243

is_susp(ns));

1244

if (ns.aftr_isp != os.aftr_isp)

1245

pbp += sprintf(pbp, "aftr_isp( %d -> %d ) ",

1246

os.aftr_isp,

1247

ns.aftr_isp);

1248

if (ns.peer_isp != os.peer_isp)

1249

pbp += sprintf(pbp, "peer_isp( %d -> %d ) ",

1250

os.peer_isp,

1251

ns.peer_isp);

1252

if (ns.user_isp != os.user_isp)

1253

pbp += sprintf(pbp, "user_isp( %d -> %d ) ",

1254

os.user_isp,

1255

ns.user_isp);

1161

1256

dev_info(DEV, "%s\n", pb);

1162

1257

}

1163

1258

#endif

1191

1286

/* assignment inclusive debug info about what code path

1192

1287

* initiated this state change. */

1193

1288

mdev->state = ns;

1289

1290

if (os.disk == D_ATTACHING && ns.disk >= D_NEGOTIATING)

1291

drbd_print_uuids(mdev, "attached to UUIDs");

1292

1194

1293

wake_up(&mdev->misc_wait);

1195

1294

wake_up(&mdev->state_wait);

1196

1295

1198

1297

if ((os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) &&

1199

1298

ns.conn < C_CONNECTED) {

1200

1299

mdev->ov_start_sector =

1201

BM_BIT_TO_SECT(mdev->rs_total - mdev->ov_left);

1300

BM_BIT_TO_SECT(drbd_bm_bits(mdev) - mdev->ov_left);

1202

1301

dev_info(DEV, "Online Verify reached sector %llu\n",

1203

1302

(unsigned long long)mdev->ov_start_sector);

1204

1303

}

1223

1322

unsigned long now = jiffies;

1224

1323

int i;

1225

1324

1226

mdev->ov_position = 0;

1227

mdev->rs_total = drbd_bm_bits(mdev);

1228

if (mdev->agreed_pro_version >= 90)

1229

set_ov_position(mdev, ns.conn);

1230

else

1231

mdev->ov_start_sector = 0;

1232

mdev->ov_left = mdev->rs_total

1233

- BM_SECT_TO_BIT(mdev->ov_position);

1325

set_ov_position(mdev, ns.conn);

1234

1326

mdev->rs_start = now;

1235

1327

mdev->rs_last_events = 0;

1236

1328

mdev->rs_last_sect_ev = 0;

1238

1330

mdev->ov_last_oos_start = 0;

1239

1331

1240

1332

for (i = 0; i < DRBD_SYNC_MARKS; i++) {

1241

mdev->rs_mark_left[i] = mdev->rs_total;

1333

mdev->rs_mark_left[i] = mdev->ov_left;

1242

1334

mdev->rs_mark_time[i] = now;

1243

1335

}

1244

1336

1337

drbd_rs_controller_reset(mdev);

1338

1245

1339

if (ns.conn == C_VERIFY_S) {

1246

1340

dev_info(DEV, "Starting Online Verify from sector %llu\n",

1247

1341

(unsigned long long)mdev->ov_position);

1345

1439

}

1346

1440

}

1347

1441

1442

int drbd_bitmap_io_from_worker(struct drbd_conf *mdev,

1443

int (*io_fn)(struct drbd_conf *),

1444

char *why, enum bm_flag flags)

1445

{

1446

int rv;

1447

1448

D_ASSERT(current == mdev->worker.task);

1449

1450

/* open coded non-blocking drbd_suspend_io(mdev); */

1451

set_bit(SUSPEND_IO, &mdev->flags);

1452

1453

drbd_bm_lock(mdev, why, flags);

1454

rv = io_fn(mdev);

1455

drbd_bm_unlock(mdev);

1456

1457

drbd_resume_io(mdev);

1458

1459

return rv;

1460

}

1461

1348

1462

/**

1349

1463

* after_state_ch() - Perform after state change actions that may sleep

1350

1464

* @mdev: DRBD device.

1390

1504

1391

1505

nsm.i = -1;

1392

1506

if (ns.susp_nod) {

1393

if (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED) {

1394

if (ns.conn == C_CONNECTED)

1395

what = resend, nsm.susp_nod = 0;

1396

else /* ns.conn > C_CONNECTED */

1397

dev_err(DEV, "Unexpected Resynd going on!\n");

1398

}

1507

if (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED)

1508

what = resend;

1399

1509

1400

1510

if (os.disk == D_ATTACHING && ns.disk > D_ATTACHING)

1401

what = restart_frozen_disk_io, nsm.susp_nod = 0;

1511

what = restart_frozen_disk_io;

1402

1512

1513

if (what != nothing)

1514

nsm.susp_nod = 0;

1403

1515

}

1404

1516

1405

1517

if (ns.susp_fen) {

1430

1542

spin_unlock_irq(&mdev->req_lock);

1431

1543

}

1432

1544

1545

/* Became sync source. With protocol >= 96, we still need to send out

1546

* the sync uuid now. Need to do that before any drbd_send_state, or

1547

* the other side may go "paused sync" before receiving the sync uuids,

1548

* which is unexpected. */

1549

if ((os.conn != C_SYNC_SOURCE && os.conn != C_PAUSED_SYNC_S) &&

1550

(ns.conn == C_SYNC_SOURCE || ns.conn == C_PAUSED_SYNC_S) &&

1551

mdev->agreed_pro_version >= 96 && get_ldev(mdev)) {

1552

drbd_gen_and_send_sync_uuid(mdev);

1553

put_ldev(mdev);

1554

}

1555

1433

1556

/* Do not change the order of the if above and the two below... */

1434

1557

if (os.pdsk == D_DISKLESS && ns.pdsk > D_DISKLESS) { /* attach on the peer */

1435

1558

drbd_send_uuids(mdev);

1436

1559

drbd_send_state(mdev);

1437

1560

}

1438

if (os.conn != C_WF_BITMAP_S && ns.conn == C_WF_BITMAP_S)

1439

drbd_queue_bitmap_io(mdev, &drbd_send_bitmap, NULL, "send_bitmap (WFBitMapS)");

1561

/* No point in queuing send_bitmap if we don't have a connection

1562

* anymore, so check also the _current_ state, not only the new state

1563

* at the time this work was queued. */

1564

if (os.conn != C_WF_BITMAP_S && ns.conn == C_WF_BITMAP_S &&

1565

mdev->state.conn == C_WF_BITMAP_S)

1566

drbd_queue_bitmap_io(mdev, &drbd_send_bitmap, NULL,

1567

"send_bitmap (WFBitMapS)",

1568

BM_LOCKED_TEST_ALLOWED);

1440

1569

1441

1570

/* Lost contact to peer's copy of the data */

1442

1571

if ((os.pdsk >= D_INCONSISTENT &&

1467

1596

1468

1597

/* D_DISKLESS Peer becomes secondary */

1469

1598

if (os.peer == R_PRIMARY && ns.peer == R_SECONDARY)

1470

drbd_al_to_on_disk_bm(mdev);

1599

/* We may still be Primary ourselves.

1600

* No harm done if the bitmap still changes,

1601

* redirtied pages will follow later. */

1602

drbd_bitmap_io_from_worker(mdev, &drbd_bm_write,

1603

"demote diskless peer", BM_LOCKED_SET_ALLOWED);

1604

put_ldev(mdev);

1605

}

1606

1607

/* Write out all changed bits on demote.

1608

* Though, no need to da that just yet

1609

* if there is a resync going on still */

1610

if (os.role == R_PRIMARY && ns.role == R_SECONDARY &&

1611

mdev->state.conn <= C_CONNECTED && get_ldev(mdev)) {

1612

/* No changes to the bitmap expected this time, so assert that,

1613

* even though no harm was done if it did change. */

1614

drbd_bitmap_io_from_worker(mdev, &drbd_bm_write,

1615

"demote", BM_LOCKED_TEST_ALLOWED);

1471

1616

put_ldev(mdev);

1472

1617

}

1473

1618

1495

1640

if (os.conn == C_WF_REPORT_PARAMS && ns.conn >= C_CONNECTED)

1496

1641

drbd_send_state(mdev);

1497

1642

1643

if (os.conn != C_AHEAD && ns.conn == C_AHEAD)

1644

drbd_send_state(mdev);

1645

1498

1646

/* We are in the progress to start a full sync... */

1499

1647

if ((os.conn != C_STARTING_SYNC_T && ns.conn == C_STARTING_SYNC_T) ||

1500

1648

(os.conn != C_STARTING_SYNC_S && ns.conn == C_STARTING_SYNC_S))

1501

drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, &abw_start_sync, "set_n_write from StartingSync");

1649

/* no other bitmap changes expected during this phase */

1650

drbd_queue_bitmap_io(mdev,

1651

&drbd_bmio_set_n_write, &abw_start_sync,

1652

"set_n_write from StartingSync", BM_LOCKED_TEST_ALLOWED);

1502

1653

1503

1654

/* We are invalidating our self... */

1504

1655

if (os.conn < C_CONNECTED && ns.conn < C_CONNECTED &&

1505

1656

os.disk > D_INCONSISTENT && ns.disk == D_INCONSISTENT)

1506

drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, NULL, "set_n_write from invalidate");

1657

/* other bitmap operation expected during this phase */

1658

drbd_queue_bitmap_io(mdev, &drbd_bmio_set_n_write, NULL,

1659

"set_n_write from invalidate", BM_LOCKED_MASK);

1507

1660

1508

1661

/* first half of local IO error, failure to attach,

1509

1662

* or administrative detach */

1525

1678

drbd_disk_str(mdev->state.disk));

1526

1679

1527

1680

if (drbd_send_state(mdev))

1528

dev_warn(DEV, "Notified peer that I am detaching my disk\n");

1529

else

1530

dev_err(DEV, "Sending state for detaching disk failed\n");

1681

dev_info(DEV, "Notified peer that I am detaching my disk\n");

1531

1682

1532

1683

drbd_rs_cancel_all(mdev);

1533

1684

1557

1708

atomic_set(&mdev->rs_pending_cnt, 0);

1558

1709

1559

1710

if (drbd_send_state(mdev))

1560

dev_warn(DEV, "Notified peer that I'm now diskless.\n");

1561

else

1562

dev_err(DEV, "Sending state for being diskless failed\n");

1711

dev_info(DEV, "Notified peer that I'm now diskless.\n");

1563

1712

/* corresponding get_ldev in __drbd_set_state

1564

* this may finaly trigger drbd_ldev_destroy. */

1713

* this may finally trigger drbd_ldev_destroy. */

1565

1714

put_ldev(mdev);

1566

1715

}

1567

1716

1717

/* Notify peer that I had a local IO error, and did not detached.. */

1718

if (os.disk == D_UP_TO_DATE && ns.disk == D_INCONSISTENT)

1719

drbd_send_state(mdev);

1720

1568

1721

/* Disks got bigger while they were detached */

1569

1722

if (ns.disk > D_NEGOTIATING && ns.pdsk > D_NEGOTIATING &&

1570

1723

test_and_clear_bit(RESYNC_AFTER_NEG, &mdev->flags)) {

1583

1736

if (os.disk < D_UP_TO_DATE && os.conn >= C_SYNC_SOURCE && ns.conn == C_CONNECTED)

1584

1737

drbd_send_state(mdev);

1585

1738

1739

/* This triggers bitmap writeout of potentially still unwritten pages

1740

* if the resync finished cleanly, or aborted because of peer disk

1741

* failure, or because of connection loss.

1742

* For resync aborted because of local disk failure, we cannot do

1743

* any bitmap writeout anymore.

1744

* No harm done if some bits change during this phase.

1745

*/

1746

if (os.conn > C_CONNECTED && ns.conn <= C_CONNECTED && get_ldev(mdev)) {

1747

drbd_queue_bitmap_io(mdev, &drbd_bm_write, NULL,

1748

"write from resync_finished", BM_LOCKED_SET_ALLOWED);

1749

put_ldev(mdev);

1750

}

1751

1586

1752

/* free tl_hash if we Got thawed and are C_STANDALONE */

1587

1753

if (ns.conn == C_STANDALONE && !is_susp(ns) && mdev->tl_hash)

1588

1754

drbd_free_tl_hash(mdev);

1703

1869

if (!try_module_get(THIS_MODULE)) {

1704

1870

dev_err(DEV, "Failed to get module reference in drbd_thread_start\n");

1705

1871

spin_unlock_irqrestore(&thi->t_lock, flags);

1706

return FALSE;

1872

return false;

1707

1873

}

1708

1874

1709

1875

init_completion(&thi->startstop);

1718

1884

dev_err(DEV, "Couldn't start thread (%d)\n", pid);

1719

1885

1720

1886

module_put(THIS_MODULE);

1721

return FALSE;

1887

return false;

1722

1888

}

1723

1889

/* waits until thi->task is set */

1724

1890

wait_for_completion(&thi->startstop);

1742

1908

break;

1743

1909

}

1744

1910

1745

return TRUE;

1911

return true;

1746

1912

}

1747

1913

1748

1914

1856

2022

{

1857

2023

int sent, ok;

1858

2024

1859

ERR_IF(!h) return FALSE;

1860

ERR_IF(!size) return FALSE;

2025

ERR_IF(!h) return false;

2026

ERR_IF(!size) return false;

1861

2027

1862

2028

h->magic = BE_DRBD_MAGIC;

1863

2029

h->command = cpu_to_be16(cmd);

1867

2033

sent = drbd_send(mdev, sock, h, size, msg_flags);

1868

2034

1869

2035

ok = (sent == size);

1870

if (!ok)

1871

dev_err(DEV, "short sent %s size=%d sent=%d\n",

2036

if (!ok && !signal_pending(current))

2037

dev_warn(DEV, "short sent %s size=%d sent=%d\n",

1872

2038

cmdname(cmd), (int)size, sent);

1873

2039

return ok;

1874

2040

}

2005

2171

else {

2006

2172

dev_err(DEV, "--dry-run is not supported by peer");

2007

2173

kfree(p);

2008

return 0;

2174

return -1;

2009

2175

}

2010

2176

}

2011

2177

p->conn_flags = cpu_to_be32(cf);

2053

2219

return _drbd_send_uuids(mdev, 8);

2054

2220

}

2055

2221

2222

void drbd_print_uuids(struct drbd_conf *mdev, const char *text)

2223

{

2224

if (get_ldev_if_state(mdev, D_NEGOTIATING)) {

2225

u64 *uuid = mdev->ldev->md.uuid;

2226

dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX\n",

2227

text,

2228

(unsigned long long)uuid[UI_CURRENT],

2229

(unsigned long long)uuid[UI_BITMAP],

2230

(unsigned long long)uuid[UI_HISTORY_START],

2231

(unsigned long long)uuid[UI_HISTORY_END]);

2232

put_ldev(mdev);

2233

} else {

2234

dev_info(DEV, "%s effective data uuid: %016llX\n",

2235

text,

2236

(unsigned long long)mdev->ed_uuid);

2237

}

2238

}

2056

2239

2057

int drbd_send_sync_uuid(struct drbd_conf *mdev, u64 val)

2240

int drbd_gen_and_send_sync_uuid(struct drbd_conf *mdev)

2058

2241

{

2059

2242

struct p_rs_uuid p;

2060

2061

p.uuid = cpu_to_be64(val);

2243

u64 uuid;

2244

2245

D_ASSERT(mdev->state.disk == D_UP_TO_DATE);

2246

2247

uuid = mdev->ldev->md.uuid[UI_BITMAP] + UUID_NEW_BM_OFFSET;

2248

drbd_uuid_set(mdev, UI_BITMAP, uuid);

2249

drbd_print_uuids(mdev, "updated sync UUID");

2250

drbd_md_sync(mdev);

2251

p.uuid = cpu_to_be64(uuid);

2062

2252

2063

2253

return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_SYNC_UUID,

2064

2254

(struct p_header80 *)&p, sizeof(p));

2068

2258

{

2069

2259

struct p_sizes p;

2070

2260

sector_t d_size, u_size;

2071

int q_order_type;

2261

int q_order_type, max_bio_size;

2072

2262

int ok;

2073

2263

2074

2264

if (get_ldev_if_state(mdev, D_NEGOTIATING)) {

2076

2266

d_size = drbd_get_max_capacity(mdev->ldev);

2077

2267

u_size = mdev->ldev->dc.disk_size;

2078

2268

q_order_type = drbd_queue_order_type(mdev);

2269

max_bio_size = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;

2270

max_bio_size = min_t(int, max_bio_size, DRBD_MAX_BIO_SIZE);

2079

2271

put_ldev(mdev);

2080

2272

} else {

2081

2273

d_size = 0;

2082

2274

u_size = 0;

2083

2275

q_order_type = QUEUE_ORDERED_NONE;

2276

max_bio_size = DRBD_MAX_BIO_SIZE; /* ... multiple BIOs per peer_request */

2084

2277

}

2085

2278

2086

2279

p.d_size = cpu_to_be64(d_size);

2087

2280

p.u_size = cpu_to_be64(u_size);

2088

2281

p.c_size = cpu_to_be64(trigger_reply ? 0 : drbd_get_capacity(mdev->this_bdev));

2089

p.max_segment_size = cpu_to_be32(queue_max_segment_size(mdev->rq_queue));

2282

p.max_bio_size = cpu_to_be32(max_bio_size);

2090

2283

p.queue_order_type = cpu_to_be16(q_order_type);

2091

2284

p.dds_flags = cpu_to_be16(flags);

2092

2285

2138

2331

(struct p_header80 *)&p, sizeof(p));

2139

2332

}

2140

2333

2141

int drbd_send_sr_reply(struct drbd_conf *mdev, int retcode)

2334

int drbd_send_sr_reply(struct drbd_conf *mdev, enum drbd_state_rv retcode)

2142

2335

{

2143

2336

struct p_req_state_reply p;

2144

2337

2242

2435

return len;

2243

2436

}

2244

2437

2245

enum { OK, FAILED, DONE }

2438

/**

2439

* send_bitmap_rle_or_plain

2440

*

2441

* Return 0 when done, 1 when another iteration is needed, and a negative error

2442

* code upon failure.

2443

*/

2444

STATIC int

2246

2445

send_bitmap_rle_or_plain(struct drbd_conf *mdev,

2247

struct p_header80 *h, struct bm_xfer_ctx *c)

2446

struct p_header80 *h, struct bm_xfer_ctx *c)

2248

2447

{

2249

2448

struct p_compressed_bm *p = (void*)h;

2250

2449

unsigned long num_words;

2254

2453

len = fill_bitmap_rle_bits(mdev, p, c);

2255

2454

2256

2455

if (len < 0)

2257

return FAILED;

2456

return -EIO;

2258

2457

2259

2458

if (len) {

2260

2459

DCBP_set_code(p, RLE_VLI_Bits);

2284

2483

if (c->bit_offset > c->bm_bits)

2285

2484

c->bit_offset = c->bm_bits;

2286

2485

}

2287

ok = ok ? ((len == 0) ? DONE : OK) : FAILED;

2288

2289

if (ok == DONE)

2290

INFO_bm_xfer_stats(mdev, "send", c);

2291

return ok;

2486

if (ok) {

2487

if (len == 0) {

2488

INFO_bm_xfer_stats(mdev, "send", c);

2489

return 0;

2490

} else

2491

return 1;

2492

}

2493

return -EIO;

2292

2494

}

2293

2495

2294

2496

/* See the comment at receive_bitmap() */

2296

2498

{

2297

2499

struct bm_xfer_ctx c;

2298

2500

struct p_header80 *p;

2299

int ret;

2501

int err;

2300

2502

2301

ERR_IF(!mdev->bitmap) return FALSE;

2503

ERR_IF(!mdev->bitmap) return false;

2302

2504

2303

2505

/* maybe we should use some per thread scratch page,

2304

2506

* and allocate that during initial device creation? */

2305

2507

p = (struct p_header80 *) __get_free_page(GFP_NOIO);

2306

2508

if (!p) {

2307

2509

dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__);

2308

return FALSE;

2510

return false;

2309

2511

}

2310

2512

2311

2513

if (get_ldev(mdev)) {

2331

2533

};

2332

2534

2333

2535

do {

2334

ret = send_bitmap_rle_or_plain(mdev, p, &c);

2335

} while (ret == OK);

2536

err = send_bitmap_rle_or_plain(mdev, p, &c);

2537

} while (err > 0);

2336

2538

2337

2539

free_page((unsigned long) p);

2338

return (ret == DONE);

2540

return err == 0;

2339

2541

}

2340

2542

2341

2543

int drbd_send_bitmap(struct drbd_conf *mdev)

2358

2560

p.set_size = cpu_to_be32(set_size);

2359

2561

2360

2562

if (mdev->state.conn < C_CONNECTED)

2361

return FALSE;

2563

return false;

2362

2564

ok = drbd_send_cmd(mdev, USE_META_SOCKET, P_BARRIER_ACK,

2363

2565

(struct p_header80 *)&p, sizeof(p));

2364

2566

return ok;

2386

2588

p.seq_num = cpu_to_be32(atomic_add_return(1, &mdev->packet_seq));

2387

2589

2388

2590

if (!mdev->meta.socket || mdev->state.conn < C_CONNECTED)

2389

return FALSE;

2591

return false;

2390

2592

ok = drbd_send_cmd(mdev, USE_META_SOCKET, cmd,

2391

2593

(struct p_header80 *)&p, sizeof(p));

2392

2594

return ok;

2492

2694

}

2493

2695

2494

2696

/* called on sndtimeo

2495

* returns FALSE if we should retry,

2496

* TRUE if we think connection is dead

2697

* returns false if we should retry,

2698

* true if we think connection is dead

2497

2699

*/

2498

2700

STATIC int we_should_drop_the_connection(struct drbd_conf *mdev, struct socket *sock)

2499

2701

{

2507

2709

|| mdev->state.conn < C_CONNECTED;

2508

2710

2509

2711

if (drop_it)

2510

return TRUE;

2712

return true;

2511

2713

2512

2714

drop_it = !--mdev->ko_count;

2513

2715

if (!drop_it) {

2640

2842

return 1;

2641

2843

}

2642

2844

2845

/* see also wire_flags_to_bio()

2846

* DRBD_REQ_*, because we need to semantically map the flags to data packet

2847

* flags and back. We may replicate to other kernel versions. */

2643

2848

static u32 bio_flags_to_wire(struct drbd_conf *mdev, unsigned long bi_rw)

2644

2849

{

2645

2850

if (mdev->agreed_pro_version >= 95)

2646

return (bi_rw & REQ_SYNC ? (DP_RW_SYNC | DP_BCOMP_UNPLUG): 0) |

2647

(bi_rw & REQ_UNPLUG ? DP_UNPLUG : 0) |

2648

(bi_rw & REQ_FUA ? DP_FUA : 0) |

2649

(bi_rw & REQ_FLUSH ? DP_FLUSH : 0) |

2650

(bi_rw & REQ_DISCARD ? DP_DISCARD : 0);

2651

else

2652

return bi_rw & (REQ_SYNC | REQ_UNPLUG) ? DP_RW_SYNC : 0;

2851

return (bi_rw & DRBD_REQ_SYNC ? DP_RW_SYNC : 0) |

2852

(bi_rw & DRBD_REQ_UNPLUG ? DP_UNPLUG : 0) |

2853

(bi_rw & DRBD_REQ_FUA ? DP_FUA : 0) |

2854

(bi_rw & DRBD_REQ_FLUSH ? DP_FLUSH : 0) |

2855

(bi_rw & DRBD_REQ_DISCARD ? DP_DISCARD : 0);

2856

2857

/* else: we used to communicate one bit only in older DRBD */

2858

return bi_rw & (DRBD_REQ_SYNC | DRBD_REQ_UNPLUG) ? DP_RW_SYNC : 0;

2653

2859

}

2654

2860

2655

2861

/* Used to send write requests

2699

2905

if (ok && dgs) {

2700

2906

dgb = mdev->int_dig_out;

2701

2907

drbd_csum_bio(mdev, mdev->integrity_w_tfm, req->master_bio, dgb);

2702

ok = drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);

2908

ok = dgs == drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);

2703

2909

}

2704

2910

if (ok) {

2705

if (mdev->net_conf->wire_protocol == DRBD_PROT_A)

2911

/* For protocol A, we have to memcpy the payload into

2912

* socket buffers, as we may complete right away

2913

* as soon as we handed it over to tcp, at which point the data

2914

* pages may become invalid.

2915

*

2916

* For data-integrity enabled, we copy it as well, so we can be

2917

* sure that even if the bio pages may still be modified, it

2918

* won't change the data on the wire, thus if the digest checks

2919

* out ok after sending on this side, but does not fit on the

2920

* receiving side, we sure have detected corruption elsewhere.

2921

*/

2922

if (mdev->net_conf->wire_protocol == DRBD_PROT_A || dgs)

2706

2923

ok = _drbd_send_bio(mdev, req->master_bio);

2707

2924

else

2708

2925

ok = _drbd_send_zc_bio(mdev, req->master_bio);

2926

2927

/* double check digest, sometimes buffers have been modified in flight. */

2928

if (dgs > 0 && dgs <= 64) {

2929

/* 64 byte, 512 bit, is the largest digest size

2930

* currently supported in kernel crypto. */

2931

unsigned char digest[64];

2932

drbd_csum_bio(mdev, mdev->integrity_w_tfm, req->master_bio, digest);

2933

if (memcmp(mdev->int_dig_out, digest, dgs)) {

2934

dev_warn(DEV,

2935

"Digest mismatch, buffer modified by upper layers during write: %llus +%u\n",

2936

(unsigned long long)req->sector, req->size);

2937

}

2938

} /* else if (dgs > 64) {

2939

... Be noisy about digest too large ...

2940

} */

2709

2941

}

2710

2942

2711

2943

drbd_put_data_sock(mdev);

2756

2988

if (ok && dgs) {

2757

2989

dgb = mdev->int_dig_out;

2758

2990

drbd_csum_ee(mdev, mdev->integrity_w_tfm, e, dgb);

2759

ok = drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);

2991

ok = dgs == drbd_send(mdev, mdev->data.socket, dgb, dgs, 0);

2760

2992

}

2761

2993

if (ok)

2762

2994

ok = _drbd_send_zc_ee(mdev, e);

2766

2998

return ok;

2767

2999

}

2768

3000

3001

int drbd_send_oos(struct drbd_conf *mdev, struct drbd_request *req)

3002

{

3003

struct p_block_desc p;

3004

3005

p.sector = cpu_to_be64(req->sector);

3006

p.blksize = cpu_to_be32(req->size);

3007

3008

return drbd_send_cmd(mdev, USE_DATA_SOCKET, P_OUT_OF_SYNC, &p.head, sizeof(p));

3009

}

3010

2769

3011

/*

2770

3012

drbd_send distinguishes two cases:

2771

3013

2935

3177

}

2936

3178

#endif

2937

3179

3180

#ifdef blk_queue_plugged

2938

3181

STATIC void drbd_unplug_fn(struct request_queue *q)

2939

3182

{

2940

3183

struct drbd_conf *mdev = q->queuedata;

2965

3208

if (mdev->state.disk >= D_INCONSISTENT)

2966

3209

drbd_kick_lo(mdev);

2967

3210

}

3211

#endif

2968

3212

2969

3213

STATIC void drbd_set_defaults(struct drbd_conf *mdev)

2970

3214

{

3027

3271

atomic_set(&mdev->pp_in_use_by_net, 0);

3028

3272

atomic_set(&mdev->rs_sect_in, 0);

3029

3273

atomic_set(&mdev->rs_sect_ev, 0);

3274

atomic_set(&mdev->ap_in_flight, 0);

3030

3275

3031

3276

mutex_init(&mdev->md_io_mutex);

3032

3277

mutex_init(&mdev->data.mutex);

3055

3300

INIT_LIST_HEAD(&mdev->unplug_work.list);

3056

3301

INIT_LIST_HEAD(&mdev->go_diskless.list);

3057

3302

INIT_LIST_HEAD(&mdev->md_sync_work.list);

3303

INIT_LIST_HEAD(&mdev->start_resync_work.list);

3058

3304

INIT_LIST_HEAD(&mdev->bm_io_work.w.list);

3059

3305

3060

mdev->resync_work.cb = w_resync_inactive;

3306

mdev->resync_work.cb = w_resync_timer;

3061

3307

mdev->unplug_work.cb = w_send_write_hint;

3062

3308

mdev->go_diskless.cb = w_go_diskless;

3063

3309

mdev->md_sync_work.cb = w_md_sync;

3064

3310

mdev->bm_io_work.w.cb = w_bitmap_io;

3311

mdev->start_resync_work.cb = w_start_resync;

3065

3312

init_timer(&mdev->resync_timer);

3066

3313

init_timer(&mdev->md_sync_timer);

3314

init_timer(&mdev->start_resync_timer);

3315

init_timer(&mdev->request_timer);

3067

3316

mdev->resync_timer.function = resync_timer_fn;

3068

3317

mdev->resync_timer.data = (unsigned long) mdev;

3069

3318

mdev->md_sync_timer.function = md_sync_timer_fn;

3070

3319

mdev->md_sync_timer.data = (unsigned long) mdev;

3320

mdev->start_resync_timer.function = start_resync_timer_fn;

3321

mdev->start_resync_timer.data = (unsigned long) mdev;

3322

mdev->request_timer.function = request_timer_fn;

3323

mdev->request_timer.data = (unsigned long) mdev;

3071

3324

3072

3325

init_waitqueue_head(&mdev->misc_wait);

3073

3326

init_waitqueue_head(&mdev->state_wait);

3083

3336

mdev->agreed_pro_version = PRO_VERSION_MAX;

3084

3337

mdev->write_ordering = WO_bio_barrier;

3085

3338

mdev->resync_wenr = LC_FREE;

3339

mdev->peer_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;

3340

mdev->local_max_bio_size = DRBD_MAX_BIO_SIZE_SAFE;

3086

3341

}

3087

3342

3088

3343

void drbd_mdev_cleanup(struct drbd_conf *mdev)

3138

3393

D_ASSERT(list_empty(&mdev->resync_work.list));

3139

3394

D_ASSERT(list_empty(&mdev->unplug_work.list));

3140

3395

D_ASSERT(list_empty(&mdev->go_diskless.list));

3396

3397

drbd_set_defaults(mdev);

3141

3398

}

3142

3399

3143

3400

3180

3437

STATIC int drbd_create_mempools(void)

3181

3438

{

3182

3439

struct page *page;

3183

const int number = (DRBD_MAX_SEGMENT_SIZE/PAGE_SIZE) * minor_count;

3440

const int number = (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count;

3184

3441

int i;

3185

3442

3186

3443

/* prepare our caches and mempools */

3220

3477

3221

3478

drbd_ee_mempool = mempool_create(number,

3222

3479

mempool_alloc_slab, mempool_free_slab, drbd_ee_cache);

3223

if (drbd_request_mempool == NULL)

3480

if (drbd_ee_mempool == NULL)

3224

3481

goto Enomem;

3225

3482

3226

3483

/* drbd's page pool */

3315

3572

3316

3573

drbd_release_ee_lists(mdev);

3317

3574

3318

/* should be free'd on disconnect? */

3575

/* should be freed on disconnect? */

3319

3576

kfree(mdev->ee_hash);

3320

3577

/*

3321

3578

mdev->ee_hash_s = 0;

3344

3601

3345

3602

unregister_reboot_notifier(&drbd_notifier);

3346

3603

3604

/* first remove proc,

3605

* drbdsetup uses it's presence to detect

3606

* whether DRBD is loaded.

3607

* If we would get stuck in proc removal,

3608

* but have netlink already deregistered,

3609

* some drbdsetup commands may wait forever

3610

* for an answer.

3611

*/

3612

if (drbd_proc)

3613

remove_proc_entry("drbd", NULL);

3614

3347

3615

drbd_nl_cleanup();

3348

3616

3349

3617

if (minor_table) {

3350

if (drbd_proc)

3351

remove_proc_entry("drbd", NULL);

3352

3618

i = minor_count;

3353

3619

while (i--)

3354

3620

drbd_delete_device(i);

3376

3642

char reason = '-';

3377

3643

int r = 0;

3378

3644

3379

if (!__inc_ap_bio_cond(mdev)) {

3645

if (!may_inc_ap_bio(mdev)) {

3380

3646

/* DRBD has frozen IO */

3381

3647

r = bdi_bits;

3382

3648

reason = 'd';

3429

3695

goto out_no_disk;

3430

3696

mdev->vdisk = disk;

3431

3697

3432

set_disk_ro(disk, TRUE);

3698

set_disk_ro(disk, true);

3433

3699

3434

3700

disk->queue = q;

3435

3701

disk->major = DRBD_MAJOR;

3445

3711

q->backing_dev_info.congested_fn = drbd_congested;

3446

3712

q->backing_dev_info.congested_data = mdev;

3447

3713

3448

blk_queue_make_request(q, drbd_make_request_26);

3449

blk_queue_max_segment_size(q, DRBD_MAX_SEGMENT_SIZE);

3714

blk_queue_make_request(q, drbd_make_request);

3715

/* Setting the max_hw_sectors to an odd value of 8kibyte here

3716

This triggers a max_bio_size message upon first attach or connect */

3717

blk_queue_max_hw_sectors(q, DRBD_MAX_BIO_SIZE_SAFE >> 8);

3450

3718

blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);

3451

3719

blk_queue_merge_bvec(q, drbd_merge_bvec);

3452

3720

q->queue_lock = &mdev->req_lock; /* needed since we use */

3721

#ifdef blk_queue_plugged

3453

3722

/* plugging on a queue, that actually has no requests! */

3454

3723

q->unplug_fn = drbd_unplug_fn;

3724

#endif

3455

3725

3456

3726

mdev->md_io_page = alloc_page(GFP_KERNEL);

3457

3727

if (!mdev->md_io_page)

3510

3780

put_disk(mdev->vdisk);

3511

3781

blk_cleanup_queue(mdev->rq_queue);

3512

3782

free_cpumask_var(mdev->cpu_mask);

3783

drbd_free_tl_hash(mdev);

3513

3784

kfree(mdev);

3514

3785

}

3515

3786

3525

3796

return -EINVAL;

3526

3797

}

3527

3798

3528

if (1 > minor_count || minor_count > 255) {

3799

if (minor_count < DRBD_MINOR_COUNT_MIN || minor_count > DRBD_MINOR_COUNT_MAX) {

3529

3800

printk(KERN_ERR

3530

3801

"drbd: invalid minor_count (%d)\n", minor_count);

3531

3802

#ifdef MODULE

3599

3870

if (ldev == NULL)

3600

3871

return;

3601

3872

3602

bd_release(ldev->backing_bdev);

3603

bd_release(ldev->md_bdev);

3604

3605

fput(ldev->lo_file);

3606

fput(ldev->md_file);

3873

blkdev_put(ldev->backing_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);

3874

blkdev_put(ldev->md_bdev, FMODE_READ | FMODE_WRITE | FMODE_EXCL);

3607

3875

3608

3876

kfree(ldev);

3609

3877

}

3610

3878

3879

3611

3880

void drbd_free_sock(struct drbd_conf *mdev)

3612

3881

{

3613

3882

if (mdev->data.socket) {

3662

3931

/* `-- act_log->nr_elements <-- sync_conf.al_extents */

3663

3932

u32 bm_offset; /* offset to the bitmap, from here */

3664

3933

u32 bm_bytes_per_bit; /* BM_BLOCK_SIZE */

3665

u32 reserved_u32[4];

3934

u32 la_peer_max_bio_size; /* last peer max_bio_size */

3935

u32 reserved_u32[3];

3666

3936

3667

3937

} __packed;

3668

3938

3705

3975

buffer->device_uuid = cpu_to_be64(mdev->ldev->md.device_uuid);

3706

3976

3707

3977

buffer->bm_offset = cpu_to_be32(mdev->ldev->md.bm_offset);

3978

buffer->la_peer_max_bio_size = cpu_to_be32(mdev->peer_max_bio_size);

3708

3979

3709

3980

D_ASSERT(drbd_md_ss__(mdev, mdev->ldev) == mdev->ldev->md.md_offset);

3710

3981

sector = mdev->ldev->md.md_offset;

3712

3983

if (!drbd_md_sync_page_io(mdev, mdev->ldev, sector, WRITE)) {

3713

3984

/* this was a try anyways ... */

3714

3985

dev_err(DEV, "meta data update failed!\n");

3715

drbd_chk_io_error(mdev, 1, TRUE);

3986

drbd_chk_io_error(mdev, 1, true);

3716

3987

}

3717

3988

3718

3989

/* Update mdev->ldev->md.la_size_sect,

3728

3999

* @mdev: DRBD device.

3729

4000

* @bdev: Device from which the meta data should be read in.

3730

4001

*

3731

* Return 0 (NO_ERROR) on success, and an enum drbd_ret_codes in case

4002

* Return 0 (NO_ERROR) on success, and an enum drbd_ret_code in case

3732

4003

* something goes wrong. Currently only: ERR_IO_MD_DISK, ERR_MD_INVALID.

3733

4004

*/

3734

4005

int drbd_md_read(struct drbd_conf *mdev, struct drbd_backing_dev *bdev)

3745

4016

buffer = (struct meta_data_on_disk *)page_address(mdev->md_io_page);

3746

4017

3747

4018

if (!drbd_md_sync_page_io(mdev, bdev, bdev->md.md_offset, READ)) {

3748

/* NOTE: cant do normal error processing here as this is

4019

/* NOTE: can't do normal error processing here as this is

3749

4020

called BEFORE disk is attached */

3750

4021

dev_err(DEV, "Error while reading metadata.\n");

3751

4022

rv = ERR_IO_MD_DISK;

3790

4061

mdev->sync_conf.al_extents = be32_to_cpu(buffer->al_nr_extents);

3791

4062

bdev->md.device_uuid = be64_to_cpu(buffer->device_uuid);

3792

4063

4064

spin_lock_irq(&mdev->req_lock);

4065

if (mdev->state.conn < C_CONNECTED) {

4066

int peer;

4067

peer = be32_to_cpu(buffer->la_peer_max_bio_size);

4068

peer = max_t(int, peer, DRBD_MAX_BIO_SIZE_SAFE);

4069

mdev->peer_max_bio_size = peer;

4070

}

4071

spin_unlock_irq(&mdev->req_lock);

4072

3793

4073

if (mdev->sync_conf.al_extents < 7)

3794

4074

mdev->sync_conf.al_extents = 127;

3795

4075

3800

4080

return rv;

3801

4081

}

3802

4082

3803

static void debug_drbd_uuid(struct drbd_conf *mdev, enum drbd_uuid_index index)

3804

{

3805

static char *uuid_str[UI_EXTENDED_SIZE] = {

3806

[UI_CURRENT] = "CURRENT",

3807

[UI_BITMAP] = "BITMAP",

3808

[UI_HISTORY_START] = "HISTORY_START",

3809

[UI_HISTORY_END] = "HISTORY_END",

3810

[UI_SIZE] = "SIZE",

3811

[UI_FLAGS] = "FLAGS",

3812

};

3813

3814

if (index >= UI_EXTENDED_SIZE) {

3815

dev_warn(DEV, " uuid_index >= EXTENDED_SIZE\n");

3816

return;

3817

}

3818

3819

dynamic_dev_dbg(DEV, " uuid[%s] now %016llX\n",

3820

uuid_str[index],

3821

(unsigned long long)mdev->ldev->md.uuid[index]);

3822

}

3823

3824

3825

4083

/**

3826

4084

* drbd_md_mark_dirty() - Mark meta data super block as dirty

3827

4085

* @mdev: DRBD device.

3847

4105

}

3848

4106

#endif

3849

4107

3850

STATIC void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local)

4108

static void drbd_uuid_move_history(struct drbd_conf *mdev) __must_hold(local)

3851

4109

{

3852

4110

int i;

3853

4111

3854

for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++) {

4112

for (i = UI_HISTORY_START; i < UI_HISTORY_END; i++)

3855

4113

mdev->ldev->md.uuid[i+1] = mdev->ldev->md.uuid[i];

3856

3857

debug_drbd_uuid(mdev, i+1);

3858

}

3859

4114

}

3860

4115

3861

4116

void _drbd_uuid_set(struct drbd_conf *mdev, int idx, u64 val) __must_hold(local)

3870

4125

}

3871

4126

3872

4127

mdev->ldev->md.uuid[idx] = val;

3873

debug_drbd_uuid(mdev, idx);

3874

4128

drbd_md_mark_dirty(mdev);

3875

4129

}

3876

4130

3880

4134

if (mdev->ldev->md.uuid[idx]) {

3881

4135

drbd_uuid_move_history(mdev);

3882

4136

mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[idx];

3883

debug_drbd_uuid(mdev, UI_HISTORY_START);

3884

4137

}

3885

4138

_drbd_uuid_set(mdev, idx, val);

3886

4139

}

3895

4148

void drbd_uuid_new_current(struct drbd_conf *mdev) __must_hold(local)

3896

4149

{

3897

4150

u64 val;

3898

3899

dev_info(DEV, "Creating new current UUID\n");

3900

D_ASSERT(mdev->ldev->md.uuid[UI_BITMAP] == 0);

4151

unsigned long long bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];

4152

4153

if (bm_uuid)

4154

dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);

4155

3901

4156

mdev->ldev->md.uuid[UI_BITMAP] = mdev->ldev->md.uuid[UI_CURRENT];

3902

debug_drbd_uuid(mdev, UI_BITMAP);

3903

4157

3904

4158

get_random_bytes(&val, sizeof(u64));

3905

4159

_drbd_uuid_set(mdev, UI_CURRENT, val);

4160

drbd_print_uuids(mdev, "new current UUID");

3906

4161

/* get it to stable storage _now_ */

3907

4162

drbd_md_sync(mdev);

3908

4163

}

3916

4171

drbd_uuid_move_history(mdev);

3917

4172

mdev->ldev->md.uuid[UI_HISTORY_START] = mdev->ldev->md.uuid[UI_BITMAP];

3918

4173

mdev->ldev->md.uuid[UI_BITMAP] = 0;

3919

debug_drbd_uuid(mdev, UI_HISTORY_START);

3920

debug_drbd_uuid(mdev, UI_BITMAP);

3921

4174

} else {

3922

if (mdev->ldev->md.uuid[UI_BITMAP])

3923

dev_warn(DEV, "bm UUID already set");

3924

3925

mdev->ldev->md.uuid[UI_BITMAP] = val;

3926

mdev->ldev->md.uuid[UI_BITMAP] &= ~((u64)1);

3927

3928

debug_drbd_uuid(mdev, UI_BITMAP);

4175

unsigned long long bm_uuid = mdev->ldev->md.uuid[UI_BITMAP];

4176

if (bm_uuid)

4177

dev_warn(DEV, "bm UUID was already set: %llX\n", bm_uuid);

4178

4179

mdev->ldev->md.uuid[UI_BITMAP] = val & ~((u64)1);

3929

4180

}

3930

4181

drbd_md_mark_dirty(mdev);

3931

4182

}

3981

4232

STATIC int w_bitmap_io(struct drbd_conf *mdev, struct drbd_work *w, int unused)

3982

4233

{

3983

4234

struct bm_io_work *work = container_of(w, struct bm_io_work, w);

3984

int rv;

4235

int rv = -EIO;

3985

4236

3986

4237

D_ASSERT(atomic_read(&mdev->ap_bio_cnt) == 0);

3987

4238

3988

drbd_bm_lock(mdev, work->why);

3989

rv = work->io_fn(mdev);

3990

drbd_bm_unlock(mdev);

4239

if (get_ldev(mdev)) {

4240

drbd_bm_lock(mdev, work->why, work->flags);

4241

rv = work->io_fn(mdev);

4242

drbd_bm_unlock(mdev);

4243

put_ldev(mdev);

4244

}

3991

4245

3992

4246

clear_bit(BITMAP_IO, &mdev->flags);

4247

smp_mb__after_clear_bit();

3993

4248

wake_up(&mdev->misc_wait);

3994

4249

3995

4250

if (work->done)

3997

4252

3998

4253

clear_bit(BITMAP_IO_QUEUED, &mdev->flags);

3999

4254

work->why = NULL;

4255

work->flags = 0;

4000

4256

4001

4257

return 1;

4002

4258

}

4051

4307

void drbd_queue_bitmap_io(struct drbd_conf *mdev,

4052

4308

int (*io_fn)(struct drbd_conf *),

4053

4309

void (*done)(struct drbd_conf *, int),

4054

char *why)

4310

char *why, enum bm_flag flags)

4055

4311

{

4056

4312

D_ASSERT(current == mdev->worker.task);

4057

4313

4065

4321

mdev->bm_io_work.io_fn = io_fn;

4066

4322

mdev->bm_io_work.done = done;

4067

4323

mdev->bm_io_work.why = why;

4324

mdev->bm_io_work.flags = flags;

4068

4325

4326

spin_lock_irq(&mdev->req_lock);

4069

4327

set_bit(BITMAP_IO, &mdev->flags);

4070

4328

if (atomic_read(&mdev->ap_bio_cnt) == 0) {

4071

if (list_empty(&mdev->bm_io_work.w.list)) {

4072

set_bit(BITMAP_IO_QUEUED, &mdev->flags);

4329

if (!test_and_set_bit(BITMAP_IO_QUEUED, &mdev->flags))

4073

4330

drbd_queue_work(&mdev->data.work, &mdev->bm_io_work.w);

4074

} else

4075

dev_err(DEV, "FIXME avoided double queuing bm_io_work\n");

4076

4331

}

4332

spin_unlock_irq(&mdev->req_lock);

4077

4333

}

4078

4334

4079

4335

/**

4085

4341

* freezes application IO while that the actual IO operations runs. This

4086

4342

* functions MAY NOT be called from worker context.

4087

4343

*/

4088

int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *), char *why)

4344

int drbd_bitmap_io(struct drbd_conf *mdev, int (*io_fn)(struct drbd_conf *),

4345

char *why, enum bm_flag flags)

4089

4346

{

4090

4347

int rv;

4091

4348

4092

4349

D_ASSERT(current != mdev->worker.task);

4093

4350

4094

drbd_suspend_io(mdev);

4351

if ((flags & BM_LOCKED_SET_ALLOWED) == 0)

4352

drbd_suspend_io(mdev);

4095

4353

4096

drbd_bm_lock(mdev, why);

4354

drbd_bm_lock(mdev, why, flags);

4097

4355

rv = io_fn(mdev);

4098

4356

drbd_bm_unlock(mdev);

4099

4357

4100

drbd_resume_io(mdev);

4358

if ((flags & BM_LOCKED_SET_ALLOWED) == 0)

4359

drbd_resume_io(mdev);

4101

4360

4102

4361

return rv;

4103

4362

}