vos.c

Bug Summary

File:	volser/vos.c
Location:	line 5368, column 25
Description:	Access to field 'data' results in a dereference of a null pointer (loaded from field 'items')

Annotated Source Code

* This software has been released under the terms of the IBM Public

* License. For details, see the LICENSE file in the top-level source

* directory or online at http://www.openafs.org/dl/license10.html

#include <afsconfig.h>

#include <afs/param.h>

#include <roken.h>

#ifdef IGNORE_SOME_GCC_WARNINGS

# pragma GCC diagnostic warning "-Wimplicit-function-declaration"

#endif

#ifdef AFS_NT40_ENV

#include <WINNT/afsreg.h>

#endif

#ifdef AFS_AIX_ENV

#include <sys/statfs.h>

#endif

#include <lock.h>

#include <afs/stds.h>

#include <rx/xdr.h>

#include <rx/rx.h>

#include <rx/rx_globals.h>

#include <afs/nfs.h>

#include <afs/vlserver.h>

#include <afs/cellconfig.h>

#include <afs/keys.h>

#include <afs/afsutil.h>

#include <ubik.h>

#include <afs/afsint.h>

#include <afs/cmd.h>

#include <afs/usd.h>

#include "volser.h"

#include "volint.h"

#include <afs/ihandle.h>

#include <afs/vnode.h>

#include <afs/volume.h>

#include <afs/com_err.h>

#include "dump.h"

#include "lockdata.h"

#include "volser_internal.h"

#include "volser_prototypes.h"

#include "vsutils_prototypes.h"

#include "lockprocs_prototypes.h"

#ifdef HAVE_POSIX_REGEX1

#include <regex.h>

#endif

/* Local Prototypes */

int PrintDiagnostics(char *astring, afs_int32 acode);

int GetVolumeInfo(afs_uint32 volid, afs_uint32 *server, afs_int32 *part,

afs_int32 *voltype, struct nvldbentry *rentry);

struct tqElem {

afs_uint32 volid;

struct tqElem *next;

};

struct tqHead {

afs_int32 count;

struct tqElem *next;

};

#define COMMONPARMScmd_Seek(ts, 12);cmd_AddParm(ts, "-cell", 2, 1, "cell name");
cmd_AddParm(ts, "-noauth", 1, 1, "don't authenticate");cmd_AddParm
(ts, "-localauth",1,1,"use server tickets");cmd_AddParm(ts, "-verbose"
, 1, 1, "verbose");cmd_AddParm(ts, "-encrypt", 1, 1, "encrypt commands"
);cmd_AddParm(ts, "-noresolve", 1, 1, "don't resolve addresses"
); cmd_AddParm(ts, "-config", 2, 1, "config location"); cmd_Seek(ts, 12);\

cmd_AddParm(ts, "-cell", CMD_SINGLE2, CMD_OPTIONAL1, "cell name");\

cmd_AddParm(ts, "-noauth", CMD_FLAG1, CMD_OPTIONAL1, "don't authenticate");\

cmd_AddParm(ts, "-localauth",CMD_FLAG1,CMD_OPTIONAL1,"use server tickets");\

cmd_AddParm(ts, "-verbose", CMD_FLAG1, CMD_OPTIONAL1, "verbose");\

cmd_AddParm(ts, "-encrypt", CMD_FLAG1, CMD_OPTIONAL1, "encrypt commands");\

cmd_AddParm(ts, "-noresolve", CMD_FLAG1, CMD_OPTIONAL1, "don't resolve addresses"); \

cmd_AddParm(ts, "-config", CMD_SINGLE2, CMD_OPTIONAL1, "config location"); \

#define ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0) do { \

error = (code); \

goto error_exit; \

} while (0)

int rxInitDone = 0;

struct rx_connection *tconn;

afs_uint32 tserver;

extern struct ubik_client *cstruct;

const char *confdir;

static struct tqHead busyHead, notokHead;

static void

qInit(struct tqHead *ahead)

{

memset(ahead, 0, sizeof(struct tqHead));

100

return;

101

}

102

103

104

static void

105

qPut(struct tqHead *ahead, afs_uint32 volid)

106

{

107

struct tqElem *elem;

108

109

elem = (struct tqElem *)malloc(sizeof(struct tqElem));

110

elem->next = ahead->next;

111

elem->volid = volid;

112

ahead->next = elem;

113

ahead->count++;

114

return;

115

}

116

117

static void

118

qGet(struct tqHead *ahead, afs_uint32 *volid)

119

{

120

struct tqElem *tmp;

121

122

if (ahead->count <= 0)

123

return;

124

*volid = ahead->next->volid;

125

tmp = ahead->next;

126

ahead->next = tmp->next;

127

ahead->count--;

128

free(tmp);

129

return;

130

}

131

132

/* returns 1 if <filename> exists else 0 */

133

static int

134

FileExists(char *filename)

135

{

136

usd_handle_t ufd;

137

int code;

138

afs_int64 size;

139

140

code = usd_Open(filename, USD_OPEN_RDONLY0, 0, &ufd);

141

if (code) {

142

return 0;

143

}

144

code = USD_IOCTL(ufd, USD_IOCTL_GETSIZE, &size)((*(ufd)->ioctl)(ufd, 6, &size));

145

USD_CLOSE(ufd)((*(ufd)->close)(ufd));

146

if (code) {

147

return 0;

148

}

149

return 1;

150

}

151

152

/* returns 1 if <name> doesnot end in .readonly or .backup, else 0 */

153

static int

154

VolNameOK(char *name)

155

{

156

size_t total;

157

158

159

total = strlen(name);

160

if (!strcmp(&name[total - 9], ".readonly")) {

161

return 0;

162

} else if (!strcmp(&name[total - 7], ".backup")) {

163

return 0;

164

} else {

165

return 1;

166

}

167

}

168

169

/* return 1 if name is a number else 0 */

170

static int

171

IsNumeric(char *name)

172

{

173

int result, i;

174

size_t len;

175

char *ptr;

176

177

result = 1;

178

ptr = name;

179

len = strlen(name);

180

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

181

if (*ptr < '0' || *ptr > '9') {

182

result = 0;

183

break;

184

}

185

ptr++;

186

187

}

188

return result;

189

}

190

191

192

193

* Parse a server dotted address and return the address in network byte order

194

195

afs_uint32

196

GetServerNoresolve(char *aname)

197

{

198

int b1, b2, b3, b4;

199

afs_uint32 addr;

200

afs_int32 code;

201

202

code = sscanf(aname, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);

203

if (code == 4) {

204

addr = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;

205

addr = htonl(addr)(__builtin_constant_p(addr) ? ((((__uint32_t)(addr)) >>
24) | ((((__uint32_t)(addr)) & (0xff << 16)) >>
8) | ((((__uint32_t)(addr)) & (0xff << 8)) <<
8) | (((__uint32_t)(addr)) << 24)) : __bswap32_var(addr
)); /* convert to network byte order */

206

return addr;

207

} else

208

return 0;

209

}

210

211

* Parse a server name/address and return the address in network byte order

212

213

afs_uint32

214

GetServer(char *aname)

215

{

216

struct hostent *th;

217

afs_uint32 addr; /* in network byte order */

218

afs_int32 code;

219

char hostname[MAXHOSTCHARS64];

220

221

if ((addr = GetServerNoresolve(aname)) == 0) {

222

th = gethostbyname(aname);

223

if (!th)

224

return 0;

225

memcpy(&addr, th->h_addrh_addr_list[0], sizeof(addr));

226

}

227

228

if (rx_IsLoopbackAddr(ntohl(addr)(__builtin_constant_p(addr) ? ((((__uint32_t)(addr)) >>
24) | ((((__uint32_t)(addr)) & (0xff << 16)) >>
8) | ((((__uint32_t)(addr)) & (0xff << 8)) <<
8) | (((__uint32_t)(addr)) << 24)) : __bswap32_var(addr
)))) { /* local host */

229

code = gethostname(hostname, MAXHOSTCHARS64);

230

if (code)

231

return 0;

232

th = gethostbyname(hostname);

233

if (!th)

234

return 0;

235

memcpy(&addr, th->h_addrh_addr_list[0], sizeof(addr));

236

}

237

238

return (addr);

239

}

240

241

afs_int32

242

GetVolumeType(char *aname)

243

{

244

245

if (!strcmp(aname, "ro"))

246

return (ROVOL1);

247

else if (!strcmp(aname, "rw"))

248

return (RWVOL0);

249

else if (!strcmp(aname, "bk"))

250

return (BACKVOL2);

251

else

252

return (-1);

253

}

254

255

int

256

IsPartValid(afs_int32 partId, afs_uint32 server, afs_int32 *code)

257

{

258

struct partList dummyPartList;

259

int i, success, cnt;

260

261

success = 0;

262

*code = 0;

263

264

*code = UV_ListPartitions(server, &dummyPartList, &cnt);

265

if (*code)

266

return success;

267

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

268

if (dummyPartList.partFlags[i] & PARTVALID0x01)

269

if (dummyPartList.partId[i] == partId)

270

success = 1;

271

}

272

return success;

273

}

274

275

276

277

/*sends the contents of file associated with <fd> and <blksize> to Rx Stream

278

* associated with <call> */

279

int

280

SendFile(usd_handle_t ufd, struct rx_call *call, long blksize)

281

{

282

char *buffer = (char *)0;

283

afs_int32 error = 0;

284

int done = 0;

285

afs_uint32 nbytes;

286

287

buffer = (char *)malloc(blksize);

288

if (!buffer) {

289

fprintf(STDERR__stderrp, "malloc failed\n");

290

return -1;

291

}

292

293

while (!error && !done) {

294

#ifndef AFS_NT40_ENV /* NT csn't select on non-socket fd's */

295

fd_set in;

296

FD_ZERO(&in)do { fd_set *_p; __size_t _n; _p = (&in); _n = (((1024U) +
(((sizeof(__fd_mask) * 8)) - 1)) / ((sizeof(__fd_mask) * 8))
); while (_n > 0) _p->__fds_bits[--_n] = 0; } while (0);

297

FD_SET((intptr_t)(ufd->handle), &in)((&in)->__fds_bits[((intptr_t)(ufd->handle))/(sizeof
(__fd_mask) * 8)] |= ((__fd_mask)1 << (((intptr_t)(ufd->
handle)) % (sizeof(__fd_mask) * 8))));

298

/* don't timeout if read blocks */

299

#if defined(AFS_PTHREAD_ENV)

300

select(((intptr_t)(ufd->handle)) + 1, &in, 0, 0, 0);

301

#else

302

IOMGR_Select(((intptr_t)(ufd->handle)) + 1, &in, 0, 0, 0);

303

#endif

304

#endif

305

error = USD_READ(ufd, buffer, blksize, &nbytes)((*(ufd)->read)(ufd, buffer, blksize, &nbytes));

306

if (error) {

307

fprintf(STDERR__stderrp, "File system read failed: %s\n",

308

afs_error_message(error));

309

break;

310

}

311

if (nbytes == 0) {

312

done = 1;

313

break;

314

}

315

if (rx_Write(call, buffer, nbytes)rx_WriteProc(call, buffer, nbytes) != nbytes) {

316

error = -1;

317

break;

318

}

319

}

320

if (buffer)

321

free(buffer);

322

return error;

323

}

324

325

/* function invoked by UV_RestoreVolume, reads the data from rx_trx_stream and

326

* writes it out to the volume. */

327

afs_int32

328

WriteData(struct rx_call *call, void *rock)

329

{

330

char *filename = (char *) rock;

331

usd_handle_t ufd;

332

long blksize;

333

afs_int32 error, code;

334

int ufdIsOpen = 0;

335

afs_int64 currOffset;

336

afs_uint32 buffer;

337

afs_uint32 got;

338

339

error = 0;

340

341

if (!filename || !*filename) {

342

usd_StandardInput(&ufd);

343

blksize = 4096;

344

ufdIsOpen = 1;

345

} else {

346

code = usd_Open(filename, USD_OPEN_RDONLY0, 0, &ufd);

347

if (code == 0) {

348

ufdIsOpen = 1;

349

code = USD_IOCTL(ufd, USD_IOCTL_GETBLKSIZE, &blksize)((*(ufd)->ioctl)(ufd, 9, &blksize));

350

}

351

if (code) {

352

fprintf(STDERR__stderrp, "Could not access file '%s': %s\n", filename,

353

afs_error_message(code));

354

error = VOLSERBADOP(1492325131L);

355

goto wfail;

356

}

357

/* test if we have a valid dump */

358

USD_SEEK(ufd, 0, SEEK_END, &currOffset)((*(ufd)->seek)(ufd, 0, 2, &currOffset));

359

USD_SEEK(ufd, currOffset - sizeof(afs_uint32), SEEK_SET, &currOffset)((*(ufd)->seek)(ufd, currOffset - sizeof(afs_uint32), 0, &
currOffset));

360

USD_READ(ufd, (char *)&buffer, sizeof(afs_uint32), &got)((*(ufd)->read)(ufd, (char *)&buffer, sizeof(afs_uint32
), &got));

361

if ((got != sizeof(afs_uint32)) || (ntohl(buffer)(__builtin_constant_p(buffer) ? ((((__uint32_t)(buffer)) >>
24) | ((((__uint32_t)(buffer)) & (0xff << 16)) >>
8) | ((((__uint32_t)(buffer)) & (0xff << 8)) <<
8) | (((__uint32_t)(buffer)) << 24)) : __bswap32_var(buffer
)) != DUMPENDMAGIC0x3A214B6E)) {

362

fprintf(STDERR__stderrp, "Signature missing from end of file '%s'\n", filename);

363

error = VOLSERBADOP(1492325131L);

364

goto wfail;

365

}

366

USD_SEEK(ufd, 0, SEEK_SET, &currOffset)((*(ufd)->seek)(ufd, 0, 0, &currOffset));

367

}

368

code = SendFile(ufd, call, blksize);

369

if (code) {

370

error = code;

371

goto wfail;

372

}

373

wfail:

374

if (ufdIsOpen) {

375

code = USD_CLOSE(ufd)((*(ufd)->close)(ufd));

376

if (code) {

377

fprintf(STDERR__stderrp, "Could not close dump file %s\n",

378

(filename && *filename) ? filename : "STDOUT");

379

if (!error)

380

error = code;

381

}

382

}

383

return error;

384

}

385

386

/* Receive data from <call> stream into file associated

387

* with <fd> <blksize>

388

389

int

390

ReceiveFile(usd_handle_t ufd, struct rx_call *call, long blksize)

391

{

392

char *buffer = NULL((void *)0);

393

afs_int32 bytesread;

394

afs_uint32 bytesleft, w;

395

afs_int32 error = 0;

396

397

buffer = (char *)malloc(blksize);

398

if (!buffer) {

399

fprintf(STDERR__stderrp, "memory allocation failed\n");

400

ERROR_EXIT(-1)do { error = (-1); goto error_exit; } while (0);

401

}

402

403

while ((bytesread = rx_Read(call, buffer, blksize)rx_ReadProc(call, buffer, blksize)) > 0) {

404

for (bytesleft = bytesread; bytesleft; bytesleft -= w) {

405

#ifndef AFS_NT40_ENV /* NT csn't select on non-socket fd's */

406

fd_set out;

407

FD_ZERO(&out)do { fd_set *_p; __size_t _n; _p = (&out); _n = (((1024U)
+ (((sizeof(__fd_mask) * 8)) - 1)) / ((sizeof(__fd_mask) * 8
))); while (_n > 0) _p->__fds_bits[--_n] = 0; } while (
0);

408

FD_SET((intptr_t)(ufd->handle), &out)((&out)->__fds_bits[((intptr_t)(ufd->handle))/(sizeof
(__fd_mask) * 8)] |= ((__fd_mask)1 << (((intptr_t)(ufd->
handle)) % (sizeof(__fd_mask) * 8))));

409

/* don't timeout if write blocks */

410

#if defined(AFS_PTHREAD_ENV)

411

select(((intptr_t)(ufd->handle)) + 1, &out, 0, 0, 0);

412

#else

413

IOMGR_Select(((intptr_t)(ufd->handle)) + 1, 0, &out, 0, 0);

414

#endif

415

#endif

416

error =

417

USD_WRITE(ufd, &buffer[bytesread - bytesleft], bytesleft, &w)((*(ufd)->write)(ufd, &buffer[bytesread - bytesleft], bytesleft
, &w));

418

if (error) {

419

fprintf(STDERR__stderrp, "File system write failed: %s\n",

420

afs_error_message(error));

421

ERROR_EXIT(-1)do { error = (-1); goto error_exit; } while (0);

422

}

423

}

424

}

425

426

error_exit:

427

if (buffer)

428

free(buffer);

429

return (error);

430

}

431

432

afs_int32

433

DumpFunction(struct rx_call *call, void *rock)

434

{

435

char *filename = (char *)rock;

436

usd_handle_t ufd; /* default is to stdout */

437

afs_int32 error = 0, code;

438

afs_int64 size;

439

long blksize;

440

int ufdIsOpen = 0;

441

442

/* Open the output file */

443

if (!filename || !*filename) {

444

usd_StandardOutput(&ufd);

445

blksize = 4096;

446

ufdIsOpen = 1;

447

} else {

448

code =

449

usd_Open(filename, USD_OPEN_CREATE0x10 | USD_OPEN_RDWR1, 0666, &ufd);

450

if (code == 0) {

451

ufdIsOpen = 1;

452

size = 0;

453

code = USD_IOCTL(ufd, USD_IOCTL_SETSIZE, &size)((*(ufd)->ioctl)(ufd, 7, &size));

454

}

455

if (code == 0) {

456

code = USD_IOCTL(ufd, USD_IOCTL_GETBLKSIZE, &blksize)((*(ufd)->ioctl)(ufd, 9, &blksize));

457

}

458

if (code) {

459

fprintf(STDERR__stderrp, "Could not create file '%s': %s\n", filename,

460

afs_error_message(code));

461

ERROR_EXIT(VOLSERBADOP)do { error = ((1492325131L)); goto error_exit; } while (0);

462

}

463

}

464

465

code = ReceiveFile(ufd, call, blksize);

466

if (code)

467

ERROR_EXIT(code)do { error = (code); goto error_exit; } while (0);

468

469

error_exit:

470

/* Close the output file */

471

if (ufdIsOpen) {

472

code = USD_CLOSE(ufd)((*(ufd)->close)(ufd));

473

if (code) {

474

fprintf(STDERR__stderrp, "Could not close dump file %s\n",

475

(filename && *filename) ? filename : "STDIN");

476

if (!error)

477

error = code;

478

}

479

}

480

481

return (error);

482

}

483

484

static void

485

DisplayFormat(volintInfo *pntr, afs_uint32 server, afs_int32 part,

486

int *totalOK, int *totalNotOK, int *totalBusy, int fast,

487

int longlist, int disp)

488

{

489

char pname[10];

490

time_t t;

491

492

if (fast) {

493

fprintf(STDOUT__stdoutp, "%-10lu\n", (unsigned long)pntr->volid);

494

} else if (longlist) {

495

if (pntr->status == VOK0x02) {

496

fprintf(STDOUT__stdoutp, "%-32s ", pntr->name);

497

fprintf(STDOUT__stdoutp, "%10lu ", (unsigned long)pntr->volid);

498

if (pntr->type == 0)

499

fprintf(STDOUT__stdoutp, "RW ");

500

if (pntr->type == 1)

501

fprintf(STDOUT__stdoutp, "RO ");

502

if (pntr->type == 2)

503

fprintf(STDOUT__stdoutp, "BK ");

504

fprintf(STDOUT__stdoutp, "%10d K ", pntr->size);

505

if (pntr->inUse == 1) {

506

fprintf(STDOUT__stdoutp, "On-line");

507

*totalOK += 1;

508

} else {

509

fprintf(STDOUT__stdoutp, "Off-line");

510

*totalNotOK += 1;

511

}

512

if (pntr->needsSalvaged == 1)

513

fprintf(STDOUT__stdoutp, "**needs salvage**");

514

fprintf(STDOUT__stdoutp, "\n");

515

MapPartIdIntoName(part, pname);

516

fprintf(STDOUT__stdoutp, " %s %s \n", hostutil_GetNameByINet(server),

517

pname);

518

fprintf(STDOUT__stdoutp, " RWrite %10lu ROnly %10lu Backup %10lu \n",

519

(unsigned long)pntr->parentID,

520

(unsigned long)pntr->cloneID,

521

(unsigned long)pntr->backupID);

522

fprintf(STDOUT__stdoutp, " MaxQuota %10d K \n", pntr->maxquota);

523

t = pntr->creationDate;

524

fprintf(STDOUT__stdoutp, " Creation %s",

525

ctime(&t));

526

t = pntr->copyDate;

527

fprintf(STDOUT__stdoutp, " Copy %s",

528

ctime(&t));

529

530

t = pntr->backupDate;

531

if (!t)

532

fprintf(STDOUT__stdoutp, " Backup Never\n");

533

else

534

fprintf(STDOUT__stdoutp, " Backup %s",

535

ctime(&t));

536

537

t = pntr->accessDate;

538

if (t)

539

fprintf(STDOUT__stdoutp, " Last Access %s",

540

ctime(&t));

541

542

t = pntr->updateDate;

543

if (!t)

544

fprintf(STDOUT__stdoutp, " Last Update Never\n");

545

else

546

fprintf(STDOUT__stdoutp, " Last Update %s",

547

ctime(&t));

548

fprintf(STDOUT__stdoutp,

549

" %d accesses in the past day (i.e., vnode references)\n",

550

pntr->dayUse);

551

} else if (pntr->status == VBUSY110) {

552

*totalBusy += 1;

553

qPut(&busyHead, pntr->volid);

554

if (disp)

555

fprintf(STDOUT__stdoutp, "**** Volume %lu is busy ****\n",

556

(unsigned long)pntr->volid);

557

} else {

558

*totalNotOK += 1;

559

qPut(&notokHead, pntr->volid);

560

if (disp)

561

fprintf(STDOUT__stdoutp, "**** Could not attach volume %lu ****\n",

562

(unsigned long)pntr->volid);

563

}

564

fprintf(STDOUT__stdoutp, "\n");

565

} else { /* default listing */

566

if (pntr->status == VOK0x02) {

567

fprintf(STDOUT__stdoutp, "%-32s ", pntr->name);

568

fprintf(STDOUT__stdoutp, "%10lu ", (unsigned long)pntr->volid);

569

if (pntr->type == 0)

570

fprintf(STDOUT__stdoutp, "RW ");

571

if (pntr->type == 1)

572

fprintf(STDOUT__stdoutp, "RO ");

573

if (pntr->type == 2)

574

fprintf(STDOUT__stdoutp, "BK ");

575

fprintf(STDOUT__stdoutp, "%10d K ", pntr->size);

576

if (pntr->inUse == 1) {

577

fprintf(STDOUT__stdoutp, "On-line");

578

*totalOK += 1;

579

} else {

580

fprintf(STDOUT__stdoutp, "Off-line");

581

*totalNotOK += 1;

582

}

583

if (pntr->needsSalvaged == 1)

584

fprintf(STDOUT__stdoutp, "**needs salvage**");

585

fprintf(STDOUT__stdoutp, "\n");

586

} else if (pntr->status == VBUSY110) {

587

*totalBusy += 1;

588

qPut(&busyHead, pntr->volid);

589

if (disp)

590

fprintf(STDOUT__stdoutp, "**** Volume %lu is busy ****\n",

591

(unsigned long)pntr->volid);

592

} else {

593

*totalNotOK += 1;

594

qPut(&notokHead, pntr->volid);

595

if (disp)

596

fprintf(STDOUT__stdoutp, "**** Could not attach volume %lu ****\n",

597

(unsigned long)pntr->volid);

598

}

599

}

600

}

601

602

/*------------------------------------------------------------------------

603

* PRIVATE XDisplayFormat

604

605

* Description:

606

* Display the contents of one extended volume info structure.

607

608

* Arguments:

609

* a_xInfoP : Ptr to extended volume info struct to print.

610

* a_servID : Server ID to print.

611

* a_partID : Partition ID to print.

612

* a_totalOKP : Ptr to total-OK counter.

613

* a_totalNotOKP : Ptr to total-screwed counter.

614

* a_totalBusyP : Ptr to total-busy counter.

615

* a_fast : Fast listing?

616

* a_int32 : Int32 listing?

617

* a_showProblems : Show volume problems?

618

619

* Returns:

620

* Nothing.

621

622

* Environment:

623

* Nothing interesting.

624

625

* Side Effects:

626

* As advertised.

627

*------------------------------------------------------------------------*/

628

629

static void

630

XDisplayFormat(volintXInfo *a_xInfoP, afs_uint32 a_servID, afs_int32 a_partID,

631

int *a_totalOKP, int *a_totalNotOKP, int *a_totalBusyP,

632

int a_fast, int a_int32, int a_showProblems)

633

{ /*XDisplayFormat */

634

time_t t;

635

char pname[10];

636

637

if (a_fast) {

638

639

* Short & sweet.

640

641

fprintf(STDOUT__stdoutp, "%-10lu\n", (unsigned long)a_xInfoP->volid);

642

} else if (a_int32) {

643

644

* Fully-detailed listing.

645

646

if (a_xInfoP->status == VOK0x02) {

647

648

* Volume's status is OK - all the fields are valid.

649

650

fprintf(STDOUT__stdoutp, "%-32s ", a_xInfoP->name);

651

fprintf(STDOUT__stdoutp, "%10lu ", (unsigned long)a_xInfoP->volid);

652

if (a_xInfoP->type == 0)

653

fprintf(STDOUT__stdoutp, "RW ");

654

if (a_xInfoP->type == 1)

655

fprintf(STDOUT__stdoutp, "RO ");

656

if (a_xInfoP->type == 2)

657

fprintf(STDOUT__stdoutp, "BK ");

658

fprintf(STDOUT__stdoutp, "%10d K used ", a_xInfoP->size);

659

fprintf(STDOUT__stdoutp, "%d files ", a_xInfoP->filecount);

660

if (a_xInfoP->inUse == 1) {

661

fprintf(STDOUT__stdoutp, "On-line");

662

(*a_totalOKP)++;

663

} else {

664

fprintf(STDOUT__stdoutp, "Off-line");

665

(*a_totalNotOKP)++;

666

}

667

fprintf(STDOUT__stdoutp, "\n");

668

MapPartIdIntoName(a_partID, pname);

669

fprintf(STDOUT__stdoutp, " %s %s \n", hostutil_GetNameByINet(a_servID),

670

pname);

671

fprintf(STDOUT__stdoutp, " RWrite %10lu ROnly %10lu Backup %10lu \n",

672

(unsigned long)a_xInfoP->parentID,

673

(unsigned long)a_xInfoP->cloneID,

674

(unsigned long)a_xInfoP->backupID);

675

fprintf(STDOUT__stdoutp, " MaxQuota %10d K \n", a_xInfoP->maxquota);

676

677

t = a_xInfoP->creationDate;

678

fprintf(STDOUT__stdoutp, " Creation %s",

679

ctime(&t));

680

681

t = a_xInfoP->copyDate;

682

fprintf(STDOUT__stdoutp, " Copy %s",

683

ctime(&t));

684

685

t = a_xInfoP->backupDate;

686

if (!t)

687

fprintf(STDOUT__stdoutp, " Backup Never\n");

688

else

689

fprintf(STDOUT__stdoutp, " Backup %s",

690

ctime(&t));

691

692

t = a_xInfoP->accessDate;

693

if (t)

694

fprintf(STDOUT__stdoutp, " Last Access %s",

695

ctime(&t));

696

697

t = a_xInfoP->updateDate;

698

if (!t)

699

fprintf(STDOUT__stdoutp, " Last Update Never\n");

700

else

701

fprintf(STDOUT__stdoutp, " Last Update %s",

702

ctime(&t));

703

fprintf(STDOUT__stdoutp,

704

" %d accesses in the past day (i.e., vnode references)\n",

705

a_xInfoP->dayUse);

706

707

708

* Print all the read/write and authorship stats.

709

710

fprintf(STDOUT__stdoutp, "\n Raw Read/Write Stats\n");

711

fprintf(STDOUT__stdoutp,

712

" |-------------------------------------------|\n");

713

fprintf(STDOUT__stdoutp,

714

" | Same Network | Diff Network |\n");

715

fprintf(STDOUT__stdoutp,

716

" |----------|----------|----------|----------|\n");

717

fprintf(STDOUT__stdoutp,

718

719

fprintf(STDOUT__stdoutp,

720

" |----------|----------|----------|----------|\n");

721

fprintf(STDOUT__stdoutp, "Reads | %8d | %8d | %8d | %8d |\n",

722

a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET0],

723

a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET_AUTH1],

724

a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET2],

725

a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET_AUTH3]);

726

fprintf(STDOUT__stdoutp, "Writes | %8d | %8d | %8d | %8d |\n",

727

a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET0],

728

a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET_AUTH1],

729

a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET2],

730

a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET_AUTH3]);

731

fprintf(STDOUT__stdoutp,

732

" |-------------------------------------------|\n\n");

733

734

fprintf(STDOUT__stdoutp,

735

" Writes Affecting Authorship\n");

736

fprintf(STDOUT__stdoutp,

737

" |-------------------------------------------|\n");

738

fprintf(STDOUT__stdoutp,

739

" | File Authorship | Directory Authorship|\n");

740

fprintf(STDOUT__stdoutp,

741

" |----------|----------|----------|----------|\n");

742

fprintf(STDOUT__stdoutp,

743

744

fprintf(STDOUT__stdoutp,

745

" |----------|----------|----------|----------|\n");

746

fprintf(STDOUT__stdoutp, "0-60 sec | %8d | %8d | %8d | %8d |\n",

747

a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_00],

748

a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_00],

749

a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_00],

750

a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_00]);

751

fprintf(STDOUT__stdoutp, "1-10 min | %8d | %8d | %8d | %8d |\n",

752

a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_11],

753

a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_11],

754

a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_11],

755

a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_11]);

756

fprintf(STDOUT__stdoutp, "10min-1hr | %8d | %8d | %8d | %8d |\n",

757

a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_22],

758

a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_22],

759

a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_22],

760

a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_22]);

761

fprintf(STDOUT__stdoutp, "1hr-1day | %8d | %8d | %8d | %8d |\n",

762

a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_33],

763

a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_33],

764

a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_33],

765

a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_33]);

766

fprintf(STDOUT__stdoutp, "1day-1wk | %8d | %8d | %8d | %8d |\n",

767

a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_44],

768

a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_44],

769

a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_44],

770

a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_44]);

771

fprintf(STDOUT__stdoutp, "> 1wk | %8d | %8d | %8d | %8d |\n",

772

a_xInfoP->stat_fileSameAuthor[VOLINT_STATS_TIME_IDX_55],

773

a_xInfoP->stat_fileDiffAuthor[VOLINT_STATS_TIME_IDX_55],

774

a_xInfoP->stat_dirSameAuthor[VOLINT_STATS_TIME_IDX_55],

775

a_xInfoP->stat_dirDiffAuthor[VOLINT_STATS_TIME_IDX_55]);

