database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2026-01-26 09:41:40 +03:00
Code Activity

lwlock: Remove support for disowned lwlwocks

Browse Source 
This reverts commit f8d7f29b3e, plus parts of
subsequent commits fixing a typo in a parameter name.

Support for disowned lwlocks was added for the benefit of AIO, to be able to
have content locks "owned" by the AIO subsystem. But as of commit fcb9c977aa,
content locks do not use lwlocks anymore.

It does not seem particularly likely that we need this facility outside of the
AIO use-case, therefore remove the now unused functions.

I did choose to keep the comment added in the aforementioned commit about
lock->owner intentionally being left pointing to the last owner.

Reviewed-by: Chao Li <li.evan.chao@gmail.com>
Discussion: https://postgr.es/m/cj5mcjdpucvw4a54hehslr3ctukavrbnxltvuzzhqnimvpju5e@cy3g3mnsefwz
This commit is contained in:
Andres Freund
2026-01-15 14:54:16 -05:00
parent 55fbfb738b
commit d40fd85187
2 changed files with 6 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
src/backend/storage/lmgr/lwlock.c
View File

@@ -1783,25 +1783,18 @@ LWLockUpdateVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
/*
* Stop treating lock as held by current backend.
*
* This is the code that can be shared between actually releasing a lock
* (LWLockRelease()) and just not tracking ownership of the lock anymore
* without releasing the lock (LWLockDisown()).
*
* Returns the mode in which the lock was held by the current backend.
*
* NB: This does not call RESUME_INTERRUPTS(), but leaves that responsibility
* of the caller.
* LWLockRelease - release a previously acquired lock
*
* NB: This will leave lock->owner pointing to the current backend (if
* LOCK_DEBUG is set). This is somewhat intentional, as it makes it easier to
* debug cases of missing wakeups during lock release.
*/
static inline LWLockMode
LWLockDisownInternal(LWLock *lock)
void
LWLockRelease(LWLock *lock)
{
LWLockMode mode;
uint32 oldstate;
bool check_waiters;
int i;
/*
@@ -1821,18 +1814,7 @@ LWLockDisownInternal(LWLock *lock)
for (; i < num_held_lwlocks; i++)
held_lwlocks[i] = held_lwlocks[i + 1];
return mode;
}
/*
* Helper function to release lock, shared between LWLockRelease() and
* LWLockReleaseDisowned().
*/
static void
LWLockReleaseInternal(LWLock *lock, LWLockMode mode)
{
uint32 oldstate;
bool check_waiters;
PRINT_LWDEBUG("LWLockRelease", lock, mode);
/*
* Release my hold on lock, after that it can immediately be acquired by
@@ -1870,38 +1852,6 @@ LWLockReleaseInternal(LWLock *lock, LWLockMode mode)
LOG_LWDEBUG("LWLockRelease", lock, "releasing waiters");
LWLockWakeup(lock);
}
}
/*
* Stop treating lock as held by current backend.
*
* After calling this function it's the callers responsibility to ensure that
* the lock gets released (via LWLockReleaseDisowned()), even in case of an
* error. This only is desirable if the lock is going to be released in a
* different process than the process that acquired it.
*/
void
LWLockDisown(LWLock *lock)
{
LWLockDisownInternal(lock);
RESUME_INTERRUPTS();
}
/*
* LWLockRelease - release a previously acquired lock
*/
void
LWLockRelease(LWLock *lock)
{
LWLockMode mode;
mode = LWLockDisownInternal(lock);
PRINT_LWDEBUG("LWLockRelease", lock, mode);
LWLockReleaseInternal(lock, mode);
/*
* Now okay to allow cancel/die interrupts.
@@ -1909,15 +1859,6 @@ LWLockRelease(LWLock *lock)
RESUME_INTERRUPTS();
}
/*
* Release lock previously disowned with LWLockDisown().
*/
void
LWLockReleaseDisowned(LWLock *lock, LWLockMode mode)
{
LWLockReleaseInternal(lock, mode);
}
/*
* LWLockReleaseClearVar - release a previously acquired lock, reset variable
*/

2
src/include/storage/lwlock.h
View File

@@ -127,8 +127,6 @@ extern bool LWLockAcquireOrWait(LWLock *lock, LWLockMode mode);
extern void LWLockRelease(LWLock *lock);
extern void LWLockReleaseClearVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val);
extern void LWLockReleaseAll(void);
extern void LWLockDisown(LWLock *lock);
extern void LWLockReleaseDisowned(LWLock *lock, LWLockMode mode);
extern bool LWLockHeldByMe(LWLock *lock);
extern bool LWLockAnyHeldByMe(LWLock *lock, int nlocks, size_t stride);
extern bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode);