~drizzle-trunk/drizzle/development

void MSRepoFile::sendBlob(MSOpenTable *otab, uint64_t offset, uint64_t req_offset, uint64_t req_size, uint32_t auth_code, bool with_auth_code, bool info_only, CSHTTPOutputStream *stream)

195

{

196

MSConnectionHandler *me;

197

size_t tfer;

198

off64_t start_offset = offset;

199

MSBlobHeadRec blob_head;

200

uint8_t storage_type;

201

uint16_t head_size, meta_size;

202

uint64_t blob_data_size, local_blob_size, meta_offset;

203

uint32_t ac;

204

char num_str[CS_WIDTH_INT_64];

205

bool redirect = false;

206

207

208

enter_();

209

me = (MSConnectionHandler *) self;

210

211

read(&blob_head, start_offset, sizeof(MSBlobHeadRec), sizeof(MSBlobHeadRec));

212

local_blob_size = CS_GET_DISK_6(blob_head.rb_blob_repo_size_6); // This is the size of the BLOB data in the repository. Can be 0 if the BLOB is stored some where else.

213

blob_data_size = CS_GET_DISK_6(blob_head.rb_blob_data_size_6);// This is the actual size of the BLOB.

214

head_size = CS_GET_DISK_2(blob_head.rb_head_size_2);

215

meta_size = CS_GET_DISK_2(blob_head.rb_mdata_size_2);

216

meta_offset = start_offset + CS_GET_DISK_2(blob_head.rb_mdata_offset_2);

217

ac = CS_GET_DISK_4(blob_head.rb_auth_code_4);

218

if ((with_auth_code && auth_code != ac) || (CS_GET_DISK_4(blob_head.rd_magic_4) != MS_BLOB_HEADER_MAGIC))

219

CSException::throwException(CS_CONTEXT, MS_ERR_AUTH_FAILED, "Invalid BLOB identifier");

220

221

storage_type = CS_GET_DISK_1(blob_head.rb_storage_type_1);

222

223

if ((!info_only) && BLOB_IN_CLOUD(storage_type)) {

224

CSString *redirect_url = NULL;

225

CloudKeyRec key;

226

getBlobKey(&blob_head, &key);

227

redirect_url = otab->getDB()->myBlobCloud->cl_getDataURL(&key);

228

push_(redirect_url);

229

stream->setStatus(301);

230

stream->addHeader("Location", redirect_url->getCString());

231

release_(redirect_url);

232

redirect = true;

233

} else

234

stream->setStatus(200);

235

236

if (storage_type == MS_STANDARD_STORAGE) {

237

char hex_checksum[33];

238

cs_bin_to_hex(33, hex_checksum, 16, blob_head.rb_blob_checksum_md5d.val);

239

stream->addHeader(MS_CHECKSUM_TAG, hex_checksum);

240

}

241

242

snprintf(num_str, CS_WIDTH_INT_64, "%"PRIu64"", blob_data_size);

243

stream->addHeader(MS_BLOB_SIZE, num_str);

244

245

snprintf(num_str, CS_WIDTH_INT_64, "%"PRIu32"", CS_GET_DISK_4(blob_head.rb_last_access_4));

246

stream->addHeader(MS_LAST_ACCESS, num_str);

247

248

snprintf(num_str, CS_WIDTH_INT_64, "%"PRIu32"", CS_GET_DISK_4(blob_head.rb_access_count_4));

249

stream->addHeader(MS_ACCESS_COUNT, num_str);

250

251

snprintf(num_str, CS_WIDTH_INT_64, "%"PRIu32"", CS_GET_DISK_4(blob_head.rb_create_time_4));

252

stream->addHeader(MS_CREATION_TIME, num_str);

253

254

snprintf(num_str, CS_WIDTH_INT_64, "%"PRIu32"", storage_type);

255

stream->addHeader(MS_BLOB_TYPE, num_str);

256

257

258

// Add the meta data headers.

259

if (meta_size) {

260

MetaData metadata;

261

char *name, *value;

262

263

read(otab->myOTBuffer, meta_offset, meta_size, meta_size);

264

metadata.use_data(otab->myOTBuffer, meta_size);

265

while ((name = metadata.findNext(&value))) {

266

stream->addHeader(name, value);

267

}

268

269

}

270

271

offset += (uint64_t) head_size + req_offset;

272

local_blob_size -= req_offset;

273

if (local_blob_size > req_size)

274

local_blob_size = req_size;

275

276

stream->setContentLength((redirect || info_only)?0:local_blob_size);

277

stream->writeHead();

278

me->replyPending = false;

279

280

if ((!redirect) && !info_only) {

281

282

while (local_blob_size > 0) {

283

if (local_blob_size <= MS_OT_BUFFER_SIZE)

284

tfer = (size_t) local_blob_size;

285

else

286

tfer = MS_OT_BUFFER_SIZE;

287

read(otab->myOTBuffer, offset, tfer, tfer);

288

stream->write(otab->myOTBuffer, tfer);

289

offset += (uint64_t) tfer;

290

local_blob_size -= (uint64_t) tfer;

291

}

292

}

293

stream->flush();

294

295

if (!info_only) {

296

// Should the time stamp be updated if only the BLOB info was requested?

297

/* Update the access timestamp: */

298

updateAccess(&blob_head, start_offset);

299

}

300

301

exit_();

302

}

303

304

void MSRepoFile::update_blob_header(MSOpenTable *otab, uint64_t offset, uint64_t blob_size, uint16_t head_size, uint16_t new_head_size)

305

{

306

uint16_t w_offset = offsetof(MSBlobHeadRec, rb_ref_count_2);

307

MSRepoPointersRec ptr;

308

enter_();

309

310

ptr.rp_chars = otab->myOTBuffer;

311

CS_SET_DISK_4(ptr.rp_head->rb_mod_time_4, time(NULL));

312

313

if (head_size == new_head_size) {

314

w_offset = offsetof(MSBlobHeadRec, rb_ref_count_2);

315

write(otab->myOTBuffer + w_offset, offset + w_offset, head_size - w_offset);

316

} else {

317

/* Copy to a new space, free the old: */

318

off64_t dst_offset;

319

CSStringBuffer *buffer;

320

uint16_t ref_count, ref_size;

321

uint32_t tab_id;

322

uint64_t blob_id;

323

324

myRepo->myRepoDatabase->openWriteRepo(otab);

325

dst_offset = otab->myWriteRepo->myRepoFileSize;

326

327

/* Write the header. */

328

otab->myWriteRepoFile->write(otab->myOTBuffer, dst_offset, new_head_size);

329

330

/* We have an engine reference, copy the BLOB over: */

331

new_(buffer, CSStringBuffer());

332

push_(buffer);

333

buffer->setLength(MS_COMPACTOR_BUFFER_SIZE);

334

CSFile::transfer(RETAIN(otab->myWriteRepoFile), dst_offset + new_head_size, RETAIN(this), offset + head_size, blob_size, buffer->getBuffer(0), MS_COMPACTOR_BUFFER_SIZE);

335

release_(buffer);

336

337

#ifdef HAVE_ALIAS_SUPPORT

338

/* Update the BLOB alias if required. */

339

340

if (CS_GET_DISK_2(ptr.rp_head->rb_alias_offset_2)) {

341

uint32_t alias_hash = CS_GET_DISK_4(ptr.rp_head->rb_alias_hash_4);

342

myRepo->myRepoDatabase->moveBlobAlias(myRepo->myRepoID, offset, alias_hash, myRepo->myRepoID, dst_offset);

343

}

344

#endif

345

346

/* Update the references: */

347

ref_size = CS_GET_DISK_1(ptr.rp_head->rb_ref_size_1);

348

ref_count = CS_GET_DISK_2(ptr.rp_head->rb_ref_count_2);

349

ptr.rp_chars += myRepo->myRepoBlobHeadSize;

350

351

while (ref_count) {

352

switch (CS_GET_DISK_2(ptr.rp_ref->rr_type_2)) {

353

case MS_BLOB_FREE_REF:

354

break;

355

case MS_BLOB_TABLE_REF:

356

tab_id = CS_GET_DISK_4(ptr.rp_tab_ref->tr_table_id_4);

357

blob_id = CS_GET_DISK_6(ptr.rp_tab_ref->tr_blob_id_6);

358

359

if ((otab->haveTable()) && (otab->getDBTable()->myTableID == tab_id))

360

otab->getDBTable()->updateBlobHandle(otab, blob_id, otab->myWriteRepo->myRepoID, dst_offset, new_head_size);

361

else {

362

MSOpenTable *ref_otab;

363

364

ref_otab = MSTableList::getOpenTableByID(myRepo->myRepoDatabase->myDatabaseID, tab_id);

365

frompool_(ref_otab);

366

ref_otab->getDBTable()->updateBlobHandle(ref_otab, blob_id, otab->myWriteRepo->myRepoID, dst_offset, new_head_size);

367

backtopool_(ref_otab);

368

}

369

break;

370

case MS_BLOB_DELETE_REF:

371

break;

372

default:

373

break;

374

}

375

ptr.rp_chars += ref_size;

376

ref_count--;

377

}

378

379

otab->myWriteRepo->myRepoFileSize += new_head_size + blob_size;

380

381

/* Free the old head: */

382

ptr.rp_chars = otab->myOTBuffer;

383

if (myRepo->lockedForBackup()) {

384

// This is done to tell the backup process that this BLOB was moved

385

// after the backup had started and needs to be backed up also.

386

// (The moved BLOB doesn't though because the change took place after the backup had begone.)

387

CS_SET_DISK_1(ptr.rp_head->rb_status_1, MS_BLOB_MOVED);

388

CS_SET_DISK_4(ptr.rp_head->rb_backup_id_4, myRepo->myRepoDatabase->backupID());

389

} else

390

CS_SET_DISK_1(ptr.rp_head->rb_status_1, MS_BLOB_DELETED);

391

392

write(ptr.rp_chars + MS_BLOB_STAT_OFFS, offset + MS_BLOB_STAT_OFFS, head_size - MS_BLOB_STAT_OFFS);

393

394

#ifdef DO_NOT_WIPE_BLOB

395

// Why is the BLOB header data being wiped here?

396

// The data may be needed for backup.

397

ptr.rp_chars += myRepo->myRepoBlobHeadSize;

398

memset(ptr.rp_chars, 0, head_size - myRepo->myRepoBlobHeadSize);

399

400

w_offset = offsetof(MSBlobHeadRec, rb_alias_hash_4);

401

write(otab->myOTBuffer + w_offset, offset + w_offset, head_size - w_offset);

402

#endif

403

404

/* Increment the garbage count: */

405

updateGarbage(head_size + blob_size);

406

407

}

408

exit_();

409

}