776

fprintf(STDOUT__stdoutp,

777

" |-------------------------------------------|\n");

778

} /*Volume status OK */

779

else if (a_xInfoP->status == VBUSY110) {

780

(*a_totalBusyP)++;

781

qPut(&busyHead, a_xInfoP->volid);

782

if (a_showProblems)

783

fprintf(STDOUT__stdoutp, "**** Volume %lu is busy ****\n",

784

(unsigned long)a_xInfoP->volid);

785

} /*Busy volume */

786

else {

787

(*a_totalNotOKP)++;

788

qPut(&notokHead, a_xInfoP->volid);

789

if (a_showProblems)

790

fprintf(STDOUT__stdoutp, "**** Could not attach volume %lu ****\n",

791

(unsigned long)a_xInfoP->volid);

792

} /*Screwed volume */

793

fprintf(STDOUT__stdoutp, "\n");

794

} /*Long listing */

795

else {

796

797

* Default listing.

798

799

if (a_xInfoP->status == VOK0x02) {

800

fprintf(STDOUT__stdoutp, "%-32s ", a_xInfoP->name);

801

fprintf(STDOUT__stdoutp, "%10lu ", (unsigned long)a_xInfoP->volid);

802

if (a_xInfoP->type == 0)

803

fprintf(STDOUT__stdoutp, "RW ");

804

if (a_xInfoP->type == 1)

805

fprintf(STDOUT__stdoutp, "RO ");

806

if (a_xInfoP->type == 2)

807

fprintf(STDOUT__stdoutp, "BK ");

808

fprintf(STDOUT__stdoutp, "%10d K ", a_xInfoP->size);

809

if (a_xInfoP->inUse == 1) {

810

fprintf(STDOUT__stdoutp, "On-line");

811

(*a_totalOKP)++;

812

} else {

813

fprintf(STDOUT__stdoutp, "Off-line");

814

(*a_totalNotOKP)++;

815

}

816

fprintf(STDOUT__stdoutp, "\n");

817

} /*Volume OK */

818

else if (a_xInfoP->status == VBUSY110) {

819

(*a_totalBusyP)++;

820

qPut(&busyHead, a_xInfoP->volid);

821

if (a_showProblems)

822

fprintf(STDOUT__stdoutp, "**** Volume %lu is busy ****\n",

823

(unsigned long)a_xInfoP->volid);

824

} /*Busy volume */

825

else {

826

(*a_totalNotOKP)++;

827

qPut(&notokHead, a_xInfoP->volid);

828

if (a_showProblems)

829

fprintf(STDOUT__stdoutp, "**** Could not attach volume %lu ****\n",

830

(unsigned long)a_xInfoP->volid);

831

} /*Screwed volume */

832

} /*Default listing */

833

} /*XDisplayFormat */

834

835

/*------------------------------------------------------------------------

836

* PRIVATE XDisplayFormat2

837

838

* Description:

839

* Display the formated contents of one extended volume info structure.

840

841

* Arguments:

842

* a_xInfoP : Ptr to extended volume info struct to print.

843

* a_servID : Server ID to print.

844

* a_partID : Partition ID to print.

845

* a_totalOKP : Ptr to total-OK counter.

846

* a_totalNotOKP : Ptr to total-screwed counter.

847

* a_totalBusyP : Ptr to total-busy counter.

848

* a_fast : Fast listing?

849

* a_int32 : Int32 listing?

850

* a_showProblems : Show volume problems?

851

852

* Returns:

853

* Nothing.

854

855

* Environment:

856

* Nothing interesting.

857

858

* Side Effects:

859

* As advertised.

860

*------------------------------------------------------------------------*/

861

862

static void

863

XDisplayFormat2(volintXInfo *a_xInfoP, afs_uint32 a_servID, afs_int32 a_partID,

864

int *a_totalOKP, int *a_totalNotOKP, int *a_totalBusyP,

865

int a_fast, int a_int32, int a_showProblems)

866

{ /*XDisplayFormat */

867

time_t t;

868

if (a_fast) {

869

870

* Short & sweet.

871

872

fprintf(STDOUT__stdoutp, "vold_id\t%-10lu\n", (unsigned long)a_xInfoP->volid);

873

} else if (a_int32) {

874

875

* Fully-detailed listing.

876

877

if (a_xInfoP->status == VOK0x02) {

878

879

* Volume's status is OK - all the fields are valid.

880

881

882

static long server_cache = -1, partition_cache = -1;

883

static char hostname[256], address[32], pname[16];

884

int i,ai[] = {VOLINT_STATS_TIME_IDX_00,VOLINT_STATS_TIME_IDX_11,VOLINT_STATS_TIME_IDX_22,

885

VOLINT_STATS_TIME_IDX_33,VOLINT_STATS_TIME_IDX_44,VOLINT_STATS_TIME_IDX_55};

886

887

if (a_servID != server_cache) {

888

struct in_addr s;

889

890

s.s_addr = a_servID;

891

strcpy(hostname, hostutil_GetNameByINet(a_servID));

892

strcpy(address, inet_ntoa__inet_ntoa(s));

893

server_cache = a_servID;

894

}

895

if (a_partID != partition_cache) {

896

MapPartIdIntoName(a_partID, pname);

897

partition_cache = a_partID;

898

}

899

900

fprintf(STDOUT__stdoutp, "name\t\t%s\n", a_xInfoP->name);

901

fprintf(STDOUT__stdoutp, "id\t\t%lu\n", afs_printable_uint32_lu(a_xInfoP->volid));

902

fprintf(STDOUT__stdoutp, "serv\t\t%s\t%s\n", address, hostname);

903

fprintf(STDOUT__stdoutp, "part\t\t%s\n", pname);

904

fprintf(STDOUT__stdoutp, "status\t\tOK\n");

905

fprintf(STDOUT__stdoutp, "backupID\t%lu\n",

906

afs_printable_uint32_lu(a_xInfoP->backupID));

907

fprintf(STDOUT__stdoutp, "parentID\t%lu\n",

908

afs_printable_uint32_lu(a_xInfoP->parentID));

909

fprintf(STDOUT__stdoutp, "cloneID\t\t%lu\n",

910

afs_printable_uint32_lu(a_xInfoP->cloneID));

911

fprintf(STDOUT__stdoutp, "inUse\t\t%s\n", a_xInfoP->inUse ? "Y" : "N");

912

switch (a_xInfoP->type) {

913

case 0:

914

fprintf(STDOUT__stdoutp, "type\t\tRW\n");

915

break;

916

case 1:

917

fprintf(STDOUT__stdoutp, "type\t\tRO\n");

918

break;

919

case 2:

920

fprintf(STDOUT__stdoutp, "type\t\tBK\n");

921

break;

922

default:

923

fprintf(STDOUT__stdoutp, "type\t\t?\n");

924

break;

925

}

926

t = a_xInfoP->creationDate;

927

fprintf(STDOUT__stdoutp, "creationDate\t%-9lu\t%s",

928

afs_printable_uint32_lu(a_xInfoP->creationDate),

929

ctime(&t));

930

931

t = a_xInfoP->accessDate;

932

fprintf(STDOUT__stdoutp, "accessDate\t%-9lu\t%s",

933

afs_printable_uint32_lu(a_xInfoP->accessDate),

934

ctime(&t));

935

936

t = a_xInfoP->updateDate;

937

fprintf(STDOUT__stdoutp, "updateDate\t%-9lu\t%s",

938

afs_printable_uint32_lu(a_xInfoP->updateDate),

939

ctime(&t));

940

941

t = a_xInfoP->backupDate;

942

fprintf(STDOUT__stdoutp, "backupDate\t%-9lu\t%s",

943

afs_printable_uint32_lu(a_xInfoP->backupDate),

944

ctime(&t));

945

946

t = a_xInfoP->copyDate;

947

fprintf(STDOUT__stdoutp, "copyDate\t%-9lu\t%s",

948

afs_printable_uint32_lu(a_xInfoP->copyDate),

949

ctime(&t));

950

951

fprintf(STDOUT__stdoutp, "diskused\t%u\n", a_xInfoP->size);

952

fprintf(STDOUT__stdoutp, "maxquota\t%u\n", a_xInfoP->maxquota);

953

954

fprintf(STDOUT__stdoutp, "filecount\t%u\n", a_xInfoP->filecount);

955

fprintf(STDOUT__stdoutp, "dayUse\t\t%u\n", a_xInfoP->dayUse);

956

957

958

959

fprintf(STDOUT__stdoutp,"reads_same_net\t%8d\n",a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET0]);

960

fprintf(STDOUT__stdoutp,"reads_same_net_auth\t%8d\n",a_xInfoP->stat_reads[VOLINT_STATS_SAME_NET_AUTH1]);

961

fprintf(STDOUT__stdoutp,"reads_diff_net\t%8d\n",a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET2]);

962

fprintf(STDOUT__stdoutp,"reads_diff_net_auth\t%8d\n",a_xInfoP->stat_reads[VOLINT_STATS_DIFF_NET_AUTH3]);

963

964

fprintf(STDOUT__stdoutp,"writes_same_net\t%8d\n",a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET0]);

965

fprintf(STDOUT__stdoutp,"writes_same_net_auth\t%8d\n",a_xInfoP->stat_writes[VOLINT_STATS_SAME_NET_AUTH1]);

966

fprintf(STDOUT__stdoutp,"writes_diff_net\t%8d\n",a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET2]);

967

fprintf(STDOUT__stdoutp,"writes_diff_net_auth\t%8d\n",a_xInfoP->stat_writes[VOLINT_STATS_DIFF_NET_AUTH3]);

968

969

for(i=0;i<5;i++)

970

{

971

fprintf(STDOUT__stdoutp,"file_same_author_idx_%d\t%8d\n",i+1,a_xInfoP->stat_fileSameAuthor[ai[i]]);

972

fprintf(STDOUT__stdoutp,"file_diff_author_idx_%d\t%8d\n",i+1,a_xInfoP->stat_fileDiffAuthor[ai[i]]);

973

fprintf(STDOUT__stdoutp,"dir_same_author_idx_%d\t%8d\n",i+1,a_xInfoP->stat_dirSameAuthor[ai[i]]);

974

fprintf(STDOUT__stdoutp,"dir_dif_author_idx_%d\t%8d\n",i+1,a_xInfoP->stat_dirDiffAuthor[ai[i]]);

975

}

976

977

} /*Volume status OK */

978

else if (a_xInfoP->status == VBUSY110) {

979

(*a_totalBusyP)++;

980

qPut(&busyHead, a_xInfoP->volid);

981

if (a_showProblems)

982

fprintf(STDOUT__stdoutp, "BUSY_VOL\t%lu\n",

983

(unsigned long)a_xInfoP->volid);

984

} /*Busy volume */

985

else {

986

(*a_totalNotOKP)++;

987

qPut(&notokHead, a_xInfoP->volid);

988

if (a_showProblems)

989

fprintf(STDOUT__stdoutp, "COULD_NOT_ATTACH\t%lu\n",

990

(unsigned long)a_xInfoP->volid);

991

} /*Screwed volume */

992

} /*Long listing */

993

else {

994

995

* Default listing.

996

997

if (a_xInfoP->status == VOK0x02) {

998

fprintf(STDOUT__stdoutp, "name\t%-32s\n", a_xInfoP->name);

999

fprintf(STDOUT__stdoutp, "volID\t%10lu\n", (unsigned long)a_xInfoP->volid);

1000

if (a_xInfoP->type == 0)

1001

fprintf(STDOUT__stdoutp, "type\tRW\n");

1002

if (a_xInfoP->type == 1)

1003

fprintf(STDOUT__stdoutp, "type\tRO\n");

1004

if (a_xInfoP->type == 2)

1005

fprintf(STDOUT__stdoutp, "type\tBK\n");

1006

fprintf(STDOUT__stdoutp, "size\t%10dK\n", a_xInfoP->size);

1007

1008

fprintf(STDOUT__stdoutp, "inUse\t%d\n",a_xInfoP->inUse);

1009

if (a_xInfoP->inUse == 1)

1010

(*a_totalOKP)++;

1011

else

1012

(*a_totalNotOKP)++;

1013

1014

} /*Volume OK */

1015

else if (a_xInfoP->status == VBUSY110) {

1016

(*a_totalBusyP)++;

1017

qPut(&busyHead, a_xInfoP->volid);

1018

if (a_showProblems)

1019

fprintf(STDOUT__stdoutp, "VOLUME_BUSY\t%lu\n",

1020

(unsigned long)a_xInfoP->volid);

1021

} /*Busy volume */

1022

else {

1023

(*a_totalNotOKP)++;

1024

qPut(&notokHead, a_xInfoP->volid);

1025

if (a_showProblems)

1026

fprintf(STDOUT__stdoutp, "COULD_NOT_ATTACH_VOLUME\t%lu\n",

1027

(unsigned long)a_xInfoP->volid);

1028

} /*Screwed volume */

1029

} /*Default listing */

1030

} /*XDisplayFormat */

1031

1032

static void

1033

DisplayFormat2(long server, long partition, volintInfo *pntr)

1034

{

1035

static long server_cache = -1, partition_cache = -1;

1036

static char hostname[256], address[32], pname[16];

1037

time_t t;

1038

1039

if (server != server_cache) {

1040

struct in_addr s;

1041

1042

s.s_addr = server;

1043

strcpy(hostname, hostutil_GetNameByINet(server));

1044

strcpy(address, inet_ntoa__inet_ntoa(s));

1045

server_cache = server;

1046

}

1047

if (partition != partition_cache) {

1048

MapPartIdIntoName(partition, pname);

1049

partition_cache = partition;

1050

}

1051

1052

if (pntr->status == VOK0x02)

1053

fprintf(STDOUT__stdoutp, "name\t\t%s\n", pntr->name);

1054

1055

fprintf(STDOUT__stdoutp, "id\t\t%lu\n",

1056

afs_printable_uint32_lu(pntr->volid));

1057

fprintf(STDOUT__stdoutp, "serv\t\t%s\t%s\n", address, hostname);

1058

fprintf(STDOUT__stdoutp, "part\t\t%s\n", pname);

1059

switch (pntr->status) {

1060

case VOK0x02:

1061

fprintf(STDOUT__stdoutp, "status\t\tOK\n");

1062

break;

1063

case VBUSY110:

1064

fprintf(STDOUT__stdoutp, "status\t\tBUSY\n");

1065

return;

1066

default:

1067

fprintf(STDOUT__stdoutp, "status\t\tUNATTACHABLE\n");

1068

return;

1069

}

1070

fprintf(STDOUT__stdoutp, "backupID\t%lu\n",

1071

afs_printable_uint32_lu(pntr->backupID));

1072

fprintf(STDOUT__stdoutp, "parentID\t%lu\n",

1073

afs_printable_uint32_lu(pntr->parentID));

1074

fprintf(STDOUT__stdoutp, "cloneID\t\t%lu\n",

1075

afs_printable_uint32_lu(pntr->cloneID));

1076

fprintf(STDOUT__stdoutp, "inUse\t\t%s\n", pntr->inUse ? "Y" : "N");

1077

fprintf(STDOUT__stdoutp, "needsSalvaged\t%s\n", pntr->needsSalvaged ? "Y" : "N");

1078

/* 0xD3 is from afs/volume.h since I had trouble including the file */

1079

fprintf(STDOUT__stdoutp, "destroyMe\t%s\n", pntr->destroyMe == 0xD3 ? "Y" : "N");

1080

switch (pntr->type) {

1081

case 0:

1082

fprintf(STDOUT__stdoutp, "type\t\tRW\n");

1083

break;

1084

case 1:

1085

fprintf(STDOUT__stdoutp, "type\t\tRO\n");

1086

break;

1087

case 2:

1088

fprintf(STDOUT__stdoutp, "type\t\tBK\n");

1089

break;

1090

default:

1091

fprintf(STDOUT__stdoutp, "type\t\t?\n");

1092

break;

1093

}

1094

t = pntr->creationDate;

1095

fprintf(STDOUT__stdoutp, "creationDate\t%-9lu\t%s",

1096

afs_printable_uint32_lu(pntr->creationDate),

1097

ctime(&t));

1098

1099

t = pntr->accessDate;

1100

fprintf(STDOUT__stdoutp, "accessDate\t%-9lu\t%s",

1101

afs_printable_uint32_lu(pntr->accessDate),

1102

ctime(&t));

1103

1104

t = pntr->updateDate;

1105

fprintf(STDOUT__stdoutp, "updateDate\t%-9lu\t%s",

1106

afs_printable_uint32_lu(pntr->updateDate),

1107

ctime(&t));

1108

1109

t = pntr->backupDate;

1110

fprintf(STDOUT__stdoutp, "backupDate\t%-9lu\t%s",

1111

afs_printable_uint32_lu(pntr->backupDate),

1112

ctime(&t));

1113

1114

t = pntr->copyDate;

1115

fprintf(STDOUT__stdoutp, "copyDate\t%-9lu\t%s",

1116

afs_printable_uint32_lu(pntr->copyDate),

1117

ctime(&t));

1118

1119

fprintf(STDOUT__stdoutp, "flags\t\t%#lx\t(Optional)\n",

1120

afs_printable_uint32_lu(pntr->flags));

1121

fprintf(STDOUT__stdoutp, "diskused\t%u\n", pntr->size);

1122

fprintf(STDOUT__stdoutp, "maxquota\t%u\n", pntr->maxquota);

1123

fprintf(STDOUT__stdoutp, "minquota\t%lu\t(Optional)\n",

1124

afs_printable_uint32_lu(pntr->spare0));

1125

fprintf(STDOUT__stdoutp, "filecount\t%u\n", pntr->filecount);

1126

fprintf(STDOUT__stdoutp, "dayUse\t\t%u\n", pntr->dayUse);

1127

fprintf(STDOUT__stdoutp, "weekUse\t\t%lu\t(Optional)\n",

1128

afs_printable_uint32_lu(pntr->spare1));

1129

fprintf(STDOUT__stdoutp, "spare2\t\t%lu\t(Optional)\n",

1130

afs_printable_uint32_lu(pntr->spare2));

1131

fprintf(STDOUT__stdoutp, "spare3\t\t%lu\t(Optional)\n",

1132

afs_printable_uint32_lu(pntr->spare3));

1133

return;

1134

}

1135

1136

static void

1137

DisplayVolumes2(long server, long partition, volintInfo *pntr, long count)

1138

{

1139

long i;

1140

1141

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

1142

fprintf(STDOUT__stdoutp, "BEGIN_OF_ENTRY\n");

1143

DisplayFormat2(server, partition, pntr);

1144

fprintf(STDOUT__stdoutp, "END_OF_ENTRY\n\n");

1145

pntr++;

1146

}

1147

return;

1148

}

1149

1150

static void

1151

DisplayVolumes(afs_uint32 server, afs_int32 part, volintInfo *pntr,

1152

afs_int32 count, afs_int32 longlist, afs_int32 fast,

1153

int quiet)

1154

{

1155

int totalOK, totalNotOK, totalBusy, i;

1156

afs_uint32 volid = 0;

1157

1158

totalOK = 0;

1159

totalNotOK = 0;

1160

totalBusy = 0;

1161

qInit(&busyHead);

1162

qInit(&notokHead);

1163

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

1164

DisplayFormat(pntr, server, part, &totalOK, &totalNotOK, &totalBusy,

1165

fast, longlist, 0);

1166

pntr++;

1167

}

1168

if (totalBusy) {

1169

while (busyHead.count) {

1170

qGet(&busyHead, &volid);

1171

fprintf(STDOUT__stdoutp, "**** Volume %lu is busy ****\n",

1172

(unsigned long)volid);

1173

}

1174

}

1175

if (totalNotOK) {

1176

while (notokHead.count) {

1177

qGet(&notokHead, &volid);

1178

fprintf(STDOUT__stdoutp, "**** Could not attach volume %lu ****\n",

1179

(unsigned long)volid);

1180

}

1181

}

1182

if (!quiet) {

1183

fprintf(STDOUT__stdoutp, "\n");

1184

if (!fast) {

1185

fprintf(STDOUT__stdoutp,

1186

"Total volumes onLine %d ; Total volumes offLine %d ; Total busy %d\n\n",

1187

totalOK, totalNotOK, totalBusy);

1188

}

1189

}

1190

}

1191

/*------------------------------------------------------------------------

1192

* PRIVATE XDisplayVolumes

1193

1194

* Description:

1195

* Display extended volume information.

1196

1197

* Arguments:

1198

* a_servID : Pointer to the Rx call we're performing.

1199

* a_partID : Partition for which we want the extended list.

1200

* a_xInfoP : Ptr to extended volume info.

1201

* a_count : Number of volume records contained above.

1202

* a_int32 : Int32 listing generated?

1203

* a_fast : Fast listing generated?

1204

* a_quiet : Quiet listing generated?

1205

1206

* Returns:

1207

* Nothing.

1208

1209

* Environment:

1210

* Nothing interesting.

1211

1212

* Side Effects:

1213

* As advertised.

1214

*------------------------------------------------------------------------*/

1215

1216

static void

1217

XDisplayVolumes(afs_uint32 a_servID, afs_int32 a_partID, volintXInfo *a_xInfoP,

1218

afs_int32 a_count, afs_int32 a_int32, afs_int32 a_fast,

1219

int a_quiet)

1220

{ /*XDisplayVolumes */

1221

1222

int totalOK; /*Total OK volumes */

1223

int totalNotOK; /*Total screwed volumes */

1224

int totalBusy; /*Total busy volumes */

1225

int i; /*Loop variable */

1226

afs_uint32 volid = 0; /*Current volume ID */

1227

1228

1229

* Initialize counters and (global!!) queues.

1230

1231

totalOK = 0;

1232

totalNotOK = 0;

1233

totalBusy = 0;

1234

qInit(&busyHead);

1235

qInit(&notokHead);

1236

1237

1238

* Display each volume in the list.

1239

1240

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

1241

XDisplayFormat(a_xInfoP, a_servID, a_partID, &totalOK, &totalNotOK,

1242

&totalBusy, a_fast, a_int32, 0);

1243

a_xInfoP++;

1244

}

1245

1246

1247

* If any volumes were found to be busy or screwed, display them.

1248

1249

if (totalBusy) {

1250

while (busyHead.count) {

1251

qGet(&busyHead, &volid);

1252

fprintf(STDOUT__stdoutp, "**** Volume %lu is busy ****\n",

1253

(unsigned long)volid);

1254

}

1255

}

1256

if (totalNotOK) {

1257

while (notokHead.count) {

1258

qGet(&notokHead, &volid);

1259

fprintf(STDOUT__stdoutp, "**** Could not attach volume %lu ****\n",

1260

(unsigned long)volid);

1261

}

1262

}

1263

1264

if (!a_quiet) {

1265

fprintf(STDOUT__stdoutp, "\n");

1266

if (!a_fast) {

1267

fprintf(STDOUT__stdoutp,

1268

"Total volumes: %d on-line, %d off-line, %d busyd\n\n",

1269

totalOK, totalNotOK, totalBusy);

1270

}

1271

}

1272

1273

} /*XDisplayVolumes */

1274

1275

/*------------------------------------------------------------------------

1276

* PRIVATE XDisplayVolumes2

1277

1278

* Description:

1279

* Display extended formated volume information.

1280

1281

* Arguments:

1282

* a_servID : Pointer to the Rx call we're performing.

1283

* a_partID : Partition for which we want the extended list.

1284

* a_xInfoP : Ptr to extended volume info.

1285

* a_count : Number of volume records contained above.

1286

* a_int32 : Int32 listing generated?

1287

* a_fast : Fast listing generated?

1288

* a_quiet : Quiet listing generated?

1289

1290

* Returns:

1291

* Nothing.

1292

1293

* Environment:

1294

* Nothing interesting.

1295

1296

* Side Effects:

1297

* As advertised.

1298

*------------------------------------------------------------------------*/

1299

1300

static void

1301

XDisplayVolumes2(afs_uint32 a_servID, afs_int32 a_partID, volintXInfo *a_xInfoP,

1302

afs_int32 a_count, afs_int32 a_int32, afs_int32 a_fast,

1303

int a_quiet)

1304

{ /*XDisplayVolumes */

1305

1306

int totalOK; /*Total OK volumes */

1307

int totalNotOK; /*Total screwed volumes */

1308

int totalBusy; /*Total busy volumes */

1309

int i; /*Loop variable */

1310

afs_uint32 volid = 0; /*Current volume ID */

1311

1312

1313

* Initialize counters and (global!!) queues.

1314

1315

totalOK = 0;

1316

totalNotOK = 0;

1317

totalBusy = 0;

1318

qInit(&busyHead);

1319

qInit(&notokHead);

1320

1321

1322

* Display each volume in the list.

1323

1324

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

1325

fprintf(STDOUT__stdoutp, "BEGIN_OF_ENTRY\n");

1326

XDisplayFormat2(a_xInfoP, a_servID, a_partID, &totalOK, &totalNotOK,

1327

&totalBusy, a_fast, a_int32, 0);

1328

fprintf(STDOUT__stdoutp, "END_OF_ENTRY\n");

1329

a_xInfoP++;

1330

}

1331

1332

1333

* If any volumes were found to be busy or screwed, display them.

1334

1335

if (totalBusy) {

1336

while (busyHead.count) {

1337

qGet(&busyHead, &volid);

1338

fprintf(STDOUT__stdoutp, "BUSY_VOL\t%lu\n",

1339

(unsigned long)volid);

1340

}

1341

}

1342

if (totalNotOK) {

1343

while (notokHead.count) {

1344

qGet(&notokHead, &volid);

1345

fprintf(STDOUT__stdoutp, "COULD_NOT_ATTACH\t%lu\n",

1346

(unsigned long)volid);

1347

}

1348

}

1349

1350

if (!a_quiet) {

1351

fprintf(STDOUT__stdoutp, "\n");

1352

if (!a_fast) {

1353

fprintf(STDOUT__stdoutp,

1354

"VOLUMES_ONLINE\t%d\nVOLUMES_OFFLINE\t%d\nVOLUMES_BUSY\t%d\n",

1355

totalOK, totalNotOK, totalBusy);

1356

}

1357

}

1358

1359

} /*XDisplayVolumes2 */

1360

1361

1362

/* set <server> and <part> to the correct values depending on

1363

* <voltype> and <entry> */

1364

static void

1365

GetServerAndPart(struct nvldbentry *entry, int voltype, afs_uint32 *server,

1366

afs_int32 *part, int *previdx)

1367

{

1368

int i, istart, vtype;

1369

1370

*server = -1;

1371

*part = -1;

1372

1373

/* Doesn't check for non-existance of backup volume */

1374

if ((voltype == RWVOL0) || (voltype == BACKVOL2)) {

1375

vtype = ITSRWVOL0x04;

1376

istart = 0; /* seach the entire entry */

1377

} else {

1378

vtype = ITSROVOL0x02;

1379

/* Seach from beginning of entry or pick up where we left off */

1380

istart = ((*previdx < 0) ? 0 : *previdx + 1);

1381

}

1382

1383

for (i = istart; i < entry->nServers; i++) {

1384

if (entry->serverFlags[i] & vtype) {

1385

*server = entry->serverNumber[i];

1386

*part = entry->serverPartition[i];

1387

*previdx = i;

1388

return;

1389

}

1390

}

1391

1392

/* Didn't find any, return -1 */

1393

*previdx = -1;

1394

return;

1395

}

1396

1397

static void

1398

PrintLocked(afs_int32 aflags)

1399

{

1400

afs_int32 flags = aflags & VLOP_ALLOPERS( 0x10 | 0x20 | 0x40 | 0x80 | 0x100);

1401

1402

if (flags) {

1403

fprintf(STDOUT__stdoutp, " Volume is currently LOCKED \n");

1404

1405

if (flags & VLOP_MOVE0x10) {

1406

fprintf(STDOUT__stdoutp, " Volume is locked for a move operation\n");

1407

}

1408

if (flags & VLOP_RELEASE0x20) {

1409

fprintf(STDOUT__stdoutp, " Volume is locked for a release operation\n");

1410

}

1411

if (flags & VLOP_BACKUP0x40) {

1412

fprintf(STDOUT__stdoutp, " Volume is locked for a backup operation\n");

1413

}

1414

if (flags & VLOP_DELETE0x80) {

1415

fprintf(STDOUT__stdoutp, " Volume is locked for a delete/misc operation\n");

1416

}

1417

if (flags & VLOP_DUMP0x100) {

1418

fprintf(STDOUT__stdoutp, " Volume is locked for a dump/restore operation\n");

1419

}

1420

}

1421

}

1422

1423

static void

1424

PostVolumeStats(struct nvldbentry *entry)

1425

{

1426

SubEnumerateEntry(entry);

1427

/* Check for VLOP_ALLOPERS */

1428

PrintLocked(entry->flags);

1429

return;

1430

}

1431

1432

/*------------------------------------------------------------------------

1433

* PRIVATE XVolumeStats

1434

1435

* Description:

1436

* Display extended volume information.

1437

1438

* Arguments:

1439

* a_xInfoP : Ptr to extended volume info.

1440

* a_entryP : Ptr to the volume's VLDB entry.

1441

* a_srvID : Server ID.

1442

* a_partID : Partition ID.

1443

* a_volType : Type of volume to print.

1444

1445

* Returns:

1446

* Nothing.

1447

1448

* Environment:

1449

* Nothing interesting.

1450

1451

* Side Effects:

1452

* As advertised.

1453

*------------------------------------------------------------------------*/

1454

1455

static void

1456

XVolumeStats(volintXInfo *a_xInfoP, struct nvldbentry *a_entryP,

1457

afs_int32 a_srvID, afs_int32 a_partID, int a_volType)

1458

{ /*XVolumeStats */

1459

1460

int totalOK, totalNotOK, totalBusy; /*Dummies - we don't really count here */

1461

1462

XDisplayFormat(a_xInfoP, /*Ptr to extended volume info */

1463

a_srvID, /*Server ID to print */

1464

a_partID, /*Partition ID to print */

1465

&totalOK, /*Ptr to total-OK counter */

1466

&totalNotOK, /*Ptr to total-screwed counter */

1467

&totalBusy, /*Ptr to total-busy counter */

1468

0, /*Don't do a fast listing */

1469

1, /*Do a long listing */

1470

1); /*Show volume problems */

1471

return;

1472

1473

} /*XVolumeStats */

1474

1475

static void

1476

VolumeStats_int(volintInfo *pntr, struct nvldbentry *entry, afs_uint32 server,

1477

afs_int32 part, int voltype)

1478

{

1479

int totalOK, totalNotOK, totalBusy;

1480

1481

DisplayFormat(pntr, server, part, &totalOK, &totalNotOK, &totalBusy, 0, 1,

1482

1);

1483

return;

1484

}

