sbin/vinum/commands.c

1010

struct plex;

sbin/vinum/commands.c

1019

get_plex_info(&plex, sd.plexno);

sbin/vinum/commands.c

1020

for (sdno = 0; sdno < plex.subdisks; sdno++) {

sbin/vinum/commands.c

1021

if (plex.sdnos[sdno] == msg.index) /* found our subdisk */

sbin/vinum/commands.c

1024

sprintf(newname, "%s.s%d", plex.name, sdno);

sbin/vinum/commands.c

1030

get_plex_info(&plex, msg.index);

sbin/vinum/commands.c

1031

get_volume_info(&vol, plex.volno);

sbin/vinum/commands.c

1033

if (vol.plex[plexno] == msg.index) /* found our subdisk */

sbin/vinum/commands.c

1037

sprintf(oldname, "%s", plex.name);

sbin/vinum/commands.c

1184

get_plex_info(&plex, plexno); /* find out who we are */

sbin/vinum/commands.c

1186

for (sdno = 0; sdno < plex.subdisks; sdno++) {

sbin/vinum/commands.c

1189

get_plex_sd_info(&sd, plex.plexno, sdno); /* get info about the subdisk */

sbin/vinum/commands.c

1210

msg.index = vol.plex[plexno]; /* number of the plex */

sbin/vinum/commands.c

1211

dorename(&msg, plex.name, plexname, MAXPLEXNAME);

sbin/vinum/commands.c

1212

get_plex_info(&plex, vol.plex[plexno]); /* find out who we are */

sbin/vinum/commands.c

1214

for (sdno = 0; sdno < plex.subdisks; sdno++) {

sbin/vinum/commands.c

1217

get_plex_sd_info(&sd, plex.plexno, sdno); /* get info about the subdisk */

sbin/vinum/commands.c

1323

get_plex_info(&plex, srcobj);

sbin/vinum/commands.c

1324

for (sdno = 0; sdno < plex.subdisks; ++sdno) {

sbin/vinum/commands.c

1325

get_plex_sd_info(&sd, plex.plexno, sdno);

sbin/vinum/commands.c

1332

plex.name,

sbin/vinum/commands.c

2307

struct plex plex;

sbin/vinum/commands.c

2327

get_plex_info(&plex, object);

sbin/vinum/commands.c

2328

plexno = plex.plexno;

sbin/vinum/commands.c

2380

if (plex.state == state) /* already in that state */

sbin/vinum/commands.c

2381

fprintf(stderr, "%s is already %s\n", plex.name, argv[0]);

sbin/vinum/commands.c

2450

struct plex plex;

sbin/vinum/commands.c

2467

get_plex_info(&plex, object);

sbin/vinum/commands.c

2468

if (!isparity((&plex)))

sbin/vinum/commands.c

2478

message->offset = plex.checkblock; /* continue where we left off */

sbin/vinum/commands.c

2481

get_plex_info(&plex, object);

sbin/vinum/commands.c

2483

block = (plex.checkblock << DEV_BSHIFT) * (plex.subdisks - 1);

sbin/vinum/commands.c

2488

((int) (block * 100 / plex.length) >> DEV_BSHIFT));

sbin/vinum/commands.c

388

for (sdno = 0; sdno < plex.subdisks; sdno++) { /* initialize each subdisk */

sbin/vinum/commands.c

412

syslog(LOG_INFO | LOG_KERN, "plex %s initialized", plex.name);

sbin/vinum/commands.c

415

plex.name,

sbin/vinum/commands.c

588

if (plex.state == plex_up) /* already up */

sbin/vinum/commands.c

589

fprintf(stderr, "%s is already up\n", plex.name);

sbin/vinum/commands.c

603

message->index = plex.plexno; /* pass object number */

sbin/vinum/commands.c

608

for (sdno = 0; sdno < plex.subdisks; sdno++) {

sbin/vinum/commands.c

808

reset_plex_stats(vol.plex[plexno], recurse);

sbin/vinum/commands.c

826

struct plex plex;

sbin/vinum/commands.c

830

get_plex_info(&plex, plexno);

sbin/vinum/commands.c

831

for (sdno = 0; sdno < plex.subdisks; sdno++) {

sbin/vinum/commands.c

832

get_plex_sd_info(&sd, plex.plexno, sdno);

sbin/vinum/commands.c

970

if ((plex.organization != plex_concat) /* not a cat plex, */

sbin/vinum/commands.c

972

fprintf(stderr, "Can't attach subdisks to a %s plex\n", plex_org(plex.organization));

sbin/vinum/list.c

1072

struct plex plex;

sbin/vinum/list.c

1108

vinum_conf.plex[vol.preferred_plex].name);

sbin/vinum/list.c

1116

get_plex_info(&plex, i);

sbin/vinum/list.c

1117

if (plex.state != plex_unallocated) {

sbin/vinum/list.c

1120

plex.name,

sbin/vinum/list.c

1121

plex_org(plex.organization));

sbin/vinum/list.c

1122

if (isstriped((&plex)))

sbin/vinum/list.c

1123

fprintf(of, "%ds ", (int) plex.stripesize);

sbin/vinum/list.c

1124

if (plex.volno >= 0) { /* we have a volume */

sbin/vinum/list.c

1125

get_volume_info(&vol, plex.volno);

sbin/vinum/list.c

1139

get_plex_info(&plex, sd.plexno);

sbin/vinum/list.c

1145

plex.name,

sbin/vinum/list.c

1196

get_plex_info(&plex, o);

sbin/vinum/list.c

1197

if ((plex.state != plex_unallocated) /* plex exists */

sbin/vinum/list.c

1198

&&(plex.state != plex_up)) { /* but it's not up */

sbin/vinum/list.c

317

get_plex_info(&plex, vol.plex[vol.preferred_plex]);

sbin/vinum/list.c

318

printf("plex %d (%s)\n", vol.preferred_plex, plex.name);

sbin/vinum/list.c

369

get_plex_info(&plex, vol.plex[plexno]);

sbin/vinum/list.c

373

plex.name,

sbin/vinum/list.c

374

plex_org(plex.organization),

sbin/vinum/list.c

375

roughlength(plex.length << DEV_BSHIFT, 0));

sbin/vinum/list.c

380

vinum_lpi(vol.plex[plexno], 0); /* first show the plexes */

sbin/vinum/list.c

382

get_plex_info(&plex, vol.plex[plexno]);

sbin/vinum/list.c

383

if (plex.subdisks > 0) {

sbin/vinum/list.c

386

for (sdno = 0; sdno < plex.subdisks; sdno++) {

sbin/vinum/list.c

387

get_plex_sd_info(&sd, vol.plex[plexno], sdno);

sbin/vinum/list.c

426

get_plex_info(&plex, plexno);

sbin/vinum/list.c

427

if (plex.state != plex_unallocated) {

sbin/vinum/list.c

430

plex.name,

sbin/vinum/list.c

431

(long long) plex.length * DEV_BSIZE,

sbin/vinum/list.c

432

(long long) plex.length * DEV_BSIZE / MEGABYTE,

sbin/vinum/list.c

433

plex.subdisks);

sbin/vinum/list.c

435

plex_state(plex.state),

sbin/vinum/list.c

436

plex_org(plex.organization));

sbin/vinum/list.c

437

if (isstriped((&plex)))

sbin/vinum/list.c

438

printf("\tStripe size: %s\n", roughlength(plex.stripesize * DEV_BSIZE, 1));

sbin/vinum/list.c

441

if ((isparity((&plex)))

sbin/vinum/list.c

442

&& (plex.checkblock != 0))

sbin/vinum/list.c

444

roughlength((plex.checkblock << DEV_BSHIFT) * (plex.subdisks - 1), 0),

sbin/vinum/list.c

445

(int) (((u_int64_t) (plex.checkblock * 100)) * (plex.subdisks - 1) / plex.length));

sbin/vinum/list.c

446

if (plex.volno >= 0) {

sbin/vinum/list.c

447

get_volume_info(&vol, plex.volno);

sbin/vinum/list.c

453

switch (plex.organization) {

sbin/vinum/list.c

471

plex.name,

sbin/vinum/list.c

473

plex_state(plex.state),

sbin/vinum/list.c

474

plex.subdisks,

sbin/vinum/list.c

475

roughlength(plex.length << DEV_BSHIFT, 0));

sbin/vinum/list.c

480

(long long) plex.reads,

sbin/vinum/list.c

481

(long long) plex.bytes_read,

sbin/vinum/list.c

482

roughlength(plex.bytes_read, 1));

sbin/vinum/list.c

483

if (plex.reads != 0)

sbin/vinum/list.c

485

(long long) (plex.bytes_read / plex.reads));

sbin/vinum/list.c

487

(long long) plex.writes,

sbin/vinum/list.c

488

(long long) plex.bytes_written,

sbin/vinum/list.c

489

roughlength(plex.bytes_written, 1));

sbin/vinum/list.c

490

if (plex.writes != 0)

sbin/vinum/list.c

492

(long long) (plex.bytes_written / plex.writes));

sbin/vinum/list.c

493

if (((plex.reads + plex.writes) > 0)

sbin/vinum/list.c

494

&& isstriped((&plex)))

sbin/vinum/list.c

497

(long long) plex.multiblock,

sbin/vinum/list.c

498

(int) (plex.multiblock * 100 / (plex.reads + plex.writes)),

sbin/vinum/list.c

499

(long long) plex.multistripe,

sbin/vinum/list.c

500

(int) (plex.multistripe * 100 / (plex.reads + plex.writes)));

sbin/vinum/list.c

501

if (plex.recovered_reads)

sbin/vinum/list.c

503

(long long) plex.recovered_reads);

sbin/vinum/list.c

504

if (plex.degraded_writes)

sbin/vinum/list.c

506

(long long) plex.degraded_writes);

sbin/vinum/list.c

507

if (plex.parityless_writes)

sbin/vinum/list.c

509

(long long) plex.parityless_writes);