410

411

void MSRepoFile::referenceBlob(MSOpenTable *otab, uint64_t offset, uint16_t head_size, uint32_t tab_id, uint64_t blob_id, uint64_t blob_ref_id, uint32_t auth_code, uint16_t col_index)

412

{

413

CSMutex *myLock;

414

MSRepoPointersRec ptr;

415

uint32_t size, ref_count;

416

size_t ref_size, read_size;

417

MSRepoBlobRefPtr free_ref = NULL;

418

MSRepoBlobRefPtr free2_ref = NULL;

419

MSRepoTableRefPtr tab_ref = NULL;

420

uint16_t new_head_size;

421

#ifdef HAVE_ALIAS_SUPPORT

422

bool reset_alias_index = false;

423

char blob_alias[BLOB_ALIAS_LENGTH];

424

#endif

425

uint64_t blob_size;

426

427

enter_();

428

/* Lock the BLOB: */

429

myLock = &myRepo->myRepoLock[offset % CS_REPO_REC_LOCK_COUNT];

430

lock_(myLock);

431

/* Read the header: */

432

if (head_size > MS_OT_BUFFER_SIZE) {

433

CSException::throwAssertion(CS_CONTEXT, "BLOB header overflow");

434

}

435

436

read_size = read(otab->myOTBuffer, offset, head_size, 0);

437

ptr.rp_chars = otab->myOTBuffer;

438

if (CS_GET_DISK_4(ptr.rp_head->rd_magic_4) != MS_BLOB_HEADER_MAGIC)

439

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "Invalid BLOB identifier");

440

if (read_size < myRepo->myRepoBlobHeadSize)

441

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "BLOB header incomplete");

442

if ( ! IN_USE_BLOB_STATUS(CS_GET_DISK_1(ptr.rp_head->rb_status_1)))

443

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "BLOB has already been deleted");

444

if (CS_GET_DISK_4(ptr.rp_bytes + myRepo->myRepoBlobHeadSize - 4) != auth_code)

445

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "BLOB data does not match reference");

446

/* Assume that what is here is correct: */

447

if (head_size != CS_GET_DISK_2(ptr.rp_head->rb_head_size_2)) {

448

head_size = CS_GET_DISK_2(ptr.rp_head->rb_head_size_2);

449

if (head_size > MS_OT_BUFFER_SIZE) { // Could happen if the header was creatd with a different version of PBMS.

450

CSException::throwAssertion(CS_CONTEXT, "BLOB header overflow");

451

}

452

read_size = read(otab->myOTBuffer, offset, head_size, myRepo->myRepoBlobHeadSize);

453

}

454

head_size = CS_GET_DISK_2(ptr.rp_head->rb_head_size_2);

455

blob_size = CS_GET_DISK_6(ptr.rp_head->rb_blob_repo_size_6);

456

if (read_size < head_size) {

457

/* This should not happen, because the file has been recovered,

458

* which should have already adjusted the head and blob

459

* size.

460

* If this happens then the file must have been truncated an the BLOB has been

461

* lost so we set the blob size to zero.

462

463

head_size = read_size;

464

blob_size = 0;

465

466

}

467

ref_size = CS_GET_DISK_1(ptr.rp_head->rb_ref_size_1);

468

ref_count = CS_GET_DISK_2(ptr.rp_head->rb_ref_count_2);

469

470

#ifdef HAVE_ALIAS_SUPPORT

471

if (CS_GET_DISK_2(ptr.rp_head->rb_alias_offset_2)) {

472

reset_alias_index = true;

473

strcpy(blob_alias, otab->myOTBuffer + CS_GET_DISK_2(ptr.rp_head->rb_alias_offset_2));

474

}

475

#endif

476

477

size = head_size - myRepo->myRepoBlobHeadSize;

478

if (size > ref_size * ref_count)

479

size = ref_size * ref_count;

480

CS_SET_DISK_4(ptr.rp_head->rb_last_ref_4, (uint32_t) time(NULL)); // Set the reference time

481

CS_SET_DISK_1(ptr.rp_head->rb_status_1, MS_BLOB_REFERENCED);

482

ptr.rp_chars += myRepo->myRepoBlobHeadSize;

483

while (size >= ref_size) {

484

switch (CS_GET_DISK_2(ptr.rp_ref->rr_type_2)) {

485

case MS_BLOB_FREE_REF:

486

if (!free_ref)

487

free_ref = ptr.rp_blob_ref;

488

else if (!free2_ref)

489

free2_ref = ptr.rp_blob_ref;

490

break;

491

case MS_BLOB_TABLE_REF:

492

#ifdef HAVE_ALIAS_SUPPORT

493

reset_alias_index = false; // No need to reset the index if the BLOB is already referenced. (We don't care what table references it.)

494

#endif

495

if (CS_GET_DISK_4(ptr.rp_tab_ref->tr_table_id_4) == tab_id &&

496

CS_GET_DISK_6(ptr.rp_tab_ref->tr_blob_id_6) == blob_id)

497

tab_ref = ptr.rp_tab_ref;

498

break;

499

case MS_BLOB_DELETE_REF: {

500

uint32_t tab_index;

501

502

tab_index = CS_GET_DISK_2(ptr.rp_temp_ref->tp_del_ref_2);

503

if (tab_index && tab_index < ref_count) {

504

MSRepoTableRefPtr tr;

505

506

tab_index--;

507

tr = (MSRepoTableRefPtr) (otab->myOTBuffer + myRepo->getRepoBlobHeadSize() + tab_index * ref_size);

508

if (CS_GET_DISK_4(tr->tr_table_id_4) == tab_id &&

509

CS_GET_DISK_6(tr->tr_blob_id_6) == blob_id) {

510

CS_SET_DISK_2(ptr.rp_ref->rr_type_2, MS_BLOB_FREE_REF);

511

if (free_ref)

512

free2_ref = free_ref;

513

free_ref = ptr.rp_blob_ref;

514

}

515

}

516

else if (tab_index == INVALID_INDEX) {

517

/* The is a reference from the temporary log only!! */

518

if (free_ref)

519

free2_ref = free_ref;

520

free_ref = ptr.rp_blob_ref;

521

}

522

break;

523

}

524

default: { // Must be a blob REF, check that the BLOB reference doesn't already exist.

525

uint32_t tab_index;

526

tab_index = CS_GET_DISK_2(ptr.rp_blob_ref->er_table_2);

527

528

if (tab_index && tab_index < ref_count) {

529

MSRepoTableRefPtr tr;

530

531

tab_index--;

532

tr = (MSRepoTableRefPtr) (otab->myOTBuffer + myRepo->getRepoBlobHeadSize() + tab_index * ref_size);

533

if (CS_GET_DISK_4(tr->tr_table_id_4) == tab_id &&

534

CS_GET_DISK_6(tr->tr_blob_id_6) == blob_id) {

535

if (COMMIT_MASK(CS_GET_DISK_8(ptr.rp_blob_ref->er_blob_ref_id_8)) == blob_ref_id) {

536

char message[100];

537

snprintf(message, 100, "Duplicate BLOB reference: db_id: %"PRIu32", tab_id:%"PRIu32", blob_ref_id: %"PRIu64"\n", myRepo->myRepoDatabase->myDatabaseID, tab_id, blob_ref_id);

538

/* The reference already exists so there is nothing to do... */

539

self->myException.log(self, message);

540

goto done;

541

}

542

}

543

}

544

break;

545

}

546

}

547

ptr.rp_chars += ref_size;

548

size -= ref_size;

549

}

550

551

// A BLOB reference needs to be added and if there is not

552

// already a table reference then a table reference must be added

553

// also.

554

if (!free_ref || (!tab_ref && !free2_ref)) {

555

size_t new_refs = (tab_ref)?1:2;

556

ptr.rp_chars = otab->myOTBuffer;

557

size_t sp = MS_VAR_SPACE(ptr.rp_head);

558

559

if (sp > (new_refs * CS_GET_DISK_1(ptr.rp_head->rb_ref_size_1))) {

560

sp = MS_MIN_BLOB_HEAD_SIZE;

561

}

562

563

if (MS_CAN_ADD_REFS(ptr.rp_head, new_refs)) {

564

new_head_size = head_size;

565

566

} else { // The header must be grown

567

size_t new_size, max_refs;

568

569

if (ref_count < 2)

570

max_refs = 4;

571

else if (ref_count > 32)

572

max_refs = ref_count + 32;

573

else

574

max_refs = 2 * ref_count;

575

576

if (max_refs > (MS_OT_BUFFER_SIZE/ref_size))

577

max_refs = (MS_OT_BUFFER_SIZE/ref_size);

578

579

if (max_refs < (ref_count + new_refs))

580

CSException::throwAssertion(CS_CONTEXT, "BLOB reference header overflow");

581

582

new_size = head_size + ref_size * max_refs;

583

584

//Shift the metadata in the header

585

if (CS_GET_DISK_2(ptr.rp_head->rb_mdata_size_2)) {

586

uint16_t mdata_size, mdata_offset, alias_offset, shift;

587

(void)mdata_size;

588

589

shift = new_size - head_size;

590

mdata_size = CS_GET_DISK_2(ptr.rp_head->rb_mdata_size_2);

591

mdata_offset = CS_GET_DISK_2(ptr.rp_head->rb_mdata_offset_2);

592

alias_offset = CS_GET_DISK_2(ptr.rp_head->rb_alias_offset_2);

593

594

memmove(ptr.rp_chars + mdata_offset + shift, ptr.rp_chars + mdata_offset, shift);

595

memset(ptr.rp_chars + mdata_offset, 0, shift);

596

mdata_offset += shift;

597

alias_offset += shift;

598

599

CS_SET_DISK_2(ptr.rp_head->rb_mdata_offset_2, mdata_offset);

600

CS_SET_DISK_2(ptr.rp_head->rb_alias_offset_2, alias_offset);

601

602

} else

603

memset(ptr.rp_chars + head_size, 0, new_size - head_size);

604

605

new_head_size = new_size;

606

}

607

CS_SET_DISK_2(ptr.rp_head->rb_head_size_2, new_head_size);

608

CS_SET_DISK_2(ptr.rp_head->rb_ref_count_2, ref_count + new_refs);

609

ptr.rp_chars += myRepo->myRepoBlobHeadSize + ref_count * ref_size;

610

611

if (!free_ref) {

612

free_ref = ptr.rp_blob_ref;

613

memset(free_ref, 0, ref_size);

614

ptr.rp_chars += ref_size;

615

}

616

617

if (!tab_ref) {

618

free2_ref = ptr.rp_blob_ref;

619

memset(free2_ref, 0, ref_size);

620

}

621

622

ref_count += new_refs;

623

}

