lmgr.c Source File (original) (raw)

55{

69void

71{

77 if (relation->rd_rel->relisshared)

79 else

81}

87static inline void

89{

94 else

98}

100

101

102

103

104

105

106void

108{

112

114

115 res = LockAcquireExtended(&tag, lockmode, false, false, true, &locallock,

116 false);

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

135 {

138 }

139}

140

141

142

143

144

145

146

147

148

149

150bool

152{

156

158

160 false);

161

163 return false;

164

165

166

167

168

170 {

173 }

174

175 return true;

176}

177

178

179

180

181

182

183

184void

186{

190

192

193 res = LockAcquireExtended(&tag, lockmode, false, false, true, &locallock,

194 false);

195

196

197

198

199

201 {

204 }

205}

206

207

208

209

210

211

212

213void

215{

217

219

221}

222

223

224

225

226

227

228void

230{

232

234

236}

237

238

239

240

241

242

243

244

245void

247{

251

255

256 res = LockAcquireExtended(&tag, lockmode, false, false, true, &locallock,

257 false);

258

259

260

261

262

264 {

267 }

268}

269

270

271

272

273

274

275

276

277bool

279{

283

287

289 false);

290

292 return false;

293

294

295

296

297

299 {

302 }

303

304 return true;

305}

306

307

308

309

310

311

312

313void

315{

317

321

323}

324

325

326

327

328

329

330

331

332

333bool

335{

337

341

342 return LockHeldByMe(&tag, lockmode, orstronger);

343}

344

345

346

347

348

349

350bool

352{

354

356

357 return LockHeldByMe(&tag, lockmode, orstronger);

358}

359

360

361

362

363

364

365

366bool

368{

370

374

376}

377

378

379

380

381

382

383

384

385

386

387

388

389

390void

392{

394

396

397 (void) LockAcquire(&tag, lockmode, true, false);

398}

399

400

401

402

403void

405{

407

409

411}

412

413

414

415

416

417

418

419

420

421

422

423void

425{

427

431

432 (void) LockAcquire(&tag, lockmode, false, false);

433}

434

435

436

437

438

439

440

441bool

443{

445

449

451}

452

453

454

455

456

457

458int

460{

462

466

468}

469

470

471

472

473void

475{

477

481

483}

484

485

486

487

488

489

490void

492{

494

496

497 (void) LockAcquire(&tag, lockmode, false, false);

498}

499

500

501

502

503

504

505

506void

508{

510

514 blkno);

515

516 (void) LockAcquire(&tag, lockmode, false, false);

517}

518

519

520

521

522

523

524

525bool

527{

529

533 blkno);

534

536}

537

538

539

540

541void

543{

545

549 blkno);

550

552}

553

554

555

556

557

558

559

560

561void

563{

565

571

572 (void) LockAcquire(&tag, lockmode, false, false);

573}

574

575

576

577

578

579

580

581bool

583 bool logLockFailure)

584{

586

592

595}

596

597

598

599

600void

602{

604

610

612}

613

614

615

616

617

618

619

620

621void

623{

625

627

629}

630

631

632

633

634

635

636

637

638void

640{

642

644

646}

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662void

665{

669 bool first = true;

670

671

672

673

674

676 {

679

680 info.rel = rel;

681 info.ctid = ctid;

683

688 }

689

690 for (;;)

691 {

694

696

698

700

702 break;

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719 if (!first)

720 {

723 }

724 first = false;

726 }

727

730}

731

732

733

734

735

736

737

738bool

740{

742 bool first = true;

743

744 for (;;)

745 {

748

750

752 logLockFailure)

754 return false;

755

757

759 break;

760

761

762 if (!first)

763 {

766 }

767 first = false;

769 }

770

771 return true;

772}

773

774

775

776

777

778

779

780

781

782

783

784

787{

789

791

792

793

794

797

799

801

803}

804

805

806

807

808

809

810

811void

813{

815

817

819}

820

821

822

823

824

825

826

827void

829{

831

833

836

839}

840

841

842

843

844

845static void