1485

1486

/* command to forcibly remove a volume */

1487

static int

1488

NukeVolume(struct cmd_syndesc *as)

1489

{

1490

afs_int32 code;

1491

afs_uint32 volID;

1492

afs_int32 err;

1493

afs_int32 partID;

1494

afs_uint32 server;

1495

char *tp;

1496

1497

server = GetServer(tp = as->parms[0].items->data);

1498

if (!server) {

1499

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n", tp);

1500

return 1;

1501

}

1502

1503

partID = volutil_GetPartitionID(tp = as->parms[1].items->data);

1504

if (partID == -1) {

1505

fprintf(STDERR__stderrp, "vos: could not parse '%s' as a partition name", tp);

1506

return 1;

1507

}

1508

1509

volID = vsu_GetVolumeID(tp = as->parms[2].items->data, cstruct, &err);

1510

if (volID == 0) {

1511

if (err)

1512

PrintError("", err);

1513

else

1514

fprintf(STDERR__stderrp,

1515

"vos: could not parse '%s' as a numeric volume ID", tp);

1516

return 1;

1517

}

1518

1519

fprintf(STDOUT__stdoutp,

1520

"vos: forcibly removing all traces of volume %d, please wait...",

1521

volID);

1522

fflush(STDOUT__stdoutp);

1523

code = UV_NukeVolume(server, partID, volID);

1524

if (code == 0)

1525

fprintf(STDOUT__stdoutp, "done.\n");

1526

else

1527

fprintf(STDOUT__stdoutp, "failed with code %d.\n", code);

1528

return code;

1529

}

1530

1531

1532

/*------------------------------------------------------------------------

1533

* PRIVATE ExamineVolume

1534

1535

* Description:

1536

* Routine used to examine a single volume, contacting the VLDB as

1537

* well as the Volume Server.

1538

1539

* Arguments:

1540

* as : Ptr to parsed command line arguments.

1541

1542

* Returns:

1543

* 0 for a successful operation,

1544

* Otherwise, one of the ubik or VolServer error values.

1545

1546

* Environment:

1547

* Nothing interesting.

1548

1549

* Side Effects:

1550

* As advertised.

1551

*------------------------------------------------------------------------

1552

1553

static int

1554

ExamineVolume(struct cmd_syndesc *as, void *arock)

1555

{

1556

struct nvldbentry entry;

1557

afs_int32 vcode = 0;

1558

volintInfo *pntr = (volintInfo *) 0;

1559

volintXInfo *xInfoP = (volintXInfo *) 0;

1560

afs_uint32 volid;

1561

afs_int32 code, err, error = 0;

1562

int voltype, foundserv = 0, foundentry = 0;

1563

afs_uint32 aserver;

1564

afs_int32 apart;

1565

int previdx = -1;

1566

int wantExtendedInfo; /*Do we want extended vol info? */

1567

int isSubEnum=0; /* Keep track whether sub enumerate called. */

1568

wantExtendedInfo = (as->parms[1].items ? 1 : 0); /* -extended */

1569

1570

volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err); /* -id */

1571

if (volid == 0) {

1572

if (err)

1573

PrintError("", err);

1574

else

1575

fprintf(STDERR__stderrp, "Unknown volume ID or name '%s'\n",

1576

as->parms[0].items->data);

1577

return -1;

1578

}

1579

1580

if (verbose) {

1581

fprintf(STDOUT__stdoutp, "Fetching VLDB entry for %lu .. ",

1582

(unsigned long)volid);

1583

fflush(STDOUT__stdoutp);

1584

}

1585

vcode = VLDB_GetEntryByID(volid, -1, &entry);

1586

if (vcode) {

1587

fprintf(STDERR__stderrp,

1588

"Could not fetch the entry for volume number %lu from VLDB \n",

1589

(unsigned long)volid);

1590

return (vcode);

1591

}

1592

if (verbose)

1593

fprintf(STDOUT__stdoutp, "done\n");

1594

MapHostToNetwork(&entry);

1595

1596

if (entry.volumeId[RWVOL0] == volid)

1597

voltype = RWVOL0;

1598

else if (entry.volumeId[BACKVOL2] == volid)

1599

voltype = BACKVOL2;

1600

else /* (entry.volumeId[ROVOL] == volid) */

1601

voltype = ROVOL1;

1602

1603

do { /* do {...} while (voltype == ROVOL) */

1604

/* Get the entry for the volume. If its a RW vol, get the RW entry.

1605

* It its a BK vol, get the RW entry (even if VLDB may say the BK doen't exist).

1606

* If its a RO vol, get the next RO entry.

1607

1608

GetServerAndPart(&entry, ((voltype == ROVOL1) ? ROVOL1 : RWVOL0),

1609

&aserver, &apart, &previdx);

1610

if (previdx == -1) { /* searched all entries */

1611

if (!foundentry) {

1612

fprintf(STDERR__stderrp, "Volume %s does not exist in VLDB\n\n",

1613

as->parms[0].items->data);

1614

error = ENOENT2;

1615

}

1616

break;

1617

}

1618

foundentry = 1;

1619

1620

/* Get information about the volume from the server */

1621

if (verbose) {

1622

fprintf(STDOUT__stdoutp, "Getting volume listing from the server %s .. ",

1623

hostutil_GetNameByINet(aserver));

1624

fflush(STDOUT__stdoutp);

1625

}

1626

if (wantExtendedInfo)

1627

code = UV_XListOneVolume(aserver, apart, volid, &xInfoP);

1628

else

1629

code = UV_ListOneVolume(aserver, apart, volid, &pntr);

1630

if (verbose)

1631

fprintf(STDOUT__stdoutp, "done\n");

1632

1633

if (code) {

1634

error = code;

1635

if (code == ENODEV19) {

1636

if ((voltype == BACKVOL2) && !(entry.flags & BACK_EXISTS0x4000)) {

1637

/* The VLDB says there is no backup volume and its not on disk */

1638

fprintf(STDERR__stderrp, "Volume %s does not exist\n",

1639

as->parms[0].items->data);

1640

error = ENOENT2;

1641

} else {

1642

fprintf(STDERR__stderrp,

1643

"Volume does not exist on server %s as indicated by the VLDB\n",

1644

hostutil_GetNameByINet(aserver));

1645

}

1646

} else {

1647

PrintDiagnostics("examine", code);

1648

}

1649

fprintf(STDOUT__stdoutp, "\n");

1650

} else {

1651

foundserv = 1;

1652

if (wantExtendedInfo)

1653

XVolumeStats(xInfoP, &entry, aserver, apart, voltype);

1654

else if (as->parms[2].items) {

1655

DisplayFormat2(aserver, apart, pntr);

1656

EnumerateEntry(&entry);

1657

isSubEnum = 1;

1658

} else

1659

VolumeStats_int(pntr, &entry, aserver, apart, voltype);

1660

1661

if ((voltype == BACKVOL2) && !(entry.flags & BACK_EXISTS0x4000)) {

1662

/* The VLDB says there is no backup volume yet we found one on disk */

1663

fprintf(STDERR__stderrp, "Volume %s does not exist in VLDB\n",

1664

as->parms[0].items->data);

1665

error = ENOENT2;

1666

}

1667

}

1668

1669

if (pntr)

1670

free(pntr);

1671

if (xInfoP)

1672

free(xInfoP);

1673

} while (voltype == ROVOL1);

1674

1675

if (!foundserv) {

1676

fprintf(STDERR__stderrp, "Dump only information from VLDB\n\n");

1677

fprintf(STDOUT__stdoutp, "%s \n", entry.name); /* PostVolumeStats doesn't print name */

1678

}

1679

1680

if (!isSubEnum)

1681

PostVolumeStats(&entry);

1682

1683

return (error);

1684

}

1685

1686

/*------------------------------------------------------------------------

1687

* PRIVATE SetFields

1688

1689

* Description:

1690

* Routine used to change the status of a single volume.

1691

1692

* Arguments:

1693

* as : Ptr to parsed command line arguments.

1694

1695

* Returns:

1696

* 0 for a successful operation,

1697

* Otherwise, one of the ubik or VolServer error values.

1698

1699

* Environment:

1700

* Nothing interesting.

1701

1702

* Side Effects:

1703

* As advertised.

1704

*------------------------------------------------------------------------

1705

1706

static int

1707

SetFields(struct cmd_syndesc *as, void *arock)

1708

{

1709

struct nvldbentry entry;

1710

volintInfo info;

1711

afs_uint32 volid;

1712

afs_int32 code, err;

1713

afs_uint32 aserver;

1714

afs_int32 apart;

1715

int previdx = -1;

1716

1717

volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err); /* -id */

1718

if (volid == 0) {

1719

if (err)

1720

PrintError("", err);

1721

else

1722

fprintf(STDERR__stderrp, "Unknown volume ID or name '%s'\n",

1723

as->parms[0].items->data);

1724

return -1;

1725

}

1726

1727

code = VLDB_GetEntryByID(volid, RWVOL0, &entry);

1728

if (code) {

1729

fprintf(STDERR__stderrp,

1730

"Could not fetch the entry for volume number %lu from VLDB \n",

1731

(unsigned long)volid);

1732

return (code);

1733

}

1734

MapHostToNetwork(&entry);

1735

1736

GetServerAndPart(&entry, RWVOL0, &aserver, &apart, &previdx);

1737

if (previdx == -1) {

1738

fprintf(STDERR__stderrp, "Volume %s does not exist in VLDB\n\n",

1739

as->parms[0].items->data);

1740

return (ENOENT2);

1741

}

1742

1743

init_volintInfo(&info);

1744

info.volid = volid;

1745

info.type = RWVOL0;

1746

1747

if (as->parms[1].items) {

1748

/* -max <quota> */

1749

code = util_GetHumanInt32(as->parms[1].items->data, &info.maxquota);

1750

if (code) {

1751

fprintf(STDERR__stderrp, "invalid quota value\n");

1752

return code;

1753

}

1754

}

1755

if (as->parms[2].items) {

1756

/* -clearuse */

1757

info.dayUse = 0;

1758

}

1759

if (as->parms[3].items) {

1760

/* -clearVolUpCounter */

1761

info.spare2 = 0;

1762

}

1763

code = UV_SetVolumeInfo(aserver, apart, volid, &info);

1764

if (code)

1765

fprintf(STDERR__stderrp,

1766

"Could not update volume info fields for volume number %lu\n",

1767

(unsigned long)volid);

1768

return (code);

1769

}

1770

1771

/*------------------------------------------------------------------------

1772

* PRIVATE volOnline

1773

1774

* Description:

1775

* Brings a volume online.

1776

1777

* Arguments:

1778

* as : Ptr to parsed command line arguments.

1779

1780

* Returns:

1781

* 0 for a successful operation,

1782

1783

* Environment:

1784

* Nothing interesting.

1785

1786

* Side Effects:

1787

* As advertised.

1788

*------------------------------------------------------------------------

1789

1790

static int

1791

volOnline(struct cmd_syndesc *as, void *arock)

1792

{

1793

afs_uint32 server;

1794

afs_int32 partition;

1795

afs_uint32 volid;

1796

afs_int32 code, err = 0;

1797

1798

server = GetServer(as->parms[0].items->data);

1799

if (server == 0) {

1800

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

1801

as->parms[0].items->data);

1802

return -1;

1803

}

1804

1805

partition = volutil_GetPartitionID(as->parms[1].items->data);

1806

if (partition < 0) {

1807

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

1808

as->parms[1].items->data);

1809

return ENOENT2;

1810

}

1811

1812

volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err); /* -id */

1813

if (!volid) {

1814

if (err)

1815

PrintError("", err);

1816

else

1817

fprintf(STDERR__stderrp, "Unknown volume ID or name '%s'\n",

1818

as->parms[0].items->data);

1819

return -1;

1820

}

1821

1822

code = UV_SetVolume(server, partition, volid, ITOffline1, 0 /*online */ ,

1823

0 /*sleep */ );

1824

if (code) {

1825

fprintf(STDERR__stderrp, "Failed to set volume. Code = %d\n", code);

1826

return -1;

1827

}

1828

1829

return 0;

1830

}

1831

1832

/*------------------------------------------------------------------------

1833

* PRIVATE volOffline

1834

1835

* Description:

1836

* Brings a volume offline.

1837

1838

* Arguments:

1839

* as : Ptr to parsed command line arguments.

1840

1841

* Returns:

1842

* 0 for a successful operation,

1843

1844

* Environment:

1845

* Nothing interesting.

1846

1847

* Side Effects:

1848

* As advertised.

1849

*------------------------------------------------------------------------

1850

1851

static int

1852

volOffline(struct cmd_syndesc *as, void *arock)

1853

{

1854

afs_uint32 server;

1855

afs_int32 partition;

1856

afs_uint32 volid;

1857

afs_int32 code, err = 0;

1858

afs_int32 transflag, sleeptime, transdone;

1859

1860

server = GetServer(as->parms[0].items->data);

1861

if (server == 0) {

1862

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

1863

as->parms[0].items->data);

1864

return -1;

1865

}

1866

1867

partition = volutil_GetPartitionID(as->parms[1].items->data);

1868

if (partition < 0) {

1869

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

1870

as->parms[1].items->data);

1871

return ENOENT2;

1872

}

1873

1874

volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err); /* -id */

1875

if (!volid) {

1876

if (err)

1877

PrintError("", err);

1878

else

1879

fprintf(STDERR__stderrp, "Unknown volume ID or name '%s'\n",

1880

as->parms[0].items->data);

1881

return -1;

1882

}

1883

1884

transflag = (as->parms[4].items ? ITBusy2 : ITOffline1);

1885

sleeptime = (as->parms[3].items ? atol(as->parms[3].items->data) : 0);

1886

transdone = (sleeptime ? 0 /*online */ : VTOutOfService2);

1887

if (as->parms[4].items && !as->parms[3].items) {

1888

fprintf(STDERR__stderrp, "-sleep option must be used with -busy flag\n");

1889

return -1;

1890

}

1891

1892

code =

1893

UV_SetVolume(server, partition, volid, transflag, transdone,

1894

sleeptime);

1895

if (code) {

1896

fprintf(STDERR__stderrp, "Failed to set volume. Code = %d\n", code);

1897

return -1;

1898

}

1899

1900

return 0;

1901

}

1902

1903

static int

1904

CreateVolume(struct cmd_syndesc *as, void *arock)

1905

{

1906

afs_int32 pnum;

1907

char part[10];

1908

afs_uint32 volid = 0, rovolid = 0, bkvolid = 0;

1909

afs_uint32 *arovolid;

1910

afs_int32 code;

1911

struct nvldbentry entry;

1912

afs_int32 vcode;

1913

afs_int32 quota;

1914

1915

arovolid = &rovolid;

1916

1917

quota = 5000;

1918

tserver = GetServer(as->parms[0].items->data);

1919

if (!tserver) {

1920

fprintf(STDERR__stderrp, "vos: host '%s' not found in host table\n",

1921

as->parms[0].items->data);

1922

return ENOENT2;

1923

}

1924

pnum = volutil_GetPartitionID(as->parms[1].items->data);

1925

if (pnum < 0) {

1926

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

1927

as->parms[1].items->data);

1928

return ENOENT2;

1929

}

1930

if (!IsPartValid(pnum, tserver, &code)) { /*check for validity of the partition */

1931

if (code)

1932

PrintError("", code);

1933

else

1934

fprintf(STDERR__stderrp,

1935

"vos : partition %s does not exist on the server\n",

1936

as->parms[1].items->data);

1937

return ENOENT2;

1938

}

1939

if (!ISNAMEVALID(as->parms[2].items->data)(strlen(as->parms[2].items->data) < (32 - 9))) {

1940

fprintf(STDERR__stderrp,

1941

"vos: the name of the root volume %s exceeds the size limit of %d\n",

1942

as->parms[2].items->data, VOLSER_OLDMAXVOLNAME32 - 10);

1943

return E2BIG7;

1944

}

1945

if (!VolNameOK(as->parms[2].items->data)) {

1946

fprintf(STDERR__stderrp,

1947

"Illegal volume name %s, should not end in .readonly or .backup\n",

1948

as->parms[2].items->data);

1949

return EINVAL22;

1950

}

1951

if (IsNumeric(as->parms[2].items->data)) {

1952

fprintf(STDERR__stderrp, "Illegal volume name %s, should not be a number\n",

1953

as->parms[2].items->data);

1954

return EINVAL22;

1955

}

1956

vcode = VLDB_GetEntryByName(as->parms[2].items->data, &entry);

1957

if (!vcode) {

1958

fprintf(STDERR__stderrp, "Volume %s already exists\n",

1959

as->parms[2].items->data);

1960

PrintDiagnostics("create", code);

1961

return EEXIST17;

1962

}

1963

1964

if (as->parms[3].items) {

1965

code = util_GetHumanInt32(as->parms[3].items->data, &quota);

1966

if (code) {

1967

fprintf(STDERR__stderrp, "vos: bad integer specified for quota.\n");

1968

return code;

1969

}

1970

}

1971

1972

if (as->parms[4].items) {

1973

if (!IsNumeric(as->parms[4].items->data)) {

1974

fprintf(STDERR__stderrp, "vos: Given volume ID %s should be numeric.\n",

1975

as->parms[4].items->data);

1976

return EINVAL22;

1977

}

1978

1979

code = util_GetUInt32(as->parms[4].items->data, &volid);

1980

if (code) {

1981

fprintf(STDERR__stderrp, "vos: bad integer specified for volume ID.\n");

1982

return code;

1983

}

1984

}

1985

1986

if (as->parms[5].items) {

1987

if (!IsNumeric(as->parms[5].items->data)) {

1988

fprintf(STDERR__stderrp, "vos: Given RO volume ID %s should be numeric.\n",

1989

as->parms[5].items->data);

1990

return EINVAL22;

1991

}

1992

1993

code = util_GetUInt32(as->parms[5].items->data, &rovolid);

1994

if (code) {

1995

fprintf(STDERR__stderrp, "vos: bad integer specified for volume ID.\n");

1996

return code;

1997

}

1998

1999

if (rovolid == 0) {

2000

arovolid = NULL((void *)0);

2001

}

2002

}

2003

2004

code =

2005

UV_CreateVolume3(tserver, pnum, as->parms[2].items->data, quota, 0,

2006

0, 0, 0, &volid, arovolid, &bkvolid);

2007

if (code) {

2008

PrintDiagnostics("create", code);

2009

return code;

2010

}

2011

MapPartIdIntoName(pnum, part);

2012

fprintf(STDOUT__stdoutp, "Volume %lu created on partition %s of %s\n",

2013

(unsigned long)volid, part, as->parms[0].items->data);

2014

2015

return 0;

2016

}

2017

2018

#if 0

2019

static afs_int32

2020

DeleteAll(struct nvldbentry *entry)

2021

{

2022

int i;

2023

afs_int32 error, code, curserver, curpart;

2024

afs_uint32 volid;

2025

2026

MapHostToNetwork(entry);

2027

error = 0;

2028

for (i = 0; i < entry->nServers; i++) {

2029

curserver = entry->serverNumber[i];

2030

curpart = entry->serverPartition[i];

2031

if (entry->serverFlags[i] & ITSROVOL0x02) {

2032

volid = entry->volumeId[ROVOL1];

2033

} else {

2034

volid = entry->volumeId[RWVOL0];

2035

}

2036

code = UV_DeleteVolume(curserver, curpart, volid);

2037

if (code && !error)

2038

error = code;

2039

}

2040

return error;

2041

}

2042

#endif

2043

2044

static int

2045

DeleteVolume(struct cmd_syndesc *as, void *arock)

2046

{

2047

afs_int32 err, code = 0;

2048

afs_uint32 server = 0;

2049

afs_int32 partition = -1;

2050

afs_uint32 volid;

2051

char pname[10];

2052

afs_int32 idx, j;

2053

2054

if (as->parms[0].items) {

2055

server = GetServer(as->parms[0].items->data);

2056

if (!server) {

2057

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

2058

as->parms[0].items->data);

2059

return ENOENT2;

2060

}

2061

}

2062

2063

if (as->parms[1].items) {

2064

partition = volutil_GetPartitionID(as->parms[1].items->data);

2065

if (partition < 0) {

2066

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

2067

as->parms[1].items->data);

2068

return EINVAL22;

2069

}

2070

2071

/* Check for validity of the partition */

2072

if (!IsPartValid(partition, server, &code)) {

2073

if (code) {

2074

PrintError("", code);

2075

} else {

2076

fprintf(STDERR__stderrp,

2077

"vos : partition %s does not exist on the server\n",

2078

as->parms[1].items->data);

2079

}

2080

return ENOENT2;

2081

}

2082

}

2083

2084

volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);

2085

if (volid == 0) {

2086

fprintf(STDERR__stderrp, "Can't find volume name '%s' in VLDB\n",

2087

as->parms[2].items->data);

2088

if (err)

2089

PrintError("", err);

2090

return ENOENT2;

2091

}

2092

2093

/* If the server or partition option are not complete, try to fill

2094

* them in from the VLDB entry.

2095

2096

if ((partition == -1) || !server) {

2097

struct nvldbentry entry;

2098

2099

code = VLDB_GetEntryByID(volid, -1, &entry);

2100

if (code) {

2101

fprintf(STDERR__stderrp,

2102

"Could not fetch the entry for volume %lu from VLDB\n",

2103

(unsigned long)volid);

2104

PrintError("", code);

2105

return (code);

2106

}

2107

2108

if (((volid == entry.volumeId[RWVOL0]) && (entry.flags & RW_EXISTS0x1000))

2109

|| ((volid == entry.volumeId[BACKVOL2])

2110

&& (entry.flags & BACK_EXISTS0x4000))) {

2111

idx = Lp_GetRwIndex(&entry);

2112

if ((idx == -1) || (server && (server != entry.serverNumber[idx]))

2113

|| ((partition != -1)

2114

&& (partition != entry.serverPartition[idx]))) {

2115

fprintf(STDERR__stderrp, "VLDB: Volume '%s' no match\n",

2116

as->parms[2].items->data);

2117

return ENOENT2;

2118

}

2119

} else if ((volid == entry.volumeId[ROVOL1])

2120

&& (entry.flags & RO_EXISTS0x2000)) {

2121

for (idx = -1, j = 0; j < entry.nServers; j++) {

2122

if (entry.serverFlags[j] != ITSROVOL0x02)

2123

continue;

2124

2125

if (((server == 0) || (server == entry.serverNumber[j]))

2126

&& ((partition == -1)

2127

|| (partition == entry.serverPartition[j]))) {

2128

if (idx != -1) {

2129

fprintf(STDERR__stderrp,

2130

"VLDB: Volume '%s' matches more than one RO\n",

2131

as->parms[2].items->data);

2132

return ENOENT2;

2133

}

2134

idx = j;

2135

}

2136

}

2137

if (idx == -1) {

2138

fprintf(STDERR__stderrp, "VLDB: Volume '%s' no match\n",

2139

as->parms[2].items->data);

2140

return ENOENT2;

2141

}

2142

} else {

2143

fprintf(STDERR__stderrp, "VLDB: Volume '%s' no match\n",

2144

as->parms[2].items->data);

2145

return ENOENT2;

2146

}

2147

2148

server = htonl(entry.serverNumber[idx])(__builtin_constant_p(entry.serverNumber[idx]) ? ((((__uint32_t
)(entry.serverNumber[idx])) >> 24) | ((((__uint32_t)(entry
.serverNumber[idx])) & (0xff << 16)) >> 8) | (
(((__uint32_t)(entry.serverNumber[idx])) & (0xff <<
8)) << 8) | (((__uint32_t)(entry.serverNumber[idx])) <<
24)) : __bswap32_var(entry.serverNumber[idx]));

2149

partition = entry.serverPartition[idx];

2150

}

2151

2152

2153

code = UV_DeleteVolume(server, partition, volid);

2154

if (code) {

2155

PrintDiagnostics("remove", code);

2156

return code;

2157

}

2158

2159

MapPartIdIntoName(partition, pname);

2160

fprintf(STDOUT__stdoutp, "Volume %lu on partition %s server %s deleted\n",

2161

(unsigned long)volid, pname, hostutil_GetNameByINet(server));

2162

return 0;

2163

}

2164

2165

#define TESTM0 0 /* set for move space tests, clear for production */

2166

static int

2167

MoveVolume(struct cmd_syndesc *as, void *arock)

2168

{

2169

2170

afs_uint32 volid;

2171

afs_uint32 fromserver, toserver;

2172

afs_int32 frompart, topart;

2173

afs_int32 flags, code, err;

2174

char fromPartName[10], toPartName[10];

2175

2176

struct diskPartition64 partition; /* for space check */

2177

volintInfo *p;

2178

2179

volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

2180

if (volid == 0) {

2181

if (err)

2182

PrintError("", err);

2183

else

2184

fprintf(STDERR__stderrp, "vos: can't find volume ID or name '%s'\n",

2185

as->parms[0].items->data);

2186

return ENOENT2;

2187

}

2188

fromserver = GetServer(as->parms[1].items->data);

2189

if (fromserver == 0) {

2190

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

2191

as->parms[1].items->data);

2192

return ENOENT2;

2193

}

2194

toserver = GetServer(as->parms[3].items->data);

2195

if (toserver == 0) {

2196

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

2197

as->parms[3].items->data);

2198

return ENOENT2;

2199

}

2200

frompart = volutil_GetPartitionID(as->parms[2].items->data);

2201

if (frompart < 0) {

2202

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

2203

as->parms[2].items->data);

2204

return EINVAL22;

2205

}

2206

if (!IsPartValid(frompart, fromserver, &code)) { /*check for validity of the partition */

2207

if (code)

2208

PrintError("", code);

2209

else

2210

fprintf(STDERR__stderrp,

2211

"vos : partition %s does not exist on the server\n",

2212

as->parms[2].items->data);

2213

return ENOENT2;

2214

}

2215

topart = volutil_GetPartitionID(as->parms[4].items->data);

2216

if (topart < 0) {

2217

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

2218

as->parms[4].items->data);

2219

return EINVAL22;

2220

}

2221

if (!IsPartValid(topart, toserver, &code)) { /*check for validity of the partition */

2222

if (code)

2223

PrintError("", code);

2224

else

2225

fprintf(STDERR__stderrp,

2226

"vos : partition %s does not exist on the server\n",

2227

as->parms[4].items->data);

2228

return ENOENT2;

2229

}

2230

2231

flags = 0;

2232

if (as->parms[5].items) flags |= RV_NOCLONE0x080000;

2233

2234

2235

* check source partition for space to clone volume

2236

2237

2238

MapPartIdIntoName(topart, toPartName);

2239

MapPartIdIntoName(frompart, fromPartName);

2240

2241

2242

* check target partition for space to move volume

2243

2244

2245

code = UV_PartitionInfo64(toserver, toPartName, &partition);

2246

if (code) {

2247

fprintf(STDERR__stderrp, "vos: cannot access partition %s\n", toPartName);

2248

exit(1);

2249

}

2250

if (TESTM0)

2251

fprintf(STDOUT__stdoutp, "target partition %s free space %" AFS_INT64_FMT"lld" "\n", toPartName,

2252

partition.free);

2253

2254

p = (volintInfo *) 0;

2255

code = UV_ListOneVolume(fromserver, frompart, volid, &p);

2256

if (code) {

2257

fprintf(STDERR__stderrp, "vos:cannot access volume %lu\n",

2258

(unsigned long)volid);

2259

exit(1);

2260

}

2261

if (TESTM0)

2262

fprintf(STDOUT__stdoutp, "volume %lu size %d\n", (unsigned long)volid,

2263

p->size);

2264

if (partition.free <= p->size) {

2265

fprintf(STDERR__stderrp,

2266

"vos: no space on target partition %s to move volume %lu\n",

2267

toPartName, (unsigned long)volid);

2268

free(p);

2269

exit(1);

2270

}

2271

free(p);

2272

2273

if (TESTM0) {

2274

fprintf(STDOUT__stdoutp, "size test - don't do move\n");

2275

exit(0);

2276

}

2277

2278

/* successful move still not guaranteed but shoot for it */

2279

2280

code =

2281

UV_MoveVolume2(volid, fromserver, frompart, toserver, topart, flags);

2282

if (code) {

2283

PrintDiagnostics("move", code);

2284

return code;

2285

}

2286

MapPartIdIntoName(topart, toPartName);

2287

MapPartIdIntoName(frompart, fromPartName);

2288

fprintf(STDOUT__stdoutp, "Volume %lu moved from %s %s to %s %s \n",

2289

(unsigned long)volid, as->parms[1].items->data, fromPartName,

2290

as->parms[3].items->data, toPartName);

2291

2292

return 0;

2293

}

2294

2295

static int

2296

CopyVolume(struct cmd_syndesc *as, void *arock)

2297

{

2298

afs_uint32 volid;

2299

afs_uint32 fromserver, toserver;

2300

afs_int32 frompart, topart, code, err, flags;

2301

char fromPartName[10], toPartName[10], *tovolume;

2302

struct nvldbentry entry;

2303

struct diskPartition64 partition; /* for space check */

2304

volintInfo *p;

2305

2306

volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

2307

if (volid == 0) {

2308

if (err)

2309

PrintError("", err);

2310

else

2311

fprintf(STDERR__stderrp, "vos: can't find volume ID or name '%s'\n",

2312

as->parms[0].items->data);

2313

return ENOENT2;

2314

}

2315

fromserver = GetServer(as->parms[1].items->data);

2316

if (fromserver == 0) {

2317

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

2318

as->parms[1].items->data);

2319

return ENOENT2;

2320

}

2321

2322

toserver = GetServer(as->parms[4].items->data);

2323

if (toserver == 0) {

2324

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

2325

as->parms[4].items->data);

2326

return ENOENT2;

2327

}

2328

2329

tovolume = as->parms[3].items->data;

2330

if (!ISNAMEVALID(tovolume)(strlen(tovolume) < (32 - 9))) {

2331

fprintf(STDERR__stderrp,

2332

"vos: the name of the root volume %s exceeds the size limit of %d\n",

2333

tovolume, VOLSER_OLDMAXVOLNAME32 - 10);

2334

return E2BIG7;

2335

}

2336

if (!VolNameOK(tovolume)) {

2337

fprintf(STDERR__stderrp,

2338

"Illegal volume name %s, should not end in .readonly or .backup\n",

2339

tovolume);

2340

return EINVAL22;

2341

}

2342

if (IsNumeric(tovolume)) {

2343

fprintf(STDERR__stderrp, "Illegal volume name %s, should not be a number\n",

2344

tovolume);

2345

return EINVAL22;

2346

}

2347

code = VLDB_GetEntryByName(tovolume, &entry);

2348

if (!code) {

2349

fprintf(STDERR__stderrp, "Volume %s already exists\n", tovolume);

2350

PrintDiagnostics("copy", code);

2351

return EEXIST17;

2352

}