624

else

625

new_head_size = head_size;

626

627

if (!tab_ref) {

628

tab_ref = (MSRepoTableRefPtr) free2_ref;

629

630

CS_SET_DISK_2(tab_ref->rr_type_2, MS_BLOB_TABLE_REF);

631

CS_SET_DISK_4(tab_ref->tr_table_id_4, tab_id);

632

CS_SET_DISK_6(tab_ref->tr_blob_id_6, blob_id);

633

}

634

635

size_t tab_idx;

636

637

tab_idx = (((char *) tab_ref - otab->myOTBuffer) - myRepo->myRepoBlobHeadSize) / ref_size;

638

639

CS_SET_DISK_2(free_ref->er_table_2, tab_idx+1);

640

CS_SET_DISK_2(free_ref->er_col_index_2, col_index);

641

CS_SET_DISK_8(free_ref->er_blob_ref_id_8, UNCOMMITTED(blob_ref_id));

642

643

update_blob_header(otab, offset, blob_size, head_size, new_head_size);

644

#ifdef HAVE_ALIAS_SUPPORT

645

if (reset_alias_index)

646

myRepo->myRepoDatabase->registerBlobAlias(myRepo->myRepoID, offset, blob_alias);

647

#endif

648

649

done:

650

651

unlock_(myLock);

652

exit_();

653

}

654

655

void MSRepoFile::setBlobMetaData(MSOpenTable *otab, uint64_t offset, const char *meta_data, uint16_t meta_data_len, bool reset_alias, const char *alias)

656

{

657

CSMutex *mylock;

658

MSRepoPointersRec ptr;

659

size_t read_size;

660

uint16_t new_head_size;

661

uint64_t blob_size;

662

uint16_t head_size, mdata_size, mdata_offset, alias_offset = 0;

663

MSBlobHeadRec blob;

664

665

enter_();

666

/* Lock the BLOB: */

667

mylock = &myRepo->myRepoLock[offset % CS_REPO_REC_LOCK_COUNT];

668

lock_(mylock);

669

670

/* Read the header: */

671

if (read(&blob, offset, sizeof(MSBlobHeadRec), 0) < sizeof(MSBlobHeadRec)) {

672

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "BLOB header incomplete");

673

}

674

675

head_size = CS_GET_DISK_2(blob.rb_head_size_2);

676

677

if (head_size > MS_OT_BUFFER_SIZE) {

678

CSException::throwAssertion(CS_CONTEXT, "BLOB header overflow");

679

}

680

681

read_size = read(otab->myOTBuffer, offset, head_size, 0);

682

ptr.rp_chars = otab->myOTBuffer;

683

if (CS_GET_DISK_4(ptr.rp_head->rd_magic_4) != MS_BLOB_HEADER_MAGIC)

684

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "Invalid BLOB identifier");

685

if (read_size < myRepo->myRepoBlobHeadSize)

686

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "BLOB header incomplete");

687

if (! IN_USE_BLOB_STATUS(CS_GET_DISK_1(ptr.rp_head->rb_status_1)))

688

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "BLOB has already been deleted");

689

690

691

blob_size = CS_GET_DISK_6(ptr.rp_head->rb_blob_repo_size_6);

692

if (read_size < head_size) {

693

/* This should not happen, because the file has been recovered,

694

* which should have already adjusted the head and blob

695

* size.

696

* If this happens then the file must have been truncated an the BLOB has been

697

* lost so we set the blob size to zero.

698

699

head_size = read_size;

700

blob_size = 0;

701

}

702

mdata_size = CS_GET_DISK_2(ptr.rp_head->rb_mdata_size_2);

703

704

if ((meta_data_len < mdata_size) || MS_CAN_ADD_MDATA(ptr.rp_head, meta_data_len - mdata_size))

705

new_head_size = head_size;

706

else { // The header must be grown

707

708

new_head_size = head_size + meta_data_len - mdata_size;

709

if (new_head_size > MS_OT_BUFFER_SIZE)

710

CSException::throwAssertion(CS_CONTEXT, "BLOB reference header overflow");

711

712

memset(ptr.rp_chars + head_size, 0, new_head_size - head_size);

713

CS_SET_DISK_2(ptr.rp_head->rb_head_size_2, new_head_size);

714

715

}

716

717

// Meta data is placed at the end of the header.

718

if (meta_data_len)

719

mdata_offset = new_head_size - meta_data_len;

720

else

721

mdata_offset = 0;

722

mdata_size = meta_data_len;

723

724

725

CS_SET_DISK_2(ptr.rp_head->rb_mdata_size_2, mdata_size);

726

CS_SET_DISK_2(ptr.rp_head->rb_mdata_offset_2, mdata_offset);

727

#ifdef HAVE_ALIAS_SUPPORT

728

uint32_t alias_hash = INVALID_ALIAS_HASH;

729

if (alias) {

730

alias_hash = CS_GET_DISK_4(ptr.rp_head->rb_alias_hash_4);

731

alias_offset = CS_GET_DISK_2(ptr.rp_head->rb_alias_offset_2);

732

if (reset_alias) {

733

if (alias_offset)

734

alias_hash = myRepo->myRepoDatabase->updateBlobAlias(myRepo->myRepoID, offset, alias_hash, alias);

735

else {

736

alias_hash = myRepo->myRepoDatabase->registerBlobAlias(myRepo->myRepoID, offset, alias);

737

}

738

}

739

alias_offset = mdata_offset + (alias - meta_data);

740

741

} else if (reset_alias && CS_GET_DISK_2(ptr.rp_head->rb_alias_offset_2)) {

742

alias_offset = CS_GET_DISK_2(ptr.rp_head->rb_alias_offset_2);

743

myRepo->myRepoDatabase->deleteBlobAlias(myRepo->myRepoID, offset, CS_GET_DISK_4(ptr.rp_head->rb_alias_hash_4));

744

alias_offset = 0;

745

}

746

#else

747

uint32_t alias_hash = ((uint32_t)-1);

748

if (alias || reset_alias) {

749

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_IMPLEMENTED, "No BLOB alias support.");

750

}

751

#endif

752

753

CS_SET_DISK_2(ptr.rp_head->rb_alias_offset_2, alias_offset);

754

CS_SET_DISK_4(ptr.rp_head->rb_alias_hash_4, alias_hash);

755

756

memcpy(ptr.rp_chars + mdata_offset, meta_data, meta_data_len);

757

758

update_blob_header(otab, offset, blob_size, head_size, new_head_size);

759

760

unlock_(mylock);

761

exit_();

762

763

}

764

765

766

void MSRepoFile::releaseBlob(MSOpenTable *otab, uint64_t offset, uint16_t head_size, uint32_t tab_id, uint64_t blob_id, uint64_t blob_ref_id, uint32_t auth_code)

767

{

768

CSMutex *mylock;

769

MSRepoPointersRec ptr;

770

uint32_t table_ref_count = 0;

771

uint32_t size;

772

size_t ref_size, ref_count, read_size;

773

MSRepoTempRefPtr temp_ref = NULL;

774

uint16_t tab_index = 0;

775

MSRepoTableRefPtr tab_ref;

776

uint16_t alias_offset;

777

uint32_t alias_hash;

778

779

(void)alias_offset;

780

(void)alias_hash;

781

782

enter_();

783

/* Lock the BLOB: */

784

mylock = &myRepo->myRepoLock[offset % CS_REPO_REC_LOCK_COUNT];

785

lock_(mylock);

786

/* Read the header: */

787

ASSERT(head_size <= MS_OT_BUFFER_SIZE);

788

read_size = read(otab->myOTBuffer, offset, head_size, 0);

789

ptr.rp_chars = otab->myOTBuffer;

790

if (CS_GET_DISK_4(ptr.rp_head->rd_magic_4) != MS_BLOB_HEADER_MAGIC)

791

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "Invalid BLOB identifier");

792

if (read_size < myRepo->myRepoBlobHeadSize) {

793

removeBlob(otab, tab_id, blob_id, offset, auth_code);

794

goto exit;

795

}

796

if ((! IN_USE_BLOB_STATUS(CS_GET_DISK_1(ptr.rp_head->rb_status_1))) ||

797

CS_GET_DISK_4(ptr.rp_bytes + myRepo->myRepoBlobHeadSize - 4) != auth_code) {

798

removeBlob(otab, tab_id, blob_id, offset, auth_code);

799

goto exit;

800

}

801

802

/* Assume that what is here is correct: */

803

if (head_size != CS_GET_DISK_2(ptr.rp_head->rb_head_size_2)) {

804

head_size = CS_GET_DISK_2(ptr.rp_head->rb_head_size_2);

805

read_size = read(otab->myOTBuffer, offset, head_size, myRepo->myRepoBlobHeadSize);

806

}

807

head_size = CS_GET_DISK_2(ptr.rp_head->rb_head_size_2);

808