847{

849

850

851

852

853

856 {

857 const char *cxt;

858

859 switch (info->oper)

860 {

862 cxt = gettext_noop("while updating tuple (%u,%u) in relation \"%s\"");

863 break;

865 cxt = gettext_noop("while deleting tuple (%u,%u) in relation \"%s\"");

866 break;

868 cxt = gettext_noop("while locking tuple (%u,%u) in relation \"%s\"");

869 break;

871 cxt = gettext_noop("while locking updated version (%u,%u) of tuple in relation \"%s\"");

872 break;

874 cxt = gettext_noop("while inserting index tuple (%u,%u) in relation \"%s\"");

875 break;

877 cxt = gettext_noop("while checking uniqueness of tuple (%u,%u) in relation \"%s\"");

878 break;

880 cxt = gettext_noop("while rechecking updated tuple (%u,%u) in relation \"%s\"");

881 break;

883 cxt = gettext_noop("while checking exclusion constraint on tuple (%u,%u) in relation \"%s\"");

884 break;

885

886 default:

887 return;

888 }

889

894 }

895}

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910void

912{

915 int total = 0;

916 int done = 0;

917

918

919 if (locktags == NIL)

920 return;

921

922

923 foreach(lc, locktags)

924 {

926 int count;

927

928 holders = lappend(holders,

932 total += count;

933 }

934

937

938

939

940

941

942

943

944 foreach(lc, holders)

945 {

947

949 {

950

952 {

954

955 if (holder)

957 holder->pid);

958 }

960 lockholders++;

961

964 }

965 }

967 {

968 const int index[] = {

972 };

974 0, 0, 0

975 };

976

978 }

979

981}

982

983

984

985

986

987

988void

990{

992

996}

997

998

999

1000

1001

1002

1003

1004

1005

1006

1007void

1010{

1012

1015 classid,

1016 objid,

1017 objsubid);

1018

1019 (void) LockAcquire(&tag, lockmode, false, false);

1020

1021

1023}

1024

1025

1026

1027

1028

1029

1030

1031bool

1034{

1038

1041 classid,

1042 objid,

1043 objsubid);

1044

1045 res = LockAcquireExtended(&tag, lockmode, false, true, true, &locallock,

1046 false);

1047

1049 return false;

1050

1051

1052

1053

1054

1056 {

1059 }

1060

1061 return true;

1062}

1063

1064

1065

1066

1067void

1070{

1072

1075 classid,

1076 objid,

1077 objsubid);

1078

1080}

1081

1082

1083

1084

1085

1086

1087void

1090{

1092

1095 classid,

1096 objid,

1097 objsubid);

1098

1099 (void) LockAcquire(&tag, lockmode, false, false);

1100

1101

1103}

1104

1105

1106

1107

1108

1109

1110

1111bool

1114{

1118

1121 classid,

1122 objid,

1123 objsubid);

1124

1125 res = LockAcquireExtended(&tag, lockmode, false, true, true, &locallock,

1126 false);

1127

1129 return false;

1130

1131

1132

1133

1134

1136 {

1139 }

1140

1141 return true;

1142}

1143

1144

1145

1146

1147void

1150{

1152

1155 classid,

1156 objid,

1157 objsubid);

1158

1160}

1161

1162

1163

1164

1165

1166

1167

1168void

1171{

1173

1176 classid,

1177 objid,

1178 objsubid);

1179

1180 (void) LockAcquire(&tag, lockmode, true, false);

1181}

1182

1183

1184

1185

1186void

1189{

1191

1194 classid,

1195 objid,

1196 objsubid);

1197

1199}

1200

1201

1202

1203

1204

1205

1206

1207

1208void

1211{

1213

1216 suboid,

1217 xid,

1218 objid);

1219

1220 (void) LockAcquire(&tag, lockmode, true, false);

1221}

1222

1223

1224

1225

1226void

1229{

1231

1234 suboid,

1235 xid,

1236 objid);

1237

1239}

1240

1241

1242

1243

1244

1245

1246

1247

1248void

