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)

721 first = false;

723 }

724

727}

728

729

730

731

732

733

734

735bool

737{

739 bool first = true;

740

741 for (;;)

742 {

745

747

749 logLockFailure)

751 return false;

752

754

756 break;

757

758

759 if (!first)

761 first = false;

763 }

764

765 return true;

766}

767

768

769

770

771

772

773

774

775

776

777

778

781{

783

785

786

787

788

791

793

795

797}

798

799

800

801

802

803

804

805void

807{

809

811

813}

814

815

816

817

818

819

820

821void

823{

825

827

830

833}

834

835

836

837

838

839static void

841{

843

844

845

846

847

850 {

851 const char *cxt;

852

853 switch (info->oper)

854 {

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

857 break;

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

860 break;

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

863 break;

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

866 break;

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

869 break;

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

872 break;

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

875 break;

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

878 break;

879

880 default:

881 return;

882 }

883

888 }

889}

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904void

906{

909 int total = 0;

910 int done = 0;

911

912

913 if (locktags == NIL)

914 return;

915

916

917 foreach(lc, locktags)

918 {

920 int count;

921

922 holders = lappend(holders,

926 total += count;

927 }

928

931

932

933

934

935

936

937

938 foreach(lc, holders)

939 {

941

943 {

944

946 {

948

949 if (holder)

951 holder->pid);

952 }

954 lockholders++;

955

958 }

959 }

961 {

962 const int index[] = {

966 };

968 0, 0, 0

969 };

970

972 }

973

975}

976

977

978

979

980

981

982void

984{

986

990}

991

992

993

994

995

996

997

998

999

1000

1001void

1004{

1006

1009 classid,

1010 objid,

1011 objsubid);

1012

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

1014

1015

1017}

1018

1019

1020

1021

1022

1023

1024

1025bool

1028{

1032

1035 classid,

1036 objid,

1037 objsubid);

1038

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

1040 false);

1041

1043 return false;

1044

1045

1046

1047

1048

1050 {

1053 }

1054

1055 return true;

1056}

1057

1058

1059

1060

1061void

1064{

1066

1069 classid,

1070 objid,

1071 objsubid);

1072

1074}

1075

1076

1077

1078

1079

1080

1081void

1084{

1086

1089 classid,

1090 objid,

1091 objsubid);

1092

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

1094

1095

1097}

1098

1099

1100

1101

1102

1103

1104

1105bool

1108{

1112

1115 classid,

1116 objid,

1117 objsubid);

1118

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

1120 false);

1121

1123 return false;

1124

1125

1126

1127

1128

1130 {

1133 }

1134

1135 return true;

1136}

1137

1138

1139

1140

1141void

1144{

1146

1149 classid,

1150 objid,

1151 objsubid);

1152

1154}

1155

1156

1157

1158

1159

1160

1161

1162void

1165{

1167

1170 classid,

1171 objid,

1172 objsubid);

1173

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

1175}

1176

1177

1178

1179

1180void

1183{

1185

1188 classid,

1189 objid,

1190 objsubid);

1191

1193}

1194

1195

1196

1197

1198

1199

1200

1201

1202void

1205{

1207

1210 suboid,

1211 xid,

1212 objid);

1213

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

1215}

1216

1217

1218

1219

1220void

1223{

1225

1228 suboid,

1229 xid,

1230 objid);

1231

1233}

1234

1235

1236

1237

1238

1239

1240

1241

1242void

1244{

1246 {

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

1252 break;

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

1258 break;

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

1263 break;

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

1270 break;

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

1278 break;

1281 _("transaction %u"),

1283 break;

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

1289 break;

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

1295 break;

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

1302 break;

1304

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

1310 break;

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

1318 break;

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

1325 break;

1326 default:

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

1330 break;

1331 }

1332}

1333

1334

1335

1336

1337

1338

1339const char *

1341{

1343 return "???";

1345}

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 XactLockTableWait(TransactionId xid, Relation rel, ItemPointer ctid, XLTW_Oper oper)

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

bool ConditionalLockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode, bool logLockFailure)

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

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 LockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode)

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

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 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)

void UnlockTuple(Relation relation, ItemPointer tid, LOCKMODE lockmode)

@ 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[]

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

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,...)

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)