if (read_size < head_size) {

809

/* This should not happen, because the file has been recovered,

810

* which should have already adjusted the head and blob

811

* size.

812

* If this happens then the file must have been truncated an the BLOB has been

813

* lost so we set the blob size to zero.

814

815

head_size = read_size;

816

}

817

ref_size = CS_GET_DISK_1(ptr.rp_head->rb_ref_size_1);

818

ref_count = CS_GET_DISK_2(ptr.rp_head->rb_ref_count_2);

819

820

alias_offset = CS_GET_DISK_2(ptr.rp_head->rb_alias_offset_2);

821

alias_hash = CS_GET_DISK_4(ptr.rp_head->rb_alias_hash_4);

822

823

size = head_size - myRepo->myRepoBlobHeadSize;

824

if (size > ref_size * ref_count)

825

size = ref_size * ref_count;

826

ptr.rp_chars += myRepo->myRepoBlobHeadSize;

827

while (size >= ref_size) {

828

switch (CS_GET_DISK_2(ptr.rp_ref->rr_type_2)) {

829

case MS_BLOB_FREE_REF:

830

case MS_BLOB_TABLE_REF:

831

break;

832

case MS_BLOB_DELETE_REF: {

833

uint32_t tabi;

834

835

tabi = CS_GET_DISK_2(ptr.rp_temp_ref->tp_del_ref_2);

836

if (tabi && tabi < ref_count) {

837

tabi--;

838

tab_ref = (MSRepoTableRefPtr) (otab->myOTBuffer + myRepo->myRepoBlobHeadSize + tabi * ref_size);

839

if (CS_GET_DISK_4(tab_ref->tr_table_id_4) == tab_id &&

840

CS_GET_DISK_6(tab_ref->tr_blob_id_6) == blob_id) {

841

/* This is an old free, take it out. */

842

// Barry: What happens to the record in the temp log associated with this ref

843

// that is waiting to free the BLOB?

844

// Answer: It will find that there is MS_BLOB_DELETE_REF record with the BLOB

845

// or if there is one it will be for a different free in a different temp log

846

// or with a different temp log offset.

847

CS_SET_DISK_2(ptr.rp_ref->rr_type_2, MS_BLOB_FREE_REF);

848

}

849

}

850

break;

851

}

852

default: // Must be a blob REF

853

tab_ref = (MSRepoTableRefPtr) (otab->myOTBuffer + myRepo->myRepoBlobHeadSize + (CS_GET_DISK_2(ptr.rp_blob_ref->er_table_2)-1) * ref_size);

854

if (CS_GET_DISK_4(tab_ref->tr_table_id_4) == tab_id &&

855

CS_GET_DISK_6(tab_ref->tr_blob_id_6) == blob_id) {

856

if (COMMIT_MASK(CS_GET_DISK_8(ptr.rp_blob_ref->er_blob_ref_id_8)) == blob_ref_id) {

857

/* Found the reference, remove it... */

858

tab_index = CS_GET_DISK_2(ptr.rp_blob_ref->er_table_2)-1;

859

temp_ref = ptr.rp_temp_ref;

860

//temp_ref = (MSRepoTempRefPtr) tab_ref; // Set temp ref to the table ref so that it will be removed if there are no more references to it.

861

CS_SET_DISK_2(ptr.rp_ref->rr_type_2, MS_BLOB_FREE_REF);

862

}

863

else

864

table_ref_count++;

865

}

866

break;

867

}

868

ptr.rp_chars += ref_size;

869

size -= ref_size;

870

}

871

872

// If the refernce was found and there are no

873

// table references then the BLOB can be scheduled for deletion.

874

if ((!table_ref_count) && temp_ref) {

875

uint32_t log_id;

876

uint32_t log_offset;

877

uint32_t temp_time;

878

#ifdef HAVE_ALIAS_SUPPORT

879

MSDiskAliasRec aliasDiskRec;

880

MSDiskAliasPtr aliasDiskPtr = NULL;

881

882

if (alias_offset) {

883

CS_SET_DISK_4(aliasDiskRec.ar_repo_id_4, myRepo->myRepoID);

884

CS_SET_DISK_8(aliasDiskRec.ar_offset_8, offset);

885

CS_SET_DISK_4(aliasDiskRec.ar_hash_4, alias_hash);

886

aliasDiskPtr = &aliasDiskRec;

887

}

888

889

myRepo->myRepoDatabase->queueForDeletion(otab, MS_TL_BLOB_REF, tab_id, blob_id, auth_code, &log_id, &log_offset, &temp_time, aliasDiskPtr);

890

#else

891

myRepo->myRepoDatabase->queueForDeletion(otab, MS_TL_BLOB_REF, tab_id, blob_id, auth_code, &log_id, &log_offset, &temp_time);

892

#endif

893

myRepo->myLastTempTime = temp_time;

894

CS_SET_DISK_2(temp_ref->rr_type_2, MS_BLOB_DELETE_REF);

895

CS_SET_DISK_2(temp_ref->tp_del_ref_2, tab_index+1);

896

CS_SET_DISK_4(temp_ref->tp_log_id_4, log_id);

897

CS_SET_DISK_4(temp_ref->tp_offset_4, log_offset);

898

899

CS_SET_DISK_1(ptr.rp_head->rb_status_1, MS_BLOB_ALLOCATED); // The BLOB is allocated but no longer referenced

900

}

901

if (temp_ref) {

902

/* The reason I do not write the header of the header, is because

903

* I want to handle the rb_last_access_4 being set at the

904

* same time!

905

906

write(otab->myOTBuffer + MS_BLOB_STAT_OFFS, offset + MS_BLOB_STAT_OFFS, head_size - MS_BLOB_STAT_OFFS);

907

} else if (PBMSDaemon::isDaemonState(PBMSDaemon::DaemonStartUp) == false) {

908

char message[100];

909

snprintf(message, 100, "BLOB reference not found: db_id: %"PRIu32", tab_id:%"PRIu32", blob_ref_id: %"PRIu64"\n", myRepo->myRepoDatabase->myDatabaseID, tab_id, blob_ref_id);

910

/* The reference already exists so there is nothing to do... */

911

self->myException.log(self, message);

912

}

913

914

exit:

915

unlock_(mylock);

916

exit_();

917

}

918

919

void MSRepoFile::commitBlob(MSOpenTable *otab, uint64_t offset, uint16_t head_size, uint32_t tab_id, uint64_t blob_id, uint64_t blob_ref_id, uint32_t auth_code)

920

{

921

CSMutex *mylock;

922

MSRepoPointersRec ptr;

923

uint32_t size;

924

size_t ref_size, ref_count, read_size;

925

MSRepoTableRefPtr tab_ref;

926

927

enter_();

928

/* Lock the BLOB: */

929

mylock = &myRepo->myRepoLock[offset % CS_REPO_REC_LOCK_COUNT];

930

lock_(mylock);

931

/* Read the header: */

932

ASSERT(head_size <= MS_OT_BUFFER_SIZE);

933

read_size = read(otab->myOTBuffer, offset, head_size, 0);

934

ptr.rp_chars = otab->myOTBuffer;

935

if (CS_GET_DISK_4(ptr.rp_head->rd_magic_4) != MS_BLOB_HEADER_MAGIC)

936

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "Invalid BLOB identifier");

937

938

939

if (read_size < myRepo->myRepoBlobHeadSize)

940

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "BLOB header incomplete");

941

if ( ! IN_USE_BLOB_STATUS(CS_GET_DISK_1(ptr.rp_head->rb_status_1)))

942

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "BLOB has already been deleted");

943

if (auth_code && CS_GET_DISK_4(ptr.rp_bytes + myRepo->myRepoBlobHeadSize - 4) != auth_code)

944

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "BLOB data does not match reference");

945

946

947

/* Assume that what is here is correct: */

948

if (head_size != CS_GET_DISK_2(ptr.rp_head->rb_head_size_2)) {

949

head_size = CS_GET_DISK_2(ptr.rp_head->rb_head_size_2);

950

read_size = read(otab->myOTBuffer, offset, head_size, myRepo->myRepoBlobHeadSize);

951

}

952

953

head_size = CS_GET_DISK_2(ptr.rp_head->rb_head_size_2);

954

if (read_size < head_size) {

955

/* This should not happen, because the file has been recovered,

956

* which should have already adjusted the head and blob

957

* size.

958

* If this happens then the file must have been truncated an the BLOB has been

959

* lost so we set the blob size to zero.

960

961

head_size = read_size;

962

}

963

ref_size = CS_GET_DISK_1(ptr.rp_head->rb_ref_size_1);

964

ref_count = CS_GET_DISK_2(ptr.rp_head->rb_ref_count_2);

965

966

size = head_size - myRepo->myRepoBlobHeadSize;

967

if (size > ref_size * ref_count)

968

size = ref_size * ref_count;

969

ptr.rp_chars += myRepo->myRepoBlobHeadSize;

970

while (size >= ref_size) {

971

switch (CS_GET_DISK_2(ptr.rp_ref->rr_type_2)) {

972

case MS_BLOB_FREE_REF:

973

case MS_BLOB_TABLE_REF:

974

break;

975

case MS_BLOB_DELETE_REF: {

976

break;

977

}

978

default: // Must be a blob REF

979

tab_ref = (MSRepoTableRefPtr) (otab->myOTBuffer + myRepo->myRepoBlobHeadSize + (CS_GET_DISK_2(ptr.rp_blob_ref->er_table_2)-1) * ref_size);

980

if (CS_GET_DISK_4(tab_ref->tr_table_id_4) == tab_id &&

981

CS_GET_DISK_6(tab_ref->tr_blob_id_6) == blob_id) {

982

uint64_t ref_id = CS_GET_DISK_8(ptr.rp_blob_ref->er_blob_ref_id_8);

983

if (COMMIT_MASK(ref_id) == blob_ref_id) {

984

/* Found the reference, mark it as committed... */

985

CS_SET_DISK_8(ptr.rp_blob_ref->er_blob_ref_id_8, blob_ref_id);

986

offset += (ptr.rp_chars - otab->myOTBuffer) + offsetof(MSRepoBlobRefRec, er_blob_ref_id_8);

987

write(&(ptr.rp_blob_ref->er_blob_ref_id_8), offset, 8);

988

goto exit;

989

}