1250{

1252 {

1255 _("relation %u of database %u"),

1258 break;

1261 _("extension of relation %u of database %u"),

1264 break;

1267 _("pg_database.datfrozenxid of database %u"),

1269 break;

1272 _("page %u of relation %u of database %u"),

1276 break;

1279 _("tuple (%u,%u) of relation %u of database %u"),

1284 break;

1287 _("transaction %u"),

1289 break;

1292 _("virtual transaction %d/%u"),

1295 break;

1298 _("speculative token %u of transaction %u"),

1301 break;

1304 _("object %u of class %u of database %u"),

1308 break;

1310

1312 _("user lock [%u,%u,%u]"),

1316 break;

1319 _("advisory lock [%u,%u,%u,%u]"),

1324 break;

1327 _("remote transaction %u of subscription %u of database %u"),

1331 break;

1332 default:

1334 _("unrecognized locktag type %d"),

1336 break;

1337 }

1338}

1339

1340

1341

1342

1343

1344

1345const char *

1347{

1349 return "???";

1351}

void pgstat_progress_update_param(int index, int64 val)

void pgstat_progress_update_multi_param(int nparam, const int *index, const int64 *val)

static Datum values[MAXATTR]

#define OidIsValid(objectId)

bool IsSharedRelation(Oid relationId)

ErrorContextCallback * error_context_stack

Assert(PointerIsAligned(start, uint64))

void AcceptInvalidationMessages(void)

static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)

static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)

static bool ItemPointerIsValid(const ItemPointerData *pointer)

List * lappend(List *list, void *datum)

void list_free(List *list)

void list_free_deep(List *list)

bool ConditionalLockRelationOid(Oid relid, LOCKMODE lockmode)

void UnlockTuple(Relation relation, const ItemPointerData *tid, LOCKMODE lockmode)

void LockSharedObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

bool ConditionalLockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)

bool ConditionalLockTuple(Relation relation, const ItemPointerData *tid, LOCKMODE lockmode, bool logLockFailure)

void UnlockRelationOid(Oid relid, LOCKMODE lockmode)

void LockDatabaseObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

void UnlockRelation(Relation relation, LOCKMODE lockmode)

void DescribeLockTag(StringInfo buf, const LOCKTAG *tag)

void SpeculativeInsertionWait(TransactionId xid, uint32 token)

bool ConditionalLockSharedObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

void UnlockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

void WaitForLockersMultiple(List *locktags, LOCKMODE lockmode, bool progress)

void LockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)

void RelationInitLockInfo(Relation relation)

void LockRelationOid(Oid relid, LOCKMODE lockmode)

void LockRelation(Relation relation, LOCKMODE lockmode)

void UnlockRelationId(LockRelId *relid, LOCKMODE lockmode)

void WaitForLockers(LOCKTAG heaplocktag, LOCKMODE lockmode, bool progress)

bool ConditionalXactLockTableWait(TransactionId xid, bool logLockFailure)

void XactLockTableDelete(TransactionId xid)

void XactLockTableInsert(TransactionId xid)

uint32 SpeculativeInsertionLockAcquire(TransactionId xid)

void LockRelationForExtension(Relation relation, LOCKMODE lockmode)

bool CheckRelationLockedByMe(Relation relation, LOCKMODE lockmode, bool orstronger)

void UnlockApplyTransactionForSession(Oid suboid, TransactionId xid, uint16 objid, LOCKMODE lockmode)

void SpeculativeInsertionLockRelease(TransactionId xid)

static void XactLockTableWaitErrorCb(void *arg)

void LockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)

bool ConditionalLockRelationForExtension(Relation relation, LOCKMODE lockmode)

bool CheckRelationOidLockedByMe(Oid relid, LOCKMODE lockmode, bool orstronger)

static void SetLocktagRelationOid(LOCKTAG *tag, Oid relid)

void UnlockPage(Relation relation, BlockNumber blkno, LOCKMODE lockmode)

void UnlockRelationIdForSession(LockRelId *relid, LOCKMODE lockmode)

bool ConditionalLockRelation(Relation relation, LOCKMODE lockmode)

static uint32 speculativeInsertionToken

void LockTuple(Relation relation, const ItemPointerData *tid, LOCKMODE lockmode)

bool ConditionalLockDatabaseObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

void LockDatabaseFrozenIds(LOCKMODE lockmode)

struct XactLockTableWaitInfo XactLockTableWaitInfo

void UnlockRelationForExtension(Relation relation, LOCKMODE lockmode)

const char * GetLockNameFromTagType(uint16 locktag_type)

void UnlockSharedObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

void XactLockTableWait(TransactionId xid, Relation rel, const ItemPointerData *ctid, XLTW_Oper oper)

void LockApplyTransactionForSession(Oid suboid, TransactionId xid, uint16 objid, LOCKMODE lockmode)

void LockSharedObjectForSession(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

void LockRelationId(LockRelId *relid, LOCKMODE lockmode)

bool LockHasWaitersRelation(Relation relation, LOCKMODE lockmode)

void UnlockDatabaseObject(Oid classid, Oid objid, uint16 objsubid, LOCKMODE lockmode)

int RelationExtensionLockWaiterCount(Relation relation)

@ XLTW_RecheckExclusionConstr

LockAcquireResult LockAcquire(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait)

bool LockHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode, bool orstronger)

int LockWaiterCount(const LOCKTAG *locktag)

bool LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)

bool VirtualXactLock(VirtualTransactionId vxid, bool wait)

VirtualTransactionId * GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)

LockAcquireResult LockAcquireExtended(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait, bool reportMemoryError, LOCALLOCK **locallockp, bool logLockFailure)

bool LockHasWaiters(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)

void MarkLockClear(LOCALLOCK *locallock)

#define SET_LOCKTAG_DATABASE_FROZEN_IDS(locktag, dboid)

#define SET_LOCKTAG_RELATION_EXTEND(locktag, dboid, reloid)

@ LOCKTAG_RELATION_EXTEND

@ LOCKTAG_SPECULATIVE_TOKEN

@ LOCKTAG_APPLY_TRANSACTION

@ LOCKTAG_DATABASE_FROZEN_IDS

@ LOCKTAG_VIRTUALTRANSACTION

#define SET_LOCKTAG_APPLY_TRANSACTION(locktag, dboid, suboid, xid, objid)

#define VirtualTransactionIdIsValid(vxid)

#define SET_LOCKTAG_TRANSACTION(locktag, xid)

#define SET_LOCKTAG_RELATION(locktag, dboid, reloid)

#define SET_LOCKTAG_SPECULATIVE_INSERTION(locktag, xid, token)

#define LOCKTAG_LAST_TYPE

#define SET_LOCKTAG_PAGE(locktag, dboid, reloid, blocknum)

#define SET_LOCKTAG_TUPLE(locktag, dboid, reloid, blocknum, offnum)

#define SET_LOCKTAG_OBJECT(locktag, dboid, classoid, objoid, objsubid)

@ LOCKACQUIRE_ALREADY_CLEAR

const char *const LockTagTypeNames[]

#define CHECK_FOR_INTERRUPTS()

Operator oper(ParseState *pstate, List *opname, Oid ltypeId, Oid rtypeId, bool noError, int location)

static char buf[DEFAULT_XLOG_SEG_SIZE]

PGPROC * ProcNumberGetProc(ProcNumber procNumber)

bool TransactionIdIsInProgress(TransactionId xid)

#define PROGRESS_WAITFOR_DONE

#define PROGRESS_WAITFOR_TOTAL

#define PROGRESS_WAITFOR_CURRENT_PID

#define RelationGetRelid(relation)

#define RelationGetRelationName(relation)

#define RelationIsValid(relation)

void pg_usleep(long microsec)

void appendStringInfo(StringInfo str, const char *fmt,...)

const ItemPointerData * ctid

TransactionId SubTransGetTopmostTransaction(TransactionId xid)

static void callback(struct sockaddr *addr, struct sockaddr *mask, void *unused)

#define TransactionIdEquals(id1, id2)

#define TransactionIdIsValid(xid)

TransactionId GetTopTransactionIdIfAny(void)