sbin/vinum/list.c

512

plex.name,

sbin/vinum/list.c

513

(long long) plex.reads,

sbin/vinum/list.c

514

(long long) plex.bytes_read);

sbin/vinum/list.c

515

if (plex.reads != 0)

sbin/vinum/list.c

517

(long long) (plex.bytes_read / plex.reads));

sbin/vinum/list.c

520

printf("%7lld\t", (long long) plex.recovered_reads);

sbin/vinum/list.c

522

(long long) plex.writes,

sbin/vinum/list.c

523

(long long) plex.bytes_written);

sbin/vinum/list.c

524

if (plex.writes != 0)

sbin/vinum/list.c

526

(long long) (plex.bytes_written / plex.writes));

sbin/vinum/list.c

530

(long long) plex.multiblock,

sbin/vinum/list.c

531

(long long) plex.multistripe);

sbin/vinum/list.c

534

if (plex.subdisks > 0) {

sbin/vinum/list.c

539

for (sdno = 0; sdno < plex.subdisks; sdno++) {

sbin/vinum/list.c

547

if (plex.organization == plex_concat)

sbin/vinum/list.c

555

for (sdno = 0; sdno < plex.subdisks; sdno++) {

sbin/vinum/list.c

607

get_plex_info(&plex, sd.plexno);

sbin/vinum/list.c

608

printf("\t\tPlex %s", plex.name);

sbin/vinum/v.c

466

get_plex_info(struct plex *plex, int index)

sbin/vinum/v.c

468

*(int *) plex = index; /* put in plex to hand to driver */

sbin/vinum/v.c

469

if (ioctl(superdev, VINUM_PLEXCONFIG, plex) < 0) {

sbin/vinum/v.c

622

make_plex_dev(plex.plexno, recurse);

sbin/vinum/v.c

637

get_plex_info(&plex, plexno);

sbin/vinum/v.c

638

if (plex.state != plex_unallocated) {

sbin/vinum/v.c

642

sprintf(filename, VINUM_DIR "/plex/%s", plex.name);

sbin/vinum/v.c

646

if (plex.volno >= 0) {

sbin/vinum/v.c

647

get_volume_info(&vol, plex.volno);

sbin/vinum/v.c

648

plexdev = VINUMDEV(plex.volno, plexno, 0, VINUM_PLEX_TYPE);

sbin/vinum/v.c

651

sprintf(filename, VINUM_DIR "/vol/%s.plex/%s", vol.name, plex.name);

sbin/vinum/v.c

656

sprintf(filename, VINUM_DIR "/vol/%s.plex/%s.sd", vol.name, plex.name);

sbin/vinum/v.c

661

for (sdno = 0; sdno < plex.subdisks; sdno++) {

sbin/vinum/v.c

662

get_plex_sd_info(&sd, plex.plexno, sdno);

sbin/vinum/v.c

731

get_plex_info(&plex, object);

sbin/vinum/v.c

732

if (strcmp(name, plex.name) == 0) {

sbin/vinum/v.c

93

struct plex plex;

sbin/vinum/vext.h

131

void get_plex_info(struct plex *plex, int index);

sbin/vinum/vext.h

162

extern struct plex plex;

sbin/vinum/vinumparser.c

77

keypair(plex),

sbin/vinum/vinumutil.c

152

for (i = 0; i < STATECOUNT(plex); i++)

sbin/vinum/vinumutil.c

256

return VOL[Volno(dev)].plex[(minor(dev) >> VINUM_PLEX_SHIFT) & (MASK(VINUM_PLEX_WIDTH))];

sbin/vinum/vinumutil.c

75

if (((unsigned) state) >= STATECOUNT(plex)) {

sys/dev/raid/vinum/request.h

263

struct plex *plex; /* for daemonrq_init */

sys/dev/raid/vinum/vinum.c

232

struct plex *plex = &vinum_conf.plex[i];

sys/dev/raid/vinum/vinum.c

234

if (plex->plex_dev) {

sys/dev/raid/vinum/vinum.c

235

destroy_dev(plex->plex_dev);

sys/dev/raid/vinum/vinum.c

236

plex->plex_dev = NULL;

sys/dev/raid/vinum/vinum.c

239

if (plex->state != plex_unallocated) { /* we have real data there */

sys/dev/raid/vinum/vinum.c

240

if (plex->sdnos)

sys/dev/raid/vinum/vinum.c

241

Free(plex->sdnos);

sys/dev/raid/vinum/vinum.c

281

PLEX = (struct plex *) Malloc(sizeof(struct plex) * INITIAL_PLEXES);

sys/dev/raid/vinum/vinum.c

283

bzero(PLEX, sizeof(struct plex) * INITIAL_PLEXES);

sys/dev/raid/vinum/vinum.c

378

struct plex *plex;

sys/dev/raid/vinum/vinum.c

417

plex = &PLEX[index];

sys/dev/raid/vinum/vinum.c

419

switch (plex->state) {

sys/dev/raid/vinum/vinum.c

425

plex->flags |= VF_OPEN; /* note we're open */

sys/dev/raid/vinum/vinumconfig.c

1129

struct plex *plex; /* for tidying up dangling references */

sys/dev/raid/vinum/vinumconfig.c

1136

plex = &PLEX[sd->plexno]; /* now take a look at our plex */

sys/dev/raid/vinum/vinumconfig.c

1137

for (i = 0; i < plex->subdisks; i++) { /* look for the pointer */

sys/dev/raid/vinum/vinumconfig.c

1138

if (plex->sdnos[i] == namedsdno) /* pointing to the old subdisk */

sys/dev/raid/vinum/vinumconfig.c

1139

plex->sdnos[i] = sdno; /* bend it to point here */

sys/dev/raid/vinum/vinumconfig.c

1304

struct plex *plex; /* and pointer to it */

sys/dev/raid/vinum/vinumconfig.c

1312

plex = &PLEX[plexno]; /* and point to it */

sys/dev/raid/vinum/vinumconfig.c

1313

plex->plexno = plexno; /* and back to the config */

sys/dev/raid/vinum/vinumconfig.c

1334

*plex = PLEX[namedplexno]; /* get the info */

sys/dev/raid/vinum/vinumconfig.c

1335

plex->plex_dev = NULL;

sys/dev/raid/vinum/vinumconfig.c

1336

made_plex(plex);

sys/dev/raid/vinum/vinumconfig.c

1339

vol = &VOL[plex->volno]; /* point to the volume */

sys/dev/raid/vinum/vinumconfig.c

1341

if (vol->plex[i] == namedplexno)

sys/dev/raid/vinum/vinumconfig.c

1342

vol->plex[i] = plexno; /* bend the pointer */

sys/dev/raid/vinum/vinumconfig.c

1352

ksnprintf(plex->name, sizeof(plex->name),

sys/dev/raid/vinum/vinumconfig.c

1364

plex->organization = plex_concat;

sys/dev/raid/vinum/vinumconfig.c

1371

plex->organization = plex_striped;

sys/dev/raid/vinum/vinumconfig.c

1374

plex->name,

sys/dev/raid/vinum/vinumconfig.c

1377

plex->stripesize = stripesize / DEV_BSIZE;

sys/dev/raid/vinum/vinumconfig.c

1385

plex->organization = plex_raid4;

sys/dev/raid/vinum/vinumconfig.c

1388

plex->name,

sys/dev/raid/vinum/vinumconfig.c

1391

plex->stripesize = stripesize / DEV_BSIZE;

sys/dev/raid/vinum/vinumconfig.c

1399

plex->organization = plex_raid5;

sys/dev/raid/vinum/vinumconfig.c

1402

plex->name,

sys/dev/raid/vinum/vinumconfig.c

1405

plex->stripesize = stripesize / DEV_BSIZE;

sys/dev/raid/vinum/vinumconfig.c

1412

if (isstriped(plex)

sys/dev/raid/vinum/vinumconfig.c

1413

&& (plex->stripesize == 0)) /* didn't specify a valid stripe size */

sys/dev/raid/vinum/vinumconfig.c

1418

plex->volno = find_volume(token[++parameter], 1); /* insert a pointer to the volume */

sys/dev/raid/vinum/vinumconfig.c

1439

plex->name,

sys/dev/raid/vinum/vinumconfig.c

1444

if (plex->organization == plex_disorg)

sys/dev/raid/vinum/vinumconfig.c

1447

if ((plex->volno < 0) /* we don't have a volume */

sys/dev/raid/vinum/vinumconfig.c

1449

plex->volno = current_volume;

sys/dev/raid/vinum/vinumconfig.c

1451

if (plex->volno >= 0)

sys/dev/raid/vinum/vinumconfig.c

1452

pindex = give_plex_to_volume(plex->volno, plexno); /* Now tell the volume that it has this plex */

sys/dev/raid/vinum/vinumconfig.c

1455

if (plex->name[0] == '\0') { /* no name */

sys/dev/raid/vinum/vinumconfig.c

1458

if (plex->volno >= 0) /* we have a volume */

sys/dev/raid/vinum/vinumconfig.c

1459

strcpy(plex->name, /* take it from there */

sys/dev/raid/vinum/vinumconfig.c

1460

VOL[plex->volno].name);

sys/dev/raid/vinum/vinumconfig.c

1464

strcat(plex->name, plexsuffix); /* and add it to the name */

sys/dev/raid/vinum/vinumconfig.c

1466

if (isstriped(plex)) {

sys/dev/raid/vinum/vinumconfig.c

1467

plex->lock = (struct rangelock *)

sys/dev/raid/vinum/vinumconfig.c

1469

CHECKALLOC(plex->lock, "vinum: Can't allocate lock table\n");

sys/dev/raid/vinum/vinumconfig.c

1470

bzero((char *) plex->lock, PLEX_LOCKS * sizeof(struct rangelock));

sys/dev/raid/vinum/vinumconfig.c

1474

plex->state = state; /* set whatever state we chose */

sys/dev/raid/vinum/vinumconfig.c

1475

made_plex(plex);

sys/dev/raid/vinum/vinumconfig.c

1520

vol->plex[vol->plexes] = plexno;

sys/dev/raid/vinum/vinumconfig.c

1546

vol->plex[vol->plexes - 1] = myplexno; /* add it to our list */

sys/dev/raid/vinum/vinumconfig.c

159

if (vol->plex[i] == plexno)

sys/dev/raid/vinum/vinumconfig.c

1609

vol->size = u64max(vol->size, PLEX[vol->plex[i]].length);

sys/dev/raid/vinum/vinumconfig.c

172

struct plex *plex;

sys/dev/raid/vinum/vinumconfig.c

174

plex = &PLEX[plexno];

sys/dev/raid/vinum/vinumconfig.c

175

for (i = 0; i < plex->subdisks; i++)

sys/dev/raid/vinum/vinumconfig.c

176

if (plex->sdnos[i] == sdno)

sys/dev/raid/vinum/vinumconfig.c

1767

struct plex *plex = &PLEX[sd->plexno]; /* point to our plex */

sys/dev/raid/vinum/vinumconfig.c

1771

mysdno < plex->subdisks && &SD[plex->sdnos[mysdno]] != sd;

sys/dev/raid/vinum/vinumconfig.c

1773

if (mysdno == plex->subdisks) /* didn't find it */

sys/dev/raid/vinum/vinumconfig.c

1777

plex->name);

sys/dev/raid/vinum/vinumconfig.c

1779

if (mysdno < (plex->subdisks - 1)) /* not the last subdisk */

sys/dev/raid/vinum/vinumconfig.c

1780

bcopy(&plex->sdnos[mysdno + 1],

sys/dev/raid/vinum/vinumconfig.c

1781

&plex->sdnos[mysdno],

sys/dev/raid/vinum/vinumconfig.c

1782

(plex->subdisks - 1 - mysdno) * sizeof(int));

sys/dev/raid/vinum/vinumconfig.c

1783

plex->subdisks--;

sys/dev/raid/vinum/vinumconfig.c

1793

if (plex->organization != plex_concat) /* not concatenated, */

sys/dev/raid/vinum/vinumconfig.c

1794

set_plex_state(plex->plexno, plex_faulty, setstate_force); /* need to reinitialize */

sys/dev/raid/vinum/vinumconfig.c

1809

struct plex *plex = &PLEX[plexno];

sys/dev/raid/vinum/vinumconfig.c

1813

||(plex->state == plex_unallocated)) { /* or nothing there */

sys/dev/raid/vinum/vinumconfig.c

1816

} else if (plex->flags & VF_OPEN) { /* we're open */

sys/dev/raid/vinum/vinumconfig.c

1820

if (plex->subdisks) {

sys/dev/raid/vinum/vinumconfig.c

1823

int sds = plex->subdisks;

sys/dev/raid/vinum/vinumconfig.c

1825

free_sd(plex->sdnos[sdno]); /* free all subdisks */

sys/dev/raid/vinum/vinumconfig.c

1827

int sds = plex->subdisks;

sys/dev/raid/vinum/vinumconfig.c

1829

SD[plex->sdnos[sdno]].plexno = -1; /* no plex any more */

sys/dev/raid/vinum/vinumconfig.c

1836

if (plex->volno >= 0) { /* we are part of a volume */

sys/dev/raid/vinum/vinumconfig.c

1838

struct volume *vol = &VOL[plex->volno];

sys/dev/raid/vinum/vinumconfig.c

1842

if (vol->plex[myplexno] == plexno) /* found it */

sys/dev/raid/vinum/vinumconfig.c

1847

plex->name,

sys/dev/raid/vinum/vinumconfig.c

1850

bcopy(&vol->plex[myplexno + 1],

sys/dev/raid/vinum/vinumconfig.c

1851

&vol->plex[myplexno],

sys/dev/raid/vinum/vinumconfig.c

1859

log(LOG_INFO, "vinum: removing %s\n", plex->name);

sys/dev/raid/vinum/vinumconfig.c

1883

remove_plex_entry(vol->plex[plexno], force, recurse);

sys/dev/raid/vinum/vinumconfig.c

1910

struct plex *plex = &PLEX[plexno];

sys/dev/raid/vinum/vinumconfig.c

1918

if (plex->state < plex_init) /* not a real plex, */

sys/dev/raid/vinum/vinumconfig.c

1921

if (plex->volno >= 0) { /* we have a volume */

sys/dev/raid/vinum/vinumconfig.c

1922

vol = &VOL[plex->volno];

sys/dev/raid/vinum/vinumconfig.c

1931

if ((plex->flags & VF_NEWBORN)

sys/dev/raid/vinum/vinumconfig.c

1944

if (plex->organization == plex_striped) {

sys/dev/raid/vinum/vinumconfig.c

1945

data_sds = plex->subdisks;

sys/dev/raid/vinum/vinumconfig.c

1947

} else if (isparity(plex)) { /* RAID 4 or 5 */

sys/dev/raid/vinum/vinumconfig.c

1948

data_sds = plex->subdisks - 1;

sys/dev/raid/vinum/vinumconfig.c

1953

if (plex->subdisks < required_sds) {

sys/dev/raid/vinum/vinumconfig.c

1956

plex->name,

sys/dev/raid/vinum/vinumconfig.c

1964

if (plex->length > 0) {

sys/dev/raid/vinum/vinumconfig.c

1966

if (plex->stripesize > 0) {

sys/dev/raid/vinum/vinumconfig.c

1967

remainder = (int) (plex->length /* are we exact? */

sys/dev/raid/vinum/vinumconfig.c

1968

% ((u_int64_t) plex->stripesize * data_sds));

sys/dev/raid/vinum/vinumconfig.c

1972

plex->name);

sys/dev/raid/vinum/vinumconfig.c

1973

plex->length -= remainder; /* shorten the plex */

sys/dev/raid/vinum/vinumconfig.c

1975

for (sdno = 0; sdno < plex->subdisks; sdno++) {

sys/dev/raid/vinum/vinumconfig.c

1976

sd = &SD[plex->sdnos[sdno]]; /* point to the subdisk */

sys/dev/raid/vinum/vinumconfig.c

1984

plex->length = 0; /* reset length */

sys/dev/raid/vinum/vinumconfig.c

1989

for (sdno = 0; sdno < plex->subdisks; sdno++) {

sys/dev/raid/vinum/vinumconfig.c

1990

sd = &SD[plex->sdnos[sdno]];

sys/dev/raid/vinum/vinumconfig.c

1991

if (isstriped(plex)

sys/dev/raid/vinum/vinumconfig.c

1993

&& (sd->sectors != SD[plex->sdnos[sdno - 1]].sectors)) {

sys/dev/raid/vinum/vinumconfig.c

1994

log(LOG_ERR, "vinum: %s must have equal sized subdisks\n", plex->name);

sys/dev/raid/vinum/vinumconfig.c

2003

if (plex->subdisks) { /* plex has subdisks, calculate size */

sys/dev/raid/vinum/vinumconfig.c

2008

if (isparity(plex))

sys/dev/raid/vinum/vinumconfig.c

2009

size = size / plex->subdisks * (plex->subdisks - 1); /* less space for RAID-4 and RAID-5 */

sys/dev/raid/vinum/vinumconfig.c

2010

if (plex->length != size)

sys/dev/raid/vinum/vinumconfig.c

2013

plex->name,

sys/dev/raid/vinum/vinumconfig.c

2014

(long long) plex->length,

sys/dev/raid/vinum/vinumconfig.c

2016

plex->length = size;

sys/dev/raid/vinum/vinumconfig.c

2018

plex->length = 0; /* no size */

sys/dev/raid/vinum/vinumconfig.c

2021

plex->flags &= ~VF_NEWBORN;

sys/dev/raid/vinum/vinumconfig.c

2028

struct plex *plex;

sys/dev/raid/vinum/vinumconfig.c

2041

plex = &PLEX[vol->plex[plexno]];

sys/dev/raid/vinum/vinumconfig.c

2042

vol->size = u64max(plex->length, vol->size);

sys/dev/raid/vinum/vinumconfig.c

2043

plex->volplexno = plexno; /* note it in the plex */

sys/dev/raid/vinum/vinumconfig.c

205

vol->plex[vol->plexes] = plexno; /* this one */

sys/dev/raid/vinum/vinumconfig.c

211

vol->size = u64max(vol->size, PLEX[vol->plex[i]].length);

sys/dev/raid/vinum/vinumconfig.c

222

struct plex *plex;

sys/dev/raid/vinum/vinumconfig.c

235

plex = &PLEX[plexno]; /* point to the plex */

sys/dev/raid/vinum/vinumconfig.c

240

if (plex->subdisks > 0) {

sys/dev/raid/vinum/vinumconfig.c

241

struct sd *lastsd = &SD[plex->sdnos[plex->subdisks - 1]]; /* last subdisk */

sys/dev/raid/vinum/vinumconfig.c

243

if (plex->organization == plex_concat) /* concat, */

sys/dev/raid/vinum/vinumconfig.c

246

sd->plexoffset = plex->stripesize * plex->subdisks; /* starts here */

sys/dev/raid/vinum/vinumconfig.c

250

if (plex->subdisks == MAXSD) /* we already have our maximum */

sys/dev/raid/vinum/vinumconfig.c

254

plex->name);

sys/dev/raid/vinum/vinumconfig.c

256

plex->subdisks++; /* another entry */

sys/dev/raid/vinum/vinumconfig.c

257

if (plex->subdisks >= plex->subdisks_allocated) /* need more space */

sys/dev/raid/vinum/vinumconfig.c

258

EXPAND(plex->sdnos, int, plex->subdisks_allocated, INITIAL_SUBDISKS_IN_PLEX);

sys/dev/raid/vinum/vinumconfig.c

261

if (isparity(plex)) /* RAID-4 or RAID-5 */

sys/dev/raid/vinum/vinumconfig.c

262

plex->length = (plex->subdisks - 1) * sd->sectors; /* size is one disk short */

sys/dev/raid/vinum/vinumconfig.c

264

plex->length += sd->sectors; /* plex gets this much bigger */

sys/dev/raid/vinum/vinumconfig.c

265

if (plex->volno >= 0) /* we have a volume */

sys/dev/raid/vinum/vinumconfig.c

266

VOL[plex->volno].size = u64max(VOL[plex->volno].size, plex->length); /* adjust its size */

sys/dev/raid/vinum/vinumconfig.c

274

for (i = 0; i < plex->subdisks - 1; i++) {

sys/dev/raid/vinum/vinumconfig.c

275

if (sd->plexoffset < SD[plex->sdnos[i]].plexoffset) { /* it fits before this one */

sys/dev/raid/vinum/vinumconfig.c

279

for (j = plex->subdisks - 1; j > i; j--) /* move up one at a time */

sys/dev/raid/vinum/vinumconfig.c

280

plex->sdnos[j] = plex->sdnos[j - 1];

sys/dev/raid/vinum/vinumconfig.c

281

plex->sdnos[i] = sdno;

sys/dev/raid/vinum/vinumconfig.c

291

plex->sdnos[i] = sdno;

sys/dev/raid/vinum/vinumconfig.c

293

sd->plexno = plex->plexno; /* and who we belong to */

sys/dev/raid/vinum/vinumconfig.c

749

plex->name, VOL[plex->volno].name);

sys/dev/raid/vinum/vinumconfig.c

75

static void made_plex(struct plex *plex);

sys/dev/raid/vinum/vinumconfig.c

777

made_plex(struct plex *plex)

sys/dev/raid/vinum/vinumconfig.c

779

if (plex->plex_dev == NULL && plex->state != plex_unallocated) {

sys/dev/raid/vinum/vinumconfig.c

780

plex->plex_dev = make_dev(&vinum_ops, VINUM_PLEX(plex->plexno),

sys/dev/raid/vinum/vinumconfig.c

782

VINUM_BASE "plex/%s", plex->name);

sys/dev/raid/vinum/vinumconfig.c

783

udev_dict_set_cstr(plex->plex_dev, "subsystem", "raid");

sys/dev/raid/vinum/vinumconfig.c

784

udev_dict_set_cstr(plex->plex_dev, "disk-type", "raid");

sys/dev/raid/vinum/vinumconfig.c

785

if (plex->volno >= 0) {

sys/dev/raid/vinum/vinumconfig.c

786

make_dev_alias(plex->plex_dev, "vol/%s.plex/%s",

sys/dev/raid/vinum/vinumconfig.c

787

plex->name, VOL[plex->volno].name);

sys/dev/raid/vinum/vinumconfig.c

790

if (plex->plex_dev && plex->state == plex_unallocated) {

sys/dev/raid/vinum/vinumconfig.c

791

destroy_dev(plex->plex_dev);

sys/dev/raid/vinum/vinumconfig.c

792

plex->plex_dev = NULL;

sys/dev/raid/vinum/vinumconfig.c

801

struct plex *plex; /* if we allocate one */

sys/dev/raid/vinum/vinumconfig.c

810

EXPAND(PLEX, struct plex, vinum_conf.plexes_allocated, INITIAL_PLEXES);

sys/dev/raid/vinum/vinumconfig.c

813

plex = &PLEX[plexno]; /* this one is ours */

sys/dev/raid/vinum/vinumconfig.c

814

bzero(plex, sizeof(struct plex)); /* polish it up */

sys/dev/raid/vinum/vinumconfig.c

815

plex->sdnos = (int *) Malloc(sizeof(int) * INITIAL_SUBDISKS_IN_PLEX); /* allocate sd table */

sys/dev/raid/vinum/vinumconfig.c

816

CHECKALLOC(plex->sdnos, "vinum: Can't allocate plex subdisk table");

sys/dev/raid/vinum/vinumconfig.c

817

bzero(plex->sdnos, (sizeof(int) * INITIAL_SUBDISKS_IN_PLEX)); /* do we need this? */

sys/dev/raid/vinum/vinumconfig.c

818

plex->flags |= VF_NEWBORN; /* newly born plex */

sys/dev/raid/vinum/vinumconfig.c

819

plex->subdisks = 0; /* no subdisks in use */

sys/dev/raid/vinum/vinumconfig.c

820

plex->subdisks_allocated = INITIAL_SUBDISKS_IN_PLEX; /* and we have space for this many */

sys/dev/raid/vinum/vinumconfig.c

821

plex->organization = plex_disorg; /* and it's not organized */

sys/dev/raid/vinum/vinumconfig.c

822

plex->volno = -1; /* no volume yet */

sys/dev/raid/vinum/vinumconfig.c

836

struct plex *plex;

sys/dev/raid/vinum/vinumconfig.c

849

plex = &PLEX[plexno]; /* point to it */

sys/dev/raid/vinum/vinumconfig.c

850

ksnprintf(plex->name, sizeof(plex->name), "%s", name);

sys/dev/raid/vinum/vinumconfig.c

861

struct plex *plex;

sys/dev/raid/vinum/vinumconfig.c

863

plex = &PLEX[plexno];

sys/dev/raid/vinum/vinumconfig.c

864

if (plex->sdnos)

sys/dev/raid/vinum/vinumconfig.c

865

Free(plex->sdnos);

sys/dev/raid/vinum/vinumconfig.c

866

if (plex->lock)

sys/dev/raid/vinum/vinumconfig.c

867

Free(plex->lock);

sys/dev/raid/vinum/vinumconfig.c

868

plex->state = plex_unallocated;

sys/dev/raid/vinum/vinumconfig.c

869

made_plex(plex);

sys/dev/raid/vinum/vinumconfig.c

870

bzero(plex, sizeof(struct plex)); /* and clear it out */

sys/dev/raid/vinum/vinumconfig.c

871

plex->state = plex_unallocated;

sys/dev/raid/vinum/vinumconfig.c

897

vol->plex[i] = -1;

sys/dev/raid/vinum/vinumext.h

187

void invalidate_subdisks(struct plex *, enum sdstate);

sys/dev/raid/vinum/vinumext.h

194

struct buf *parityrebuild(struct plex *, vinum_off_t, int, enum parityop, struct rangelock **, off_t *);

sys/dev/raid/vinum/vinumext.h

203

enum sdstates sdstatemap(struct plex *plex);

sys/dev/raid/vinum/vinumext.h

204

enum volplexstate vpstate(struct plex *plex);

sys/dev/raid/vinum/vinumext.h

220

struct plex *validplex(int plexno, struct _ioctl_reply *);

sys/dev/raid/vinum/vinumext.h

234

int lockplex(struct plex *plex);

sys/dev/raid/vinum/vinumext.h

235

void unlockplex(struct plex *plex);

sys/dev/raid/vinum/vinumext.h

236

struct rangelock *lockrange(vinum_off_t stripe, struct buf *bp, struct plex *plex);

sys/dev/raid/vinum/vinumext.h

76

int plex_index(struct plex *plex);

sys/dev/raid/vinum/vinumio.c

450

vinum_conf.plex[vol->preferred_plex].name);

sys/dev/raid/vinum/vinumio.c

459

struct plex *plex;

sys/dev/raid/vinum/vinumio.c

461

plex = &vinum_conf.plex[i];

sys/dev/raid/vinum/vinumio.c

462

if ((plex->state > plex_referenced)

sys/dev/raid/vinum/vinumio.c

463

&& (plex->name[0] != '\0')) { /* paranoia */

sys/dev/raid/vinum/vinumio.c

467

plex->name,

sys/dev/raid/vinum/vinumio.c

468

plex_state(plex->state),

sys/dev/raid/vinum/vinumio.c

469

plex_org(plex->organization));

sys/dev/raid/vinum/vinumio.c

472

if (isstriped(plex)) {

sys/dev/raid/vinum/vinumio.c

476

(int) plex->stripesize);

sys/dev/raid/vinum/vinumio.c

480

if (plex->volno >= 0) /* we have a volume */

sys/dev/raid/vinum/vinumio.c

484

vinum_conf.volume[plex->volno].name);

sys/dev/raid/vinum/vinumio.c

487

for (j = 0; j < plex->subdisks; j++) {

sys/dev/raid/vinum/vinumio.c

491

vinum_conf.sd[plex->sdnos[j]].name);

sys/dev/raid/vinum/vinumio.c

522

vinum_conf.plex[sd->plexno].name,

sys/dev/raid/vinum/vinumio.h

128

#define VINUM_PLEXCONFIG _IOWR(L, 68, struct plex)

sys/dev/raid/vinum/vinumioctl.c

156

bcopy(&PLEX[index], data, sizeof(struct plex));

sys/dev/raid/vinum/vinumioctl.c

403

struct plex *

sys/dev/raid/vinum/vinumioctl.c

464

struct plex *plex = &PLEX[msg->index];

sys/dev/raid/vinum/vinumioctl.c

465

if (plex->state > plex_referenced) {

sys/dev/raid/vinum/vinumioctl.c

466

plex->reads = 0;

sys/dev/raid/vinum/vinumioctl.c

467

plex->writes = 0; /* number of writes on this plex */

sys/dev/raid/vinum/vinumioctl.c

468

plex->bytes_read = 0; /* number of bytes read */

sys/dev/raid/vinum/vinumioctl.c

469

plex->bytes_written = 0; /* number of bytes written */

sys/dev/raid/vinum/vinumioctl.c

470

plex->recovered_reads = 0; /* number of recovered read operations */

sys/dev/raid/vinum/vinumioctl.c

471

plex->degraded_writes = 0; /* number of degraded writes */

sys/dev/raid/vinum/vinumioctl.c

472

plex->parityless_writes = 0; /* number of parityless writes */

sys/dev/raid/vinum/vinumioctl.c

473

plex->multiblock = 0; /* requests that needed more than one block */

sys/dev/raid/vinum/vinumioctl.c

474

plex->multistripe = 0; /* requests that needed more than one stripe */

sys/dev/raid/vinum/vinumioctl.c

511

struct plex *plex;

sys/dev/raid/vinum/vinumioctl.c

526

plex = validplex(msg->otherobject, reply);

sys/dev/raid/vinum/vinumioctl.c

527

if (plex) {

sys/dev/raid/vinum/vinumioctl.c

535

if ((plex->organization != plex_concat) /* can't attach to striped and RAID-4/5 */

sys/dev/raid/vinum/vinumioctl.c

548

give_sd_to_plex(plex->plexno, sd->sdno); /* and give it to the plex */

sys/dev/raid/vinum/vinumioctl.c

559

plex = validplex(msg->index, reply); /* get plex */

sys/dev/raid/vinum/vinumioctl.c

560

if (plex == NULL)

sys/dev/raid/vinum/vinumioctl.c

565

||(plex->volno >= 0)) { /* or the plex has an owner */

sys/dev/raid/vinum/vinumioctl.c

570

for (sdno = 0; sdno < plex->subdisks; sdno++) {

sys/dev/raid/vinum/vinumioctl.c

571

sd = &SD[plex->sdnos[sdno]];

sys/dev/raid/vinum/vinumioctl.c

574

set_sd_state(plex->sdnos[sdno], sd_stale, setstate_force); /* make it stale */

sys/dev/raid/vinum/vinumioctl.c

576

set_plex_state(plex->plexno, plex_up, setstate_none); /* update plex state */

sys/dev/raid/vinum/vinumioctl.c

578

update_plex_config(plex->plexno, 0);

sys/dev/raid/vinum/vinumioctl.c

590

struct plex *plex;

sys/dev/raid/vinum/vinumioctl.c

612

plex = &PLEX[sd->plexno];

sys/dev/raid/vinum/vinumioctl.c

614

&&((plex->state == plex_up) /* and the plex is up */

sys/dev/raid/vinum/vinumioctl.c

615

||((plex->state == plex_flaky) && sd->state == sd_up))) { /* or flaky with this sd up */

sys/dev/raid/vinum/vinumioctl.c

621

if (plex->subdisks == 1) { /* this was the only subdisk */

sys/dev/raid/vinum/vinumioctl.c

622

Free(plex->sdnos); /* free the subdisk array */

sys/dev/raid/vinum/vinumioctl.c

623

plex->sdnos = NULL; /* and note the fact */

sys/dev/raid/vinum/vinumioctl.c

624

plex->subdisks_allocated = 0; /* no subdisk space */

sys/dev/raid/vinum/vinumioctl.c

626

for (sdno = 0; sdno < plex->subdisks; sdno++) {

sys/dev/raid/vinum/vinumioctl.c

627

if (plex->sdnos[sdno] == msg->index) /* found our subdisk */

sys/dev/raid/vinum/vinumioctl.c

630

if (sdno < (plex->subdisks - 1)) /* not the last one, compact */

sys/dev/raid/vinum/vinumioctl.c

631

bcopy(&plex->sdnos[sdno + 1],

sys/dev/raid/vinum/vinumioctl.c

632

&plex->sdnos[sdno],

sys/dev/raid/vinum/vinumioctl.c

633

(plex->subdisks - 1 - sdno) * sizeof(int));

sys/dev/raid/vinum/vinumioctl.c

635

plex->subdisks--;

sys/dev/raid/vinum/vinumioctl.c

636

if (!bcmp(plex->name, sd->name, strlen(plex->name) + 1))

sys/dev/raid/vinum/vinumioctl.c

645

update_plex_config(plex->plexno, 0);

sys/dev/raid/vinum/vinumioctl.c

646

if (isstriped(plex)) /* we've just mutilated our plex, */

sys/dev/raid/vinum/vinumioctl.c

647

set_plex_state(plex->plexno,

sys/dev/raid/vinum/vinumioctl.c

656

plex = validplex(msg->index, reply); /* get plex */

sys/dev/raid/vinum/vinumioctl.c

657

if (plex == NULL)

sys/dev/raid/vinum/vinumioctl.c

659

if (plex->volno >= 0) {

sys/dev/raid/vinum/vinumioctl.c

660

int volno = plex->volno;

sys/dev/raid/vinum/vinumioctl.c

674

plex->volno = -1; /* anonymous plex */

sys/dev/raid/vinum/vinumioctl.c

676

if (vol->plex[plexno] == msg->index) /* found our plex */

sys/dev/raid/vinum/vinumioctl.c

680

bcopy(&vol->plex[plexno + 1],

sys/dev/raid/vinum/vinumioctl.c

681

&vol->plex[plexno],

sys/dev/raid/vinum/vinumioctl.c

685

if (!bcmp(vol->name, plex->name, strlen(vol->name) + 1))

sys/dev/raid/vinum/vinumioctl.c

692

for (sdno = 0; sdno < plex->subdisks; sdno++) {

sys/dev/raid/vinum/vinumioctl.c

693

struct sd *sd = &SD[plex->sdnos[sdno]];

sys/dev/raid/vinum/vinumioctl.c

695

if (!bcmp(plex->name, sd->name, strlen(plex->name) + 1))

sys/dev/raid/vinum/vinumioctl.c

706

bcopy(plex->name,

sys/dev/raid/vinum/vinumioctl.c

707

&plex->name[3],

sys/dev/raid/vinum/vinumioctl.c

708

imin(strlen(plex->name) + 1, MAXPLEXNAME - 3));

sys/dev/raid/vinum/vinumioctl.c

709

bcopy("ex-", plex->name, 3);

sys/dev/raid/vinum/vinumioctl.c

710

plex->name[MAXPLEXNAME - 1] = '\0';

sys/dev/raid/vinum/vinumioctl.c

728

struct plex *plex;

sys/dev/raid/vinum/vinumioctl.c

767

plex = validplex(msg->index, reply);

sys/dev/raid/vinum/vinumioctl.c

768

if (plex) {

sys/dev/raid/vinum/vinumioctl.c

769

bcopy(msg->newname, plex->name, MAXPLEXNAME);

sys/dev/raid/vinum/vinumioctl.c

770

update_plex_config(plex->plexno, 0);

sys/dev/raid/vinum/vinumlock.c

108

lockrange(vinum_off_t stripe, struct buf *bp, struct plex *plex)

sys/dev/raid/vinum/vinumlock.c

139

while (plex->usedlocks == PLEX_LOCKS) /* all in use */

sys/dev/raid/vinum/vinumlock.c

140

tsleep(&plex->usedlocks, 0, "vlock", 0);

sys/dev/raid/vinum/vinumlock.c

143

if (plex->usedlocks >= PLEX_LOCKS)

sys/dev/raid/vinum/vinumlock.c

147

lock = plex->lock; /* pointer in lock table */

sys/dev/raid/vinum/vinumlock.c

148

if (plex->usedlocks > 0) /* something locked, */

sys/dev/raid/vinum/vinumlock.c

150

for (; lock < &plex->lock[PLEX_LOCKS]

sys/dev/raid/vinum/vinumlock.c

151

&& foundlocks < plex->usedlocks;

sys/dev/raid/vinum/vinumlock.c

166

plex->lockwaits++; /* waited one more time */

sys/dev/raid/vinum/vinumlock.c

168

lock = &plex->lock[-1]; /* start again */

sys/dev/raid/vinum/vinumlock.c

190

plex->usedlocks++; /* one more lock */

sys/dev/raid/vinum/vinumlock.c

203

struct plex *plex;

sys/dev/raid/vinum/vinumlock.c

205

plex = &PLEX[plexno];

sys/dev/raid/vinum/vinumlock.c

207

if (lock < &plex->lock[0] || lock >= &plex->lock[PLEX_LOCKS])

sys/dev/raid/vinum/vinumlock.c

211

&plex->lock[0],

sys/dev/raid/vinum/vinumlock.c

212

&plex->lock[PLEX_LOCKS]);

sys/dev/raid/vinum/vinumlock.c

219

plex->usedlocks--; /* one less lock */

sys/dev/raid/vinum/vinumlock.c

220

if (plex->usedlocks == PLEX_LOCKS - 1) /* we were full, */

sys/dev/raid/vinum/vinumlock.c

221

wakeup(&plex->usedlocks); /* get a waiter if one's there */

sys/dev/raid/vinum/vinumparser.c

89

keypair(plex),

sys/dev/raid/vinum/vinumraid5.c

125

struct plex *plex;

sys/dev/raid/vinum/vinumraid5.c

138

plex = &PLEX[plexno]; /* point to the plex */

sys/dev/raid/vinum/vinumraid5.c

142

if (*diskaddr >= plex->length) /* beyond the end of the plex */

sys/dev/raid/vinum/vinumraid5.c

153

m.stripeoffset = *diskaddr % (plex->stripesize * (plex->subdisks - 1));

sys/dev/raid/vinum/vinumraid5.c

162

if (plex->organization == plex_raid5)

sys/dev/raid/vinum/vinumraid5.c

163

m.psdno = plex->subdisks - 1

sys/dev/raid/vinum/vinumraid5.c

164

- (*diskaddr / (plex->stripesize * (plex->subdisks - 1)))

sys/dev/raid/vinum/vinumraid5.c

165

% plex->subdisks;

sys/dev/raid/vinum/vinumraid5.c

167

m.psdno = plex->subdisks - 1;

sys/dev/raid/vinum/vinumraid5.c

173

m.firstsdno = m.stripeoffset / plex->stripesize;

sys/dev/raid/vinum/vinumraid5.c

181

m.initoffset = m.stripeoffset % plex->stripesize;

sys/dev/raid/vinum/vinumraid5.c

184

m.sdbase = m.stripebase / (plex->subdisks - 1);

sys/dev/raid/vinum/vinumraid5.c

193

plex->stripesize - m.initoffset); /* and the amount left in this block */

sys/dev/raid/vinum/vinumraid5.c

201

plex->stripesize * (plex->subdisks - 1) - m.stripeoffset);

sys/dev/raid/vinum/vinumraid5.c

204

m.sdcount = (m.stripesectors + m.initoffset + plex->stripesize - 1) / plex->stripesize;

sys/dev/raid/vinum/vinumraid5.c

350

plex->multiblock++; /* more than one block for the request */

sys/dev/raid/vinum/vinumraid5.c

357

if (rsectors < plex->stripesize) {

sys/dev/raid/vinum/vinumraid5.c

363

if (SD[plex->sdnos[m.psdno]].state < sd_reborn) /* is our parity subdisk down? */

sys/dev/raid/vinum/vinumraid5.c

369

if (mysdno == plex->subdisks) /* wraparound */

sys/dev/raid/vinum/vinumraid5.c

374

if (SD[plex->sdnos[mysdno]].state < sd_reborn) { /* got a bad subdisk, */

sys/dev/raid/vinum/vinumraid5.c

381

plex->recovered_reads++; /* count another one */

sys/dev/raid/vinum/vinumraid5.c

388

m.datalen = umin(rsectors, plex->stripesize); /* amount that will fit in this block */

sys/dev/raid/vinum/vinumraid5.c

394

if (mysdno == plex->subdisks) /* wraparound */

sys/dev/raid/vinum/vinumraid5.c

399

sd = &SD[plex->sdnos[mysdno]];

sys/dev/raid/vinum/vinumraid5.c

414

struct sd *sd = &SD[plex->sdnos[sdno]];

sys/dev/raid/vinum/vinumraid5.c

422

plex->degraded_writes++; /* count another one */

sys/dev/raid/vinum/vinumraid5.c

441

m.datalen = umin(rsectors, plex->stripesize); /* amount that will fit in this block */

sys/dev/raid/vinum/vinumraid5.c

444

struct sd *psd = &SD[plex->sdnos[m.psdno]];

sys/dev/raid/vinum/vinumraid5.c

452

plex->parityless_writes++; /* count another one */

sys/dev/raid/vinum/vinumraid5.c

463

m.rqcount = plex->subdisks; /* all subdisks */

sys/dev/raid/vinum/vinumraid5.c

488

sd = &SD[plex->sdnos[m.psdno]]; /* the subdisk in question */

sys/dev/raid/vinum/vinumraid5.c

495

if (build_rq_buffer(rqe, plex)) /* build the buffer */

sys/dev/raid/vinum/vinumraid5.c

509

if (mysdno == plex->subdisks) /* got to the end, */

sys/dev/raid/vinum/vinumraid5.c

515

sd = &SD[plex->sdnos[mysdno]]; /* the subdisk in question */

sys/dev/raid/vinum/vinumraid5.c

534

if (build_rq_buffer(rqe, plex)) /* build the buffer */

sys/dev/raid/vinum/vinumraid5.c

544

m.datalen = umin(m.stripesectors, plex->stripesize); /* and recalculate */

sys/dev/raid/vinum/vinumraid5.c

560

if (mysdno == plex->subdisks) /* got to the end, */

sys/dev/raid/vinum/vinumraid5.c

566

sd = &SD[plex->sdnos[mysdno]]; /* the subdisk in question */

sys/dev/raid/vinum/vinumraid5.c

579

if (build_rq_buffer(rqe, plex)) /* build the buffer */

sys/dev/raid/vinum/vinumraid5.c

594

plex->multistripe++; /* count another one */

sys/dev/raid/vinum/vinumraid5.c

90

enum requeststatus build_rq_buffer(struct rqelement *rqe, struct plex *plex);

sys/dev/raid/vinum/vinumrequest.c

474

struct plex *plex;

sys/dev/raid/vinum/vinumrequest.c

487

plex = &PLEX[plexno]; /* point to the plex */

sys/dev/raid/vinum/vinumrequest.c

489

switch (plex->organization) {

sys/dev/raid/vinum/vinumrequest.c

492

for (sdno = 0; sdno < plex->subdisks; sdno++) {

sys/dev/raid/vinum/vinumrequest.c

493

sd = &SD[plex->sdnos[sdno]];

sys/dev/raid/vinum/vinumrequest.c

535

if (build_rq_buffer(rqe, plex)) { /* build the buffer */

sys/dev/raid/vinum/vinumrequest.c

563

if (*diskaddr >= plex->length) /* beyond the end of the plex */

sys/dev/raid/vinum/vinumrequest.c

567

stripeoffset = *diskaddr % (plex->stripesize * plex->subdisks);

sys/dev/raid/vinum/vinumrequest.c

573

sdno = stripeoffset / plex->stripesize;

sys/dev/raid/vinum/vinumrequest.c

576

blockoffset = stripeoffset % plex->stripesize;

sys/dev/raid/vinum/vinumrequest.c

578

sd = &SD[plex->sdnos[sdno]]; /* the subdisk in question */

sys/dev/raid/vinum/vinumrequest.c

58

enum requeststatus build_rq_buffer(struct rqelement *rqe, struct plex *plex);

sys/dev/raid/vinum/vinumrequest.c

589

rqe->sdoffset = stripebase / plex->subdisks + blockoffset; /* start offset in this subdisk */

sys/dev/raid/vinum/vinumrequest.c

593

plex->stripesize - blockoffset);

sys/dev/raid/vinum/vinumrequest.c

631

plex->name,

sys/dev/raid/vinum/vinumrequest.c

644

if (build_rq_buffer(rqe, plex)) { /* build the buffer */

sys/dev/raid/vinum/vinumrequest.c

652

&&(*diskaddr < plex->length)) { /* and there's more to come */

sys/dev/raid/vinum/vinumrequest.c

653

plex->multiblock++; /* count another one */

sys/dev/raid/vinum/vinumrequest.c

654

if (sdno == plex->subdisks - 1) /* last subdisk, */

sys/dev/raid/vinum/vinumrequest.c

655

plex->multistripe++; /* another stripe as well */

sys/dev/raid/vinum/vinumrequest.c

671

log(LOG_ERR, "vinum: invalid plex type %d in bre\n", plex->organization);

sys/dev/raid/vinum/vinumrequest.c

706

status = bre(rq, vol->plex[plexindex], &diskaddr, diskend); /* build up a request */

sys/dev/raid/vinum/vinumrequest.c

739

bre(rq, vol->plex[plexno], &diskaddr, diskend); /* try a request */

sys/dev/raid/vinum/vinumrequest.c

786

bre(rq, vol->plex[plexno], &diskstart, diskend));

sys/dev/raid/vinum/vinumrequest.c

793

build_rq_buffer(struct rqelement *rqe, struct plex *plex)

sys/dev/raid/vinum/vinumrevive.c

100

if (stripeoffset + (size >> DEV_BSHIFT) > plex->stripesize)

sys/dev/raid/vinum/vinumrevive.c

101

size = (plex->stripesize - stripeoffset) << DEV_BSHIFT;

sys/dev/raid/vinum/vinumrevive.c

103

+ (sd->revived - stripeoffset) * plex->subdisks /* offset to beginning of stripe */

sys/dev/raid/vinum/vinumrevive.c

109

stripeoffset = sd->revived % plex->stripesize; /* offset from beginning of stripe */

sys/dev/raid/vinum/vinumrevive.c

111

+ (sd->revived - stripeoffset) * (plex->subdisks - 1) /* offset to beginning of stripe */

sys/dev/raid/vinum/vinumrevive.c

113

stripe = (sd->revived / plex->stripesize); /* stripe number */

sys/dev/raid/vinum/vinumrevive.c

116

size = u64min(size, (plex->stripesize - stripeoffset) << DEV_BSHIFT);

sys/dev/raid/vinum/vinumrevive.c

117

if (plex->organization == plex_raid4)

sys/dev/raid/vinum/vinumrevive.c

118

psd = plex->subdisks - 1; /* parity subdisk for this stripe */

sys/dev/raid/vinum/vinumrevive.c

120

psd = plex->subdisks - 1 - stripe % plex->subdisks; /* parity subdisk for this stripe */

sys/dev/raid/vinum/vinumrevive.c

121

paritysd = plex->sdnos[psd] == sdno; /* note if it's the parity subdisk */

sys/dev/raid/vinum/vinumrevive.c

128

plexblkno -= plex->stripesize; /* one stripe less */

sys/dev/raid/vinum/vinumrevive.c

130

plexblkno -= plex->stripesize * sd->plexsdno; /* go back to the beginning of the band */

sys/dev/raid/vinum/vinumrevive.c

138

bp = parityrebuild(plex, sd->revived, size, rebuildparity, &lock, NULL); /* do the grunt work */

sys/dev/raid/vinum/vinumrevive.c

154

if (isstriped(plex)) /* we need to lock striped plexes */

sys/dev/raid/vinum/vinumrevive.c

155

lock = lockrange(plexblkno << DEV_BSHIFT, bp, plex); /* lock it */

sys/dev/raid/vinum/vinumrevive.c

250

struct plex *plex;

sys/dev/raid/vinum/vinumrevive.c

264

plex = &PLEX[plexno];

sys/dev/raid/vinum/vinumrevive.c

265

if (!isparity(plex)) { /* not RAID-4 or RAID-5 */

sys/dev/raid/vinum/vinumrevive.c

268

} else if (plex->state < plex_flaky) {

sys/dev/raid/vinum/vinumrevive.c

275

plex->stripesize << DEV_BSHIFT);

sys/dev/raid/vinum/vinumrevive.c

278

pbp = parityrebuild(plex, pstripe, size, op, &lock, &errorloc); /* do the grunt work */

sys/dev/raid/vinum/vinumrevive.c

308

plex->checkblock = pstripe + (pbp->b_bcount >> DEV_BSHIFT); /* moved this much further down */

sys/dev/raid/vinum/vinumrevive.c

309

if (plex->checkblock >= SD[plex->sdnos[0]].sectors) { /* finished */

sys/dev/raid/vinum/vinumrevive.c

310

plex->checkblock = 0;

sys/dev/raid/vinum/vinumrevive.c

345

parityrebuild(struct plex *plex,

sys/dev/raid/vinum/vinumrevive.c

367

stripe = pstripe / plex->stripesize; /* stripe number */

sys/dev/raid/vinum/vinumrevive.c

368

psd = plex->subdisks - 1 - stripe % plex->subdisks; /* parity subdisk for this stripe */

sys/dev/raid/vinum/vinumrevive.c

382

mysize = u64min(size, (plex->stripesize * (stripe + 1) - pstripe) << DEV_BSHIFT);

sys/dev/raid/vinum/vinumrevive.c

384

bufcount = plex->subdisks + 1; /* sd buffers plus result buffer */

sys/dev/raid/vinum/vinumrevive.c

385

newpsd = plex->subdisks;

sys/dev/raid/vinum/vinumrevive.c

397

bpp[sdno]->b_bio1.bio_driver_info = SD[plex->sdnos[psd]].sd_dev; /* write back to the parity SD */

sys/dev/raid/vinum/vinumrevive.c

399

bpp[sdno]->b_bio1.bio_driver_info = SD[plex->sdnos[sdno]].sd_dev; /* device number */

sys/dev/raid/vinum/vinumrevive.c

418

*lockp = lockrange(pstripe * plex->stripesize * (plex->subdisks - 1),

sys/dev/raid/vinum/vinumrevive.c

420

plex);

sys/dev/raid/vinum/vinumrevive.c

428

for (sdno = 0; sdno < plex->subdisks; sdno++) { /* for each real subdisk */

sys/dev/raid/vinum/vinumrevive.c

442

for (sdno = 0; sdno < plex->subdisks; sdno++) { /* for each subdisk */

sys/dev/raid/vinum/vinumrevive.c

470

*errorloc = (off_t) (pstripe << DEV_BSHIFT) * (plex->subdisks - 1)

sys/dev/raid/vinum/vinumrevive.c

499

struct plex *plex;

sys/dev/raid/vinum/vinumrevive.c

509

plex = &PLEX[sd->plexno]; /* point to plex */

sys/dev/raid/vinum/vinumrevive.c

512

if (plex->stripesize != 0) /* we're striped, don't init more than */

sys/dev/raid/vinum/vinumrevive.c

514

plex->stripesize << DEV_BSHIFT);

sys/dev/raid/vinum/vinumrevive.c

60

struct plex *plex;

sys/dev/raid/vinum/vinumrevive.c

78

plex = &PLEX[sd->plexno]; /* point to plex */

sys/dev/raid/vinum/vinumrevive.c

79

if (plex->volno >= 0)

sys/dev/raid/vinum/vinumrevive.c

80

vol = &VOL[plex->volno];

sys/dev/raid/vinum/vinumrevive.c

93

switch (plex->organization) {

sys/dev/raid/vinum/vinumrevive.c

99

stripeoffset = sd->revived % plex->stripesize; /* offset from beginning of stripe */

sys/dev/raid/vinum/vinumstate.c

1005

plex = &PLEX[msg->index];

sys/dev/raid/vinum/vinumstate.c

1007

|| (plex->state <= plex_unallocated)) {

sys/dev/raid/vinum/vinumstate.c

1013

if (plex->state != plex_initializing) {

sys/dev/raid/vinum/vinumstate.c

1018

for (sdno = 0; sdno < plex->subdisks; sdno++) {

sys/dev/raid/vinum/vinumstate.c

1019

sd = &SD[plex->sdnos[sdno]];

sys/dev/raid/vinum/vinumstate.c

1020

set_sd_state(plex->sdnos[sdno], sd_initializing, msg->force);

sys/dev/raid/vinum/vinumstate.c

107

struct plex *plex;

sys/dev/raid/vinum/vinumstate.c

237

plex = &PLEX[sd->plexno];

sys/dev/raid/vinum/vinumstate.c

238

if (plex->volno >= 0) /* have a volume */

sys/dev/raid/vinum/vinumstate.c

239

vol = &VOL[plex->volno];

sys/dev/raid/vinum/vinumstate.c

252

&& ((!isparity(plex))

sys/dev/raid/vinum/vinumstate.c

253

|| (plex->sddowncount > 1))) {

sys/dev/raid/vinum/vinumstate.c

314

struct plex *plex; /* point to our plex */

sys/dev/raid/vinum/vinumstate.c

318

plex = &PLEX[plexno]; /* point to our plex */

sys/dev/raid/vinum/vinumstate.c

319

oldstate = plex->state;

sys/dev/raid/vinum/vinumstate.c

322

if (plex->state == plex_unallocated)

sys/dev/raid/vinum/vinumstate.c

333

vps = vpstate(plex); /* how do we compare with the other plexes? */

sys/dev/raid/vinum/vinumstate.c

341

update_plex_state(plex->plexno); /* it'll come up if it can */

sys/dev/raid/vinum/vinumstate.c

353

plex->state = state; /* do it */

sys/dev/raid/vinum/vinumstate.c

354

invalidate_subdisks(plex, sd_down); /* and down all up subdisks */

sys/dev/raid/vinum/vinumstate.c

362

plex->state = state; /* do it */

sys/dev/raid/vinum/vinumstate.c

363

invalidate_subdisks(plex, sd_crashed); /* and crash all up subdisks */

sys/dev/raid/vinum/vinumstate.c

370

plex->state = state; /* do it */

sys/dev/raid/vinum/vinumstate.c

377

if (plex->state != oldstate) /* we've changed, */

sys/dev/raid/vinum/vinumstate.c

380

plex->name,

sys/dev/raid/vinum/vinumstate.c

381

plex_state(plex->state));

sys/dev/raid/vinum/vinumstate.c

386

if (plex->volno >= 0) /* we have a volume */

sys/dev/raid/vinum/vinumstate.c

387

update_volume_state(plex->volno); /* update its state */

sys/dev/raid/vinum/vinumstate.c

474

struct plex *plex;

sys/dev/raid/vinum/vinumstate.c

477

plex = &PLEX[plexno]; /* point to the plex */

sys/dev/raid/vinum/vinumstate.c

478

plex->state = plex_up; /* and bring it up */

sys/dev/raid/vinum/vinumstate.c

481

for (sdno = 0; sdno < plex->subdisks; sdno++) {

sys/dev/raid/vinum/vinumstate.c

482

SD[plex->sdnos[sdno]].state = sd_up;

sys/dev/raid/vinum/vinumstate.c

485

SD[plex->sdnos[sdno]].name);

sys/dev/raid/vinum/vinumstate.c

493

struct plex *plex; /* point to our plex */

sys/dev/raid/vinum/vinumstate.c

498

plex = &PLEX[plexno]; /* point to our plex */

sys/dev/raid/vinum/vinumstate.c

499

oldstate = plex->state;

sys/dev/raid/vinum/vinumstate.c

500

statemap = sdstatemap(plex); /* get a map of the subdisk states */

sys/dev/raid/vinum/vinumstate.c

501

vps = vpstate(plex); /* how do we compare with the other plexes? */

sys/dev/raid/vinum/vinumstate.c

504

plex->state = plex_initializing; /* yup, that makes the plex the same */

sys/dev/raid/vinum/vinumstate.c

511

plex->state = plex_up;

sys/dev/raid/vinum/vinumstate.c

512

else if (isparity(plex) /* RAID-4 or RAID-5 plex */

sys/dev/raid/vinum/vinumstate.c

513

&&(plex->sddowncount == 1)) /* and exactly one subdisk down */

sys/dev/raid/vinum/vinumstate.c

514

plex->state = plex_degraded; /* limping a bit */

sys/dev/raid/vinum/vinumstate.c

519

struct volume *vol = &VOL[plex->volno]; /* possible volume to which it points */

sys/dev/raid/vinum/vinumstate.c

538

if ((plex->state == plex_init)

sys/dev/raid/vinum/vinumstate.c

539

&& (plex->volno >= 0)

sys/dev/raid/vinum/vinumstate.c

542

forceup(VOL[plex->volno].plex[plexno]);

sys/dev/raid/vinum/vinumstate.c

544

||(plex->organization == plex_concat) /* and we're not RAID-4 or RAID-5 */

sys/dev/raid/vinum/vinumstate.c

545

||(plex->organization == plex_striped))

sys/dev/raid/vinum/vinumstate.c

555

plex->state = plex_up; /* we can come up too */

sys/dev/raid/vinum/vinumstate.c

557

plex->state = plex_faulty;

sys/dev/raid/vinum/vinumstate.c

560

plex->state = plex_flaky;

sys/dev/raid/vinum/vinumstate.c

562

plex->state = plex_corrupt; /* corrupt */

sys/dev/raid/vinum/vinumstate.c

564

plex->state = plex_initializing;

sys/dev/raid/vinum/vinumstate.c

566

plex->state = plex_faulty;

sys/dev/raid/vinum/vinumstate.c

568

if (plex->state != oldstate) /* state has changed, */

sys/dev/raid/vinum/vinumstate.c

571

plex->name,

sys/dev/raid/vinum/vinumstate.c

572

plex_state(plex->state));

sys/dev/raid/vinum/vinumstate.c

573

if (plex->volno >= 0) /* we're part of a volume, */

sys/dev/raid/vinum/vinumstate.c

574

update_volume_state(plex->volno); /* update its state */

sys/dev/raid/vinum/vinumstate.c

589

struct plex *plex = &PLEX[vol->plex[plexno]]; /* point to the plex */

sys/dev/raid/vinum/vinumstate.c

590

if (plex->state >= plex_corrupt) { /* something accessible, */

sys/dev/raid/vinum/vinumstate.c

621

struct plex *plex = &PLEX[sd->plexno];

sys/dev/raid/vinum/vinumstate.c

648

if (plex->organization == plex_striped) /* plex is striped, */

sys/dev/raid/vinum/vinumstate.c

651

else if (isparity(plex)) { /* RAID-4 or RAID-5 plex */

sys/dev/raid/vinum/vinumstate.c

652

if (plex->sddowncount > 1) /* with more than one sd down, */

sys/dev/raid/vinum/vinumstate.c

704

sdstatemap(struct plex *plex)

sys/dev/raid/vinum/vinumstate.c

709

plex->sddowncount = 0; /* no subdisks down yet */

sys/dev/raid/vinum/vinumstate.c

710

for (sdno = 0; sdno < plex->subdisks; sdno++) {

sys/dev/raid/vinum/vinumstate.c

711

struct sd *sd = &SD[plex->sdnos[sdno]]; /* point to the subdisk */

sys/dev/raid/vinum/vinumstate.c

716

(plex->sddowncount)++; /* another unusable subdisk */

sys/dev/raid/vinum/vinumstate.c

721

(plex->sddowncount)++; /* another unusable subdisk */

sys/dev/raid/vinum/vinumstate.c

726

(plex->sddowncount)++; /* another unusable subdisk */

sys/dev/raid/vinum/vinumstate.c

731

(plex->sddowncount)++; /* another unusable subdisk */

sys/dev/raid/vinum/vinumstate.c

736

(plex->sddowncount)++; /* another unusable subdisk */

sys/dev/raid/vinum/vinumstate.c

741

(plex->sddowncount)++; /* another unusable subdisk */

sys/dev/raid/vinum/vinumstate.c

754

(plex->sddowncount)++; /* another unusable subdisk */

sys/dev/raid/vinum/vinumstate.c

759

(plex->sddowncount)++; /* another unusable subdisk */

sys/dev/raid/vinum/vinumstate.c

767

(plex->sddowncount)++; /* another unusable subdisk */

sys/dev/raid/vinum/vinumstate.c

775

vpstate(struct plex *plex)

sys/dev/raid/vinum/vinumstate.c

781

if (plex->volno < 0) { /* not associated with a volume */

sys/dev/raid/vinum/vinumstate.c

782

if (plex->state > plex_degraded)

sys/dev/raid/vinum/vinumstate.c

787

vol = &VOL[plex->volno]; /* point to our volume */

sys/dev/raid/vinum/vinumstate.c

789

if (&PLEX[vol->plex[plexno]] == plex) { /* us */

sys/dev/raid/vinum/vinumstate.c

790

if (PLEX[vol->plex[plexno]].state >= plex_degraded) /* are we up? */

sys/dev/raid/vinum/vinumstate.c

793

if (PLEX[vol->plex[plexno]].state >= plex_degraded) /* not us */

sys/dev/raid/vinum/vinumstate.c

813

invalidate_subdisks(struct plex *plex, enum sdstate state)

sys/dev/raid/vinum/vinumstate.c

817

for (sdno = 0; sdno < plex->subdisks; sdno++) { /* for each subdisk */

sys/dev/raid/vinum/vinumstate.c

818

struct sd *sd = &SD[plex->sdnos[sdno]];

sys/dev/raid/vinum/vinumstate.c

837

set_sd_state(plex->sdnos[sdno], state, setstate_force);

sys/dev/raid/vinum/vinumstate.c

978

struct plex *plex;

sys/dev/raid/vinum/vinumutil.c

157

for (i = 0; i < STATECOUNT(plex); i++)

sys/dev/raid/vinum/vinumutil.c

261

return VOL[Volno(dev)].plex[(minor(dev) >> VINUM_PLEX_SHIFT) & (MASK(VINUM_PLEX_WIDTH))];

sys/dev/raid/vinum/vinumutil.c

80

if (((unsigned) state) >= STATECOUNT(plex)) {

sys/dev/raid/vinum/vinumvar.h

228

unsigned plex:3; /* up to 8 plexes per volume */

sys/dev/raid/vinum/vinumvar.h

320

struct plex *plex;

sys/dev/raid/vinum/vinumvar.h

350

#define PLEX vinum_conf.plex

sys/dev/raid/vinum/vinumvar.h

634

int plex[MAXPLEX]; /* index of plexes */