2353

2354

frompart = volutil_GetPartitionID(as->parms[2].items->data);

2355

if (frompart < 0) {

2356

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

2357

as->parms[2].items->data);

2358

return EINVAL22;

2359

}

2360

if (!IsPartValid(frompart, fromserver, &code)) { /*check for validity of the partition */

2361

if (code)

2362

PrintError("", code);

2363

else

2364

fprintf(STDERR__stderrp,

2365

"vos : partition %s does not exist on the server\n",

2366

as->parms[2].items->data);

2367

return ENOENT2;

2368

}

2369

2370

topart = volutil_GetPartitionID(as->parms[5].items->data);

2371

if (topart < 0) {

2372

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

2373

as->parms[5].items->data);

2374

return EINVAL22;

2375

}

2376

if (!IsPartValid(topart, toserver, &code)) { /*check for validity of the partition */

2377

if (code)

2378

PrintError("", code);

2379

else

2380

fprintf(STDERR__stderrp,

2381

"vos : partition %s does not exist on the server\n",

2382

as->parms[5].items->data);

2383

return ENOENT2;

2384

}

2385

2386

flags = 0;

2387

if (as->parms[6].items) flags |= RV_OFFLINE0x000002;

2388

if (as->parms[7].items) flags |= RV_RDONLY0x010000;

2389

if (as->parms[8].items) flags |= RV_NOCLONE0x080000;

2390

2391

MapPartIdIntoName(topart, toPartName);

2392

MapPartIdIntoName(frompart, fromPartName);

2393

2394

2395

* check target partition for space to move volume

2396

2397

2398

code = UV_PartitionInfo64(toserver, toPartName, &partition);

2399

if (code) {

2400

fprintf(STDERR__stderrp, "vos: cannot access partition %s\n", toPartName);

2401

exit(1);

2402

}

2403

if (TESTM0)

2404

fprintf(STDOUT__stdoutp, "target partition %s free space %" AFS_INT64_FMT"lld" "\n", toPartName,

2405

partition.free);

2406

2407

p = (volintInfo *) 0;

2408

code = UV_ListOneVolume(fromserver, frompart, volid, &p);

2409

if (code) {

2410

fprintf(STDERR__stderrp, "vos:cannot access volume %lu\n",

2411

(unsigned long)volid);

2412

exit(1);

2413

}

2414

2415

if (partition.free <= p->size) {

2416

fprintf(STDERR__stderrp,

2417

"vos: no space on target partition %s to copy volume %lu\n",

2418

toPartName, (unsigned long)volid);

2419

free(p);

2420

exit(1);

2421

}

2422

free(p);

2423

2424

/* successful copy still not guaranteed but shoot for it */

2425

2426

code =

2427

UV_CopyVolume2(volid, fromserver, frompart, tovolume, toserver,

2428

topart, 0, flags);

2429

if (code) {

2430

PrintDiagnostics("copy", code);

2431

return code;

2432

}

2433

MapPartIdIntoName(topart, toPartName);

2434

MapPartIdIntoName(frompart, fromPartName);

2435

fprintf(STDOUT__stdoutp, "Volume %lu copied from %s %s to %s on %s %s \n",

2436

(unsigned long)volid, as->parms[1].items->data, fromPartName,

2437

tovolume, as->parms[4].items->data, toPartName);

2438

2439

return 0;

2440

}

2441

2442

2443

static int

2444

ShadowVolume(struct cmd_syndesc *as, void *arock)

2445

{

2446

afs_uint32 volid, tovolid;

2447

afs_uint32 fromserver, toserver;

2448

afs_int32 frompart, topart;

2449

afs_int32 code, err, flags;

2450

char fromPartName[10], toPartName[10], toVolName[32], *tovolume;

2451

struct diskPartition64 partition; /* for space check */

2452

volintInfo *p, *q;

2453

2454

p = (volintInfo *) 0;

2455

q = (volintInfo *) 0;

2456

2457

volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

2458

if (volid == 0) {

2459

if (err)

2460

PrintError("", err);

2461

else

2462

fprintf(STDERR__stderrp, "vos: can't find volume ID or name '%s'\n",

2463

as->parms[0].items->data);

2464

return ENOENT2;

2465

}

2466

fromserver = GetServer(as->parms[1].items->data);

2467

if (fromserver == 0) {

2468

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

2469

as->parms[1].items->data);

2470

return ENOENT2;

2471

}

2472

2473

toserver = GetServer(as->parms[3].items->data);

2474

if (toserver == 0) {

2475

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

2476

as->parms[3].items->data);

2477

return ENOENT2;

2478

}

2479

2480

frompart = volutil_GetPartitionID(as->parms[2].items->data);

2481

if (frompart < 0) {

2482

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

2483

as->parms[2].items->data);

2484

return EINVAL22;

2485

}

2486

if (!IsPartValid(frompart, fromserver, &code)) { /*check for validity of the partition */

2487

if (code)

2488

PrintError("", code);

2489

else

2490

fprintf(STDERR__stderrp,

2491

"vos : partition %s does not exist on the server\n",

2492

as->parms[2].items->data);

2493

return ENOENT2;

2494

}

2495

2496

topart = volutil_GetPartitionID(as->parms[4].items->data);

2497

if (topart < 0) {

2498

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

2499

as->parms[4].items->data);

2500

return EINVAL22;

2501

}

2502

if (!IsPartValid(topart, toserver, &code)) { /*check for validity of the partition */

2503

if (code)

2504

PrintError("", code);

2505

else

2506

fprintf(STDERR__stderrp,

2507

"vos : partition %s does not exist on the server\n",

2508

as->parms[4].items->data);

2509

return ENOENT2;

2510

}

2511

2512

if (as->parms[5].items) {

2513

tovolume = as->parms[5].items->data;

2514

if (!ISNAMEVALID(tovolume)(strlen(tovolume) < (32 - 9))) {

2515

fprintf(STDERR__stderrp,

2516

"vos: the name of the root volume %s exceeds the size limit of %d\n",

2517

tovolume, VOLSER_OLDMAXVOLNAME32 - 10);

2518

return E2BIG7;

2519

}

2520

if (!VolNameOK(tovolume)) {

2521

fprintf(STDERR__stderrp,

2522

"Illegal volume name %s, should not end in .readonly or .backup\n",

2523

tovolume);

2524

return EINVAL22;

2525

}

2526

if (IsNumeric(tovolume)) {

2527

fprintf(STDERR__stderrp,

2528

"Illegal volume name %s, should not be a number\n",

2529

tovolume);

2530

return EINVAL22;

2531

}

2532

} else {

2533

/* use actual name of source volume */

2534

code = UV_ListOneVolume(fromserver, frompart, volid, &p);

2535

if (code) {

2536

fprintf(STDERR__stderrp, "vos:cannot access volume %lu\n",

2537

(unsigned long)volid);

2538

exit(1);

2539

}

2540

strcpy(toVolName, p->name);

2541

tovolume = toVolName;

2542

/* save p for size checks later */

2543

}

2544

2545

if (as->parms[6].items) {

2546

tovolid = vsu_GetVolumeID(as->parms[6].items->data, cstruct, &err);

2547

if (tovolid == 0) {

2548

if (err)

2549

PrintError("", err);

2550

else

2551

fprintf(STDERR__stderrp, "vos: can't find volume ID or name '%s'\n",

2552

as->parms[6].items->data);

2553

if (p)

2554

free(p);

2555

return ENOENT2;

2556

}

2557

} else {

2558

tovolid = vsu_GetVolumeID(tovolume, cstruct, &err);

2559

if (tovolid == 0) {

2560

if (err)

2561

PrintError("", err);

2562

else

2563

fprintf(STDERR__stderrp, "vos: can't find volume ID or name '%s'\n",

2564

tovolume);

2565

if (p)

2566

free(p);

2567

return ENOENT2;

2568

}

2569

}

2570

2571

flags = RV_NOVLDB0x040000;

2572

if (as->parms[7].items) flags |= RV_OFFLINE0x000002;

2573

if (as->parms[8].items) flags |= RV_RDONLY0x010000;

2574

if (as->parms[9].items) flags |= RV_NOCLONE0x080000;

2575

if (as->parms[10].items) flags |= RV_CPINCR0x020000;

2576

2577

MapPartIdIntoName(topart, toPartName);

2578

MapPartIdIntoName(frompart, fromPartName);

2579

2580

2581

* check target partition for space to move volume

2582

2583

2584

code = UV_PartitionInfo64(toserver, toPartName, &partition);

2585

if (code) {

2586

fprintf(STDERR__stderrp, "vos: cannot access partition %s\n", toPartName);

2587

exit(1);

2588

}

2589

if (TESTM0)

2590

fprintf(STDOUT__stdoutp, "target partition %s free space %" AFS_INT64_FMT"lld" "\n", toPartName,

2591

partition.free);

2592

2593

/* Don't do this again if we did it above */

2594

if (!p) {

2595

code = UV_ListOneVolume(fromserver, frompart, volid, &p);

2596

if (code) {

2597

fprintf(STDERR__stderrp, "vos:cannot access volume %lu\n",

2598

(unsigned long)volid);

2599

exit(1);

2600

}

2601

}

2602

2603

/* OK if this fails */

2604

code = UV_ListOneVolume(toserver, topart, tovolid, &q);

2605

2606

/* Treat existing volume size as "free" */

2607

if (q)

2608

p->size = (q->size < p->size) ? p->size - q->size : 0;

2609

2610

if (partition.free <= p->size) {

2611

fprintf(STDERR__stderrp,

2612

"vos: no space on target partition %s to copy volume %lu\n",

2613

toPartName, (unsigned long)volid);

2614

free(p);

2615

if (q) free(q);

2616

exit(1);

2617

}

2618

free(p);

2619

if (q) free(q);

2620

2621

/* successful copy still not guaranteed but shoot for it */

2622

2623

code =

2624

UV_CopyVolume2(volid, fromserver, frompart, tovolume, toserver,

2625

topart, tovolid, flags);

2626

if (code) {

2627

PrintDiagnostics("shadow", code);

2628

return code;

2629

}

2630

MapPartIdIntoName(topart, toPartName);

2631

MapPartIdIntoName(frompart, fromPartName);

2632

fprintf(STDOUT__stdoutp, "Volume %lu shadowed from %s %s to %s %s \n",

2633

(unsigned long)volid, as->parms[1].items->data, fromPartName,

2634

as->parms[3].items->data, toPartName);

2635

2636

return 0;

2637

}

2638

2639

2640

static int

2641

CloneVolume(struct cmd_syndesc *as, void *arock)

2642

{

2643

afs_uint32 volid, cloneid;

2644

afs_uint32 server;

2645

afs_int32 part, voltype;

2646

char partName[10], *volname;

2647

afs_int32 code, err, flags;

2648

struct nvldbentry entry;

2649

2650

volid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

2651

if (volid == 0) {

2652

if (err)

2653

PrintError("", err);

2654

else

2655

fprintf(STDERR__stderrp, "vos: can't find volume ID or name '%s'\n",

2656

as->parms[0].items->data);

2657

return ENOENT2;

2658

}

2659

2660

if (as->parms[1].items || as->parms[2].items) {

2661

if (!as->parms[1].items || !as->parms[2].items) {

2662

fprintf(STDERR__stderrp,

2663

"Must specify both -server and -partition options\n");

2664

return -1;

2665

}

2666

server = GetServer(as->parms[1].items->data);

2667

if (server == 0) {

2668

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

2669

as->parms[1].items->data);

2670

return ENOENT2;

2671

}

2672

part = volutil_GetPartitionID(as->parms[2].items->data);

2673

if (part < 0) {

2674

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

2675

as->parms[2].items->data);

2676

return EINVAL22;

2677

}

2678

if (!IsPartValid(part, server, &code)) { /*check for validity of the partition */

2679

if (code)

2680

PrintError("", code);

2681

else

2682

fprintf(STDERR__stderrp,

2683

"vos : partition %s does not exist on the server\n",

2684

as->parms[2].items->data);

2685

return ENOENT2;

2686

}

2687

} else {

2688

code = GetVolumeInfo(volid, &server, &part, &voltype, &entry);

2689

if (code)

2690

return code;

2691

}

2692

2693

volname = 0;

2694

if (as->parms[3].items) {

2695

volname = as->parms[3].items->data;

2696

if (strlen(volname) > VOLSER_OLDMAXVOLNAME32 - 1) {

2697

fprintf(STDERR__stderrp,

2698

"vos: the name of the root volume %s exceeds the size limit of %d\n",

2699

volname, VOLSER_OLDMAXVOLNAME32 - 1);

2700

return E2BIG7;

2701

}

2702

#if 0

2703

2704

* In order that you be able to make clones of RO or BK, this

2705

* check must be omitted.

2706

2707

if (!VolNameOK(volname)) {

2708

fprintf(STDERR__stderrp,

2709

"Illegal volume name %s, should not end in .readonly or .backup\n",

2710

volname);

2711

return EINVAL22;

2712

}

2713

#endif

2714

if (IsNumeric(volname)) {

2715

fprintf(STDERR__stderrp,

2716

"Illegal volume name %s, should not be a number\n",

2717

volname);

2718

return EINVAL22;

2719

}

2720

}

2721

2722

cloneid = 0;

2723

if (as->parms[4].items) {

2724

cloneid = vsu_GetVolumeID(as->parms[4].items->data, cstruct, &err);

2725

if (cloneid == 0) {

2726

if (err)

2727

PrintError("", err);

2728

else

2729

fprintf(STDERR__stderrp, "vos: can't find volume ID or name '%s'\n",

2730

as->parms[4].items->data);

2731

return ENOENT2;

2732

}

2733

}

2734

2735

flags = 0;

2736

if (as->parms[5].items) flags |= RV_OFFLINE0x000002;

2737

if (as->parms[6].items) flags |= RV_RDONLY0x010000;

2738

2739

2740

code =

2741

UV_CloneVolume(server, part, volid, cloneid, volname, flags);

2742

2743

if (code) {

2744

PrintDiagnostics("clone", code);

2745

return code;

2746

}

2747

MapPartIdIntoName(part, partName);

2748

fprintf(STDOUT__stdoutp, "Created clone for volume %s\n",

2749

as->parms[0].items->data);

2750

2751

return 0;

2752

}

2753

2754

2755

static int

2756

BackupVolume(struct cmd_syndesc *as, void *arock)

2757

{

2758

afs_uint32 avolid;

2759

afs_uint32 aserver;

2760

afs_int32 apart, vtype, code, err;

2761

struct nvldbentry entry;

2762

2763

afs_uint32 buvolid;

2764

afs_uint32 buserver;

2765

afs_int32 bupart, butype;

2766

struct nvldbentry buentry;

2767

2768

avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

2769

if (avolid == 0) {

2770

if (err)

2771

PrintError("", err);

2772

else

2773

fprintf(STDERR__stderrp, "vos: can't find volume ID or name '%s'\n",

2774

as->parms[0].items->data);

2775

return ENOENT2;

2776

}

2777

code = GetVolumeInfo(avolid, &aserver, &apart, &vtype, &entry);

2778

if (code)

2779

exit(1);

2780

2781

/* verify this is a readwrite volume */

2782

2783

if (vtype != RWVOL0) {

2784

fprintf(STDERR__stderrp, "%s not RW volume\n", as->parms[0].items->data);

2785

exit(1);

2786

}

2787

2788

/* is there a backup volume already? */

2789

2790

if (entry.flags & BACK_EXISTS0x4000) {

2791

/* yep, where is it? */

2792

2793

buvolid = entry.volumeId[BACKVOL2];

2794

code = GetVolumeInfo(buvolid, &buserver, &bupart, &butype, &buentry);

2795

if (code)

2796

exit(1);

2797

2798

/* is it local? */

2799

code = VLDB_IsSameAddrs(buserver, aserver, &err);

2800

if (err) {

2801

fprintf(STDERR__stderrp,

2802

"Failed to get info about server's %d address(es) from vlserver; aborting call!\n",

2803

buserver);

2804

exit(1);

2805

}

2806

if (!code) {

2807

fprintf(STDERR__stderrp,

2808

"FATAL ERROR: backup volume %lu exists on server %lu\n",

2809

(unsigned long)buvolid, (unsigned long)buserver);

2810

exit(1);

2811

}

2812

}

2813

2814

/* nope, carry on */

2815

2816

code = UV_BackupVolume(aserver, apart, avolid);

2817

2818

if (code) {

2819

PrintDiagnostics("backup", code);

2820

return code;

2821

}

2822

fprintf(STDOUT__stdoutp, "Created backup volume for %s \n",

2823

as->parms[0].items->data);

2824

return 0;

2825

}

2826

2827

static int

2828

ReleaseVolume(struct cmd_syndesc *as, void *arock)

2829

{

2830

2831

struct nvldbentry entry;

2832

afs_uint32 avolid;

2833

afs_uint32 aserver;

2834

afs_int32 apart, vtype, code, err;

2835

int force = 0;

2836

2837

if (as->parms[1].items)

2838

force = 1;

2839

avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

2840

if (avolid == 0) {

2841

if (err)

2842

PrintError("", err);

2843

else

2844

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

2845

as->parms[0].items->data);

2846

return ENOENT2;

2847

}

2848

code = GetVolumeInfo(avolid, &aserver, &apart, &vtype, &entry);

2849

if (code)

2850

return code;

2851

2852

if (vtype != RWVOL0) {

2853

fprintf(STDERR__stderrp, "%s not a RW volume\n", as->parms[0].items->data);

2854

return (ENOENT2);

2855

}

2856

2857

if (!ISNAMEVALID(entry.name)(strlen(entry.name) < (32 - 9))) {

2858

fprintf(STDERR__stderrp,

2859

"Volume name %s is too long, rename before releasing\n",

2860

entry.name);

2861

return E2BIG7;

2862

}

2863

2864

code = UV_ReleaseVolume(avolid, aserver, apart, force);

2865

if (code) {

2866

PrintDiagnostics("release", code);

2867

return code;

2868

}

2869

fprintf(STDOUT__stdoutp, "Released volume %s successfully\n",

2870

as->parms[0].items->data);

2871

return 0;

2872

}

2873

2874

static int

2875

DumpVolumeCmd(struct cmd_syndesc *as, void *arock)

2876

{

2877

afs_uint32 avolid;

2878

afs_uint32 aserver;

2879

afs_int32 apart, voltype, fromdate = 0, code, err, i, flags;

2880

char filename[MAXPATHLEN1024];

2881

struct nvldbentry entry;

2882

2883

rx_SetRxDeadTime(60 * 10)(rx_connDeadTime = (60 * 10));

2884

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

2885

struct rx_connection *rxConn = ubik_GetRPCConn(cstruct, i)((i) >= 20? 0 : (cstruct)->conns[i]);

2886

if (rxConn == 0)

2887

break;

2888

rx_SetConnDeadTime(rxConn, rx_connDeadTime);

2889

if (rxConn->service)

2890

rxConn->service->connDeadTime = rx_connDeadTime;

2891

}

2892

2893

avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

2894

if (avolid == 0) {

2895

if (err)

2896

PrintError("", err);

2897

else

2898

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

2899

as->parms[0].items->data);

2900

return ENOENT2;

2901

}

2902

2903

if (as->parms[3].items || as->parms[4].items) {

2904

if (!as->parms[3].items || !as->parms[4].items) {

2905

fprintf(STDERR__stderrp,

2906

"Must specify both -server and -partition options\n");

2907

return -1;

2908

}

2909

aserver = GetServer(as->parms[3].items->data);

2910

if (aserver == 0) {

2911

fprintf(STDERR__stderrp, "Invalid server name\n");

2912

return -1;

2913

}

2914

apart = volutil_GetPartitionID(as->parms[4].items->data);

2915

if (apart < 0) {

2916

fprintf(STDERR__stderrp, "Invalid partition name\n");

2917

return -1;

2918

}

2919

} else {

2920

code = GetVolumeInfo(avolid, &aserver, &apart, &voltype, &entry);

2921

if (code)

2922

return code;

2923

}

2924

2925

if (as->parms[1].items && strcmp(as->parms[1].items->data, "0")) {

2926

code = ktime_DateToInt32(as->parms[1].items->data, &fromdate);

2927

if (code) {

2928

fprintf(STDERR__stderrp, "vos: failed to parse date '%s' (error=%d))\n",

2929

as->parms[1].items->data, code);

2930

return code;

2931

}

2932

}

2933

if (as->parms[2].items) {

2934

strcpy(filename, as->parms[2].items->data);

2935

} else {

2936

strcpy(filename, "");

2937

}

2938

2939

flags = as->parms[6].items ? VOLDUMPV2_OMITDIRS1 : 0;

2940

retry_dump:

2941

if (as->parms[5].items) {

2942

code =

2943

UV_DumpClonedVolume(avolid, aserver, apart, fromdate,

2944

DumpFunction, filename, flags);

2945

} else {

2946

code =

2947

UV_DumpVolume(avolid, aserver, apart, fromdate, DumpFunction,

2948

filename, flags);

2949

}

2950

if ((code == RXGEN_OPCODE-455) && (as->parms[6].items)) {

2951

flags &= ~VOLDUMPV2_OMITDIRS1;

2952

goto retry_dump;

2953

}

2954

if (code) {

2955

PrintDiagnostics("dump", code);

2956

return code;

2957

}

2958

if (strcmp(filename, ""))

2959

fprintf(STDERR__stderrp, "Dumped volume %s in file %s\n",

2960

as->parms[0].items->data, filename);

2961

else

2962

fprintf(STDERR__stderrp, "Dumped volume %s in stdout \n",

2963

as->parms[0].items->data);

2964

return 0;

2965

}

2966

2967

#define ASK0 0

2968

#define ABORT1 1

2969

#define FULL2 2

2970

#define INC3 3

2971

2972

#define TS_DUMP1 1

2973

#define TS_KEEP2 2

2974

#define TS_NEW3 3

2975

2976

static int

2977

RestoreVolumeCmd(struct cmd_syndesc *as, void *arock)

2978

{

2979

afs_uint32 avolid, aparentid;

2980

afs_uint32 aserver;

2981

afs_int32 apart, code, vcode, err;

2982

afs_int32 aoverwrite = ASK0;

2983

afs_int32 acreation = 0, alastupdate = 0;

2984

int restoreflags = 0;

2985

int readonly = 0, offline = 0, voltype = RWVOL0;

2986

char afilename[MAXPATHLEN1024], avolname[VOLSER_MAXVOLNAME65 + 1], apartName[10];

2987

char volname[VOLSER_MAXVOLNAME65 + 1];

2988

struct nvldbentry entry;

2989

2990

aparentid = 0;

2991

if (as->parms[4].items) {

2992

avolid = vsu_GetVolumeID(as->parms[4].items->data, cstruct, &err);

2993

if (avolid == 0) {

2994

if (err)

2995

PrintError("", err);

2996

else

2997

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

2998

as->parms[4].items->data);

2999

exit(1);

3000

}

3001

} else

3002

avolid = 0;

3003

3004

if (as->parms[5].items) {

3005

if ((strcmp(as->parms[5].items->data, "a") == 0)

3006

|| (strcmp(as->parms[5].items->data, "abort") == 0)) {

3007

aoverwrite = ABORT1;

3008

} else if ((strcmp(as->parms[5].items->data, "f") == 0)

3009

|| (strcmp(as->parms[5].items->data, "full") == 0)) {

3010

aoverwrite = FULL2;

3011

} else if ((strcmp(as->parms[5].items->data, "i") == 0)

3012

|| (strcmp(as->parms[5].items->data, "inc") == 0)

3013

|| (strcmp(as->parms[5].items->data, "increment") == 0)

3014

|| (strcmp(as->parms[5].items->data, "incremental") == 0)) {

3015

aoverwrite = INC3;

3016

} else {

3017

fprintf(STDERR__stderrp, "vos: %s is not a valid argument to -overwrite\n",

3018

as->parms[5].items->data);

3019

exit(1);

3020

}

3021

}

3022

if (as->parms[6].items)

3023

offline = 1;

3024

if (as->parms[7].items) {

3025

readonly = 1;

3026

voltype = ROVOL1;

3027

}

3028

3029

if (as->parms[8].items) {

3030

if ((strcmp(as->parms[8].items->data, "d") == 0)

3031

|| (strcmp(as->parms[8].items->data, "dump") == 0)) {

3032

acreation = TS_DUMP1;

3033

} else if ((strcmp(as->parms[8].items->data, "k") == 0)

3034

|| (strcmp(as->parms[8].items->data, "keep") == 0)) {

3035

acreation = TS_KEEP2;

3036

} else if ((strcmp(as->parms[8].items->data, "n") == 0)

3037

|| (strcmp(as->parms[8].items->data, "new") == 0)) {

3038

acreation = TS_NEW3;

3039

} else {

3040

fprintf(STDERR__stderrp, "vos: %s is not a valid argument to -creation\n",

3041

as->parms[8].items->data);

3042

exit(1);

3043

}

3044

}

3045

3046

if (as->parms[9].items) {

3047

if ((strcmp(as->parms[9].items->data, "d") == 0)

3048

|| (strcmp(as->parms[9].items->data, "dump") == 0)) {

3049

alastupdate = TS_DUMP1;

3050

} else if ((strcmp(as->parms[9].items->data, "k") == 0)

3051

|| (strcmp(as->parms[9].items->data, "keep") == 0)) {

3052

alastupdate = TS_KEEP2;

3053

} else if ((strcmp(as->parms[9].items->data, "n") == 0)

3054

|| (strcmp(as->parms[9].items->data, "new") == 0)) {

3055

alastupdate = TS_NEW3;

3056

} else {

3057

fprintf(STDERR__stderrp, "vos: %s is not a valid argument to -lastupdate\n",

3058

as->parms[9].items->data);

3059

exit(1);

3060

}

3061

}

3062

3063

aserver = GetServer(as->parms[0].items->data);

3064

if (aserver == 0) {

3065

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

3066

as->parms[0].items->data);

3067

exit(1);

3068

}

3069

apart = volutil_GetPartitionID(as->parms[1].items->data);

3070

if (apart < 0) {

3071

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

3072

as->parms[1].items->data);

3073

exit(1);

3074

}

3075

if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */

3076

if (code)

3077

PrintError("", code);

3078

else

3079

fprintf(STDERR__stderrp,

3080

"vos : partition %s does not exist on the server\n",

3081

as->parms[1].items->data);

3082

exit(1);

3083

}

3084

strcpy(avolname, as->parms[2].items->data);

3085

if (!ISNAMEVALID(avolname)(strlen(avolname) < (32 - 9))) {

3086

fprintf(STDERR__stderrp,

3087

"vos: the name of the volume %s exceeds the size limit\n",

3088

avolname);

3089

exit(1);

3090

}

3091

if (!VolNameOK(avolname)) {

3092

fprintf(STDERR__stderrp,

3093

"Illegal volume name %s, should not end in .readonly or .backup\n",

3094

avolname);

3095

exit(1);

3096

}

3097

if (as->parms[3].items) {

3098

strcpy(afilename, as->parms[3].items->data);

3099

if (!FileExists(afilename)) {

3100

fprintf(STDERR__stderrp, "Can't access file %s\n", afilename);

3101

exit(1);

3102

}

3103

} else {

3104

strcpy(afilename, "");

3105

}

3106

3107

/* Check if volume exists or not */

3108

3109

vsu_ExtractName(volname, avolname);

3110

vcode = VLDB_GetEntryByName(volname, &entry);

3111

if (vcode) { /* no volume - do a full restore */

3112

restoreflags = RV_FULLRST0x000001;

3113

if ((aoverwrite == INC3) || (aoverwrite == ABORT1))

3114

fprintf(STDERR__stderrp,

3115

"Volume does not exist; Will perform a full restore\n");

3116

}

3117

3118

else if ((!readonly && Lp_GetRwIndex(&entry) == -1) /* RW volume does not exist - do a full */

3119

||(readonly && !Lp_ROMatch(0, 0, &entry))) { /* RO volume does not exist - do a full */

3120

restoreflags = RV_FULLRST0x000001;

3121

if ((aoverwrite == INC3) || (aoverwrite == ABORT1))

3122

fprintf(STDERR__stderrp,

3123

"%s Volume does not exist; Will perform a full restore\n",

3124

readonly ? "RO" : "RW");

3125

3126

if (avolid == 0) {

3127

avolid = entry.volumeId[voltype];

3128

} else if (entry.volumeId[voltype] != 0

3129

&& entry.volumeId[voltype] != avolid) {

3130

avolid = entry.volumeId[voltype];

3131

}

3132

aparentid = entry.volumeId[RWVOL0];

3133

}

3134

3135

else { /* volume exists - do we do a full incremental or abort */

3136

afs_uint32 Oserver;

3137

afs_int32 Opart, Otype, vol_elsewhere = 0;

3138

struct nvldbentry Oentry;

3139

int c, dc;

3140

3141

if (avolid == 0) {

3142

avolid = entry.volumeId[voltype];

3143

} else if (entry.volumeId[voltype] != 0

3144

&& entry.volumeId[voltype] != avolid) {

3145

avolid = entry.volumeId[voltype];

3146

}

3147

aparentid = entry.volumeId[RWVOL0];

3148

3149

/* A file name was specified - check if volume is on another partition */

3150

vcode = GetVolumeInfo(avolid, &Oserver, &Opart, &Otype, &Oentry);

3151

if (vcode)

3152

exit(1);

3153

3154

vcode = VLDB_IsSameAddrs(Oserver, aserver, &err);

3155

if (err) {

3156

fprintf(STDERR__stderrp,

3157

"Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n",

3158

Oserver, err);

3159

exit(1);

3160

}

3161

if (!vcode || (Opart != apart))

3162

vol_elsewhere = 1;

3163

3164

if (aoverwrite == ASK0) {

3165

if (strcmp(afilename, "") == 0) { /* The file is from standard in */

3166

fprintf(STDERR__stderrp,

3167

"Volume exists and no -overwrite option specified; Aborting restore command\n");

3168

exit(1);

3169

}

3170

3171

/* Ask what to do */

3172

if (vol_elsewhere) {

3173

fprintf(STDERR__stderrp,

3174

"The volume %s %u already exists on a different server/part\n",

3175

volname, entry.volumeId[voltype]);

3176

fprintf(STDERR__stderrp,

3177

"Do you want to do a full restore or abort? [fa](a): ");

3178

} else {

3179

fprintf(STDERR__stderrp,

3180

"The volume %s %u already exists in the VLDB\n",

3181

volname, entry.volumeId[voltype]);

3182

fprintf(STDERR__stderrp,

3183

"Do you want to do a full/incremental restore or abort? [fia](a): ");

3184

}

3185

dc = c = getchar()(!__isthreaded ? (--(__stdinp)->_r < 0 ? __srget(__stdinp
) : (int)(*(__stdinp)->_p++)) : (getc)(__stdinp));

3186

while (!(dc == EOF(-1) || dc == '\n'))

3187

dc = getchar()(!__isthreaded ? (--(__stdinp)->_r < 0 ? __srget(__stdinp
) : (int)(*(__stdinp)->_p++)) : (getc)(__stdinp)); /* goto end of line */

3188

if ((c == 'f') || (c == 'F'))

3189

aoverwrite = FULL2;

3190

else if ((c == 'i') || (c == 'I'))

3191

aoverwrite = INC3;

3192

else

3193

aoverwrite = ABORT1;

3194

}

3195

3196

if (aoverwrite == ABORT1) {

3197

fprintf(STDERR__stderrp, "Volume exists; Aborting restore command\n");

3198

exit(1);

3199

} else if (aoverwrite == FULL2) {

3200

restoreflags = RV_FULLRST0x000001;

3201

fprintf(STDERR__stderrp,

3202

"Volume exists; Will delete and perform full restore\n");

3203

} else if (aoverwrite == INC3) {

3204

restoreflags = 0;

3205

if (vol_elsewhere) {

3206

fprintf(STDERR__stderrp,

3207

"%s volume %lu already exists on a different server/part; not allowed\n",

3208

readonly ? "RO" : "RW", (unsigned long)avolid);

3209

exit(1);

3210

}

3211

}

3212

}

3213

if (offline)

3214

restoreflags |= RV_OFFLINE0x000002;

3215

if (readonly)

3216

restoreflags |= RV_RDONLY0x010000;

3217

3218

switch (acreation) {

3219

case TS_DUMP1:

3220

restoreflags |= RV_CRDUMP0x000010;

3221

break;

3222

case TS_KEEP2:

3223

restoreflags |= RV_CRKEEP0x000020;

3224

break;

3225

case TS_NEW3:

3226

restoreflags |= RV_CRNEW0x000040;

3227

break;

3228

default:

3229

if (aoverwrite == FULL2)

3230

restoreflags |= RV_CRNEW0x000040;

3231

else

3232

restoreflags |= RV_CRKEEP0x000020;

3233

}

3234

3235

switch (alastupdate) {

3236

case TS_DUMP1:

3237

restoreflags |= RV_LUDUMP0x000100;

3238

break;

3239

case TS_KEEP2:

3240

restoreflags |= RV_LUKEEP0x000200;

3241

break;

3242

case TS_NEW3:

3243

restoreflags |= RV_LUNEW0x000400;

3244

break;

3245

default:

3246

restoreflags |= RV_LUDUMP0x000100;

3247

}

3248

if (as->parms[10].items) {

3249

restoreflags |= RV_NODEL0x100000;

3250

}

3251

3252

3253

code =

3254

UV_RestoreVolume2(aserver, apart, avolid, aparentid,

3255

avolname, restoreflags, WriteData, afilename);

3256

if (code) {

3257

PrintDiagnostics("restore", code);

3258

exit(1);

3259

}

3260

MapPartIdIntoName(apart, apartName);

3261

3262

3263

* patch typo here - originally "parms[1]", should be "parms[0]"

3264

3265

3266

fprintf(STDOUT__stdoutp, "Restored volume %s on %s %s\n", avolname,

3267

as->parms[0].items->data, apartName);

3268

return 0;

3269

}

3270

3271

static int

3272

LockReleaseCmd(struct cmd_syndesc *as, void *arock)

3273

{

3274

afs_uint32 avolid;

3275

afs_int32 code, err;

3276

3277

avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

3278

if (avolid == 0) {

3279

if (err)

3280

PrintError("", err);

3281

else

3282

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

3283

as->parms[0].items->data);

3284

exit(1);

3285

}

3286

3287

code = UV_LockRelease(avolid);

3288

if (code) {

3289

PrintDiagnostics("unlock", code);

3290

exit(1);

3291

}

3292

fprintf(STDOUT__stdoutp, "Released lock on vldb entry for volume %s\n",

3293

as->parms[0].items->data);

3294

return 0;

3295

}

3296

3297

static int

3298

AddSite(struct cmd_syndesc *as, void *arock)

3299

{

3300

afs_uint32 avolid;

3301

afs_uint32 aserver;

3302

afs_int32 apart, code, err, arovolid, valid = 0;

3303

char apartName[10], avolname[VOLSER_MAXVOLNAME65 + 1];

3304

3305

vsu_ExtractName(avolname, as->parms[2].items->data);;

3306

avolid = vsu_GetVolumeID(avolname, cstruct, &err);

3307

if (avolid == 0) {

3308

if (err)

3309

PrintError("", err);

3310

else

3311

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

3312

as->parms[2].items->data);

3313

exit(1);

3314

}

3315

arovolid = 0;

3316

if (as->parms[3].items) {

3317

vsu_ExtractName(avolname, as->parms[3].items->data);

3318

arovolid = vsu_GetVolumeID(avolname, cstruct, &err);

3319

if (!arovolid) {

3320

fprintf(STDERR__stderrp, "vos: invalid ro volume id '%s'\n",

3321

as->parms[3].items->data);

3322

exit(1);

3323

}

3324

}

3325

aserver = GetServer(as->parms[0].items->data);

3326

if (aserver == 0) {

3327

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

3328

as->parms[0].items->data);

3329

exit(1);

3330

}

3331

apart = volutil_GetPartitionID(as->parms[1].items->data);

3332

if (apart < 0) {

3333

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

3334

as->parms[1].items->data);

3335

exit(1);

3336

}

3337

if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */

3338

if (code)

3339

PrintError("", code);

3340

else

3341

fprintf(STDERR__stderrp,

3342

"vos : partition %s does not exist on the server\n",

3343

as->parms[1].items->data);

3344

exit(1);

3345

}

3346

if (as->parms[4].items) {

3347

valid = 1;

3348

}

3349

code = UV_AddSite2(aserver, apart, avolid, arovolid, valid);

3350

if (code) {

3351

PrintDiagnostics("addsite", code);

3352

exit(1);

3353

}

3354

MapPartIdIntoName(apart, apartName);

3355

fprintf(STDOUT__stdoutp, "Added replication site %s %s for volume %s\n",

3356

as->parms[0].items->data, apartName, as->parms[2].items->data);

3357

return 0;

3358

}

3359

3360

static int

3361

RemoveSite(struct cmd_syndesc *as, void *arock)

3362

{

3363

3364

afs_uint32 avolid;

3365

afs_uint32 aserver;

3366

afs_int32 apart, code, err;

3367

char apartName[10], avolname[VOLSER_MAXVOLNAME65 + 1];

3368

3369

vsu_ExtractName(avolname, as->parms[2].items->data);

3370

avolid = vsu_GetVolumeID(avolname, cstruct, &err);

3371

if (avolid == 0) {

3372

if (err)

3373

PrintError("", err);

3374

else

3375

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

3376

as->parms[2].items->data);

3377

exit(1);

3378

}

3379

aserver = GetServer(as->parms[0].items->data);

3380

if (aserver == 0) {

3381

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

3382

as->parms[0].items->data);

3383

exit(1);

3384

}

3385

apart = volutil_GetPartitionID(as->parms[1].items->data);

3386

if (apart < 0) {

3387

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

3388

as->parms[1].items->data);

3389

exit(1);

3390

}

3391

3392

*skip the partition validity check, since it is possible that the partition

3393

*has since been decomissioned.

3394

3395

3396

if (!IsPartValid(apart,aserver,&code)){

3397

if(code) PrintError("",code);

3398

else fprintf(STDERR,"vos : partition %s does not exist on the server\n",as->parms[1].items->data);

3399

exit(1);

3400

}

3401

3402

code = UV_RemoveSite(aserver, apart, avolid);

3403

if (code) {

3404

PrintDiagnostics("remsite", code);

3405

exit(1);

3406

}

3407

MapPartIdIntoName(apart, apartName);

3408

fprintf(STDOUT__stdoutp, "Removed replication site %s %s for volume %s\n",

3409

as->parms[0].items->data, apartName, as->parms[2].items->data);

3410

return 0;

3411

}

3412

3413

static int

3414

ChangeLocation(struct cmd_syndesc *as, void *arock)

3415

{

3416

afs_uint32 avolid;

3417

afs_uint32 aserver;

3418

afs_int32 apart, code, err;

3419

char apartName[10];

3420

3421

avolid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);

3422

if (avolid == 0) {

3423

if (err)

3424

PrintError("", err);

3425

else

3426

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

3427

as->parms[2].items->data);

3428

exit(1);

3429

}

3430

aserver = GetServer(as->parms[0].items->data);

3431

if (aserver == 0) {

3432

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

3433

as->parms[0].items->data);

3434

exit(1);

3435

}

3436

apart = volutil_GetPartitionID(as->parms[1].items->data);

3437

if (apart < 0) {

3438

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

3439

as->parms[1].items->data);

3440

exit(1);

3441

}

3442

if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */

3443

if (code)

3444

PrintError("", code);

3445

else

3446

fprintf(STDERR__stderrp,

3447

"vos : partition %s does not exist on the server\n",

3448

as->parms[1].items->data);

3449

exit(1);

3450

}

3451

code = UV_ChangeLocation(aserver, apart, avolid);

3452

if (code) {

3453

PrintDiagnostics("addsite", code);

3454

exit(1);

3455

}

3456

MapPartIdIntoName(apart, apartName);

3457

fprintf(STDOUT__stdoutp, "Changed location to %s %s for volume %s\n",

3458

as->parms[0].items->data, apartName, as->parms[2].items->data);

3459

return 0;

3460

}

3461

3462

static int

3463

ListPartitions(struct cmd_syndesc *as, void *arock)

3464

{

3465

afs_uint32 aserver;

3466

afs_int32 code;

3467

struct partList dummyPartList;

3468

int i;

3469

char pname[10];

3470

int total, cnt;

3471

3472

aserver = GetServer(as->parms[0].items->data);

3473

if (aserver == 0) {

3474

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

3475

as->parms[0].items->data);

3476

exit(1);

3477

}

3478

3479

3480

code = UV_ListPartitions(aserver, &dummyPartList, &cnt);

3481

if (code) {

3482

PrintDiagnostics("listpart", code);

3483

exit(1);

3484

}

3485

total = 0;

3486

fprintf(STDOUT__stdoutp, "The partitions on the server are:\n");

3487

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

3488

if (dummyPartList.partFlags[i] & PARTVALID0x01) {

3489

memset(pname, 0, sizeof(pname));

3490

MapPartIdIntoName(dummyPartList.partId[i], pname);

3491

fprintf(STDOUT__stdoutp, " %10s ", pname);

3492

total++;

3493

if ((i % 5) == 0 && (i != 0))

3494

fprintf(STDOUT__stdoutp, "\n");

3495

}

3496

}

3497

fprintf(STDOUT__stdoutp, "\n");

3498

fprintf(STDOUT__stdoutp, "Total: %d\n", total);

3499

return 0;

3500

3501

}

3502

3503

static int

3504

CompareVolName(const void *p1, const void *p2)

3505

{

3506

volintInfo *arg1, *arg2;

3507

3508

arg1 = (volintInfo *) p1;

3509

arg2 = (volintInfo *) p2;

3510

return (strcmp(arg1->name, arg2->name));

3511

3512

}

3513

3514

/*------------------------------------------------------------------------

3515

* PRIVATE XCompareVolName

3516

3517

* Description:

3518

* Comparison routine for volume names coming from an extended

3519

* volume listing.

3520

3521

* Arguments:

3522

* a_obj1P : Char ptr to first extended vol info object

3523

* a_obj1P : Char ptr to second extended vol info object

3524

3525

* Returns:

3526

* The value of strcmp() on the volume names within the passed

3527

* objects (i,e., -1, 0, or 1).

3528

3529

* Environment:

3530

* Passed to qsort() as the designated comparison routine.

3531

3532

* Side Effects:

3533

* As advertised.

3534

*------------------------------------------------------------------------*/

3535

3536

static int

3537

XCompareVolName(const void *a_obj1P, const void *a_obj2P)

3538

{ /*XCompareVolName */

3539

3540

return (strcmp

3541

(((struct volintXInfo *)(a_obj1P))->name,

3542

((struct volintXInfo *)(a_obj2P))->name));

3543

3544

} /*XCompareVolName */

3545

3546

static int

3547

CompareVolID(const void *p1, const void *p2)

3548

{

3549

volintInfo *arg1, *arg2;

3550

3551

arg1 = (volintInfo *) p1;

3552

arg2 = (volintInfo *) p2;

3553

if (arg1->volid == arg2->volid)

3554

return 0;

3555

if (arg1->volid > arg2->volid)

3556

return 1;

3557

else

3558

return -1;

3559

3560

}

3561

3562

/*------------------------------------------------------------------------

3563

* PRIVATE XCompareVolID

3564

3565

* Description:

3566

* Comparison routine for volume IDs coming from an extended

3567

* volume listing.

3568

3569

* Arguments:

3570

* a_obj1P : Char ptr to first extended vol info object

3571

* a_obj1P : Char ptr to second extended vol info object

3572

3573

* Returns:

3574

* The value of strcmp() on the volume names within the passed

3575

* objects (i,e., -1, 0, or 1).

3576

3577

* Environment:

3578

* Passed to qsort() as the designated comparison routine.

3579

3580

* Side Effects:

3581

* As advertised.

3582

*------------------------------------------------------------------------*/

3583

3584

static int

3585

XCompareVolID(const void *a_obj1P, const void *a_obj2P)

3586

{ /*XCompareVolID */

3587

3588

afs_int32 id1, id2; /*Volume IDs we're comparing */

3589

3590

id1 = ((struct volintXInfo *)(a_obj1P))->volid;

3591

id2 = ((struct volintXInfo *)(a_obj2P))->volid;

3592

if (id1 == id2)

3593

return (0);

3594

else if (id1 > id2)

3595

return (1);

3596

else

3597

return (-1);

3598

3599

} /*XCompareVolID */

3600

3601

/*------------------------------------------------------------------------

3602

* PRIVATE ListVolumes

3603

3604

* Description:

3605

* Routine used to list volumes, contacting the Volume Server

3606

* directly, bypassing the VLDB.

3607

3608

* Arguments:

3609

* as : Ptr to parsed command line arguments.

3610

3611

* Returns:

3612

* 0 Successful operation

3613

3614

* Environment:

3615

* Nothing interesting.

3616

3617

* Side Effects:

3618

* As advertised.

3619

*------------------------------------------------------------------------*/

3620

3621

static int

3622

ListVolumes(struct cmd_syndesc *as, void *arock)

3623

{

3624

afs_int32 apart, int32list, fast;

3625

afs_uint32 aserver;

3626

afs_int32 code;

3627

volintInfo *pntr;

3628

volintInfo *oldpntr = NULL((void *)0);

3629

afs_int32 count;

3630

int i;

3631

char *base;

3632

volintXInfo *xInfoP;

3633

volintXInfo *origxInfoP = NULL((void *)0); /*Ptr to current/orig extended vol info */

3634

int wantExtendedInfo; /*Do we want extended vol info? */

3635

3636

char pname[10];

3637

struct partList dummyPartList;

3638

int all;

3639

int quiet, cnt;

3640

3641

apart = -1;

3642

fast = 0;

3643

int32list = 0;

3644

3645

if (as->parms[3].items)

3646

int32list = 1;

3647

if (as->parms[4].items)

3648

quiet = 1;

3649

else

3650

quiet = 0;

3651

if (as->parms[2].items)

3652

fast = 1;

3653

if (fast)

3654

all = 0;

3655

else

3656

all = 1;

3657

if (as->parms[5].items) {

3658

3659

* We can't coexist with the fast flag.

3660

3661

if (fast) {

3662

fprintf(STDERR__stderrp,

3663

"vos: Can't use the -fast and -extended flags together\n");

3664

exit(1);

3665

}

3666

3667

3668

* We need to turn on ``long'' listings to get the full effect.

3669

3670

wantExtendedInfo = 1;

3671

int32list = 1;

3672

} else

3673

wantExtendedInfo = 0;

3674

if (as->parms[1].items) {

3675

apart = volutil_GetPartitionID(as->parms[1].items->data);

3676

if (apart < 0) {

3677

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

3678

as->parms[1].items->data);

3679

exit(1);

3680

}

3681

dummyPartList.partId[0] = apart;

3682

dummyPartList.partFlags[0] = PARTVALID0x01;

3683

cnt = 1;

3684

}

3685

aserver = GetServer(as->parms[0].items->data);

3686

if (aserver == 0) {

3687

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

3688

as->parms[0].items->data);

3689

exit(1);

3690

}

3691

3692

if (apart != -1) {

3693

if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */

3694

if (code)

3695

PrintError("", code);

3696

else

3697

fprintf(STDERR__stderrp,

3698

"vos : partition %s does not exist on the server\n",

3699

as->parms[1].items->data);

3700

exit(1);

3701

}

3702

} else {

3703

code = UV_ListPartitions(aserver, &dummyPartList, &cnt);

3704

if (code) {

3705

PrintDiagnostics("listvol", code);

3706

exit(1);

3707

}

3708

}

3709

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

3710

if (dummyPartList.partFlags[i] & PARTVALID0x01) {

3711

if (wantExtendedInfo)

3712

code =

3713

UV_XListVolumes(aserver, dummyPartList.partId[i], all,

3714

&xInfoP, &count);

3715

else

3716

code =

3717

UV_ListVolumes(aserver, dummyPartList.partId[i], all,

3718

&pntr, &count);

3719

if (code) {

3720

PrintDiagnostics("listvol", code);

3721

if (pntr)

3722

free(pntr);

3723

exit(1);

3724

}

3725

if (wantExtendedInfo) {

3726

origxInfoP = xInfoP;

3727

base = (char *)xInfoP;

3728

} else {

3729

oldpntr = pntr;

3730

base = (char *)pntr;

3731

}

3732

3733

if (!fast) {

3734

if (wantExtendedInfo)

3735

qsort(base, count, sizeof(volintXInfo), XCompareVolName);

3736

else

3737

qsort(base, count, sizeof(volintInfo), CompareVolName);

3738

} else {

3739

if (wantExtendedInfo)

3740

qsort(base, count, sizeof(volintXInfo), XCompareVolID);

3741

else

3742

qsort(base, count, sizeof(volintInfo), CompareVolID);

3743

}

3744

MapPartIdIntoName(dummyPartList.partId[i], pname);

3745

if (!quiet)

3746

fprintf(STDOUT__stdoutp,

3747

"Total number of volumes on server %s partition %s: %lu \n",

3748

as->parms[0].items->data, pname,

3749

(unsigned long)count);

3750

if (wantExtendedInfo) {

3751

if (as->parms[6].items)

3752

XDisplayVolumes2(aserver, dummyPartList.partId[i], origxInfoP,

3753

count, int32list, fast, quiet);

3754

else

3755

XDisplayVolumes(aserver, dummyPartList.partId[i], origxInfoP,

3756

count, int32list, fast, quiet);

3757

if (xInfoP)

3758

free(xInfoP);

3759

xInfoP = (volintXInfo *) 0;

3760

} else {

3761

if (as->parms[6].items)

3762

DisplayVolumes2(aserver, dummyPartList.partId[i], oldpntr,

3763

count);

3764

else

3765

DisplayVolumes(aserver, dummyPartList.partId[i], oldpntr,

3766

count, int32list, fast, quiet);

3767

if (pntr)

3768

free(pntr);

3769

pntr = (volintInfo *) 0;

3770

}

3771

}

3772

}

3773

return 0;

3774

}

3775

3776

static int

3777

SyncVldb(struct cmd_syndesc *as, void *arock)

3778

{

3779

afs_int32 pnum = 0, code; /* part name */

3780

char part[10];

3781

int flags = 0;

3782

char *volname = 0;

3783

3784

tserver = 0;

3785

if (as->parms[0].items) {

3786

tserver = GetServer(as->parms[0].items->data);

3787

if (!tserver) {

3788

fprintf(STDERR__stderrp, "vos: host '%s' not found in host table\n",

3789

as->parms[0].items->data);

3790

exit(1);

3791

}

3792

}

3793

3794

if (as->parms[1].items) {

3795

pnum = volutil_GetPartitionID(as->parms[1].items->data);

3796

if (pnum < 0) {

3797

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

3798

as->parms[1].items->data);

3799

exit(1);

3800

}

3801

if (!IsPartValid(pnum, tserver, &code)) { /*check for validity of the partition */

3802

if (code)

3803

PrintError("", code);

3804

else

3805

fprintf(STDERR__stderrp,

3806

"vos: partition %s does not exist on the server\n",

3807

as->parms[1].items->data);

3808

exit(1);

3809

}

3810

flags = 1;

3811

3812

if (!tserver) {

3813

fprintf(STDERR__stderrp,

3814

"The -partition option requires a -server option\n");

3815

exit(1);

3816

}

3817

}

3818

3819

if (as->parms[3].items) {

3820

flags |= 2; /* don't update */

3821

}

3822

3823

if (as->parms[2].items) {

3824

/* Synchronize an individual volume */

3825

volname = as->parms[2].items->data;

3826

code = UV_SyncVolume(tserver, pnum, volname, flags);

3827

} else {

3828

if (!tserver) {

3829

fprintf(STDERR__stderrp,

3830

"Without a -volume option, the -server option is required\n");

3831

exit(1);

3832

}

3833

code = UV_SyncVldb(tserver, pnum, flags, 0 /*unused */ );

3834

}

3835

3836

if (code) {

3837

PrintDiagnostics("syncvldb", code);

3838

exit(1);

3839

}

3840

3841

/* Print a summary of what we did */

3842

if (volname)

3843

fprintf(STDOUT__stdoutp, "VLDB volume %s synchronized", volname);

3844

else

3845

fprintf(STDOUT__stdoutp, "VLDB synchronized");

3846

if (tserver) {

3847

fprintf(STDOUT__stdoutp, " with state of server %s", as->parms[0].items->data);

3848

}

3849

if (flags & 1) {

3850

MapPartIdIntoName(pnum, part);

3851

fprintf(STDOUT__stdoutp, " partition %s\n", part);

3852

}

3853

fprintf(STDOUT__stdoutp, "\n");

3854

3855

return 0;

3856

}

3857

3858

static int

3859

SyncServer(struct cmd_syndesc *as, void *arock)

3860

{

3861

afs_int32 pnum, code; /* part name */

3862

char part[10];

3863

3864

int flags = 0;

3865

3866

tserver = GetServer(as->parms[0].items->data);

3867

if (!tserver) {

3868

fprintf(STDERR__stderrp, "vos: host '%s' not found in host table\n",

3869

as->parms[0].items->data);

3870

exit(1);

3871

}

3872

if (as->parms[1].items) {

3873

pnum = volutil_GetPartitionID(as->parms[1].items->data);

3874

if (pnum < 0) {

3875

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

3876

as->parms[1].items->data);

3877

exit(1);

3878

}

3879

if (!IsPartValid(pnum, tserver, &code)) { /*check for validity of the partition */

3880

if (code)

3881

PrintError("", code);

3882

else

3883

fprintf(STDERR__stderrp,

3884

"vos : partition %s does not exist on the server\n",

3885

as->parms[1].items->data);

3886

exit(1);

3887

}

3888

flags = 1;

3889

} else {

3890

pnum = -1;

3891

}

3892

3893

if (as->parms[2].items) {

3894

flags |= 2; /* don't update */

3895

}

3896

code = UV_SyncServer(tserver, pnum, flags, 0 /*unused */ );

3897

if (code) {

3898

PrintDiagnostics("syncserv", code);

3899

exit(1);

3900

}

3901

if (flags & 1) {

3902

MapPartIdIntoName(pnum, part);

3903

fprintf(STDOUT__stdoutp, "Server %s partition %s synchronized with VLDB\n",

3904

as->parms[0].items->data, part);

3905

} else

3906

fprintf(STDOUT__stdoutp, "Server %s synchronized with VLDB\n",

3907

as->parms[0].items->data);

3908

return 0;

3909

3910

}

3911

3912

static int

3913

VolumeInfoCmd(char *name)

3914

{

3915

struct nvldbentry entry;

3916

afs_int32 vcode;

3917

3918

/* The vlserver will handle names with the .readonly

3919

* and .backup extension as well as volume ids.

3920

3921

vcode = VLDB_GetEntryByName(name, &entry);

3922

if (vcode) {

3923

PrintError("", vcode);

3924

exit(1);

3925

}

3926

MapHostToNetwork(&entry);

3927

EnumerateEntry(&entry);

3928

3929

/* Defect #3027: grubby check to handle locked volume.

3930

* If VLOP_ALLOPERS is set, the entry is locked.

3931

* Leave this routine as is, but put in correct check.

3932

3933

PrintLocked(entry.flags);

3934

3935

return 0;

3936

}

3937

3938

static int

3939

VolumeZap(struct cmd_syndesc *as, void *arock)

3940

{

3941

struct nvldbentry entry;

3942

afs_uint32 volid, zapbackupid = 0, backupid = 0;

3943

afs_int32 code, server, part, err;

3944

3945

if (as->parms[3].items) {

3946

/* force flag is on, use the other version */

3947

return NukeVolume(as);

3948

}

3949

3950

if (as->parms[4].items) {

3951

zapbackupid = 1;

3952

}

3953

3954

volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);

3955

if (volid == 0) {

3956

if (err)

3957

PrintError("", err);

3958

else

3959

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

3960

as->parms[2].items->data);

3961

exit(1);

3962

}

3963

part = volutil_GetPartitionID(as->parms[1].items->data);

3964

if (part < 0) {

3965

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

3966

as->parms[1].items->data);

3967

exit(1);

3968

}

3969

server = GetServer(as->parms[0].items->data);

3970

if (!server) {

3971

fprintf(STDERR__stderrp, "vos: host '%s' not found in host table\n",

3972

as->parms[0].items->data);

3973

exit(1);

3974

}

3975

if (!IsPartValid(part, server, &code)) { /*check for validity of the partition */

3976

if (code)

3977

PrintError("", code);

3978

else

3979

fprintf(STDERR__stderrp,

3980

"vos : partition %s does not exist on the server\n",

3981

as->parms[1].items->data);

3982

exit(1);

3983

}

3984

code = VLDB_GetEntryByID(volid, -1, &entry);

3985

if (!code) {

3986

if (volid == entry.volumeId[RWVOL0])

3987

backupid = entry.volumeId[BACKVOL2];

3988

fprintf(STDERR__stderrp,

3989

"Warning: Entry for volume number %lu exists in VLDB (but we're zapping it anyway!)\n",

3990

(unsigned long)volid);

3991

}

3992

if (zapbackupid) {

3993

volintInfo *pntr = (volintInfo *) 0;

3994

3995

if (!backupid) {

3996

code = UV_ListOneVolume(server, part, volid, &pntr);

3997

if (!code) {

3998

if (volid == pntr->parentID)

3999

backupid = pntr->backupID;

4000

if (pntr)

4001

free(pntr);

4002

}

4003

}

4004

if (backupid) {

4005

code = UV_VolumeZap(server, part, backupid);

4006

if (code) {

4007

PrintDiagnostics("zap", code);

4008

exit(1);

4009

}

4010

fprintf(STDOUT__stdoutp, "Backup Volume %lu deleted\n",

4011

(unsigned long)backupid);

4012

}

4013

}

4014

code = UV_VolumeZap(server, part, volid);

4015

if (code) {

4016

PrintDiagnostics("zap", code);

4017

exit(1);

4018

}

4019

fprintf(STDOUT__stdoutp, "Volume %lu deleted\n", (unsigned long)volid);

4020

4021

return 0;

4022

}

4023

4024

static int

4025

VolserStatus(struct cmd_syndesc *as, void *arock)

4026

{

4027

afs_uint32 server;

4028

afs_int32 code;

4029

transDebugInfo *pntr, *oldpntr;

4030

afs_int32 count;

4031

int i;

4032

char pname[10];

4033

time_t t;

4034

4035

server = GetServer(as->parms[0].items->data);

4036

if (!server) {

4037

fprintf(STDERR__stderrp, "vos: host '%s' not found in host table\n",

4038

as->parms[0].items->data);

4039

exit(1);

4040

}

4041

code = UV_VolserStatus(server, &pntr, &count);

4042

if (code) {

4043

PrintDiagnostics("status", code);

4044

exit(1);

4045

}

4046

oldpntr = pntr;

4047

if (count == 0)

4048

fprintf(STDOUT__stdoutp, "No active transactions on %s\n",

4049

as->parms[0].items->data);

4050

else {

4051

fprintf(STDOUT__stdoutp, "Total transactions: %d\n", count);

4052

}

4053

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

4054

/*print out the relevant info */

4055

fprintf(STDOUT__stdoutp, "--------------------------------------\n");

4056

t = pntr->creationTime;

4057

fprintf(STDOUT__stdoutp, "transaction: %lu created: %s",

4058

(unsigned long)pntr->tid, ctime(&t));

4059

t = pntr->time;

4060

fprintf(STDOUT__stdoutp, "lastActiveTime: %s", ctime(&t));

4061

if (pntr->returnCode) {

4062

fprintf(STDOUT__stdoutp, "returnCode: %lu\n",

4063

(unsigned long)pntr->returnCode);

4064

}

4065

if (pntr->iflags) {

4066

fprintf(STDOUT__stdoutp, "attachFlags: ");

4067

switch (pntr->iflags) {

4068

case ITOffline1:

4069

fprintf(STDOUT__stdoutp, "offline ");

4070

break;

4071

case ITBusy2:

4072

fprintf(STDOUT__stdoutp, "busy ");

4073

break;

4074

case ITReadOnly8:

4075

fprintf(STDOUT__stdoutp, "readonly ");

4076

break;

4077

case ITCreate0x10:

4078

fprintf(STDOUT__stdoutp, "create ");

4079

break;

4080

case ITCreateVolID0x1000:

4081

fprintf(STDOUT__stdoutp, "create volid ");

4082

break;

4083

}

4084

fprintf(STDOUT__stdoutp, "\n");

4085

}

4086

if (pntr->vflags) {

4087

fprintf(STDOUT__stdoutp, "volumeStatus: ");

4088

switch (pntr->vflags) {

4089

case VTDeleteOnSalvage1:

4090

fprintf(STDOUT__stdoutp, "deleteOnSalvage ");

4091

case VTOutOfService2:

4092

fprintf(STDOUT__stdoutp, "outOfService ");

4093

case VTDeleted4:

4094

fprintf(STDOUT__stdoutp, "deleted ");

4095

}

4096

fprintf(STDOUT__stdoutp, "\n");

4097

}

4098

if (pntr->tflags) {

4099

fprintf(STDOUT__stdoutp, "transactionFlags: ");

4100

fprintf(STDOUT__stdoutp, "delete\n");

4101

}

4102

MapPartIdIntoName(pntr->partition, pname);

4103

fprintf(STDOUT__stdoutp, "volume: %lu partition: %s procedure: %s\n",

4104

(unsigned long)pntr->volid, pname, pntr->lastProcName);

4105

if (pntr->callValid) {

4106

t = pntr->lastReceiveTime;

4107

fprintf(STDOUT__stdoutp, "packetRead: %lu lastReceiveTime: %s",

4108

(unsigned long)pntr->readNext, ctime(&t));

4109

t = pntr->lastSendTime;

4110

fprintf(STDOUT__stdoutp, "packetSend: %lu lastSendTime: %s",

4111

(unsigned long)pntr->transmitNext, ctime(&t));

4112

}

4113

pntr++;

4114

fprintf(STDOUT__stdoutp, "--------------------------------------\n");

4115

fprintf(STDOUT__stdoutp, "\n");

4116

}

4117

if (oldpntr)

4118

free(oldpntr);

4119

return 0;

4120

}

4121

4122

static int

4123

RenameVolume(struct cmd_syndesc *as, void *arock)

4124

{

4125

afs_int32 code1, code2, code;

4126

struct nvldbentry entry;

4127

4128

code1 = VLDB_GetEntryByName(as->parms[0].items->data, &entry);

4129

if (code1) {

4130

fprintf(STDERR__stderrp, "vos: Could not find entry for volume %s\n",

4131

as->parms[0].items->data);

4132

exit(1);

4133

}

4134

code2 = VLDB_GetEntryByName(as->parms[1].items->data, &entry);

4135

if ((!code1) && (!code2)) { /*the newname already exists */

4136

fprintf(STDERR__stderrp, "vos: volume %s already exists\n",

4137

as->parms[1].items->data);

4138

exit(1);

4139

}

4140

4141

if (code1 && code2) {

4142

fprintf(STDERR__stderrp, "vos: Could not find entry for volume %s or %s\n",

4143

as->parms[0].items->data, as->parms[1].items->data);

4144

exit(1);

4145

}

4146

if (!VolNameOK(as->parms[0].items->data)) {

4147

fprintf(STDERR__stderrp,

4148

"Illegal volume name %s, should not end in .readonly or .backup\n",

4149

as->parms[0].items->data);

4150

exit(1);

4151

}

4152

if (!ISNAMEVALID(as->parms[1].items->data)(strlen(as->parms[1].items->data) < (32 - 9))) {

4153

fprintf(STDERR__stderrp,

4154

"vos: the new volume name %s exceeds the size limit of %d\n",

4155

as->parms[1].items->data, VOLSER_OLDMAXVOLNAME32 - 10);

4156

exit(1);

4157

}

4158

if (!VolNameOK(as->parms[1].items->data)) {

4159

fprintf(STDERR__stderrp,

4160

"Illegal volume name %s, should not end in .readonly or .backup\n",

4161

as->parms[1].items->data);

4162

exit(1);

4163

}

4164

if (IsNumeric(as->parms[1].items->data)) {

4165

fprintf(STDERR__stderrp, "Illegal volume name %s, should not be a number\n",

4166

as->parms[1].items->data);

4167

exit(1);

4168

}

4169

MapHostToNetwork(&entry);

4170

code =

4171

UV_RenameVolume(&entry, as->parms[0].items->data,

4172

as->parms[1].items->data);

4173

if (code) {

4174

PrintDiagnostics("rename", code);

4175

exit(1);

4176

}

4177

fprintf(STDOUT__stdoutp, "Renamed volume %s to %s\n", as->parms[0].items->data,

4178

as->parms[1].items->data);

4179

return 0;

4180

}

4181

4182

int

4183

GetVolumeInfo(afs_uint32 volid, afs_uint32 *server, afs_int32 *part, afs_int32 *voltype,

4184

struct nvldbentry *rentry)

4185

{

4186

afs_int32 vcode;

4187

int i, index = -1;

4188

4189

vcode = VLDB_GetEntryByID(volid, -1, rentry);

4190

if (vcode) {

4191

fprintf(STDERR__stderrp,

4192

"Could not fetch the entry for volume %lu from VLDB \n",

4193

(unsigned long)volid);

4194

PrintError("", vcode);

4195

return (vcode);

4196

}

4197

MapHostToNetwork(rentry);

4198

if (volid == rentry->volumeId[ROVOL1]) {

4199

*voltype = ROVOL1;

4200

for (i = 0; i < rentry->nServers; i++) {

4201

if ((index == -1) && (rentry->serverFlags[i] & ITSROVOL0x02)

4202

&& !(rentry->serverFlags[i] & RO_DONTUSE0x20))

4203

index = i;

4204

}

4205

if (index == -1) {

4206

fprintf(STDERR__stderrp,

4207

"RO volume is not found in VLDB entry for volume %lu\n",

4208

(unsigned long)volid);

4209

return -1;

4210

}

4211

4212

*server = rentry->serverNumber[index];

4213

*part = rentry->serverPartition[index];

4214

return 0;

4215

}

4216

4217

index = Lp_GetRwIndex(rentry);

4218

if (index == -1) {

4219

fprintf(STDERR__stderrp,

4220

"RW Volume is not found in VLDB entry for volume %lu\n",

4221

(unsigned long)volid);

4222

return -1;

4223

}

4224

if (volid == rentry->volumeId[RWVOL0]) {

4225

*voltype = RWVOL0;

4226

*server = rentry->serverNumber[index];

4227

*part = rentry->serverPartition[index];

4228

return 0;

4229

}

4230

if (volid == rentry->volumeId[BACKVOL2]) {

4231

*voltype = BACKVOL2;

4232

*server = rentry->serverNumber[index];

4233

*part = rentry->serverPartition[index];

4234

return 0;

4235

}

4236

fprintf(STDERR__stderrp,

4237

"unexpected volume type for volume %lu\n",

4238

(unsigned long)volid);

4239

return -1;

4240

}

4241

4242

static int

4243

DeleteEntry(struct cmd_syndesc *as, void *arock)

4244

{

4245

afs_int32 apart = 0;

4246

afs_uint32 avolid;

4247

afs_int32 vcode;

4248

struct VldbListByAttributes attributes;

4249

nbulkentries arrayEntries;

4250

struct nvldbentry *vllist;

4251

struct cmd_item *itp;

4252

afs_int32 nentries;

4253

int j;

4254

char prefix[VOLSER_MAXVOLNAME65 + 1];

4255

int seenprefix = 0;

4256

afs_int32 totalBack = 0, totalFail = 0, err;

4257

4258

if (as->parms[0].items) { /* -id */

4259

if (as->parms[1].items || as->parms[2].items || as->parms[3].items) {

4260

fprintf(STDERR__stderrp,

4261

"You cannot use -server, -partition, or -prefix with the -id argument\n");

4262

exit(-2);

4263

}

4264

for (itp = as->parms[0].items; itp; itp = itp->next) {

4265

avolid = vsu_GetVolumeID(itp->data, cstruct, &err);

4266

if (avolid == 0) {

4267

if (err)

4268

PrintError("", err);

4269

else

4270

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

4271

itp->data);

4272

continue;

4273

}

4274

if (as->parms[4].items || as->parms[5].items) {

4275

/* -noexecute (hidden) or -dryrun */

4276

fprintf(STDOUT__stdoutp, "Would have deleted VLDB entry for %s \n",

4277

itp->data);

4278

fflush(STDOUT__stdoutp);

4279

continue;

4280

}

4281

vcode = ubik_VL_DeleteEntry(cstruct, 0, avolid, RWVOL0);

4282

if (vcode) {

4283

fprintf(STDERR__stderrp, "Could not delete entry for volume %s\n",

4284

itp->data);

4285

fprintf(STDERR__stderrp,

4286

"You must specify a RW volume name or ID "

4287

"(the entire VLDB entry will be deleted)\n");

4288

PrintError("", vcode);

4289

totalFail++;

4290

continue;

4291

}

4292

totalBack++;

4293

}

4294

fprintf(STDOUT__stdoutp, "Deleted %d VLDB entries\n", totalBack);

4295

return (totalFail);

4296

}

4297

4298

if (!as->parms[1].items && !as->parms[2].items && !as->parms[3].items) {

4299

fprintf(STDERR__stderrp, "You must specify an option\n");

4300

exit(-2);

4301

}

4302

4303

/* Zero out search attributes */

4304

memset(&attributes, 0, sizeof(struct VldbListByAttributes));

4305

4306

if (as->parms[1].items) { /* -prefix */

4307

strncpy(prefix, as->parms[1].items->data, VOLSER_MAXVOLNAME65);

4308

seenprefix = 1;

4309

if (!as->parms[2].items && !as->parms[3].items) { /* a single entry only */

4310

fprintf(STDERR__stderrp,

4311

"You must provide -server with the -prefix argument\n");

4312

exit(-2);

4313

}

4314

}

4315

4316

if (as->parms[2].items) { /* -server */

4317

afs_uint32 aserver;

4318

aserver = GetServer(as->parms[2].items->data);

4319

if (aserver == 0) {

4320

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

4321

as->parms[2].items->data);

4322

exit(-1);

4323

}

4324

attributes.server = ntohl(aserver)(__builtin_constant_p(aserver) ? ((((__uint32_t)(aserver)) >>
24) | ((((__uint32_t)(aserver)) & (0xff << 16)) >>
8) | ((((__uint32_t)(aserver)) & (0xff << 8)) <<
8) | (((__uint32_t)(aserver)) << 24)) : __bswap32_var(
aserver));

4325

attributes.Mask |= VLLIST_SERVER0x1;

4326

}

4327

4328

if (as->parms[3].items) { /* -partition */

4329

if (!as->parms[2].items) {

4330

fprintf(STDERR__stderrp,

4331

"You must provide -server with the -partition argument\n");

4332

exit(-2);

4333

}

4334

apart = volutil_GetPartitionID(as->parms[3].items->data);

4335

if (apart < 0) {

4336

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

4337

as->parms[3].items->data);

4338

exit(-1);

4339

}

4340

attributes.partition = apart;

4341

attributes.Mask |= VLLIST_PARTITION0x2;

4342

}

4343

4344

/* Print status line of what we are doing */

4345

fprintf(STDOUT__stdoutp, "Deleting VLDB entries for ");

4346

if (as->parms[2].items) {

4347

fprintf(STDOUT__stdoutp, "server %s ", as->parms[2].items->data);

4348

}

4349

if (as->parms[3].items) {

4350

char pname[10];

4351

MapPartIdIntoName(apart, pname);

4352

fprintf(STDOUT__stdoutp, "partition %s ", pname);

4353

}

4354

if (seenprefix) {

4355

fprintf(STDOUT__stdoutp, "which are prefixed with %s ", prefix);

4356

}

4357

fprintf(STDOUT__stdoutp, "\n");

4358

fflush(STDOUT__stdoutp);

4359

4360

/* Get all the VLDB entries on a server and/or partition */

4361

memset(&arrayEntries, 0, sizeof(arrayEntries));

4362

vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);

4363

if (vcode) {

4364

fprintf(STDERR__stderrp, "Could not access the VLDB for attributes\n");

4365

PrintError("", vcode);

4366

exit(-1);

4367

}

4368

4369

/* Process each entry */

4370

for (j = 0; j < nentries; j++) {

4371

vllist = &arrayEntries.nbulkentries_val[j];

4372

if (seenprefix) {

4373

/* It only deletes the RW volumes */

4374

if (strncmp(vllist->name, prefix, strlen(prefix))) {

4375

if (verbose) {

4376

fprintf(STDOUT__stdoutp,

4377

"Omitting to delete %s due to prefix %s mismatch\n",

4378

vllist->name, prefix);

4379

}

4380

fflush(STDOUT__stdoutp);

4381

continue;

4382

}

4383

}

4384

4385

if (as->parms[4].items || as->parms[5].items) {

4386

/* -noexecute (hidden) or -dryrun */

4387

fprintf(STDOUT__stdoutp, "Would have deleted VLDB entry for %s \n",

4388

vllist->name);

4389

fflush(STDOUT__stdoutp);

4390

continue;

4391

}

4392

4393

/* Only matches the RW volume name */

4394

avolid = vllist->volumeId[RWVOL0];

4395

vcode = ubik_VL_DeleteEntry(cstruct, 0, avolid, RWVOL0);

4396

if (vcode) {

4397

fprintf(STDOUT__stdoutp, "Could not delete VLDB entry for %s\n",

4398

vllist->name);

4399

totalFail++;

4400

PrintError("", vcode);

4401

continue;

4402

} else {

4403

totalBack++;

4404

if (verbose)

4405

fprintf(STDOUT__stdoutp, "Deleted VLDB entry for %s \n", vllist->name);

4406

}

4407

fflush(STDOUT__stdoutp);

4408

} /*for */

4409

4410

fprintf(STDOUT__stdoutp, "----------------------\n");

4411

fprintf(STDOUT__stdoutp,

4412

"Total VLDB entries deleted: %lu; failed to delete: %lu\n",

4413

(unsigned long)totalBack, (unsigned long)totalFail);

4414

4415

xdr_freeafs_xdr_free((xdrproc_t) xdr_nbulkentries, &arrayEntries);

4416

return 0;

4417

}

4418

4419

4420

static int

4421

CompareVldbEntryByName(const void *p1, const void *p2)

4422

{

4423

struct nvldbentry *arg1, *arg2;

4424

4425

arg1 = (struct nvldbentry *)p1;

4426

arg2 = (struct nvldbentry *)p2;

4427

return (strcmp(arg1->name, arg2->name));

4428

}

4429

4430

4431

static int CompareVldbEntry(char *p1, char *p2)

4432

{

4433

struct nvldbentry *arg1,*arg2;

4434

int i;

4435

int pos1, pos2;

4436

char comp1[100],comp2[100];

4437

char temp1[20],temp2[20];

4438

4439

arg1 = (struct nvldbentry *)p1;

4440

arg2 = (struct nvldbentry *)p2;

4441

pos1 = -1;

4442

pos2 = -1;

4443

4444

for(i = 0; i < arg1->nServers; i++)

4445

if(arg1->serverFlags[i] & ITSRWVOL) pos1 = i;

4446

for(i = 0; i < arg2->nServers; i++)

4447

if(arg2->serverFlags[i] & ITSRWVOL) pos2 = i;

4448

if(pos1 == -1 || pos2 == -1){

4449

pos1 = 0;

4450

pos2 = 0;

4451

}

4452

sprintf(comp1,"%10u",arg1->serverNumber[pos1]);

4453

sprintf(comp2,"%10u",arg2->serverNumber[pos2]);

4454

sprintf(temp1,"%10u",arg1->serverPartition[pos1]);

4455

sprintf(temp2,"%10u",arg2->serverPartition[pos2]);

4456

strcat(comp1,temp1);

4457

strcat(comp2,temp2);

4458

strcat(comp1,arg1->name);

4459

strcat(comp1,arg2->name);

4460

return(strcmp(comp1,comp2));

4461

4462

}

4463

4464

4465

static int

4466

ListVLDB(struct cmd_syndesc *as, void *arock)

4467

{

4468

afs_int32 apart;

4469

afs_uint32 aserver;

4470

afs_int32 code;

4471

afs_int32 vcode;

4472

struct VldbListByAttributes attributes;

4473

nbulkentries arrayEntries;

4474

struct nvldbentry *vllist, *tarray = 0, *ttarray;

4475

afs_int32 centries, nentries = 0;

4476

afs_int32 tarraysize = 0;

4477

afs_int32 parraysize;

4478

int j;

4479

char pname[10];

4480

int quiet, sort, lock;

4481

afs_int32 thisindex, nextindex;

4482

4483

aserver = 0;

4484

apart = 0;

4485

4486

attributes.Mask = 0;

4487

lock = (as->parms[3].items ? 1 : 0); /* -lock flag */

4488

quiet = (as->parms[4].items ? 1 : 0); /* -quit flag */

4489

sort = (as->parms[5].items ? 0 : 1); /* -nosort flag */

4490

4491

/* If the volume name is given, Use VolumeInfoCmd to look it up

4492

* and not ListAttributes.

4493

4494

if (as->parms[0].items) {

4495

if (lock) {

4496

fprintf(STDERR__stderrp,

4497

"vos: illegal use of '-locked' switch, need to specify server and/or partition\n");

4498

exit(1);

4499

}

4500

code = VolumeInfoCmd(as->parms[0].items->data);

4501

if (code) {

4502

PrintError("", code);

4503

exit(1);

4504

}

4505

return 0;

4506

}

4507

4508

/* Server specified */

4509

if (as->parms[1].items) {

4510

aserver = GetServer(as->parms[1].items->data);

4511

if (aserver == 0) {

4512

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

4513

as->parms[1].items->data);

4514

exit(1);

4515

}

4516

4517

attributes.Mask |= VLLIST_SERVER0x1;

4518

}

4519

4520

/* Partition specified */

4521

if (as->parms[2].items) {

4522

apart = volutil_GetPartitionID(as->parms[2].items->data);

4523

if (apart < 0) {

4524

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

4525

as->parms[2].items->data);

4526

exit(1);

4527

}

4528

attributes.partition = apart;

4529

attributes.Mask |= VLLIST_PARTITION0x2;

4530

}

4531

4532

if (lock) {

4533

attributes.Mask |= VLLIST_FLAG0x10;

4534

attributes.flag = VLOP_ALLOPERS( 0x10 | 0x20 | 0x40 | 0x80 | 0x100);

4535

}

4536

4537

/* Print header information */

4538

if (!quiet) {

4539

MapPartIdIntoName(apart, pname);

4540

fprintf(STDOUT__stdoutp, "VLDB entries for %s %s%s%s %s\n",

4541

(as->parms[1].items ? "server" : "all"),

4542

(as->parms[1].items ? as->parms[1].items->data : "servers"),

4543

(as->parms[2].items ? " partition " : ""),

4544

(as->parms[2].items ? pname : ""),

4545

(lock ? "which are locked:" : ""));

4546

}

4547

4548

for (thisindex = 0; (thisindex != -1); thisindex = nextindex) {

4549

memset(&arrayEntries, 0, sizeof(arrayEntries));

4550

centries = 0;

4551

nextindex = -1;

4552

4553

vcode =

4554

VLDB_ListAttributesN2(&attributes, 0, thisindex, &centries,

4555

&arrayEntries, &nextindex);

4556

if (vcode == RXGEN_OPCODE-455) {

4557

/* Vlserver not running with ListAttributesN2. Fall back */

4558

vcode =

4559

VLDB_ListAttributes(&attributes, &centries, &arrayEntries);

4560

nextindex = -1;

4561

}

4562

if (vcode) {

4563

fprintf(STDERR__stderrp, "Could not access the VLDB for attributes\n");

4564

PrintError("", vcode);

4565

exit(1);

4566

}

4567

nentries += centries;

4568

4569

/* We don't sort, so just print the entries now */

4570

if (!sort) {

4571

for (j = 0; j < centries; j++) { /* process each entry */

4572

vllist = &arrayEntries.nbulkentries_val[j];

4573

MapHostToNetwork(vllist);

4574

EnumerateEntry(vllist);

4575

4576

PrintLocked(vllist->flags);

4577

}

4578

}

4579

4580

/* So we sort. First we must collect all the entries and keep

4581

* them in memory.

4582

4583

else if (centries > 0) {

4584

if (!tarray) {

4585

/* malloc the first bulk entries array */

4586

tarraysize = centries * sizeof(struct nvldbentry);

4587

tarray = malloc(tarraysize);

4588

if (!tarray) {

4589

fprintf(STDERR__stderrp,

4590

"Could not allocate enough space for the VLDB entries\n");

4591

goto bypass;

4592

}

4593

memcpy((char*)tarray, arrayEntries.nbulkentries_val, tarraysize);

4594

} else {

4595

/* Grow the tarray to keep the extra entries */

4596

parraysize = (centries * sizeof(struct nvldbentry));

4597

ttarray =

4598

(struct nvldbentry *)realloc(tarray,

4599

tarraysize + parraysize);

4600

if (!ttarray) {

4601

fprintf(STDERR__stderrp,

4602

"Could not allocate enough space for the VLDB entries\n");

4603

goto bypass;

4604

}

4605

tarray = ttarray;

4606

4607

/* Copy them in */

4608

memcpy(((char *)tarray) + tarraysize,

4609

(char *)arrayEntries.nbulkentries_val, parraysize);

4610

tarraysize += parraysize;

4611

}

4612

}

4613

4614

/* Free the bulk array */

4615

xdr_freeafs_xdr_free((xdrproc_t) xdr_nbulkentries, &arrayEntries);

4616

}

4617

4618

/* Here is where we now sort all the entries and print them */

4619

if (sort && (nentries > 0)) {

4620

qsort((char *)tarray, nentries, sizeof(struct nvldbentry),

4621

CompareVldbEntryByName);

4622

for (vllist = tarray, j = 0; j < nentries; j++, vllist++) {

4623

MapHostToNetwork(vllist);

4624

EnumerateEntry(vllist);

4625

4626

PrintLocked(vllist->flags);

4627

}

4628

}

4629

4630

bypass:

4631

if (!quiet)

4632

fprintf(STDOUT__stdoutp, "\nTotal entries: %lu\n", (unsigned long)nentries);

4633

if (tarray)

4634

free(tarray);

4635

return 0;

4636

}

4637

4638

static int

4639

BackSys(struct cmd_syndesc *as, void *arock)

4640

{

4641

afs_uint32 avolid;

4642

afs_int32 apart = 0;

4643

afs_uint32 aserver = 0, aserver1;

4644

afs_int32 code, apart1;

4645

afs_int32 vcode;

4646

struct VldbListByAttributes attributes;

4647

nbulkentries arrayEntries;

4648

struct nvldbentry *vllist;

4649

afs_int32 nentries;

4650

int j;

4651

char pname[10];

4652

int seenprefix, seenxprefix, exclude, ex, exp, noaction;

4653

afs_int32 totalBack = 0;

4654

afs_int32 totalFail = 0;

4655

int previdx = -1;

4656

int error;

4657

int same = 0;

4658

struct cmd_item *ti;

4659

int match = 0;

4660

#ifndef HAVE_POSIX_REGEX1

4661

char *ccode;

4662

#endif

4663

4664

memset(&attributes, 0, sizeof(struct VldbListByAttributes));

4665

attributes.Mask = 0;

4666

4667

seenprefix = (as->parms[0].items ? 1 : 0);

4668

exclude = (as->parms[3].items ? 1 : 0);

4669

seenxprefix = (as->parms[4].items ? 1 : 0);

4670

noaction = (as->parms[5].items ? 1 : 0);

4671

4672

if (as->parms[1].items) { /* -server */

4673

aserver = GetServer(as->parms[1].items->data);

4674

if (aserver == 0) {

4675

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

4676

as->parms[1].items->data);

4677

exit(1);

4678

}

4679

4680

attributes.Mask |= VLLIST_SERVER0x1;

4681

}

4682

4683

if (as->parms[2].items) { /* -partition */

4684

apart = volutil_GetPartitionID(as->parms[2].items->data);

4685

if (apart < 0) {

4686

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

4687

as->parms[2].items->data);

4688

exit(1);

4689

}

4690

attributes.partition = apart;

4691

attributes.Mask |= VLLIST_PARTITION0x2;

4692

}

4693

4694

/* Check to make sure the prefix and xprefix expressions compile ok */

4695

if (seenprefix) {

4696

for (ti = as->parms[0].items; ti; ti = ti->next) {

4697

if (strncmp(ti->data, "^", 1) == 0) {

4698

#ifdef HAVE_POSIX_REGEX1

4699

regex_t re;

4700

char errbuf[256];

4701

4702

code = regcomp(&re, ti->data, REG_NOSUB0004);

4703

if (code != 0) {

4704

regerror(code, &re, errbuf, sizeof errbuf);

4705

fprintf(STDERR__stderrp,

4706

"Unrecognizable -prefix regular expression: '%s': %s\n",

4707

ti->data, errbuf);

4708

exit(1);

4709

}

4710

regfree(&re);

4711

#else

4712

ccode = (char *)re_comp(ti->data);

4713

if (ccode) {

4714

fprintf(STDERR__stderrp,

4715

"Unrecognizable -prefix regular expression: '%s': %s\n",

4716

ti->data, ccode);

4717

exit(1);

4718

}

4719

#endif

4720

}

4721

}

4722

}

4723

if (seenxprefix) {

4724

for (ti = as->parms[4].items; ti; ti = ti->next) {

4725

if (strncmp(ti->data, "^", 1) == 0) {

4726

#ifdef HAVE_POSIX_REGEX1

4727

regex_t re;

4728

char errbuf[256];

4729

4730

code = regcomp(&re, ti->data, REG_NOSUB0004);

4731

if (code != 0) {

4732

regerror(code, &re, errbuf, sizeof errbuf);

4733

fprintf(STDERR__stderrp,

4734

"Unrecognizable -xprefix regular expression: '%s': %s\n",

4735

ti->data, errbuf);

4736

exit(1);

4737

}

4738

regfree(&re);

4739

#else

4740

ccode = (char *)re_comp(ti->data);

4741

if (ccode) {

4742

fprintf(STDERR__stderrp,

4743

"Unrecognizable -xprefix regular expression: '%s': %s\n",

4744

ti->data, ccode);

4745

exit(1);

4746

}

4747

#endif

4748

}

4749

}

4750

}

4751

4752

memset(&arrayEntries, 0, sizeof(arrayEntries)); /* initialize to hint the stub to alloc space */

4753

vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);

4754

if (vcode) {

4755

fprintf(STDERR__stderrp, "Could not access the VLDB for attributes\n");

4756

PrintError("", vcode);

4757

exit(1);

4758

}

4759

4760

if (as->parms[1].items || as->parms[2].items || verbose) {

4761

fprintf(STDOUT__stdoutp, "%s up volumes",

4762

(noaction ? "Would have backed" : "Backing"));

4763

4764

if (as->parms[1].items) {

4765

fprintf(STDOUT__stdoutp, " on server %s", as->parms[1].items->data);

4766

} else if (as->parms[2].items) {

4767

fprintf(STDOUT__stdoutp, " for all servers");

4768

}

4769

4770

if (as->parms[2].items) {

4771

MapPartIdIntoName(apart, pname);

4772

fprintf(STDOUT__stdoutp, " partition %s", pname);

4773

}

4774

4775

if (seenprefix || (!seenprefix && seenxprefix)) {

4776

ti = (seenprefix ? as->parms[0].items : as->parms[4].items);

4777

ex = (seenprefix ? exclude : !exclude);

4778

exp = (strncmp(ti->data, "^", 1) == 0);

4779

fprintf(STDOUT__stdoutp, " which %smatch %s '%s'", (ex ? "do not " : ""),

4780

(exp ? "expression" : "prefix"), ti->data);

4781

for (ti = ti->next; ti; ti = ti->next) {

4782

exp = (strncmp(ti->data, "^", 1) == 0);

4783

printf(" %sor %s '%s'", (ex ? "n" : ""),

4784

(exp ? "expression" : "prefix"), ti->data);

4785

}

4786

}

4787

4788

if (seenprefix && seenxprefix) {

4789

ti = as->parms[4].items;

4790

exp = (strncmp(ti->data, "^", 1) == 0);

4791

fprintf(STDOUT__stdoutp, " %swhich match %s '%s'",

4792

(exclude ? "adding those " : "removing those "),

4793

(exp ? "expression" : "prefix"), ti->data);

4794

for (ti = ti->next; ti; ti = ti->next) {

4795

exp = (strncmp(ti->data, "^", 1) == 0);

4796

printf(" or %s '%s'", (exp ? "expression" : "prefix"),

4797

ti->data);

4798

}

4799

}

4800

fprintf(STDOUT__stdoutp, " .. ");

4801

if (verbose)

4802

fprintf(STDOUT__stdoutp, "\n");

4803

fflush(STDOUT__stdoutp);

4804

}

4805

4806

for (j = 0; j < nentries; j++) { /* process each vldb entry */

4807

vllist = &arrayEntries.nbulkentries_val[j];

4808

4809

if (seenprefix) {

4810

for (ti = as->parms[0].items; ti; ti = ti->next) {

4811

if (strncmp(ti->data, "^", 1) == 0) {

4812

#ifdef HAVE_POSIX_REGEX1

4813

regex_t re;

4814

char errbuf[256];

4815

4816

/* XXX -- should just do the compile once! */

4817

code = regcomp(&re, ti->data, REG_NOSUB0004);

4818

if (code != 0) {

4819

regerror(code, &re, errbuf, sizeof errbuf);

4820

fprintf(STDERR__stderrp,

4821

"Error in -prefix regular expression: '%s': %s\n",

4822

ti->data, errbuf);

4823

exit(1);

4824

}

4825

match = (regexec(&re, vllist->name, 0, NULL((void *)0), 0) == 0);

4826

regfree(&re);

4827

#else

4828

ccode = (char *)re_comp(ti->data);

4829

if (ccode) {

4830

fprintf(STDERR__stderrp,

4831

"Error in -prefix regular expression: '%s': %s\n",

4832

ti->data, ccode);

4833

exit(1);

4834

}

4835

match = (re_exec(vllist->name) == 1);

4836

#endif

4837

} else {

4838

match =

4839

(strncmp(vllist->name, ti->data, strlen(ti->data)) ==

4840

0);

4841

}

4842

if (match)

4843

break;

4844

}

4845

} else {

4846

match = 1;

4847

}

4848

4849

/* Without the -exclude flag: If it matches the prefix, then

4850

* check if we want to exclude any from xprefix.

4851

* With the -exclude flag: If it matches the prefix, then

4852

* check if we want to add any from xprefix.

4853

4854

if (match && seenxprefix) {

4855

for (ti = as->parms[4].items; ti; ti = ti->next) {

4856

if (strncmp(ti->data, "^", 1) == 0) {

4857

#ifdef HAVE_POSIX_REGEX1

4858

regex_t re;

4859

char errbuf[256];

4860

4861

/* XXX -- should just do the compile once! */

4862

code = regcomp(&re, ti->data, REG_NOSUB0004);

4863

if (code != 0) {

4864

regerror(code, &re, errbuf, sizeof errbuf);

4865

fprintf(STDERR__stderrp,

4866

"Error in -xprefix regular expression: '%s': %s\n",

4867

ti->data, errbuf);

4868

exit(1);

4869

}

4870

if (regexec(&re, vllist->name, 0, NULL((void *)0), 0) == 0)

4871

match = 0;

4872

regfree(&re);

4873

#else

4874

ccode = (char *)re_comp(ti->data);

4875

if (ccode) {

4876

fprintf(STDERR__stderrp,

4877

"Error in -xprefix regular expression: '%s': %s\n",

4878

ti->data, ccode);

4879

exit(1);

4880

}

4881

if (re_exec(vllist->name) == 1) {

4882

match = 0;

4883

break;

4884

}

4885

#endif

4886

} else {

4887

if (strncmp(vllist->name, ti->data, strlen(ti->data)) ==

4888

0) {

4889

match = 0;

4890

break;

4891

}

4892

}

4893

}

4894

}

4895

4896

if (exclude)

4897

match = !match; /* -exclude will reverse the match */

4898

if (!match)

4899

continue; /* Skip if no match */

4900

4901

/* Print list of volumes to backup */

4902

if (noaction) {

4903

fprintf(STDOUT__stdoutp, " %s\n", vllist->name);

4904

continue;

4905

}

4906

4907

if (!(vllist->flags & RW_EXISTS0x1000)) {

4908

if (verbose) {

4909

fprintf(STDOUT__stdoutp,

4910

"Omitting to backup %s since RW volume does not exist \n",

4911

vllist->name);

4912

fprintf(STDOUT__stdoutp, "\n");

4913

}

4914

fflush(STDOUT__stdoutp);

4915

continue;

4916

}

4917

4918

avolid = vllist->volumeId[RWVOL0];

4919

MapHostToNetwork(vllist);

4920

GetServerAndPart(vllist, RWVOL0, &aserver1, &apart1, &previdx);

4921

if (aserver1 == -1 || apart1 == -1) {

4922

fprintf(STDOUT__stdoutp, "could not backup %s, invalid VLDB entry\n",

4923

vllist->name);

4924

totalFail++;

4925

continue;

4926

}

4927

if (aserver) {

4928

same = VLDB_IsSameAddrs(aserver, aserver1, &error);

4929

if (error) {

4930

fprintf(STDERR__stderrp,

4931

"Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n",

4932

aserver, error);

4933

totalFail++;

4934

continue;

4935

}

4936

}

4937

if ((aserver && !same) || (apart && (apart != apart1))) {

4938

if (verbose) {

4939

fprintf(STDOUT__stdoutp,

4940

"Omitting to backup %s since the RW is in a different location\n",

4941

vllist->name);

4942

}

4943

continue;

4944

}

4945

if (verbose) {

4946

time_t now = time(0);

4947

fprintf(STDOUT__stdoutp, "Creating backup volume for %s on %s",

4948

vllist->name, ctime(&now));

4949

fflush(STDOUT__stdoutp);

4950

}

4951

4952

code = UV_BackupVolume(aserver1, apart1, avolid);

4953

if (code) {

4954

fprintf(STDOUT__stdoutp, "Could not backup %s\n", vllist->name);

4955

totalFail++;

4956

} else {

4957

totalBack++;

4958

}

4959

if (verbose)

4960

fprintf(STDOUT__stdoutp, "\n");

4961

fflush(STDOUT__stdoutp);

4962

} /* process each vldb entry */

4963

fprintf(STDOUT__stdoutp, "done\n");

4964

fprintf(STDOUT__stdoutp, "Total volumes backed up: %lu; failed to backup: %lu\n",

4965

(unsigned long)totalBack, (unsigned long)totalFail);

4966

fflush(STDOUT__stdoutp);

4967

xdr_freeafs_xdr_free((xdrproc_t) xdr_nbulkentries, &arrayEntries);

4968

return 0;

4969

}

4970

4971

static int

4972

UnlockVLDB(struct cmd_syndesc *as, void *arock)

4973

{

4974

afs_int32 apart;

4975

afs_uint32 aserver = 0;

4976

afs_int32 code;

4977

afs_int32 vcode;

4978

struct VldbListByAttributes attributes;

4979

nbulkentries arrayEntries;

4980

struct nvldbentry *vllist;

4981

afs_int32 nentries;

4982

int j;

4983

afs_uint32 volid;

4984

afs_int32 totalE;

4985

char pname[10];

4986

4987

apart = -1;

4988

totalE = 0;

4989

attributes.Mask = 0;

4990

4991

if (as->parms[0].items) { /* server specified */

4992

aserver = GetServer(as->parms[0].items->data);

4993

if (aserver == 0) {

4994

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

4995

as->parms[0].items->data);

4996

exit(1);

4997

}

4998

4999

attributes.Mask |= VLLIST_SERVER0x1;

5000

}

5001

if (as->parms[1].items) { /* partition specified */

5002

apart = volutil_GetPartitionID(as->parms[1].items->data);

5003

if (apart < 0) {

5004

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

5005

as->parms[1].items->data);

5006

exit(1);

5007

}

5008

if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */

5009

if (code)

5010

PrintError("", code);

5011

else

5012

fprintf(STDERR__stderrp,

5013

"vos : partition %s does not exist on the server\n",

5014

as->parms[1].items->data);

5015

exit(1);

5016

}

5017

attributes.partition = apart;

5018

attributes.Mask |= VLLIST_PARTITION0x2;

5019

}

5020

attributes.flag = VLOP_ALLOPERS( 0x10 | 0x20 | 0x40 | 0x80 | 0x100);

5021

attributes.Mask |= VLLIST_FLAG0x10;

5022

memset(&arrayEntries, 0, sizeof(arrayEntries)); /*initialize to hint the stub to alloc space */

5023

vcode = VLDB_ListAttributes(&attributes, &nentries, &arrayEntries);

5024

if (vcode) {

5025

fprintf(STDERR__stderrp, "Could not access the VLDB for attributes\n");

5026

PrintError("", vcode);

5027

exit(1);

5028

}

5029

for (j = 0; j < nentries; j++) { /* process each entry */

5030

vllist = &arrayEntries.nbulkentries_val[j];

5031

volid = vllist->volumeId[RWVOL0];

5032

vcode =

5033

ubik_VL_ReleaseLock(cstruct, 0, volid, -1,

5034

LOCKREL_OPCODE2 | LOCKREL_AFSID4 |

5035

LOCKREL_TIMESTAMP1);

5036

if (vcode) {

5037

fprintf(STDERR__stderrp, "Could not unlock entry for volume %s\n",

5038

vllist->name);

5039

PrintError("", vcode);

5040

totalE++;

5041

}

5042

5043

}

5044

MapPartIdIntoName(apart, pname);

5045

if (totalE)

5046

fprintf(STDOUT__stdoutp,

5047

"Could not lock %lu VLDB entries of %lu locked entries\n",

5048

(unsigned long)totalE, (unsigned long)nentries);

5049

else {

5050

if (as->parms[0].items) {

5051

fprintf(STDOUT__stdoutp,

5052

"Unlocked all the VLDB entries for volumes on server %s ",

5053

as->parms[0].items->data);

5054

if (as->parms[1].items) {

5055

MapPartIdIntoName(apart, pname);

5056

fprintf(STDOUT__stdoutp, "partition %s\n", pname);

5057

} else

5058

fprintf(STDOUT__stdoutp, "\n");

5059

5060

} else if (as->parms[1].items) {

5061

MapPartIdIntoName(apart, pname);

5062

fprintf(STDOUT__stdoutp,

5063

"Unlocked all the VLDB entries for volumes on partition %s on all servers\n",

5064

pname);

5065

}

5066

}

5067

5068

xdr_freeafs_xdr_free((xdrproc_t) xdr_nbulkentries, &arrayEntries);

5069

return 0;

5070

}

5071

5072

static char *

5073

PrintInt64Size(afs_uint64 in)

5074

{

5075

afs_uint32 hi, lo;

5076

char * units;

5077

static char output[16];

5078

5079

SplitInt64(in,hi,lo)(hi) = ((afs_int64)in) >> 32; (lo) = (in) & 0xFFFFFFFF
;;

5080

5081

if (hi == 0) {

5082

units = "KB";

5083

} else if (!(hi & 0xFFFFFC00)) {

5084

units = "MB";

5085

lo = (hi << 22) | (lo >> 10);

5086

} else if (!(hi & 0xFFF00000)) {

5087

units = "GB";

5088

lo = (hi << 12) | (lo >> 20);

5089

} else if (!(hi & 0xC0000000)) {

5090

units = "TB";

5091

lo = (hi << 2) | (lo >> 30);

5092

} else {

5093

units = "PB";

5094

lo = (hi >> 8);

5095

}

5096

sprintf(output,"%u %s", lo, units);

5097

return output;

5098

}

5099

5100

static int

5101

PartitionInfo(struct cmd_syndesc *as, void *arock)

5102

{

5103

afs_int32 apart;

5104

afs_uint32 aserver;

5105

afs_int32 code;

5106

char pname[10];

5107

struct diskPartition64 partition;

5108

struct partList dummyPartList;

5109

int i, cnt;

5110

int printSummary=0, sumPartitions=0;

5111

afs_uint64 sumFree, sumStorage;

5112

5113

ZeroInt64(sumFree)(sumFree = 0);

5114

ZeroInt64(sumStorage)(sumStorage = 0);

5115

apart = -1;

5116

aserver = GetServer(as->parms[0].items->data);

5117

if (aserver == 0) {

5118

fprintf(STDERR__stderrp, "vos: server '%s' not found in host table\n",

5119

as->parms[0].items->data);

5120

exit(1);

5121

}

5122

if (as->parms[1].items) {

5123

apart = volutil_GetPartitionID(as->parms[1].items->data);

5124

if (apart < 0) {

5125

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

5126

as->parms[1].items->data);

5127

exit(1);

5128

}

5129

dummyPartList.partId[0] = apart;

5130

dummyPartList.partFlags[0] = PARTVALID0x01;

5131

cnt = 1;

5132

}

5133

if (as->parms[2].items) {

5134

printSummary = 1;

5135

}

5136

if (apart != -1) {

5137

if (!IsPartValid(apart, aserver, &code)) { /*check for validity of the partition */

5138

if (code)

5139

PrintError("", code);

5140

else

5141

fprintf(STDERR__stderrp,

5142

"vos : partition %s does not exist on the server\n",

5143

as->parms[1].items->data);

5144

exit(1);

5145

}

5146

} else {

5147

code = UV_ListPartitions(aserver, &dummyPartList, &cnt);

5148

if (code) {

5149

PrintDiagnostics("listpart", code);

5150

exit(1);

5151

}

5152

}

5153

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

5154

if (dummyPartList.partFlags[i] & PARTVALID0x01) {

5155

MapPartIdIntoName(dummyPartList.partId[i], pname);

5156

code = UV_PartitionInfo64(aserver, pname, &partition);

5157

if (code) {

5158

fprintf(STDERR__stderrp, "Could not get information on partition %s\n",

5159

pname);

5160

PrintError("", code);

5161

exit(1);

5162

}

5163

fprintf(STDOUT__stdoutp,

5164

"Free space on partition %s: %" AFS_INT64_FMT"lld" " K blocks out of total %" AFS_INT64_FMT"lld" "\n",

5165

pname, partition.free, partition.minFree);

5166

sumPartitions++;

5167

AddUInt64(sumFree,partition.free,&sumFree)*(&sumFree) = (afs_uint64)(sumFree) + (afs_uint64)(partition
.free);

5168

AddUInt64(sumStorage,partition.minFree,&sumStorage)*(&sumStorage) = (afs_uint64)(sumStorage) + (afs_uint64)(
partition.minFree);

5169

}

5170

}

5171

if (printSummary) {

5172

fprintf(STDOUT__stdoutp,

5173

"Summary: %s free out of ",

5174

PrintInt64Size(sumFree));

5175

fprintf(STDOUT__stdoutp,

5176

"%s on %d partitions\n",

5177

PrintInt64Size(sumStorage),

5178

sumPartitions);

5179

}

5180

return 0;

5181

}

5182

5183

static int

5184

ChangeAddr(struct cmd_syndesc *as, void *arock)

5185

{

5186

afs_int32 ip1, ip2, vcode;

5187

int remove = 0;

5188

5189

if (noresolve)

5190

ip1 = GetServerNoresolve(as->parms[0].items->data);

5191

else

5192

ip1 = GetServer(as->parms[0].items->data);

5193

if (!ip1) {

5194

fprintf(STDERR__stderrp, "vos: invalid host address\n");

5195

return (EINVAL22);

5196

}

5197

5198

if ((as->parms[1].items && as->parms[2].items)

5199

|| (!as->parms[1].items && !as->parms[2].items)) {

5200

fprintf(STDERR__stderrp,

5201

"vos: Must specify either '-newaddr <addr>' or '-remove' flag\n");

5202

return (EINVAL22);

5203

}

5204

5205

if (as->parms[1].items) {

5206

if (noresolve)

5207

ip2 = GetServerNoresolve(as->parms[1].items->data);

5208

else

5209

ip2 = GetServer(as->parms[1].items->data);

5210

if (!ip2) {

5211

fprintf(STDERR__stderrp, "vos: invalid host address\n");

5212

return (EINVAL22);

5213

}

5214

} else {

5215

/* Play a trick here. If we are removing an address, ip1 will be -1

5216

* and ip2 will be the original address. This switch prevents an

5217

* older revision vlserver from removing the IP address.

5218

5219

remove = 1;

5220

ip2 = ip1;

5221

ip1 = 0xffffffff;

5222

}

5223

5224

vcode = ubik_VL_ChangeAddr(cstruct, UBIK_CALL_NEW2, ntohl(ip1)(__builtin_constant_p(ip1) ? ((((__uint32_t)(ip1)) >> 24
) | ((((__uint32_t)(ip1)) & (0xff << 16)) >> 8
) | ((((__uint32_t)(ip1)) & (0xff << 8)) << 8
) | (((__uint32_t)(ip1)) << 24)) : __bswap32_var(ip1)), ntohl(ip2)(__builtin_constant_p(ip2) ? ((((__uint32_t)(ip2)) >> 24
) | ((((__uint32_t)(ip2)) & (0xff << 16)) >> 8
) | ((((__uint32_t)(ip2)) & (0xff << 8)) << 8
) | (((__uint32_t)(ip2)) << 24)) : __bswap32_var(ip2)));

5225

if (vcode) {

5226

char hoststr1[16], hoststr2[16];

5227

if (remove) {

5228

afs_inet_ntoa_r(ip2, hoststr2);

5229

fprintf(STDERR__stderrp, "Could not remove server %s from the VLDB\n",

5230

hoststr2);

5231

if (vcode == VL_NOENT(363524L)) {

5232

fprintf(STDERR__stderrp,

5233

"vlserver does not support the remove flag or ");

5234

}

5235

} else {

5236

afs_inet_ntoa_r(ip1, hoststr1);

5237

afs_inet_ntoa_r(ip2, hoststr2);

5238

fprintf(STDERR__stderrp, "Could not change server %s to server %s\n",

5239

hoststr1, hoststr2);

5240

}

5241

PrintError("", vcode);

5242

return (vcode);

5243

}

5244

5245

if (remove) {

5246

fprintf(STDOUT__stdoutp, "Removed server %s from the VLDB\n",

5247

as->parms[0].items->data);

5248

} else {

5249

fprintf(STDOUT__stdoutp, "Changed server %s to server %s\n",

5250

as->parms[0].items->data, as->parms[1].items->data);

5251

}

5252

return 0;

5253

}

5254

5255

static void

5256

print_addrs(const bulkaddrs * addrs, afsUUID * m_uuid, int nentries,

5257

int print)

5258

{

5259

int i;

5260

afs_uint32 *addrp;

5261

char buf[1024];

5262

5263

if (print) {

5264

afsUUID_to_string(m_uuid, buf, sizeof(buf));

5265

printf("UUID: %s\n", buf);

5266

}

5267

5268

/* print out the list of all the server */

5269

addrp = (afs_uint32 *) addrs->bulkaddrs_val;

5270

for (i = 0; i < nentries; i++, addrp++) {

5271

*addrp = htonl(*addrp)(__builtin_constant_p(*addrp) ? ((((__uint32_t)(*addrp)) >>
24) | ((((__uint32_t)(*addrp)) & (0xff << 16)) >>
8) | ((((__uint32_t)(*addrp)) & (0xff << 8)) <<
8) | (((__uint32_t)(*addrp)) << 24)) : __bswap32_var(*
addrp));

5272

if (noresolve) {

5273

char hoststr[16];

5274

printf("%s\n", afs_inet_ntoa_r(*addrp, hoststr));

5275

} else {

5276

printf("%s\n", hostutil_GetNameByINet(*addrp));

5277

}

5278

}

5279

5280

if (print) {

5281

printf("\n");

5282

}

5283

return;

5284

}

5285

5286

static int

5287

ListAddrs(struct cmd_syndesc *as, void *arock)

5288

{

5289

afs_int32 vcode, m_uniq=0;

5290

afs_int32 i, printuuid = 0;

5291

struct VLCallBack vlcb;

5292

afs_int32 nentries;

5293

bulkaddrs m_addrs;

5294

ListAddrByAttributes m_attrs;

5295

afsUUID m_uuid, askuuid;

5296

afs_int32 m_nentries;

5297

5298

if (as->parms[0].items && as->parms[1].items) {

1	Taking false branch

5299

fprintf(STDERR__stderrp, "vos: Can't use the -uuid and -host flags together\n");

5300

exit(-1);

5301

}

5302

5303

memset(&m_attrs, 0, sizeof(struct ListAddrByAttributes));

5304

memset(&askuuid, 0, sizeof(afsUUID));

5305

if (as->parms[0].items) {

2	Taking false branch

5306

/* -uuid */

5307

if (afsUUID_from_string(as->parms[0].items->data, &askuuid) < 0) {

5308

fprintf(STDERR__stderrp, "vos: invalid UUID '%s'\n",

5309

as->parms[0].items->data);

5310

exit(-1);

5311

}

5312

m_attrs.Mask = VLADDR_UUID0x4;

5313

m_attrs.uuid = askuuid;

5314

} else if (as->parms[1].items) {

3	Taking false branch

5315

/* -host */

5316

struct hostent *he;

5317

afs_uint32 saddr;

5318

he = hostutil_GetHostByName((char *)as->parms[1].items->data);

5319

if (he == NULL((void *)0)) {

5320

fprintf(STDERR__stderrp, "vos: Can't get host info for '%s'\n",

5321

as->parms[1].items->data);

5322

exit(-1);

5323

}

5324

memcpy(&saddr, he->h_addrh_addr_list[0], 4);

5325

m_attrs.Mask = VLADDR_IPADDR0x1;

5326

m_attrs.ipaddr = ntohl(saddr)(__builtin_constant_p(saddr) ? ((((__uint32_t)(saddr)) >>
24) | ((((__uint32_t)(saddr)) & (0xff << 16)) >>
8) | ((((__uint32_t)(saddr)) & (0xff << 8)) <<
8) | (((__uint32_t)(saddr)) << 24)) : __bswap32_var(saddr
));

5327

} else {

5328

/* by index */

5329

m_attrs.Mask = VLADDR_INDEX0x2;

5330

}

5331

5332

if (as->parms[2].items) {

4	Taking false branch

5333

printuuid = 1;

5334

}

5335

5336

memset(&m_addrs, 0, sizeof(bulkaddrs));

5337

memset(&vlcb, 0, sizeof(struct VLCallBack));

5338

5339

vcode =

5340

ubik_VL_GetAddrs(cstruct, UBIK_CALL_NEW2, 0, 0, &vlcb, &nentries,

5341

&m_addrs);

5342

if (vcode) {

5	Taking false branch

5343

fprintf(STDERR__stderrp, "vos: could not list the server addresses\n");

5344

PrintError("", vcode);

5345

goto out;

5346

}

5347

5348

for (i = 1, m_nentries = 0; nentries; i++) {

6	Loop condition is true. Entering loop body

5349

m_attrs.index = i;

5350

5351

xdr_freeafs_xdr_free((xdrproc_t)xdr_bulkaddrs, &m_addrs); /* reset addr list */

5352

vcode =

5353

ubik_VL_GetAddrsU(cstruct, UBIK_CALL_NEW2, &m_attrs, &m_uuid,

5354

&m_uniq, &m_nentries, &m_addrs);

5355

switch (vcode) {

7	Control jumps to 'case 363524:' at line 5361

5356

case 0: /* success */

5357

print_addrs(&m_addrs, &m_uuid, m_nentries, printuuid);

5358

nentries--;

5359

break;

5360

5361

case VL_NOENT(363524L):

5362

if (m_attrs.Mask == VLADDR_UUID0x4) {

8	Taking false branch

5363

fprintf(STDERR__stderrp, "vos: no entry for UUID '%s' found in VLDB\n",

5364

as->parms[0].items->data);

5365

exit(-1);

5366

} else if (m_attrs.Mask == VLADDR_IPADDR0x1) {

9	Taking true branch

5367

fprintf(STDERR__stderrp, "vos: no entry for host '%s' [0x%08x] found in VLDB\n",

5368

as->parms[1].items->data, m_attrs.ipaddr);

10	Access to field 'data' results in a dereference of a null pointer (loaded from field 'items')

5369

exit(-1);

5370

}

5371

continue;

5372

5373

case VL_INDEXERANGE(363549L):

5374

vcode = 0; /* not an error, just means we're done */

5375

goto out;

5376

5377

default: /* any other error */

5378

fprintf(STDERR__stderrp, "vos: could not list the server addresses\n");

5379

PrintError("", vcode);

5380

goto out;

5381

}

5382

5383

/* if -uuid or -host, only list one response */

5384

if (as->parms[1].items || as->parms[0].items)

5385

break;

5386

}

5387

5388

out:

5389

xdr_freeafs_xdr_free((xdrproc_t)xdr_bulkaddrs, &m_addrs);

5390

return vcode;

5391

}

5392

5393

5394

static int

5395

SetAddrs(struct cmd_syndesc *as, void *arock)

5396

{

5397

afs_int32 vcode;

5398

bulkaddrs m_addrs;

5399

afsUUID askuuid;

5400

afs_uint32 FS_HostAddrs_HBO[ADDRSPERSITE16];

5401

5402

memset(&m_addrs, 0, sizeof(bulkaddrs));

5403

memset(&askuuid, 0, sizeof(afsUUID));

5404

if (as->parms[0].items) {

5405

/* -uuid */

5406

if (afsUUID_from_string(as->parms[0].items->data, &askuuid) < 0) {

5407

fprintf(STDERR__stderrp, "vos: invalid UUID '%s'\n",

5408

as->parms[0].items->data);

5409

exit(-1);

5410

}

5411

}

5412

if (as->parms[1].items) {

5413

/* -host */

5414

struct cmd_item *ti;

5415

afs_uint32 saddr;

5416

int i = 0;

5417

5418

for (ti = as->parms[1].items; ti && i < ADDRSPERSITE16; ti = ti->next) {

5419

5420

if (noresolve)

5421

saddr = GetServerNoresolve(ti->data);

5422

else

5423

saddr = GetServer(ti->data);

5424

5425

if (!saddr) {

5426

fprintf(STDERR__stderrp, "vos: Can't get host info for '%s'\n",

5427

ti->data);

5428

exit(-1);

5429

}

5430

/* Convert it to host byte order */

5431

FS_HostAddrs_HBO[i] = ntohl(saddr)(__builtin_constant_p(saddr) ? ((((__uint32_t)(saddr)) >>
24) | ((((__uint32_t)(saddr)) & (0xff << 16)) >>
8) | ((((__uint32_t)(saddr)) & (0xff << 8)) <<
8) | (((__uint32_t)(saddr)) << 24)) : __bswap32_var(saddr
));

5432

i++;

5433

}

5434

m_addrs.bulkaddrs_len = i;

5435

m_addrs.bulkaddrs_val = FS_HostAddrs_HBO;

5436

}

5437

5438

vcode = ubik_VL_RegisterAddrs(cstruct, 0, &askuuid, 0, &m_addrs);

5439

5440

if (vcode) {

5441

if (vcode == VL_MULTIPADDR(363550L)) {

5442

fprintf(STDERR__stderrp, "vos: VL_RegisterAddrs rpc failed; The IP address exists on a different server; repair it\n");

5443

PrintError("", vcode);

5444

return vcode;

5445

} else if (vcode == RXGEN_OPCODE-455) {

5446

fprintf(STDERR__stderrp, "vlserver doesn't support VL_RegisterAddrs rpc; ignored\n");

5447

PrintError("", vcode);

5448

return vcode;

5449

}

5450

}

5451

if (verbose) {

5452

fprintf(STDOUT__stdoutp, "vos: Changed UUID with addresses:\n");

5453

print_addrs(&m_addrs, &askuuid, m_addrs.bulkaddrs_len, 1);

5454

}

5455

return 0;

5456

}

5457

5458

static int

5459

LockEntry(struct cmd_syndesc *as, void *arock)

5460

{

5461

afs_uint32 avolid;

5462

afs_int32 vcode, err;

5463

5464

avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

5465

if (avolid == 0) {

5466

if (err)

5467

PrintError("", err);

5468

else

5469

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

5470

as->parms[0].items->data);

5471

exit(1);

5472

}

5473

vcode = ubik_VL_SetLock(cstruct, 0, avolid, -1, VLOP_DELETE0x80);

5474

if (vcode) {

5475

fprintf(STDERR__stderrp, "Could not lock VLDB entry for volume %s\n",

5476

as->parms[0].items->data);

5477

PrintError("", vcode);

5478

exit(1);

5479

}

5480

fprintf(STDOUT__stdoutp, "Locked VLDB entry for volume %s\n",

5481

as->parms[0].items->data);

5482

return 0;

5483

}

5484

5485

static int

5486

ConvertRO(struct cmd_syndesc *as, void *arock)

5487

{

5488

afs_int32 partition = -1;

5489

afs_uint32 volid;

5490

afs_uint32 server;

5491

afs_int32 code, i, same;

5492

struct nvldbentry entry, storeEntry;

5493

afs_int32 vcode;

5494

afs_int32 rwindex = 0;

5495

afs_uint32 rwserver = 0;

5496

afs_int32 rwpartition = 0;

5497

afs_int32 roindex = 0;

5498

afs_uint32 roserver = 0;

5499

afs_int32 ropartition = 0;

5500

int force = 0;

5501

struct rx_connection *aconn;

5502

int c, dc;

5503

5504

server = GetServer(as->parms[0].items->data);

5505

if (!server) {

5506

fprintf(STDERR__stderrp, "vos: host '%s' not found in host table\n",

5507

as->parms[0].items->data);

5508

return ENOENT2;

5509

}

5510

partition = volutil_GetPartitionID(as->parms[1].items->data);

5511

if (partition < 0) {

5512

fprintf(STDERR__stderrp, "vos: could not interpret partition name '%s'\n",

5513

as->parms[1].items->data);

5514

return ENOENT2;

5515

}

5516

if (!IsPartValid(partition, server, &code)) {

5517

if (code)

5518

PrintError("", code);

5519

else

5520

fprintf(STDERR__stderrp,

5521

"vos : partition %s does not exist on the server\n",

5522

as->parms[1].items->data);

5523

return ENOENT2;

5524

}

5525

volid = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &code);

5526

if (volid == 0) {

5527

if (code)

5528

PrintError("", code);

5529

else

5530

fprintf(STDERR__stderrp, "Unknown volume ID or name '%s'\n",

5531

as->parms[0].items->data);

5532

return -1;

5533

}

5534

if (as->parms[3].items)

5535

force = 1;

5536

5537

vcode = VLDB_GetEntryByID(volid, -1, &entry);

5538

if (vcode) {

5539

fprintf(STDERR__stderrp,

5540

"Could not fetch the entry for volume %lu from VLDB\n",

5541

(unsigned long)volid);

5542

PrintError("convertROtoRW", code);

5543

return vcode;

5544

}

5545

5546

/* use RO volid even if user specified RW or BK volid */

5547

5548

if (volid != entry.volumeId[ROVOL1])

5549

volid = entry.volumeId[ROVOL1];

5550

5551

MapHostToNetwork(&entry);

5552

for (i = 0; i < entry.nServers; i++) {

5553

if (entry.serverFlags[i] & ITSRWVOL0x04) {

5554

rwindex = i;

5555

rwserver = entry.serverNumber[i];

5556

rwpartition = entry.serverPartition[i];

5557

}

5558

if (entry.serverFlags[i] & ITSROVOL0x02) {

5559

same = VLDB_IsSameAddrs(server, entry.serverNumber[i], &code);

5560

if (code) {

5561

fprintf(STDERR__stderrp,

5562

"Failed to get info about server's %d address(es) from vlserver (err=%d); aborting call!\n",

5563

server, code);

5564

return ENOENT2;

5565

}

5566

if (same) {

5567

roindex = i;

5568

roserver = entry.serverNumber[i];

5569

ropartition = entry.serverPartition[i];

5570

break;

5571

}

5572

}

5573

}

5574

if (!roserver) {

5575

fprintf(STDERR__stderrp, "Warning: RO volume didn't exist in vldb!\n");

5576

}

5577

if (ropartition != partition) {

5578

fprintf(STDERR__stderrp,

5579

"Warning: RO volume should be in partition %d instead of %d (vldb)\n",

5580

ropartition, partition);

5581

}

5582

5583

if (rwserver) {

5584

fprintf(STDERR__stderrp,

5585

"VLDB indicates that a RW volume exists already on %s in partition %s.\n",

5586

hostutil_GetNameByINet(rwserver),

5587

volutil_PartitionName(rwpartition));

5588

if (!force) {

5589

fprintf(STDERR__stderrp, "Overwrite this VLDB entry? [y|n] (n)\n");

5590

dc = c = getchar()(!__isthreaded ? (--(__stdinp)->_r < 0 ? __srget(__stdinp
) : (int)(*(__stdinp)->_p++)) : (getc)(__stdinp));

5591

while (!(dc == EOF(-1) || dc == '\n'))

5592

dc = getchar()(!__isthreaded ? (--(__stdinp)->_r < 0 ? __srget(__stdinp
) : (int)(*(__stdinp)->_p++)) : (getc)(__stdinp)); /* goto end of line */

5593

if ((c != 'y') && (c != 'Y')) {

5594

fprintf(STDERR__stderrp, "aborted.\n");

5595

return -1;

5596

}

5597

}

5598

}

5599

5600

vcode =

5601

ubik_VL_SetLock(cstruct, 0, entry.volumeId[RWVOL0], RWVOL0,

5602

VLOP_MOVE0x10);

5603

aconn = UV_Bind(server, AFSCONF_VOLUMEPORT7005);

5604

code = AFSVolConvertROtoRWvolume(aconn, partition, volid);

5605

if (code) {

5606

fprintf(STDERR__stderrp,

5607

"Converting RO volume %lu to RW volume failed with code %d\n",

5608

(unsigned long)volid, code);

5609

PrintError("convertROtoRW ", code);

5610

return -1;

5611

}

5612

entry.serverFlags[roindex] = ITSRWVOL0x04;

5613

entry.flags |= RW_EXISTS0x1000;

5614

entry.flags &= ~BACK_EXISTS0x4000;

5615

if (rwserver) {

5616

(entry.nServers)--;

5617

if (rwindex != entry.nServers) {

5618

entry.serverNumber[rwindex] = entry.serverNumber[entry.nServers];

5619

entry.serverPartition[rwindex] =

5620

entry.serverPartition[entry.nServers];

5621

entry.serverFlags[rwindex] = entry.serverFlags[entry.nServers];

5622

entry.serverNumber[entry.nServers] = 0;

5623

entry.serverPartition[entry.nServers] = 0;

5624

entry.serverFlags[entry.nServers] = 0;

5625

}

5626

}

5627

entry.flags &= ~RO_EXISTS0x2000;

5628

for (i = 0; i < entry.nServers; i++) {

5629

if (entry.serverFlags[i] & ITSROVOL0x02) {

5630

if (!(entry.serverFlags[i] & (RO_DONTUSE0x20 | NEW_REPSITE0x01)))

5631

entry.flags |= RO_EXISTS0x2000;

5632

}

5633

}

5634

MapNetworkToHost(&entry, &storeEntry);

5635

code =

5636

VLDB_ReplaceEntry(entry.volumeId[RWVOL0], RWVOL0, &storeEntry,

5637

(LOCKREL_OPCODE2 | LOCKREL_AFSID4 |

5638

LOCKREL_TIMESTAMP1));

5639

if (code) {

5640

fprintf(STDERR__stderrp,

5641

"Warning: volume converted, but vldb update failed with code %d!\n",

5642

code);

5643

}

5644

vcode = UV_LockRelease(entry.volumeId[RWVOL0]);

5645

if (vcode) {

5646

PrintDiagnostics("unlock", vcode);

5647

}

5648

return code;

5649

}

5650

5651

static int

5652

Sizes(struct cmd_syndesc *as, void *arock)

5653

{

5654

afs_uint32 avolid;

5655

afs_uint32 aserver;

5656

afs_int32 apart, voltype, fromdate = 0, code, err, i;

5657

struct nvldbentry entry;

5658

volintSize vol_size;

5659

5660

rx_SetRxDeadTime(60 * 10)(rx_connDeadTime = (60 * 10));

5661

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

5662

struct rx_connection *rxConn = ubik_GetRPCConn(cstruct, i)((i) >= 20? 0 : (cstruct)->conns[i]);

5663

if (rxConn == 0)

5664

break;

5665

rx_SetConnDeadTime(rxConn, rx_connDeadTime);

5666

if (rxConn->service)

5667

rxConn->service->connDeadTime = rx_connDeadTime;

5668

}

5669

5670

avolid = vsu_GetVolumeID(as->parms[0].items->data, cstruct, &err);

5671

if (avolid == 0) {

5672

if (err)

5673

PrintError("", err);

5674

else

5675

fprintf(STDERR__stderrp, "vos: can't find volume '%s'\n",

5676

as->parms[0].items->data);

5677

return ENOENT2;

5678

}

5679

5680

if (as->parms[1].items || as->parms[2].items) {

5681

if (!as->parms[1].items || !as->parms[2].items) {

5682

fprintf(STDERR__stderrp,

5683

"Must specify both -server and -partition options\n");

5684

return -1;

5685

}

5686

aserver = GetServer(as->parms[2].items->data);

5687

if (aserver == 0) {

5688

fprintf(STDERR__stderrp, "Invalid server name\n");

5689

return -1;

5690

}

5691

apart = volutil_GetPartitionID(as->parms[1].items->data);

5692

if (apart < 0) {

5693

fprintf(STDERR__stderrp, "Invalid partition name\n");

5694

return -1;

5695

}

5696

} else {

5697

code = GetVolumeInfo(avolid, &aserver, &apart, &voltype, &entry);

5698

if (code)

5699

return code;

5700

}

5701

5702

fromdate = 0;

5703

5704

if (as->parms[4].items && strcmp(as->parms[4].items->data, "0")) {

5705

code = ktime_DateToInt32(as->parms[4].items->data, &fromdate);

5706

if (code) {

5707

fprintf(STDERR__stderrp, "vos: failed to parse date '%s' (error=%d))\n",

5708

as->parms[4].items->data, code);

5709

return code;

5710

}

5711

}

5712

5713

fprintf(STDOUT__stdoutp, "Volume: %s\n", as->parms[0].items->data);

5714

5715

if (as->parms[3].items) { /* do the dump estimate */

5716

vol_size.dump_size = 0;

5717

code = UV_GetSize(avolid, aserver, apart, fromdate, &vol_size);

5718

if (code) {

5719

PrintDiagnostics("size", code);

5720

return code;

5721

}

5722

/* presumably the size info is now gathered in pntr */

5723

/* now we display it */

5724

5725

fprintf(STDOUT__stdoutp, "dump_size: %llu\n", vol_size.dump_size);

5726

}

5727

5728

/* Display info */

5729

5730

return 0;

5731

}

5732

5733

static int

5734

EndTrans(struct cmd_syndesc *as, void *arock)

5735

{

5736

afs_uint32 server;

5737

afs_int32 code, tid, rcode;

5738

struct rx_connection *aconn;

5739

5740

server = GetServer(as->parms[0].items->data);

5741

if (!server) {

5742

fprintf(STDERR__stderrp, "vos: host '%s' not found in host table\n",

5743

as->parms[0].items->data);

5744

return EINVAL22;

5745

}

5746

5747

code = util_GetInt32(as->parms[1].items->data, &tid);

5748

if (code) {

5749

fprintf(STDERR__stderrp, "vos: bad integer specified for transaction ID.\n");

5750

return code;

5751

}

5752

5753

aconn = UV_Bind(server, AFSCONF_VOLUMEPORT7005);

5754

code = AFSVolEndTrans(aconn, tid, &rcode);

5755

if (!code) {

5756

code = rcode;

5757

}

5758

5759

if (code) {

5760

PrintDiagnostics("endtrans", code);

5761

return 1;

5762

}

5763

5764

return 0;

5765

}

5766

5767

int

5768

PrintDiagnostics(char *astring, afs_int32 acode)

5769

{

5770

if (acode == EACCES13) {

5771

fprintf(STDERR__stderrp,

5772

"You are not authorized to perform the 'vos %s' command (%d)\n",

5773

astring, acode);

5774

} else {

5775

fprintf(STDERR__stderrp, "Error in vos %s command.\n", astring);

5776

PrintError("", acode);

5777

}

5778

return 0;

5779

}

5780

5781

5782

#ifdef AFS_NT40_ENV

5783

static DWORD

5784

win32_enableCrypt(void)

5785

{

5786

HKEY parmKey;

5787

DWORD dummyLen;

5788

DWORD cryptall = 0;

5789

DWORD code;

5790

5791

/* Look up configuration parameters in Registry */

5792

code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,

5793

0, (IsWow64()?KEY_WOW64_64KEY:0)|KEY_QUERY_VALUE, &parmKey);

5794

if (code != ERROR_SUCCESS) {

5795

dummyLen = sizeof(cryptall);

5796

RegQueryValueEx(parmKey, "SecurityLevel", NULL((void *)0), NULL((void *)0),

5797

(BYTE *) &cryptall, &dummyLen);

5798

}

5799

RegCloseKey (parmKey);

5800

5801

return cryptall;

5802

}

5803

#endif /* AFS_NT40_ENV */

5804

5805

static int

5806

MyBeforeProc(struct cmd_syndesc *as, void *arock)

5807

{

5808

char *tcell;

5809

afs_int32 code;

5810

afs_int32 sauth;

5811

5812

/* Initialize the ubik_client connection */

5813

rx_SetRxDeadTime(90)(rx_connDeadTime = (90));

5814

cstruct = (struct ubik_client *)0;

5815

5816

sauth = 0;

5817

tcell = NULL((void *)0);

5818

if (as->parms[12].items) /* if -cell specified */

5819

tcell = as->parms[12].items->data;

5820

if (as->parms[14].items) /* -serverauth specified */

5821

sauth = 1;

5822

if (as->parms[16].items /* -encrypt specified */

5823

#ifdef AFS_NT40_ENV

5824

|| win32_enableCrypt()

5825

#endif /* AFS_NT40_ENV */

5826

)

5827

vsu_SetCrypt(1);

5828

5829

if (as->parms[18].items) /* -config flag set */

5830

confdir = as->parms[18].items->data;

5831

5832

if ((code =

5833

vsu_ClientInit((as->parms[13].items != 0), confdir, tcell, sauth,

5834

&cstruct, UV_SetSecurity))) {

5835

fprintf(STDERR__stderrp, "could not initialize VLDB library (code=%lu) \n",

5836

(unsigned long)code);

5837

exit(1);

5838

}

5839

rxInitDone = 1;

5840

if (as->parms[15].items) /* -verbose flag set */

5841

verbose = 1;

5842

else

5843

verbose = 0;

5844

if (as->parms[17].items) /* -noresolve flag set */

5845

noresolve = 1;

5846

else

5847

noresolve = 0;

5848

5849

return 0;

5850

}

5851

5852

int

5853

osi_audit(void)

5854

{

5855

/* this sucks but it works for now.

5856

5857

return 0;

5858

}

5859

5860

#include "AFS_component_version_number.c"

5861

5862

int

5863

main(int argc, char **argv)

5864

{

5865

afs_int32 code;

5866

5867

struct cmd_syndesc *ts;

5868

5869

#ifdef AFS_AIX32_ENV

5870

5871

* The following signal action for AIX is necessary so that in case of a

5872

* crash (i.e. core is generated) we can include the user's data section

5873

* in the core dump. Unfortunately, by default, only a partial core is

5874

* generated which, in many cases, isn't too useful.

5875

5876

struct sigaction nsa;

5877

5878

sigemptyset(&nsa.sa_mask);

5879

nsa.sa_handler__sigaction_u.__sa_handler = SIG_DFL((__sighandler_t *)0);

5880

nsa.sa_flags = SA_FULLDUMP;

5881

sigaction(SIGSEGV11, &nsa, NULL((void *)0));

5882

#endif

5883

5884

confdir = AFSDIR_CLIENT_ETC_DIRPATHgetDirPath(AFSDIR_CLIENT_ETC_DIRPATH_ID);

5885

5886

cmd_SetBeforeProc(MyBeforeProc, NULL((void *)0));

5887

5888

ts = cmd_CreateSyntax("create", CreateVolume, NULL((void *)0), "create a new volume");

5889

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

5890

cmd_AddParm(ts, "-partition", CMD_SINGLE2, 0, "partition name");

5891

cmd_AddParm(ts, "-name", CMD_SINGLE2, 0, "volume name");

5892

cmd_AddParm(ts, "-maxquota", CMD_SINGLE2, CMD_OPTIONAL1,

5893

"initial quota (KB)");

5894

cmd_AddParm(ts, "-id", CMD_SINGLE2, CMD_OPTIONAL1, "volume ID");

5895

cmd_AddParm(ts, "-roid", CMD_SINGLE2, CMD_OPTIONAL1, "readonly volume ID");

5896

#ifdef notdef

5897

cmd_AddParm(ts, "-minquota", CMD_SINGLE2, CMD_OPTIONAL1, "");

5898

#endif

5899

COMMONPARMScmd_Seek(ts, 12);cmd_AddParm(ts, "-cell", 2, 1, "cell name");
cmd_AddParm(ts, "-noauth", 1, 1, "don't authenticate");cmd_AddParm
(ts, "-localauth",1,1,"use server tickets");cmd_AddParm(ts, "-verbose"
, 1, 1, "verbose");cmd_AddParm(ts, "-encrypt", 1, 1, "encrypt commands"
);cmd_AddParm(ts, "-noresolve", 1, 1, "don't resolve addresses"
); cmd_AddParm(ts, "-config", 2, 1, "config location");;

5900

5901

ts = cmd_CreateSyntax("remove", DeleteVolume, NULL((void *)0), "delete a volume");

5902

cmd_AddParm(ts, "-server", CMD_SINGLE2, CMD_OPTIONAL1, "machine name");

5903

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

5904

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

5905

5906

5907

5908

ts = cmd_CreateSyntax("move", MoveVolume, NULL((void *)0), "move a volume");

5909

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

5910

cmd_AddParm(ts, "-fromserver", CMD_SINGLE2, 0, "machine name on source");

5911

cmd_AddParm(ts, "-frompartition", CMD_SINGLE2, 0,

5912

"partition name on source");

5913

cmd_AddParm(ts, "-toserver", CMD_SINGLE2, 0,

5914

"machine name on destination");

5915

cmd_AddParm(ts, "-topartition", CMD_SINGLE2, 0,

5916

"partition name on destination");

5917

cmd_AddParm(ts, "-live", CMD_FLAG1, CMD_OPTIONAL1,

5918

"copy live volume without cloning");

5919

5920

5921

ts = cmd_CreateSyntax("copy", CopyVolume, NULL((void *)0), "copy a volume");

5922

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID on source");

5923

cmd_AddParm(ts, "-fromserver", CMD_SINGLE2, 0, "machine name on source");

5924

cmd_AddParm(ts, "-frompartition", CMD_SINGLE2, 0,

5925

"partition name on source");

5926

cmd_AddParm(ts, "-toname", CMD_SINGLE2, 0, "volume name on destination");

5927

cmd_AddParm(ts, "-toserver", CMD_SINGLE2, 0,

5928

"machine name on destination");

5929

cmd_AddParm(ts, "-topartition", CMD_SINGLE2, 0,

5930

"partition name on destination");

5931

cmd_AddParm(ts, "-offline", CMD_FLAG1, CMD_OPTIONAL1,

5932

"leave new volume offline");

5933

cmd_AddParm(ts, "-readonly", CMD_FLAG1, CMD_OPTIONAL1,

5934

"make new volume read-only");

5935

cmd_AddParm(ts, "-live", CMD_FLAG1, CMD_OPTIONAL1,

5936

"copy live volume without cloning");

5937

5938

5939

ts = cmd_CreateSyntax("shadow", ShadowVolume, NULL((void *)0),

5940

"make or update a shadow volume");

5941

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID on source");

5942

cmd_AddParm(ts, "-fromserver", CMD_SINGLE2, 0, "machine name on source");

5943

cmd_AddParm(ts, "-frompartition", CMD_SINGLE2, 0,

5944

"partition name on source");

5945

cmd_AddParm(ts, "-toserver", CMD_SINGLE2, 0,

5946

"machine name on destination");

5947

cmd_AddParm(ts, "-topartition", CMD_SINGLE2, 0,

5948

"partition name on destination");

5949

cmd_AddParm(ts, "-toname", CMD_SINGLE2, CMD_OPTIONAL1,

5950

"volume name on destination");

5951

cmd_AddParm(ts, "-toid", CMD_SINGLE2, CMD_OPTIONAL1,

5952

"volume ID on destination");

5953

cmd_AddParm(ts, "-offline", CMD_FLAG1, CMD_OPTIONAL1,

5954

"leave shadow volume offline");

5955

cmd_AddParm(ts, "-readonly", CMD_FLAG1, CMD_OPTIONAL1,

5956

"make shadow volume read-only");

5957

cmd_AddParm(ts, "-live", CMD_FLAG1, CMD_OPTIONAL1,

5958

"copy live volume without cloning");

5959

cmd_AddParm(ts, "-incremental", CMD_FLAG1, CMD_OPTIONAL1,

5960

"do incremental update if target exists");

5961

5962

5963

ts = cmd_CreateSyntax("backup", BackupVolume, NULL((void *)0),

5964

"make backup of a volume");

5965

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

5966

5967

5968

ts = cmd_CreateSyntax("clone", CloneVolume, NULL((void *)0),

5969

"make clone of a volume");

5970

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

5971

cmd_AddParm(ts, "-server", CMD_SINGLE2, CMD_OPTIONAL1, "server");

5972

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition");

5973

cmd_AddParm(ts, "-toname", CMD_SINGLE2, CMD_OPTIONAL1,

5974

"volume name on destination");

5975

cmd_AddParm(ts, "-toid", CMD_SINGLE2, CMD_OPTIONAL1,

5976

"volume ID on destination");

5977

cmd_AddParm(ts, "-offline", CMD_FLAG1, CMD_OPTIONAL1,

5978

"leave clone volume offline");

5979

cmd_AddParm(ts, "-readonly", CMD_FLAG1, CMD_OPTIONAL1,

5980

"make clone volume read-only, not readwrite");

5981

5982

5983

ts = cmd_CreateSyntax("release", ReleaseVolume, NULL((void *)0), "release a volume");

5984

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

5985

cmd_AddParm(ts, "-force", CMD_FLAG1, CMD_OPTIONAL1,

5986

"force a complete release");

5987

5988

5989

ts = cmd_CreateSyntax("dump", DumpVolumeCmd, NULL((void *)0), "dump a volume");

5990

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

5991

cmd_AddParm(ts, "-time", CMD_SINGLE2, CMD_OPTIONAL1, "dump from time");

5992

cmd_AddParm(ts, "-file", CMD_SINGLE2, CMD_OPTIONAL1, "dump file");

5993

cmd_AddParm(ts, "-server", CMD_SINGLE2, CMD_OPTIONAL1, "server");

5994

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition");

5995

cmd_AddParm(ts, "-clone", CMD_FLAG1, CMD_OPTIONAL1,

5996

"dump a clone of the volume");

5997

cmd_AddParm(ts, "-omitdirs", CMD_FLAG1, CMD_OPTIONAL1,

5998

"omit unchanged directories from an incremental dump");

5999

6000

6001

ts = cmd_CreateSyntax("restore", RestoreVolumeCmd, NULL((void *)0),

6002

"restore a volume");

6003

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6004

cmd_AddParm(ts, "-partition", CMD_SINGLE2, 0, "partition name");

6005

cmd_AddParm(ts, "-name", CMD_SINGLE2, 0, "name of volume to be restored");

6006

cmd_AddParm(ts, "-file", CMD_SINGLE2, CMD_OPTIONAL1, "dump file");

6007

cmd_AddParm(ts, "-id", CMD_SINGLE2, CMD_OPTIONAL1, "volume ID");

6008

cmd_AddParm(ts, "-overwrite", CMD_SINGLE2, CMD_OPTIONAL1,

6009

"abort | full | incremental");

6010

cmd_AddParm(ts, "-offline", CMD_FLAG1, CMD_OPTIONAL1,

6011

"leave restored volume offline");

6012

cmd_AddParm(ts, "-readonly", CMD_FLAG1, CMD_OPTIONAL1,

6013

"make restored volume read-only");

6014

cmd_AddParm(ts, "-creation", CMD_SINGLE2, CMD_OPTIONAL1,

6015

"dump | keep | new");

6016

cmd_AddParm(ts, "-lastupdate", CMD_SINGLE2, CMD_OPTIONAL1,

6017

"dump | keep | new");

6018

cmd_AddParm(ts, "-nodelete", CMD_FLAG1, CMD_OPTIONAL1,

6019

"do not delete old site when restoring to a new site");

6020

6021

6022

ts = cmd_CreateSyntax("unlock", LockReleaseCmd, NULL((void *)0),

6023

"release lock on VLDB entry for a volume");

6024

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6025

6026

6027

ts = cmd_CreateSyntax("changeloc", ChangeLocation, NULL((void *)0),

6028

"change an RW volume's location in the VLDB");

6029

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0,

6030

"machine name for new location");

6031

cmd_AddParm(ts, "-partition", CMD_SINGLE2, 0,

6032

"partition name for new location");

6033

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6034

6035

6036

ts = cmd_CreateSyntax("addsite", AddSite, NULL((void *)0), "add a replication site");

6037

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name for new site");

6038

cmd_AddParm(ts, "-partition", CMD_SINGLE2, 0,

6039

"partition name for new site");

6040

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6041

cmd_AddParm(ts, "-roid", CMD_SINGLE2, CMD_OPTIONAL1, "volume name or ID for RO");

6042

cmd_AddParm(ts, "-valid", CMD_FLAG1, CMD_OPTIONAL1, "publish as an up-to-date site in VLDB");

6043

6044

6045

ts = cmd_CreateSyntax("remsite", RemoveSite, NULL((void *)0),

6046

"remove a replication site");

6047

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6048

cmd_AddParm(ts, "-partition", CMD_SINGLE2, 0, "partition name");

6049

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6050

6051

6052

ts = cmd_CreateSyntax("listpart", ListPartitions, NULL((void *)0), "list partitions");

6053

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6054

6055

6056

ts = cmd_CreateSyntax("listvol", ListVolumes, NULL((void *)0),

6057

"list volumes on server (bypass VLDB)");

6058

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6059

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

6060

cmd_AddParm(ts, "-fast", CMD_FLAG1, CMD_OPTIONAL1, "minimal listing");

6061

cmd_AddParm(ts, "-long", CMD_FLAG1, CMD_OPTIONAL1,

6062

"list all normal volume fields");

6063

cmd_AddParm(ts, "-quiet", CMD_FLAG1, CMD_OPTIONAL1,

6064

"generate minimal information");

6065

cmd_AddParm(ts, "-extended", CMD_FLAG1, CMD_OPTIONAL1,

6066

"list extended volume fields");

6067

cmd_AddParm(ts, "-format", CMD_FLAG1, CMD_OPTIONAL1,

6068

"machine readable format");

6069

6070

6071

ts = cmd_CreateSyntax("syncvldb", SyncVldb, NULL((void *)0),

6072

"synchronize VLDB with server");

6073

cmd_AddParm(ts, "-server", CMD_SINGLE2, CMD_OPTIONAL1, "machine name");

6074

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

6075

cmd_AddParm(ts, "-volume", CMD_SINGLE2, CMD_OPTIONAL1, "volume name or ID");

6076

cmd_AddParm(ts, "-dryrun", CMD_FLAG1, CMD_OPTIONAL1, "list what would be done, don't do it");

6077

6078

6079

ts = cmd_CreateSyntax("syncserv", SyncServer, NULL((void *)0),

6080

"synchronize server with VLDB");

6081

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6082

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

6083

cmd_AddParm(ts, "-dryrun", CMD_FLAG1, CMD_OPTIONAL1, "list what would be done, don't do it");

6084

6085

6086

ts = cmd_CreateSyntax("examine", ExamineVolume, NULL((void *)0),

6087

"everything about the volume");

6088

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6089

cmd_AddParm(ts, "-extended", CMD_FLAG1, CMD_OPTIONAL1,

6090

"list extended volume fields");

6091

cmd_AddParm(ts, "-format", CMD_FLAG1, CMD_OPTIONAL1,

6092

"machine readable format");

6093

6094

cmd_CreateAlias(ts, "volinfo");

6095

6096

ts = cmd_CreateSyntax("setfields", SetFields, NULL((void *)0),

6097

"change volume info fields");

6098

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6099

cmd_AddParm(ts, "-maxquota", CMD_SINGLE2, CMD_OPTIONAL1, "quota (KB)");

6100

cmd_AddParm(ts, "-clearuse", CMD_FLAG1, CMD_OPTIONAL1, "clear dayUse");

6101

cmd_AddParm(ts, "-clearVolUpCounter", CMD_FLAG1, CMD_OPTIONAL1, "clear volUpdateCounter");

6102

6103

6104

ts = cmd_CreateSyntax("offline", volOffline, NULL((void *)0), "force the volume status to offline");

6105

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "server name");

6106

cmd_AddParm(ts, "-partition", CMD_SINGLE2, 0, "partition name");

6107

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6108

cmd_AddParm(ts, "-sleep", CMD_SINGLE2, CMD_OPTIONAL1, "seconds to sleep");

6109

cmd_AddParm(ts, "-busy", CMD_FLAG1, CMD_OPTIONAL1, "busy volume");

6110

6111

6112

ts = cmd_CreateSyntax("online", volOnline, NULL((void *)0), "force the volume status to online");

6113

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "server name");

6114

cmd_AddParm(ts, "-partition", CMD_SINGLE2, 0, "partition name");

6115

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6116

6117

6118

ts = cmd_CreateSyntax("zap", VolumeZap, NULL((void *)0),

6119

"delete the volume, don't bother with VLDB");

6120

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6121

cmd_AddParm(ts, "-partition", CMD_SINGLE2, 0, "partition name");

6122

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume ID");

6123

cmd_AddParm(ts, "-force", CMD_FLAG1, CMD_OPTIONAL1,

6124

"force deletion of bad volumes");

6125

cmd_AddParm(ts, "-backup", CMD_FLAG1, CMD_OPTIONAL1,

6126

"also delete backup volume if one is found");

6127

6128

6129

ts = cmd_CreateSyntax("status", VolserStatus, NULL((void *)0),

6130

"report on volser status");

6131

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6132

6133

6134

ts = cmd_CreateSyntax("rename", RenameVolume, NULL((void *)0), "rename a volume");

6135

cmd_AddParm(ts, "-oldname", CMD_SINGLE2, 0, "old volume name ");

6136

cmd_AddParm(ts, "-newname", CMD_SINGLE2, 0, "new volume name ");

6137

6138

6139

ts = cmd_CreateSyntax("listvldb", ListVLDB, NULL((void *)0),

6140

"list volumes in the VLDB");

6141

cmd_AddParm(ts, "-name", CMD_SINGLE2, CMD_OPTIONAL1, "volume name or ID");

6142

cmd_AddParm(ts, "-server", CMD_SINGLE2, CMD_OPTIONAL1, "machine name");

6143

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

6144

cmd_AddParm(ts, "-locked", CMD_FLAG1, CMD_OPTIONAL1, "locked volumes only");

6145

cmd_AddParm(ts, "-quiet", CMD_FLAG1, CMD_OPTIONAL1,

6146

"generate minimal information");

6147

cmd_AddParm(ts, "-nosort", CMD_FLAG1, CMD_OPTIONAL1,

6148

"do not alphabetically sort the volume names");

6149

6150

6151

ts = cmd_CreateSyntax("backupsys", BackSys, NULL((void *)0), "en masse backups");

6152

cmd_AddParm(ts, "-prefix", CMD_LIST3, CMD_OPTIONAL1,

6153

"common prefix on volume(s)");

6154

cmd_AddParm(ts, "-server", CMD_SINGLE2, CMD_OPTIONAL1, "machine name");

6155

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

6156

cmd_AddParm(ts, "-exclude", CMD_FLAG1, CMD_OPTIONAL1,

6157

"exclude common prefix volumes");

6158

cmd_AddParm(ts, "-xprefix", CMD_LIST3, CMD_OPTIONAL1,

6159

"negative prefix on volume(s)");

6160

cmd_AddParm(ts, "-dryrun", CMD_FLAG1, CMD_OPTIONAL1, "list what would be done, don't do it");

6161

6162

6163

ts = cmd_CreateSyntax("delentry", DeleteEntry, NULL((void *)0),

6164

"delete VLDB entry for a volume");

6165

cmd_AddParm(ts, "-id", CMD_LIST3, CMD_OPTIONAL1, "volume name or ID");

6166

cmd_AddParm(ts, "-prefix", CMD_SINGLE2, CMD_OPTIONAL1,

6167

"prefix of the volume whose VLDB entry is to be deleted");

6168

cmd_AddParm(ts, "-server", CMD_SINGLE2, CMD_OPTIONAL1, "machine name");

6169

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

6170

cmd_AddParm(ts, "-noexecute", CMD_FLAG1, CMD_OPTIONAL1|CMD_HIDDEN4, "");

6171

cmd_AddParm(ts, "-dryrun", CMD_FLAG1, CMD_OPTIONAL1,

6172

"list what would be done, don't do it");

6173

6174

6175

ts = cmd_CreateSyntax("partinfo", PartitionInfo, NULL((void *)0),

6176

"list partition information");

6177

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6178

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

6179

cmd_AddParm(ts, "-summary", CMD_FLAG1, CMD_OPTIONAL1,

6180

"print storage summary");

6181

6182

6183

ts = cmd_CreateSyntax("unlockvldb", UnlockVLDB, NULL((void *)0),

6184

"unlock all the locked entries in the VLDB");

6185

cmd_AddParm(ts, "-server", CMD_SINGLE2, CMD_OPTIONAL1, "machine name");

6186

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

6187

6188

6189

ts = cmd_CreateSyntax("lock", LockEntry, NULL((void *)0),

6190

"lock VLDB entry for a volume");

6191

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6192

6193

6194

ts = cmd_CreateSyntax("changeaddr", ChangeAddr, NULL((void *)0),

6195

"change the IP address of a file server");

6196

cmd_AddParm(ts, "-oldaddr", CMD_SINGLE2, 0, "original IP address");

6197

cmd_AddParm(ts, "-newaddr", CMD_SINGLE2, CMD_OPTIONAL1, "new IP address");

6198

cmd_AddParm(ts, "-remove", CMD_FLAG1, CMD_OPTIONAL1,

6199

"remove the IP address from the VLDB");

6200

6201

6202

ts = cmd_CreateSyntax("listaddrs", ListAddrs, NULL((void *)0),

6203

"list the IP address of all file servers registered in the VLDB");

6204

cmd_AddParm(ts, "-uuid", CMD_SINGLE2, CMD_OPTIONAL1, "uuid of server");

6205

cmd_AddParm(ts, "-host", CMD_SINGLE2, CMD_OPTIONAL1, "address of host");

6206

cmd_AddParm(ts, "-printuuid", CMD_FLAG1, CMD_OPTIONAL1,

6207

"print uuid of hosts");

6208

6209

6210

ts = cmd_CreateSyntax("convertROtoRW", ConvertRO, NULL((void *)0),

6211

"convert a RO volume into a RW volume (after loss of old RW volume)");

6212

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6213

cmd_AddParm(ts, "-partition", CMD_SINGLE2, 0, "partition name");

6214

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6215

cmd_AddParm(ts, "-force", CMD_FLAG1, CMD_OPTIONAL1, "don't ask");

6216

6217

6218

ts = cmd_CreateSyntax("size", Sizes, NULL((void *)0),

6219

"obtain various sizes of the volume.");

6220

cmd_AddParm(ts, "-id", CMD_SINGLE2, 0, "volume name or ID");

6221

cmd_AddParm(ts, "-partition", CMD_SINGLE2, CMD_OPTIONAL1, "partition name");

6222

cmd_AddParm(ts, "-server", CMD_SINGLE2, CMD_OPTIONAL1, "machine name");

6223

cmd_AddParm(ts, "-dump", CMD_FLAG1, CMD_OPTIONAL1,

6224

"Obtain the size of the dump");

6225

cmd_AddParm(ts, "-time", CMD_SINGLE2, CMD_OPTIONAL1, "dump from time");

6226

6227

6228

ts = cmd_CreateSyntax("endtrans", EndTrans, NULL((void *)0),

6229

"end a volserver transaction");

6230

cmd_AddParm(ts, "-server", CMD_SINGLE2, 0, "machine name");

6231

cmd_AddParm(ts, "-transaction", CMD_SINGLE2, 0,

6232

"transaction ID");

6233

6234

6235

ts = cmd_CreateSyntax("setaddrs", SetAddrs, NULL((void *)0),

6236

"set the list of IP address for a given UUID in the VLDB");

6237

cmd_AddParm(ts, "-uuid", CMD_SINGLE2, 0, "uuid of server");

6238

cmd_AddParm(ts, "-host", CMD_LIST3, 0, "address of host");

6239

6240

6241

code = cmd_Dispatch(argc, argv);

6242

if (rxInitDone) {

6243

/* Shut down the ubik_client and rx connections */

6244

if (cstruct) {

6245

(void)ubik_ClientDestroy(cstruct);

6246

cstruct = 0;

6247

}

6248

rx_Finalize();

6249

}

6250

6251

exit((code ? -1 : 0));

6252

}