990

}

991

break;

992

}

993

ptr.rp_chars += ref_size;

994

size -= ref_size;

995

}

996

997

if (PBMSDaemon::isDaemonState(PBMSDaemon::DaemonStartUp) == false) {

998

char message[100];

999

snprintf(message, 100, "BLOB reference not found: db_id: %"PRIu32", tab_id:%"PRIu32", blob_ref_id: %"PRIu64"\n", myRepo->myRepoDatabase->myDatabaseID, tab_id, blob_ref_id);

1000

self->myException.log(self, message);

1001

}

1002

1003

exit:

1004

unlock_(mylock);

1005

exit_();

1006

}

1007

1008

void MSRepoFile::realFreeBlob(MSOpenTable *otab, char *buffer, uint32_t auth_code, uint64_t offset, uint16_t head_size, uint64_t blob_size, size_t ref_size)

1009

{

1010

uint32_t tab_id;

1011

uint64_t blob_id;

1012

size_t size;

1013

MSRepoPointersRec ptr;

1014

enter_();

1015

1016

ptr.rp_chars = buffer;

1017

1018

if (BLOB_IN_CLOUD(CS_GET_DISK_1(ptr.rp_head->rb_storage_type_1))) {

1019

CloudKeyRec key;

1020

getBlobKey(ptr.rp_head, &key);

1021

if (!myRepo->myRepoDatabase->myBlobCloud)

1022

CSException::throwException(CS_CONTEXT, CS_ERR_GENERIC_ERROR, "Deleting cloud BLOB without cloud.");

1023

1024

myRepo->myRepoDatabase->myBlobCloud->cl_deleteData(&key);

1025

}

1026

1027

#ifdef HAVE_ALIAS_SUPPORT

1028

uint32_t alias_hash;

1029

alias_hash = CS_GET_DISK_4(ptr.rp_head->rb_alias_hash_4);

1030

if (alias_hash != INVALID_ALIAS_HASH)

1031

myRepo->myRepoDatabase->deleteBlobAlias(myRepo->myRepoID, offset, alias_hash);

1032

#endif

1033

1034

// Assuming the BLOB is still locked:

1035

CS_SET_DISK_1(ptr.rp_head->rb_status_1, MS_BLOB_DELETED);

1036

write(ptr.rp_chars + MS_BLOB_STAT_OFFS, offset + MS_BLOB_STAT_OFFS, head_size - MS_BLOB_STAT_OFFS);

1037

1038

/* Update garbage count: */

1039

updateGarbage(head_size + blob_size);

1040

1041

/* Remove all table references (should not be any)! */

1042

size = head_size - myRepo->myRepoBlobHeadSize;

1043

ptr.rp_chars += myRepo->myRepoBlobHeadSize;

1044

while (size >= ref_size) {

1045

if (CS_GET_DISK_2(ptr.rp_ref->rr_type_2) == MS_BLOB_TABLE_REF) {

1046

tab_id = CS_GET_DISK_4(ptr.rp_tab_ref->tr_table_id_4);

1047

blob_id = CS_GET_DISK_6(ptr.rp_tab_ref->tr_blob_id_6);

1048

removeBlob(otab, tab_id, blob_id, offset, auth_code);

1049

}

1050

ptr.rp_chars += ref_size;

1051

size -= ref_size;

1052

}

1053

exit_();

1054

}

1055

1056

/* This function will free the BLOB reference, if the record is invalid. */

1057

void MSRepoFile::freeTableReference(MSOpenTable *otab, uint64_t offset, uint16_t head_size, uint32_t tab_id, uint64_t blob_id, uint32_t auth_code)

1058

{

1059

CSMutex *mylock;

1060

MSRepoPointersRec ptr;

1061

uint32_t blob_ref_count = 0;

1062

uint32_t table_ref_count = 0;

1063

bool modified = false;

1064

uint32_t size;

1065

size_t ref_size, ref_count, read_size;

1066

MSRepoTableRefPtr tab_ref = NULL;

1067

uint64_t blob_size;

1068

1069

enter_();

1070

/* Lock the BLOB: */

1071

mylock = &myRepo->myRepoLock[offset % CS_REPO_REC_LOCK_COUNT];

1072

lock_(mylock);

1073

/* Read the header: */

1074

ASSERT(head_size <= MS_OT_BUFFER_SIZE);

1075

read_size = read(otab->myOTBuffer, offset, head_size, 0);

1076

ptr.rp_chars = otab->myOTBuffer;

1077

if (CS_GET_DISK_4(ptr.rp_head->rd_magic_4) != MS_BLOB_HEADER_MAGIC)

1078

CSException::throwException(CS_CONTEXT, MS_ERR_NOT_FOUND, "Invalid BLOB identifier");

1079

if (read_size < myRepo->myRepoBlobHeadSize) {

1080

removeBlob(otab, tab_id, blob_id, offset, auth_code);

1081

goto exit;

1082

}

1083

if ((! IN_USE_BLOB_STATUS(CS_GET_DISK_1(ptr.rp_head->rb_status_1))) ||

1084

CS_GET_DISK_4(ptr.rp_bytes + myRepo->myRepoBlobHeadSize - 4) != auth_code) {

1085

removeBlob(otab, tab_id, blob_id, offset, auth_code);

1086

goto exit;

1087

}

1088

1089

/* Assume that what is here is correct: */

1090

if (head_size != CS_GET_DISK_2(ptr.rp_head->rb_head_size_2)) {

1091

head_size = CS_GET_DISK_2(ptr.rp_head->rb_head_size_2);

1092

read_size = read(otab->myOTBuffer, offset, head_size, myRepo->myRepoBlobHeadSize);

1093

}

1094

head_size = CS_GET_DISK_2(ptr.rp_head->rb_head_size_2);

1095

blob_size = CS_GET_DISK_6(ptr.rp_head->rb_blob_repo_size_6);

1096

if (read_size < head_size) {

1097

/* This should not happen, because the file has been recovered,

1098

* which should have already adjusted the head and blob

1099

* size.

1100

* If this happens then the file must have been truncated an the BLOB has been

1101

* lost so we set the blob size to zero.

1102

1103

head_size = read_size;

1104

blob_size = 0;

1105

1106

}

1107

ref_size = CS_GET_DISK_1(ptr.rp_head->rb_ref_size_1);

1108

ref_count = CS_GET_DISK_2(ptr.rp_head->rb_ref_count_2);

1109

size = head_size - myRepo->myRepoBlobHeadSize;

1110

if (size > ref_size * ref_count)

1111

size = ref_size * ref_count;

1112

ptr.rp_chars += myRepo->myRepoBlobHeadSize;

1113

while (size >= ref_size) {

1114

switch (CS_GET_DISK_2(ptr.rp_ref->rr_type_2)) {

1115

case MS_BLOB_FREE_REF:

1116

break;

1117

case MS_BLOB_TABLE_REF:

1118

if (CS_GET_DISK_4(ptr.rp_tab_ref->tr_table_id_4) == tab_id &&

1119

CS_GET_DISK_6(ptr.rp_tab_ref->tr_blob_id_6) == blob_id)

1120

tab_ref = ptr.rp_tab_ref;

1121

break;

1122

case MS_BLOB_DELETE_REF:

1123

break;

1124

default:

1125

MSRepoTableRefPtr tr;

1126

1127

tr = (MSRepoTableRefPtr) (otab->myOTBuffer + myRepo->myRepoBlobHeadSize + (CS_GET_DISK_2(ptr.rp_blob_ref->er_table_2)-1) * ref_size);

1128

if (CS_GET_DISK_2(tr->rr_type_2) == MS_BLOB_TABLE_REF) {

1129

/* I am deleting all references of a table. So I am here to

1130

* also delete the blob references that refer to the

1131

* table reference!!!

1132

1133

if (CS_GET_DISK_4(tr->tr_table_id_4) == tab_id && CS_GET_DISK_6(tr->tr_blob_id_6) == blob_id) {

1134

/* Free the blob reference: */

1135

CS_SET_DISK_2(ptr.rp_ref->rr_type_2, MS_BLOB_FREE_REF);

1136

modified = true;

1137

}

1138

else

1139

blob_ref_count++;

1140

1141

}

1142

break;

1143

}

1144

ptr.rp_chars += ref_size;

1145

size -= ref_size;

1146

}

1147

1148

if (!table_ref_count && tab_ref) {

1149

CS_SET_DISK_2(tab_ref->rr_type_2, MS_BLOB_FREE_REF);

1150

modified = true;

1151

}

1152

1153

1154

if (!blob_ref_count) {

1155

realFreeBlob(otab, otab->myOTBuffer, auth_code, offset, head_size, blob_size, ref_size);

1156

} else if (modified)

1157

/* The reason I do not write the header of the header, is because

1158

* I want to handle the rb_last_access_4 being set at the

1159

* same time!

1160

1161

write(otab->myOTBuffer + MS_BLOB_STAT_OFFS, offset + MS_BLOB_STAT_OFFS, head_size - MS_BLOB_STAT_OFFS);

1162

1163

unlock_(mylock);

1164

1165

if (!table_ref_count || !tab_ref)

1166

/* Free the table reference, if there are no more

1167

* blob references, reference the table reference,

1168

* or if the table reference was not found in the

1169

* BLOB at all!

1170

1171

removeBlob(otab, tab_id, blob_id, offset, auth_code);

1172

1173

exit_();

1174

1175

exit:

1176

unlock_(mylock);

1177

exit_();

1178

}

1179

1180

void MSRepoFile::checkBlob(CSStringBuffer *buffer, uint64_t offset, uint32_t auth_code, uint32_t temp_log_id, uint32_t temp_log_offset)

1181

{

1182

CSMutex *mylock;

1183

MSBlobHeadRec blob;

1184

MSRepoPointersRec ptr;

1185

uint32_t blob_ref_count = 0;

1186

bool modified = false;

1187

uint32_t size;

1188

size_t ref_size, ref_count, read_size;

1189

uint8_t status;

1190

uint16_t head_size;

1191

uint64_t blob_size;

1192

MSRepoTempRefPtr my_ref = NULL;

1193

uint16_t ref_type = MS_BLOB_FREE_REF;

1194

enter_();

1195

(void)modified;

1196

(void)my_ref;

1197

1198

/* Lock the BLOB: */

1199

mylock = &myRepo->myRepoLock[offset % CS_REPO_REC_LOCK_COUNT];

1200

lock_(mylock);

1201

1202

/* Read the head of the header: */

1203

if (read(&blob, offset, sizeof(MSBlobHeadRec), 0) < sizeof(MSBlobHeadRec))

1204

goto exit;

1205

1206

// Because the temp log will be replayed from the start when the server

1207

// is restarted it is likely that it will have references to BLOBs that

1208

// no longer exist. So it is not an error if the BLOB ref doesn't point to

1209

// a valid BLOB.

1210

1211

// At some point this should probably be rethought because you cannot

1212

// tell the diference between a bad ref because of old data and a bad

1213

// ref because of a BUG.

1214

if (CS_GET_DISK_4(blob.rd_magic_4) != MS_BLOB_HEADER_MAGIC)

1215

goto exit;

1216

1217

head_size = CS_GET_DISK_2(blob.rb_head_size_2);

1218

blob_size = CS_GET_DISK_6(blob.rb_blob_repo_size_6);

1219

ref_size = CS_GET_DISK_1(blob.rb_ref_size_1);

1220

ref_count = CS_GET_DISK_2(blob.rb_ref_count_2);

1221

status = CS_GET_DISK_1(blob.rb_status_1);

1222

if (! IN_USE_BLOB_STATUS(status))

1223

goto exit;

1224

1225

/* Read the entire header: */

1226

buffer->setLength(head_size);

1227

ptr.rp_chars = buffer->getBuffer(0);

1228

read_size = read(ptr.rp_chars, offset, head_size, 0);

1229

if (read_size < myRepo->myRepoBlobHeadSize)

1230

goto exit;

1231

if (CS_GET_DISK_4(ptr.rp_bytes + myRepo->myRepoBlobHeadSize - 4) != auth_code)

1232

goto exit;

1233

if (read_size < head_size) {

1234

/* This should not happen, because the file has been recovered,

1235

* which should have already adjusted the head and blob

1236

* size.

1237

* If this happens then the file must have been truncated an the BLOB has been

1238

* lost so we set the blob size to zero.

1239

1240

head_size = read_size;

1241

blob_size = 0;

1242

}

1243

size = head_size - myRepo->myRepoBlobHeadSize;

1244

if (size > ref_size * ref_count)

1245

size = ref_size * ref_count;

1246

1247

1248

/* Search through all references: */

1249

ptr.rp_chars += myRepo->myRepoBlobHeadSize;

1250

while (size >= ref_size) {

1251

switch (CS_GET_DISK_2(ptr.rp_ref->rr_type_2)) {

1252

case MS_BLOB_FREE_REF:

1253

break;

1254

case MS_BLOB_TABLE_REF:

1255

break;

1256

case MS_BLOB_DELETE_REF:

1257

if (CS_GET_DISK_4(ptr.rp_temp_ref->tp_log_id_4) == temp_log_id &&

1258

CS_GET_DISK_4(ptr.rp_temp_ref->tp_offset_4) == temp_log_offset) {

1259

ref_type = CS_GET_DISK_2(ptr.rp_ref->rr_type_2);

1260

my_ref = ptr.rp_temp_ref;

1261

CS_SET_DISK_2(ptr.rp_ref->rr_type_2, MS_BLOB_FREE_REF);

1262

modified = true;

1263

}

1264

break;

1265

default:

1266

MSRepoTableRefPtr tr;

1267

uint32_t tabi;

1268

1269

tabi = CS_GET_DISK_2(ptr.rp_blob_ref->er_table_2);

1270

if (tabi < ref_count) {

1271

tr = (MSRepoTableRefPtr) (buffer->getBuffer(0) + myRepo->myRepoBlobHeadSize + (tabi-1) * ref_size);

1272

if (CS_GET_DISK_2(tr->rr_type_2) == MS_BLOB_TABLE_REF)

1273

blob_ref_count++;

1274

}

1275

break;

1276

}

1277

ptr.rp_chars += ref_size;

1278

size -= ref_size;

1279

}

1280

1281

if ((ref_type == (uint16_t)MS_BLOB_DELETE_REF) && !blob_ref_count) {

1282

realFreeBlob(NULL, buffer->getBuffer(0), auth_code, offset, head_size, blob_size, ref_size);

1283

}

1284

1285

exit:

1286

unlock_(mylock);

1287

exit_();

1288

}

1289

1290

void MSRepoFile::returnToPool()

1291

{

1292

myRepo->myRepoDatabase->returnRepoFileToPool(this);

1293

}

1294

1295

void MSRepoFile::removeBlob(MSOpenTable *otab, uint32_t tab_id, uint64_t blob_id, uint64_t offset, uint32_t auth_code)

1296

{

1297

enter_();

1298

if (otab && otab->getDBTable()->myTableID == tab_id)

1299

otab->getDBTable()->freeBlobHandle(otab, blob_id, myRepo->myRepoID, offset, auth_code);

1300

else {

1301

MSOpenTable *tmp_otab;

1302

1303

if ((tmp_otab = MSTableList::getOpenTableByID(myRepo->myRepoDatabase->myDatabaseID, tab_id))) {

1304

frompool_(tmp_otab);

1305

tmp_otab->getDBTable()->freeBlobHandle(tmp_otab, blob_id, myRepo->myRepoID, offset, auth_code);

1306

backtopool_(tmp_otab);

1307

}

1308

}

1309

exit_();

1310

}

1311

1312

MSRepoFile *MSRepoFile::newRepoFile(MSRepository *repo, CSPath *path)

1313

{

1314

MSRepoFile *f;

1315

1316

if (!(f = new MSRepoFile())) {

1317

path->release();

1318

CSException::throwOSError(CS_CONTEXT, ENOMEM);

1319

}

1320

f->myRepo = repo;

1321

f->myFilePath = path;

1322

return f;

1323

}

1324

1325

1326

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

1327

* REPOSITORY

1328

1329

1330

MSRepository::MSRepository(uint32_t id, MSDatabase *db, off64_t file_size):

1331

CSSharedRefObject(),

1332

myRepoID(id),

1333

myRepoFileSize(file_size),

1334

myRepoLockState(REPO_UNLOCKED),

1335

isRemovingFP(false),

1336

myRepoDatabase(db),

1337

myGarbageCount(0),

1338

myRepoHeadSize(0),

1339

myRepoDefRefSize(0),

1340

myRepoBlobHeadSize(0),

1341

myRecoveryOffset(0),

1342

myLastTempTime(0),

1343

myLastAccessTime(0),

1344

myLastCreateTime(0),

1345

myLastRefTime(0),

1346

mustBeDeleted(false),

1347

myRepoXLock(false),

1348

iFilePool(NULL)

1349

{

1350

}

1351

1352

MSRepository::~MSRepository()

1353

{

1354

CSPath *path = NULL;

1355

1356

enter_();

1357

if (mustBeDeleted) {

1358

path = getRepoFilePath();

1359

push_(path);

1360

}

1361

1362

isRemovingFP = true;

1363

removeRepoFilesNotInUse();

1364

/* With this, I also delete those that are in use!: */

1365

iPoolFiles.clear();

1366

1367

if (path) {

1368

path->removeFile();

1369

release_(path);

1370

}

1371

exit_();

1372

}

1373

1374

void MSRepository::openRepoFileForWriting(MSOpenTable *otab)

1375

{

1376

if (!otab->myWriteRepoFile)

1377

otab->myWriteRepoFile = openRepoFile();

1378

}

1379

1380

uint64_t MSRepository::receiveBlob(MSOpenTable *otab, uint16_t head_size, uint64_t blob_size, Md5Digest *checksum, CSInputStream *stream)

1381

{

1382

off64_t offset;

1383

size_t tfer;

1384

1385

enter_();

1386

1387

offset = myRepoFileSize;

1388

1389

offset += head_size;

1390

1391

ASSERT(myRepoDatabase->myBlobType == MS_STANDARD_STORAGE);

1392

if (stream) {

1393

CSMd5 md5;

1394

push_(stream);

1395

md5.md5_init();

1396

while (blob_size > 0) {

1397

if (blob_size <= MS_OT_BUFFER_SIZE)

1398

tfer = (size_t) blob_size;

1399

else

1400

tfer = MS_OT_BUFFER_SIZE;

1401

tfer = stream->read(otab->myOTBuffer, tfer);

1402

if (!tfer)

1403

CSException::throwOSError(CS_CONTEXT, EPIPE);

1404

if (checksum) md5.md5_append((const u_char *)(otab->myOTBuffer), tfer);

1405

otab->myWriteRepoFile->write(otab->myOTBuffer, offset, tfer);

1406

offset += (uint64_t) tfer;

1407

blob_size -= (uint64_t) tfer;

1408

}

1409

if (checksum) md5.md5_get_digest(checksum);

1410

release_(stream);

1411

} else {

1412

// Write 1 byte to the end to reserver the space.

1413

otab->myWriteRepoFile->write("x" , offset + blob_size -1, 1);

1414

}

1415

1416

return_( myRepoFileSize);

1417

}

1418

1419

// copyBlob() copies the BLOB and its header.

1420

uint64_t MSRepository::copyBlob(MSOpenTable *otab, uint64_t size, CSInputStream *stream)

1421

{

1422

off64_t offset = myRepoFileSize;

1423

size_t tfer;

1424

1425

while (size > 0) {

1426

if (size <= MS_OT_BUFFER_SIZE)

1427

tfer = (size_t) size;

1428

else

1429

tfer = MS_OT_BUFFER_SIZE;

1430

tfer = stream->read(otab->myOTBuffer, tfer);

1431

if (!tfer)

1432

CSException::throwOSError(CS_CONTEXT, EPIPE);

1433

otab->myWriteRepoFile->write(otab->myOTBuffer, offset, tfer);

1434

offset += (uint64_t) tfer;

1435

size -= (uint64_t) tfer;

1436

}

1437

1438

return myRepoFileSize;

1439

}

1440

1441

void MSRepository::writeBlobHead(MSOpenTable *otab, uint64_t offset, uint8_t ref_size, uint16_t head_size, uint64_t blob_size, Md5Digest *checksum, char *metadata, uint16_t metadata_size, uint64_t blob_id, uint32_t auth_code, uint32_t log_id, uint32_t log_offset, uint8_t blob_type, CloudKeyPtr cloud_key)

1442

{

1443

MSBlobHeadPtr blob ;

1444

MSRepoTableRefPtr tab_ref;

1445

MSRepoTempRefPtr temp_ref;

1446

time_t now;

1447

uint16_t tab_idx, max_ref_count = (head_size - myRepoBlobHeadSize - metadata_size) / ref_size;

1448

size_t size;

1449

1450

if (max_ref_count > MS_REPO_MIN_REF_COUNT)

1451

max_ref_count = MS_REPO_MIN_REF_COUNT;

1452

1453

ASSERT(max_ref_count > 1);

1454

1455

if (blob_type == MS_CLOUD_STORAGE)

1456

now = cloud_key->creation_time;

1457

else

1458

now = time(NULL);

1459

1460

blob = (MSBlobHeadPtr) otab->myOTBuffer;

1461

CS_SET_DISK_4(blob->rb_last_access_4, now);

1462

CS_SET_DISK_4(blob->rb_mod_time_4, now);

1463

CS_SET_DISK_4(blob->rb_access_count_4, 0);

1464

CS_SET_DISK_4(blob->rb_backup_id_4, 0);

1465

CS_SET_DISK_4(blob->rb_create_time_4, now);

1466

CS_SET_DISK_4(blob->rd_magic_4, MS_BLOB_HEADER_MAGIC);

1467

CS_SET_DISK_2(blob->rb_head_size_2, head_size);

1468

CS_SET_DISK_6(blob->rb_blob_data_size_6, blob_size);

1469

CS_SET_DISK_1(blob->rb_status_1, MS_BLOB_ALLOCATED);

1470

CS_SET_DISK_1(blob->rb_ref_size_1, ref_size);

1471

CS_SET_DISK_2(blob->rb_ref_count_2, max_ref_count);

1472

CS_SET_DISK_4(blob->rb_last_ref_4, 0);

1473

CS_SET_DISK_4(otab->myOTBuffer + myRepoBlobHeadSize - 4, auth_code);

1474

if (checksum)

1475

memcpy(&(blob->rb_blob_checksum_md5d), checksum, sizeof(Md5Digest));

1476

1477

CS_SET_DISK_2(blob->rb_mdata_size_2, metadata_size);

1478

if (metadata_size) {

1479

uint16_t metadata_offset = head_size - metadata_size;

1480

1481

CS_SET_DISK_2(blob->rb_mdata_offset_2, metadata_offset);

1482

memcpy(otab->myOTBuffer + metadata_offset, metadata, metadata_size);

1483

1484

#ifdef HAVE_ALIAS_SUPPORT

1485

MetaData md;

1486

md.use_data(metadata, metadata_size);

1487

const char *alias;

1488

alias = md.findAlias();

1489

if (alias) {

1490

uint32_t alias_hash;

1491

uint16_t alias_offset = metadata_offset + (uint16_t) (alias - metadata);

1492

CS_SET_DISK_2(blob->rb_alias_offset_2, alias_offset);

1493

alias_hash = myRepoDatabase->registerBlobAlias(myRepoID, offset, alias);

1494

CS_SET_DISK_4(blob->rb_alias_hash_4, alias_hash);

1495

} else {

1496

CS_SET_DISK_2(blob->rb_alias_offset_2, 0);

1497

}

1498

#else

1499

CS_SET_DISK_2(blob->rb_alias_offset_2, 0);

1500

#endif

1501

1502

} else {

1503

CS_SET_DISK_2(blob->rb_mdata_offset_2, 0);

1504

CS_SET_DISK_2(blob->rb_alias_offset_2, 0);

1505

}

1506

1507

1508

if (blob_id) {

1509

tab_ref = (MSRepoTableRefPtr) (otab->myOTBuffer + myRepoBlobHeadSize);

1510

CS_SET_DISK_2(tab_ref->rr_type_2, MS_BLOB_TABLE_REF);

1511

CS_SET_DISK_4(tab_ref->tr_table_id_4, otab->getDBTable()->myTableID);

1512

CS_SET_DISK_6(tab_ref->tr_blob_id_6, blob_id);

1513

temp_ref = (MSRepoTempRefPtr) (otab->myOTBuffer + myRepoBlobHeadSize + ref_size);

1514

tab_idx = 1; // This is the index of the blob table ref in the repository record.

1515

size = myRepoBlobHeadSize + ref_size + ref_size;

1516

}

1517

else {

1518

temp_ref = (MSRepoTempRefPtr) (otab->myOTBuffer + myRepoBlobHeadSize);

1519

tab_idx = INVALID_INDEX; // Means not used

1520

size = myRepoBlobHeadSize + ref_size;

1521

}

1522

1523

CS_SET_DISK_2(temp_ref->rr_type_2, MS_BLOB_DELETE_REF);

1524

CS_SET_DISK_2(temp_ref->tp_del_ref_2, tab_idx);

1525

CS_SET_DISK_4(temp_ref->tp_log_id_4, log_id);

1526

CS_SET_DISK_4(temp_ref->tp_offset_4, log_offset);

1527

1528

if (blob_type == MS_CLOUD_STORAGE) { // The data is stored in the cloud and not in the repository.

1529

CS_SET_DISK_4(blob->rb_s3_key_id_4, cloud_key->ref_index);

1530

CS_SET_DISK_4(blob->rb_s3_cloud_ref_4, cloud_key->cloud_ref);

1531

blob_size = 0; // The blob is not stored in the repository so the blob storage size in the repository is zero

1532

}

1533

1534

memset(otab->myOTBuffer + size, 0, head_size - size - metadata_size);

1535

1536

CS_SET_DISK_1(blob->rb_storage_type_1, blob_type);

1537

CS_SET_DISK_6(blob->rb_blob_repo_size_6, blob_size);

1538

otab->myWriteRepoFile->write(blob, offset, head_size);

1539

1540

setRepoFileSize(otab, offset + head_size + blob_size);

1541

}

1542

1543

void MSRepository::setRepoFileSize(MSOpenTable *otab, off64_t offset)

1544

{

1545

myRepoFileSize = offset;

1546

if (myRepoFileSize >= PBMSParameters::getRepoThreshold()

1547

/**/ || getGarbageLevel() >= PBMSParameters::getGarbageThreshold())

1548

otab->closeForWriting();

1549

}

1550

1551

void MSRepository::syncHead(MSRepoFile *fh)

1552

{

1553

MSRepoHeadRec head;

1554

1555

fh->sync();

1556

myRecoveryOffset = myRepoFileSize;

1557

CS_SET_DISK_8(head.rh_recovery_offset_8, myRecoveryOffset);

1558

CS_SET_DISK_4(head.rh_last_temp_time_4, myLastTempTime);

1559

CS_SET_DISK_4(head.rh_last_access_4, myLastAccessTime);

1560

CS_SET_DISK_4(head.rh_create_time_4, myLastCreateTime);

1561

CS_SET_DISK_4(head.rh_last_ref_4, myLastRefTime);

1562

1563

fh->write(&head.rh_recovery_offset_8, offsetof(MSRepoHeadRec, rh_recovery_offset_8), 24);

1564

fh->sync();

1565

}

1566

1567

MSRepoFile *MSRepository::openRepoFile()

1568

{

1569

MSRepoFile *fh;

1570

1571

enter_();

1572

fh = MSRepoFile::newRepoFile(this, getRepoFilePath());

1573

push_(fh);

1574

if (myRepoFileSize)

1575

fh->open(CSFile::DEFAULT);

1576

else

1577

fh->open(CSFile::CREATE);

1578

if (!myRepoHeadSize) {

1579

MSRepoHeadRec head;

1580

MSBlobHeadRec blob;

1581

size_t size;

1582

int status;

1583

int ref_size;

1584

uint16_t head_size;

1585

uint64_t blob_size;

1586

1587

lock_(this);

1588

/* Check again after locking: */

1589

if (!myRepoHeadSize) {

1590

if (fh->read(&head, 0, offsetof(MSRepoHeadRec, rh_reserved_4), 0) < offsetof(MSRepoHeadRec, rh_reserved_4)) {

1591

CS_SET_DISK_4(head.rh_magic_4, MS_REPO_FILE_MAGIC);

1592

CS_SET_DISK_2(head.rh_version_2, MS_REPO_FILE_VERSION);

1593

CS_SET_DISK_2(head.rh_repo_head_size_2, MS_REPO_FILE_HEAD_SIZE);

1594

CS_SET_DISK_2(head.rh_blob_head_size_2, sizeof(MSBlobHeadRec));

1595

CS_SET_DISK_2(head.rh_def_ref_size_2, sizeof(MSRepoGenericRefRec));

1596

CS_SET_DISK_8(head.rh_recovery_offset_8, MS_REPO_FILE_HEAD_SIZE);

1597

CS_SET_DISK_8(head.rh_garbage_count_8, 0);

1598

CS_SET_DISK_4(head.rh_last_temp_time_4, 0);

1599

CS_SET_DISK_4(head.rh_last_access_4, 0);

1600

CS_SET_DISK_4(head.rh_create_time_4, 0);

1601

CS_SET_DISK_4(head.rh_last_ref_4, 0);

1602

CS_SET_DISK_4(head.rh_reserved_4, 0);

1603

fh->write(&head, 0, sizeof(MSRepoHeadRec));

1604

}

1605

1606

/* Check the file header: */

1607

if (CS_GET_DISK_4(head.rh_magic_4) != MS_REPO_FILE_MAGIC)

1608

CSException::throwFileError(CS_CONTEXT, fh->getPathString(), CS_ERR_BAD_HEADER_MAGIC);

1609

if (CS_GET_DISK_2(head.rh_version_2) > MS_REPO_FILE_VERSION)

1610

CSException::throwFileError(CS_CONTEXT, fh->getPathString(), CS_ERR_VERSION_TOO_NEW);

1611

1612

/* Load the header details: */

1613

myRepoHeadSize = CS_GET_DISK_2(head.rh_repo_head_size_2);

1614

myRepoDefRefSize = CS_GET_DISK_2(head.rh_def_ref_size_2);

1615

myRepoBlobHeadSize = CS_GET_DISK_2(head.rh_blob_head_size_2);

1616

myRecoveryOffset = CS_GET_DISK_8(head.rh_recovery_offset_8);

1617

myGarbageCount = CS_GET_DISK_8(head.rh_garbage_count_8);

1618

myLastTempTime = CS_GET_DISK_4(head.rh_last_temp_time_4);

1619

myLastAccessTime = CS_GET_DISK_4(head.rh_last_access_4);

1620

myLastCreateTime = CS_GET_DISK_4(head.rh_create_time_4);

1621

myLastRefTime = CS_GET_DISK_4(head.rh_last_ref_4);

1622

1623

/* File size, cannot be less than header size: */

1624

if (myRepoFileSize < myRepoHeadSize)

1625

myRepoFileSize = myRepoHeadSize;

1626

1627

ASSERT(myGarbageCount <= myRepoFileSize);

1628

1629

/* Recover the file: */

1630

while (myRecoveryOffset < myRepoFileSize) {

1631

if ((size = fh->read(&blob, myRecoveryOffset, MS_MIN_BLOB_HEAD_SIZE, 0)) < MS_MIN_BLOB_HEAD_SIZE) {

1632

if (size != 0) {

1633

myRepoFileSize = myRecoveryOffset;

1634

fh->setEOF(myRepoFileSize);

1635

}

1636

break;

1637

}

1638

uint16_t ref_count, mdata_size, mdata_offset;

1639

(void)ref_count;

1640

1641

status = CS_GET_DISK_1(blob.rb_status_1);

1642

ref_size = CS_GET_DISK_1(blob.rb_ref_size_1);

1643

ref_count = CS_GET_DISK_2(blob.rb_ref_count_2);

1644

head_size = CS_GET_DISK_2(blob.rb_head_size_2);

1645

mdata_size = CS_GET_DISK_2(blob.rb_mdata_size_2);

1646

mdata_offset = CS_GET_DISK_2(blob.rb_mdata_offset_2);

1647

blob_size = CS_GET_DISK_6(blob.rb_blob_repo_size_6);

1648

if ((CS_GET_DISK_4(blob.rd_magic_4) != MS_BLOB_HEADER_MAGIC) ||

1649

(! IN_USE_BLOB_STATUS(status)) ||

1650

head_size < (myRepoBlobHeadSize + ref_size * MS_REPO_MIN_REF_COUNT) ||

1651

head_size < (mdata_offset + mdata_size) ||

1652

((blob_size == 0) && (BLOB_IN_REPOSITORY(CS_GET_DISK_1(blob.rb_storage_type_1)))) ||

1653

myRecoveryOffset + head_size + blob_size > myRepoFileSize) {

1654

myRepoFileSize = myRecoveryOffset;

1655

fh->setEOF(myRepoFileSize);

1656

break;

1657

}

1658

myRecoveryOffset += head_size + blob_size;

1659

}

1660

1661

fh->sync();

1662

myRecoveryOffset = myRepoFileSize;

1663

CS_SET_DISK_8(head.rh_recovery_offset_8, myRecoveryOffset);

1664

fh->write(&head, offsetof(MSRepoHeadRec, rh_recovery_offset_8), 8);

1665

fh->sync();

1666

}

1667

unlock_(this);

1668

}

1669

pop_(fh);

1670

return_(fh);

1671

}

1672

1673

void MSRepository::lockRepo(RepoLockState state)

1674

{

1675

CSMutex *myLock;

1676

enter_();

1677

1678

myLock = &myRepoWriteLock;

1679

lock_(myLock);

1680

1681

ASSERT(!myRepoXLock);

1682

1683

myRepoLockState = state;

1684

myRepoXLock = true;

1685

1686

unlock_(myLock);

1687

exit_();

1688

}

1689

1690

void MSRepository::signalCompactor()

1691

{

1692

#ifndef MS_COMPACTOR_POLLS

1693

if (!mustBeDeleted) {

1694

if (getGarbageLevel() >= PBMSParameters::getGarbageThreshold()) {

1695

if (myRepoDatabase->myCompactorThread)

1696

myRepoDatabase->myCompactorThread->wakeup();

1697

}

1698

}

1699

#endif

1700

}

1701

1702

void MSRepository::unlockRepo(RepoLockState state)

1703

{

1704

CSMutex *myLock;

1705

enter_();

1706

myLock = &myRepoWriteLock;

1707

lock_(myLock);

1708

1709

ASSERT(myRepoLockState & state);

1710

1711

myRepoLockState &= ~state;

1712

if (myRepoLockState == REPO_UNLOCKED) {

1713

myRepoXLock = false;

1714

signalCompactor();

1715

}

1716

unlock_(myLock);

1717

1718

exit_();

1719

}

1720

1721

// Repositories are not removed from the pool when

1722

// scheduled for backup so the REPO_BACKUP flag is

1723

// not handled here.

1724

void MSRepository::returnToPool()

1725

{

1726

CSMutex *myLock;

1727

enter_();

1728

myLock = &myRepoWriteLock;

1729

lock_(myLock);

1730

this->myRepoLockState &= ~(REPO_COMPACTING | REPO_WRITE);

1731

if ( this->myRepoLockState == REPO_UNLOCKED) {

1732

myRepoXLock = false;

1733

signalCompactor();

1734

}

1735

unlock_(myLock);

1736

1737

this->release();

1738

exit_();

1739

}

1740

1741

void MSRepository::backupCompleted()

1742

{

1743

CSMutex *myLock;

1744

enter_();

1745

myLock = &myRepoWriteLock;

1746

lock_(myLock);

1747

1748

1749

this->myRepoLockState &= ~REPO_BACKUP;

1750

if ( this->myRepoLockState == REPO_UNLOCKED) {

1751

myRepoXLock = false;

1752

signalCompactor();

1753

}

1754

1755

unlock_(myLock);

1756

exit_();

1757

}

1758

1759

bool MSRepository::lockedForBackup() { return ((myRepoLockState & REPO_BACKUP) == REPO_BACKUP);}

1760

1761

uint32_t MSRepository::initBackup()

1762

{

1763

CSMutex *myLock;

1764

uint32_t state;

1765

enter_();

1766

1767

myLock = &myRepoWriteLock;

1768

lock_(myLock);

1769

state = this->myRepoLockState;

1770

this->myRepoLockState |= REPO_BACKUP;

1771

if (this->myRepoLockState == REPO_BACKUP)

1772

this->myRepoXLock = true;

1773

1774

unlock_(myLock);

1775

return_(state);

1776

}

1777

1778

MSRepoFile *MSRepository::getRepoFile()

1779

{

1780

MSRepoFile *file;

1781

1782

if ((file = iFilePool)) {

1783

iFilePool = file->nextFile;

1784

file->nextFile = NULL;

1785

file->isFileInUse = true;

1786

file->retain();

1787

}

1788

return file;

1789

}

1790

1791

void MSRepository::addRepoFile(MSRepoFile *file)

1792

{

1793

iPoolFiles.addFront(file);

1794

}

1795

1796

void MSRepository::removeRepoFile(MSRepoFile *file)

1797

{

1798

iPoolFiles.remove(file);

1799

}

1800

1801

void MSRepository::returnRepoFile(MSRepoFile *file)

1802

{

1803

file->isFileInUse = false;

1804

file->nextFile = iFilePool;

1805

iFilePool = file;

1806

}

1807

1808

bool MSRepository::removeRepoFilesNotInUse()

1809

{

1810

MSRepoFile *file, *curr_file;

1811

1812

iFilePool = NULL;

1813

/* Remove all files that are not in use: */

1814

if ((file = (MSRepoFile *) iPoolFiles.getBack())) {

1815

do {

1816

curr_file = file;

1817

file = (MSRepoFile *) file->getNextLink();

1818

if (!curr_file->isFileInUse)

1819

iPoolFiles.remove(curr_file);

1820

} while (file);

1821

}

1822

return iPoolFiles.getSize() == 0;

1823

}

1824

1825

off64_t MSRepository::getRepoFileSize()

1826

{

1827

return myRepoFileSize;

1828

}

1829

1830

size_t MSRepository::getRepoHeadSize()

1831

{

1832

return myRepoHeadSize;

1833

}

1834

1835

size_t MSRepository::getRepoBlobHeadSize()

1836

{

1837

return myRepoBlobHeadSize;

1838

}

1839

1840

CSMutex *MSRepository::getRepoLock(off64_t offset)

1841

{

1842

return &myRepoLock[offset % CS_REPO_REC_LOCK_COUNT];

1843

}

1844

1845

uint32_t MSRepository::getRepoID()

1846

{

1847

return myRepoID;

1848

}

1849

1850

uint32_t MSRepository::getGarbageLevel()

1851

{

1852

if (myRepoFileSize <= myRepoHeadSize)

1853

return 0;

1854

return myGarbageCount * 100 / (myRepoFileSize - myRepoHeadSize);

1855

}

1856

1857

CSPath *MSRepository::getRepoFilePath()

1858

{

1859

char file_name[120];

1860

1861

cs_strcpy(120, file_name, "bs-repository");

1862

cs_add_dir_char(120, file_name);

1863

cs_strcat(120, file_name, "repo-");

1864

cs_strcat(120, file_name, myRepoID);

1865

cs_strcat(120, file_name, ".bs");

1866

1867

if (myRepoDatabase && myRepoDatabase->myDatabasePath) {

1868

return CSPath::newPath(RETAIN(myRepoDatabase->myDatabasePath), file_name);

1869

}

1870

return NULL;

1871

}

1872

Older »