4 files changed, 206 insertions, 300 deletions

diff --git a/lib/private/Lock/AbstractLockingProvider.php b/lib/private/Lock/AbstractLockingProvider.php
index f4899bbb2b2..d7e5976079c 100644
--- a/lib/private/Lock/AbstractLockingProvider.php
+++ b/lib/private/Lock/AbstractLockingProvider.php
@@ -1,28 +1,10 @@
 <?php
 
 declare(strict_types=1);
-
 /**
- * @copyright Copyright (c) 2016, ownCloud, Inc.
- *
- * @author Christoph Wurst <christoph@winzerhof-wurst.at>
- * @author Robin Appelman <robin@icewind.nl>
- * @author Roeland Jago Douma <roeland@famdouma.nl>
- *
- * @license AGPL-3.0
- *
- * This code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License, version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License, version 3,
- * along with this program. If not, see <http://www.gnu.org/licenses/>
- *
+ * SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
  */
 namespace OC\Lock;
 
@@ -30,24 +12,24 @@ use OCP\Lock\ILockingProvider;
 
 /**
  * Base locking provider that keeps track of locks acquired during the current request
- * to release any left over locks at the end of the request
+ * to release any leftover locks at the end of the request
  */
 abstract class AbstractLockingProvider implements ILockingProvider {
-	/** @var int $ttl */
-	protected $ttl; // how long until we clear stray locks in seconds
-
-	protected $acquiredLocks = [
+	protected array $acquiredLocks = [
 		'shared' => [],
 		'exclusive' => []
 	];
 
 	/**
-	 * Check if we've locally acquired a lock
 	 *
-	 * @param string $path
-	 * @param int $type
-	 * @return bool
+	 * @param int $ttl how long until we clear stray locks in seconds
 	 */
+	public function __construct(
+		protected int $ttl,
+	) {
+	}
+
+	/** @inheritDoc */
 	protected function hasAcquiredLock(string $path, int $type): bool {
 		if ($type === self::LOCK_SHARED) {
 			return isset($this->acquiredLocks['shared'][$path]) && $this->acquiredLocks['shared'][$path] > 0;
@@ -56,14 +38,9 @@ abstract class AbstractLockingProvider implements ILockingProvider {
 		}
 	}
 
-	/**
-	 * Mark a locally acquired lock
-	 *
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	protected function markAcquire(string $path, int $type) {
-		if ($type === self::LOCK_SHARED) {
+	/** @inheritDoc */
+	protected function markAcquire(string $path, int $targetType): void {
+		if ($targetType === self::LOCK_SHARED) {
 			if (!isset($this->acquiredLocks['shared'][$path])) {
 				$this->acquiredLocks['shared'][$path] = 0;
 			}
@@ -73,13 +50,8 @@ abstract class AbstractLockingProvider implements ILockingProvider {
 		}
 	}
 
-	/**
-	 * Mark a release of a locally acquired lock
-	 *
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	protected function markRelease(string $path, int $type) {
+	/** @inheritDoc */
+	protected function markRelease(string $path, int $type): void {
 		if ($type === self::LOCK_SHARED) {
 			if (isset($this->acquiredLocks['shared'][$path]) and $this->acquiredLocks['shared'][$path] > 0) {
 				$this->acquiredLocks['shared'][$path]--;
@@ -92,13 +64,8 @@ abstract class AbstractLockingProvider implements ILockingProvider {
 		}
 	}
 
-	/**
-	 * Change the type of an existing tracked lock
-	 *
-	 * @param string $path
-	 * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	protected function markChange(string $path, int $targetType) {
+	/** @inheritDoc */
+	protected function markChange(string $path, int $targetType): void {
 		if ($targetType === self::LOCK_SHARED) {
 			unset($this->acquiredLocks['exclusive'][$path]);
 			if (!isset($this->acquiredLocks['shared'][$path])) {
@@ -111,10 +78,8 @@ abstract class AbstractLockingProvider implements ILockingProvider {
 		}
 	}
 
-	/**
-	 * release all lock acquired by this instance which were marked using the mark* methods
-	 */
-	public function releaseAll() {
+	/** @inheritDoc */
+	public function releaseAll(): void {
 		foreach ($this->acquiredLocks['shared'] as $path => $count) {
 			for ($i = 0; $i < $count; $i++) {
 				$this->releaseLock($path, self::LOCK_SHARED);
@@ -126,7 +91,7 @@ abstract class AbstractLockingProvider implements ILockingProvider {
 		}
 	}
 
-	protected function getOwnSharedLockCount(string $path) {
-		return isset($this->acquiredLocks['shared'][$path]) ? $this->acquiredLocks['shared'][$path] : 0;
+	protected function getOwnSharedLockCount(string $path): int {
+		return $this->acquiredLocks['shared'][$path] ?? 0;
 	}
 }
diff --git a/lib/private/Lock/DBLockingProvider.php b/lib/private/Lock/DBLockingProvider.php
index 5eb03ad856b..cb7f5cff350 100644
--- a/lib/private/Lock/DBLockingProvider.php
+++ b/lib/private/Lock/DBLockingProvider.php
@@ -1,29 +1,9 @@
 <?php
+
 /**
- * @copyright Copyright (c) 2016, ownCloud, Inc.
- *
- * @author Christoph Wurst <christoph@winzerhof-wurst.at>
- * @author Individual IT Services <info@individual-it.net>
- * @author Joas Schilling <coding@schilljs.com>
- * @author Morris Jobke <hey@morrisjobke.de>
- * @author Ole Ostergaard <ole.c.ostergaard@gmail.com>
- * @author Robin Appelman <robin@icewind.nl>
- * @author Roeland Jago Douma <roeland@famdouma.nl>
- *
- * @license AGPL-3.0
- *
- * This code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License, version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License, version 3,
- * along with this program. If not, see <http://www.gnu.org/licenses/>
- *
+ * SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
  */
 namespace OC\Lock;
 
@@ -33,51 +13,34 @@ use OCP\DB\QueryBuilder\IQueryBuilder;
 use OCP\IDBConnection;
 use OCP\Lock\ILockingProvider;
 use OCP\Lock\LockedException;
-use Psr\Log\LoggerInterface;
 
 /**
  * Locking provider that stores the locks in the database
  */
 class DBLockingProvider extends AbstractLockingProvider {
-	/**
-	 * @var \OCP\IDBConnection
-	 */
-	private $connection;
+	private array $sharedLocks = [];
 
-	private LoggerInterface $logger;
-
-	/**
-	 * @var \OCP\AppFramework\Utility\ITimeFactory
-	 */
-	private $timeFactory;
-
-	private $sharedLocks = [];
-
-	/**
-	 * @var bool
-	 */
-	private $cacheSharedLocks;
+	public function __construct(
+		private IDBConnection $connection,
+		private ITimeFactory $timeFactory,
+		int $ttl = 3600,
+		private bool $cacheSharedLocks = true,
+	) {
+		parent::__construct($ttl);
+	}
 
 	/**
 	 * Check if we have an open shared lock for a path
-	 *
-	 * @param string $path
-	 * @return bool
 	 */
 	protected function isLocallyLocked(string $path): bool {
 		return isset($this->sharedLocks[$path]) && $this->sharedLocks[$path];
 	}
 
-	/**
-	 * Mark a locally acquired lock
-	 *
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	protected function markAcquire(string $path, int $type) {
-		parent::markAcquire($path, $type);
+	/** @inheritDoc */
+	protected function markAcquire(string $path, int $targetType): void {
+		parent::markAcquire($path, $targetType);
 		if ($this->cacheSharedLocks) {
-			if ($type === self::LOCK_SHARED) {
+			if ($targetType === self::LOCK_SHARED) {
 				$this->sharedLocks[$path] = true;
 			}
 		}
@@ -85,11 +48,8 @@ class DBLockingProvider extends AbstractLockingProvider {
 
 	/**
 	 * Change the type of an existing tracked lock
-	 *
-	 * @param string $path
-	 * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
 	 */
-	protected function markChange(string $path, int $targetType) {
+	protected function markChange(string $path, int $targetType): void {
 		parent::markChange($path, $targetType);
 		if ($this->cacheSharedLocks) {
 			if ($targetType === self::LOCK_SHARED) {
@@ -101,28 +61,7 @@ class DBLockingProvider extends AbstractLockingProvider {
 	}
 
 	/**
-	 * @param bool $cacheSharedLocks
-	 */
-	public function __construct(
-		IDBConnection $connection,
-		LoggerInterface $logger,
-		ITimeFactory $timeFactory,
-		int $ttl = 3600,
-		$cacheSharedLocks = true
-	) {
-		$this->connection = $connection;
-		$this->logger = $logger;
-		$this->timeFactory = $timeFactory;
-		$this->ttl = $ttl;
-		$this->cacheSharedLocks = $cacheSharedLocks;
-	}
-
-	/**
 	 * Insert a file locking row if it does not exists.
-	 *
-	 * @param string $path
-	 * @param int $lock
-	 * @return int number of inserted rows
 	 */
 	protected function initLockField(string $path, int $lock = 0): int {
 		$expire = $this->getExpireTime();
@@ -133,25 +72,21 @@ class DBLockingProvider extends AbstractLockingProvider {
 		]);
 	}
 
-	/**
-	 * @return int
-	 */
 	protected function getExpireTime(): int {
 		return $this->timeFactory->getTime() + $this->ttl;
 	}
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @return bool
-	 */
+	/** @inheritDoc */
 	public function isLocked(string $path, int $type): bool {
 		if ($this->hasAcquiredLock($path, $type)) {
 			return true;
 		}
-		$query = $this->connection->prepare('SELECT `lock` from `*PREFIX*file_locks` WHERE `key` = ?');
-		$query->execute([$path]);
-		$lockValue = (int)$query->fetchOne();
+		$query = $this->connection->getQueryBuilder();
+		$query->select('lock')
+			->from('file_locks')
+			->where($query->expr()->eq('key', $query->createNamedParameter($path)));
+		$result = $query->executeQuery();
+		$lockValue = (int)$result->fetchOne();
 		if ($type === self::LOCK_SHARED) {
 			if ($this->isLocallyLocked($path)) {
 				// if we have a shared lock we kept open locally but it's released we always have at least 1 shared lock in the db
@@ -166,21 +101,20 @@ class DBLockingProvider extends AbstractLockingProvider {
 		}
 	}
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function acquireLock(string $path, int $type, string $readablePath = null) {
+	/** @inheritDoc */
+	public function acquireLock(string $path, int $type, ?string $readablePath = null): void {
 		$expire = $this->getExpireTime();
 		if ($type === self::LOCK_SHARED) {
 			if (!$this->isLocallyLocked($path)) {
 				$result = $this->initLockField($path, 1);
 				if ($result <= 0) {
-					$result = $this->connection->executeUpdate(
-						'UPDATE `*PREFIX*file_locks` SET `lock` = `lock` + 1, `ttl` = ? WHERE `key` = ? AND `lock` >= 0',
-						[$expire, $path]
-					);
+					$query = $this->connection->getQueryBuilder();
+					$query->update('file_locks')
+						->set('lock', $query->func()->add('lock', $query->createNamedParameter(1, IQueryBuilder::PARAM_INT)))
+						->set('ttl', $query->createNamedParameter($expire))
+						->where($query->expr()->eq('key', $query->createNamedParameter($path)))
+						->andWhere($query->expr()->gte('lock', $query->createNamedParameter(0, IQueryBuilder::PARAM_INT)));
+					$result = $query->executeStatement();
 				}
 			} else {
 				$result = 1;
@@ -192,10 +126,13 @@ class DBLockingProvider extends AbstractLockingProvider {
 			}
 			$result = $this->initLockField($path, -1);
 			if ($result <= 0) {
-				$result = $this->connection->executeUpdate(
-					'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = ?',
-					[$expire, $path, $existing]
-				);
+				$query = $this->connection->getQueryBuilder();
+				$query->update('file_locks')
+					->set('lock', $query->createNamedParameter(-1, IQueryBuilder::PARAM_INT))
+					->set('ttl', $query->createNamedParameter($expire, IQueryBuilder::PARAM_INT))
+					->where($query->expr()->eq('key', $query->createNamedParameter($path)))
+					->andWhere($query->expr()->eq('lock', $query->createNamedParameter($existing)));
+				$result = $query->executeStatement();
 			}
 		}
 		if ($result !== 1) {
@@ -204,52 +141,53 @@ class DBLockingProvider extends AbstractLockingProvider {
 		$this->markAcquire($path, $type);
 	}
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	public function releaseLock(string $path, int $type) {
+	/** @inheritDoc */
+	public function releaseLock(string $path, int $type): void {
 		$this->markRelease($path, $type);
 
 		// we keep shared locks till the end of the request so we can re-use them
 		if ($type === self::LOCK_EXCLUSIVE) {
-			$this->connection->executeUpdate(
-				'UPDATE `*PREFIX*file_locks` SET `lock` = 0 WHERE `key` = ? AND `lock` = -1',
-				[$path]
-			);
+			$qb = $this->connection->getQueryBuilder();
+			$qb->update('file_locks')
+				->set('lock', $qb->createNamedParameter(0, IQueryBuilder::PARAM_INT))
+				->where($qb->expr()->eq('key', $qb->createNamedParameter($path)))
+				->andWhere($qb->expr()->eq('lock', $qb->createNamedParameter(-1, IQueryBuilder::PARAM_INT)));
+			$qb->executeStatement();
 		} elseif (!$this->cacheSharedLocks) {
-			$query = $this->connection->getQueryBuilder();
-			$query->update('file_locks')
-				->set('lock', $query->func()->subtract('lock', $query->createNamedParameter(1)))
-				->where($query->expr()->eq('key', $query->createNamedParameter($path)))
-				->andWhere($query->expr()->gt('lock', $query->createNamedParameter(0)));
-			$query->execute();
+			$qb = $this->connection->getQueryBuilder();
+			$qb->update('file_locks')
+				->set('lock', $qb->func()->subtract('lock', $qb->createNamedParameter(1, IQueryBuilder::PARAM_INT)))
+				->where($qb->expr()->eq('key', $qb->createNamedParameter($path)))
+				->andWhere($qb->expr()->gt('lock', $qb->createNamedParameter(0, IQueryBuilder::PARAM_INT)));
+			$qb->executeStatement();
 		}
 	}
 
-	/**
-	 * Change the type of an existing lock
-	 *
-	 * @param string $path
-	 * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function changeLock(string $path, int $targetType) {
+	/** @inheritDoc */
+	public function changeLock(string $path, int $targetType): void {
 		$expire = $this->getExpireTime();
 		if ($targetType === self::LOCK_SHARED) {
-			$result = $this->connection->executeUpdate(
-				'UPDATE `*PREFIX*file_locks` SET `lock` = 1, `ttl` = ? WHERE `key` = ? AND `lock` = -1',
-				[$expire, $path]
-			);
+			$qb = $this->connection->getQueryBuilder();
+			$result = $qb->update('file_locks')
+				->set('lock', $qb->createNamedParameter(1, IQueryBuilder::PARAM_INT))
+				->set('ttl', $qb->createNamedParameter($expire, IQueryBuilder::PARAM_INT))
+				->where($qb->expr()->andX(
+					$qb->expr()->eq('key', $qb->createNamedParameter($path)),
+					$qb->expr()->eq('lock', $qb->createNamedParameter(-1, IQueryBuilder::PARAM_INT))
+				))->executeStatement();
 		} else {
 			// since we only keep one shared lock in the db we need to check if we have more then one shared lock locally manually
 			if (isset($this->acquiredLocks['shared'][$path]) && $this->acquiredLocks['shared'][$path] > 1) {
 				throw new LockedException($path);
 			}
-			$result = $this->connection->executeUpdate(
-				'UPDATE `*PREFIX*file_locks` SET `lock` = -1, `ttl` = ? WHERE `key` = ? AND `lock` = 1',
-				[$expire, $path]
-			);
+			$qb = $this->connection->getQueryBuilder();
+			$result = $qb->update('file_locks')
+				->set('lock', $qb->createNamedParameter(-1, IQueryBuilder::PARAM_INT))
+				->set('ttl', $qb->createNamedParameter($expire, IQueryBuilder::PARAM_INT))
+				->where($qb->expr()->andX(
+					$qb->expr()->eq('key', $qb->createNamedParameter($path)),
+					$qb->expr()->eq('lock', $qb->createNamedParameter(1, IQueryBuilder::PARAM_INT))
+				))->executeStatement();
 		}
 		if ($result !== 1) {
 			throw new LockedException($path);
@@ -257,16 +195,14 @@ class DBLockingProvider extends AbstractLockingProvider {
 		$this->markChange($path, $targetType);
 	}
 
-	/**
-	 * cleanup empty locks
-	 */
-	public function cleanExpiredLocks() {
+	/** @inheritDoc */
+	public function cleanExpiredLocks(): void {
 		$expire = $this->timeFactory->getTime();
 		try {
-			$this->connection->executeUpdate(
-				'DELETE FROM `*PREFIX*file_locks` WHERE `ttl` < ?',
-				[$expire]
-			);
+			$qb = $this->connection->getQueryBuilder();
+			$qb->delete('file_locks')
+				->where($qb->expr()->lt('ttl', $qb->createNamedParameter($expire, IQueryBuilder::PARAM_INT)))
+				->executeStatement();
 		} catch (\Exception $e) {
 			// If the table is missing, the clean up was successful
 			if ($this->connection->tableExists('file_locks')) {
@@ -275,10 +211,8 @@ class DBLockingProvider extends AbstractLockingProvider {
 		}
 	}
 
-	/**
-	 * release all lock acquired by this instance which were marked using the mark* methods
-	 */
-	public function releaseAll() {
+	/** @inheritDoc */
+	public function releaseAll(): void {
 		parent::releaseAll();
 
 		if (!$this->cacheSharedLocks) {
@@ -292,15 +226,15 @@ class DBLockingProvider extends AbstractLockingProvider {
 
 		$chunkedPaths = array_chunk($lockedPaths, 100);
 
-		foreach ($chunkedPaths as $chunk) {
-			$builder = $this->connection->getQueryBuilder();
+		$qb = $this->connection->getQueryBuilder();
+		$qb->update('file_locks')
+			->set('lock', $qb->func()->subtract('lock', $qb->expr()->literal(1)))
+			->where($qb->expr()->in('key', $qb->createParameter('chunk')))
+			->andWhere($qb->expr()->gt('lock', new Literal(0)));
 
-			$query = $builder->update('file_locks')
-				->set('lock', $builder->func()->subtract('lock', $builder->expr()->literal(1)))
-				->where($builder->expr()->in('key', $builder->createNamedParameter($chunk, IQueryBuilder::PARAM_STR_ARRAY)))
-				->andWhere($builder->expr()->gt('lock', new Literal(0)));
-
-			$query->execute();
+		foreach ($chunkedPaths as $chunk) {
+			$qb->setParameter('chunk', $chunk, IQueryBuilder::PARAM_STR_ARRAY);
+			$qb->executeStatement();
 		}
 	}
 }
diff --git a/lib/private/Lock/MemcacheLockingProvider.php b/lib/private/Lock/MemcacheLockingProvider.php
index 008a7875d7e..8cc0c27bbf9 100644
--- a/lib/private/Lock/MemcacheLockingProvider.php
+++ b/lib/private/Lock/MemcacheLockingProvider.php
@@ -1,62 +1,52 @@
 <?php
 
 declare(strict_types=1);
-
 /**
- * @copyright Copyright (c) 2016, ownCloud, Inc.
- *
- * @author Christoph Wurst <christoph@winzerhof-wurst.at>
- * @author Jaakko Salo <jaakkos@gmail.com>
- * @author Robin Appelman <robin@icewind.nl>
- * @author Roeland Jago Douma <roeland@famdouma.nl>
- *
- * @license AGPL-3.0
- *
- * This code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License, version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License, version 3,
- * along with this program. If not, see <http://www.gnu.org/licenses/>
- *
+ * SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
  */
 namespace OC\Lock;
 
+use OCP\AppFramework\Utility\ITimeFactory;
 use OCP\IMemcache;
 use OCP\IMemcacheTTL;
 use OCP\Lock\LockedException;
 
 class MemcacheLockingProvider extends AbstractLockingProvider {
-	/**
-	 * @var \OCP\IMemcache
-	 */
-	private $memcache;
+	/** @var array<string, array{time: int, ttl: int}> */
+	private array $oldTTLs = [];
 
-	/**
-	 * @param \OCP\IMemcache $memcache
-	 * @param int $ttl
-	 */
-	public function __construct(IMemcache $memcache, int $ttl = 3600) {
-		$this->memcache = $memcache;
-		$this->ttl = $ttl;
+	public function __construct(
+		private IMemcache $memcache,
+		private ITimeFactory $timeFactory,
+		int $ttl = 3600,
+	) {
+		parent::__construct($ttl);
 	}
 
-	private function setTTL(string $path) {
+	private function setTTL(string $path, ?int $ttl = null, mixed $compare = null): void {
+		if (is_null($ttl)) {
+			$ttl = $this->ttl;
+		}
 		if ($this->memcache instanceof IMemcacheTTL) {
-			$this->memcache->setTTL($path, $this->ttl);
+			if ($compare !== null) {
+				$this->memcache->compareSetTTL($path, $compare, $ttl);
+			} else {
+				$this->memcache->setTTL($path, $ttl);
+			}
+		}
+	}
+
+	private function getTTL(string $path): int {
+		if ($this->memcache instanceof IMemcacheTTL) {
+			$ttl = $this->memcache->getTTL($path);
+			return $ttl === false ? -1 : $ttl;
+		} else {
+			return -1;
 		}
 	}
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @return bool
-	 */
 	public function isLocked(string $path, int $type): bool {
 		$lockValue = $this->memcache->get($path);
 		if ($type === self::LOCK_SHARED) {
@@ -68,32 +58,30 @@ class MemcacheLockingProvider extends AbstractLockingProvider {
 		}
 	}
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @param string $readablePath human readable path to use in error messages
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function acquireLock(string $path, int $type, string $readablePath = null) {
+	public function acquireLock(string $path, int $type, ?string $readablePath = null): void {
 		if ($type === self::LOCK_SHARED) {
+			// save the old TTL to for `restoreTTL`
+			$this->oldTTLs[$path] = [
+				'ttl' => $this->getTTL($path),
+				'time' => $this->timeFactory->getTime()
+			];
 			if (!$this->memcache->inc($path)) {
 				throw new LockedException($path, null, $this->getExistingLockForException($path), $readablePath);
 			}
 		} else {
+			// when getting exclusive locks, we know there are no old TTLs to restore
 			$this->memcache->add($path, 0);
+			// ttl is updated automatically when the `set` succeeds
 			if (!$this->memcache->cas($path, 0, 'exclusive')) {
 				throw new LockedException($path, null, $this->getExistingLockForException($path), $readablePath);
 			}
+			unset($this->oldTTLs[$path]);
 		}
 		$this->setTTL($path);
 		$this->markAcquire($path, $type);
 	}
 
-	/**
-	 * @param string $path
-	 * @param int $type self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 */
-	public function releaseLock(string $path, int $type) {
+	public function releaseLock(string $path, int $type): void {
 		if ($type === self::LOCK_SHARED) {
 			$ownSharedLockCount = $this->getOwnSharedLockCount($path);
 			$newValue = 0;
@@ -110,6 +98,12 @@ class MemcacheLockingProvider extends AbstractLockingProvider {
 				$newValue = $this->memcache->dec($path);
 			}
 
+			if ($newValue > 0) {
+				$this->restoreTTL($path);
+			} else {
+				unset($this->oldTTLs[$path]);
+			}
+
 			// if we somehow release more locks then exists, reset the lock
 			if ($newValue < 0) {
 				$this->memcache->cad($path, $newValue);
@@ -120,14 +114,7 @@ class MemcacheLockingProvider extends AbstractLockingProvider {
 		$this->markRelease($path, $type);
 	}
 
-	/**
-	 * Change the type of an existing lock
-	 *
-	 * @param string $path
-	 * @param int $targetType self::LOCK_SHARED or self::LOCK_EXCLUSIVE
-	 * @throws \OCP\Lock\LockedException
-	 */
-	public function changeLock(string $path, int $targetType) {
+	public function changeLock(string $path, int $targetType): void {
 		if ($targetType === self::LOCK_SHARED) {
 			if (!$this->memcache->cas($path, 'exclusive', 1)) {
 				throw new LockedException($path, null, $this->getExistingLockForException($path));
@@ -135,14 +122,53 @@ class MemcacheLockingProvider extends AbstractLockingProvider {
 		} elseif ($targetType === self::LOCK_EXCLUSIVE) {
 			// we can only change a shared lock to an exclusive if there's only a single owner of the shared lock
 			if (!$this->memcache->cas($path, 1, 'exclusive')) {
+				$this->restoreTTL($path);
 				throw new LockedException($path, null, $this->getExistingLockForException($path));
 			}
+			unset($this->oldTTLs[$path]);
 		}
 		$this->setTTL($path);
 		$this->markChange($path, $targetType);
 	}
 
-	private function getExistingLockForException($path) {
+	/**
+	 * With shared locks, each time the lock is acquired, the ttl for the path is reset.
+	 *
+	 * Due to this "ttl extension" when a shared lock isn't freed correctly for any reason
+	 * the lock won't expire until no shared locks are required for the path for 1h.
+	 * This can lead to a client repeatedly trying to upload a file, and failing forever
+	 * because the lock never gets the opportunity to expire.
+	 *
+	 * To help the lock expire in this case, we lower the TTL back to what it was before we
+	 * took the shared lock *only* if nobody else got a shared lock after we did.
+	 *
+	 * This doesn't handle all cases where multiple requests are acquiring shared locks
+	 * but it should handle some of the more common ones and not hurt things further
+	 */
+	private function restoreTTL(string $path): void {
+		if (isset($this->oldTTLs[$path])) {
+			$saved = $this->oldTTLs[$path];
+			$elapsed = $this->timeFactory->getTime() - $saved['time'];
+
+			// old value to compare to when setting ttl in case someone else changes the lock in the middle of this function
+			$value = $this->memcache->get($path);
+
+			$currentTtl = $this->getTTL($path);
+
+			// what the old ttl would be given the time elapsed since we acquired the lock
+			// note that if this gets negative the key will be expired directly when we set the ttl
+			$remainingOldTtl = $saved['ttl'] - $elapsed;
+			// what the currently ttl would be if nobody else acquired a lock since we did (+1 to cover rounding errors)
+			$expectedTtl = $this->ttl - $elapsed + 1;
+
+			// check if another request has acquired a lock (and didn't release it yet)
+			if ($currentTtl <= $expectedTtl) {
+				$this->setTTL($path, $remainingOldTtl, $value);
+			}
+		}
+	}
+
+	private function getExistingLockForException(string $path): string {
 		$existing = $this->memcache->get($path);
 		if (!$existing) {
 			return 'none';
diff --git a/lib/private/Lock/NoopLockingProvider.php b/lib/private/Lock/NoopLockingProvider.php
index 95ae8cf0cda..42f1f9ae5ec 100644
--- a/lib/private/Lock/NoopLockingProvider.php
+++ b/lib/private/Lock/NoopLockingProvider.php
@@ -1,28 +1,10 @@
 <?php
 
 declare(strict_types=1);
-
 /**
- * @copyright Copyright (c) 2016, ownCloud, Inc.
- *
- * @author Robin Appelman <robin@icewind.nl>
- * @author Roeland Jago Douma <roeland@famdouma.nl>
- * @author Vincent Petry <vincent@nextcloud.com>
- *
- * @license AGPL-3.0
- *
- * This code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License, version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License, version 3,
- * along with this program. If not, see <http://www.gnu.org/licenses/>
- *
+ * SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
  */
 namespace OC\Lock;
 
@@ -34,7 +16,6 @@ use OCP\Lock\ILockingProvider;
  * To be used when locking is disabled.
  */
 class NoopLockingProvider implements ILockingProvider {
-
 	/**
 	 * {@inheritdoc}
 	 */
@@ -45,28 +26,28 @@ class NoopLockingProvider implements ILockingProvider {
 	/**
 	 * {@inheritdoc}
 	 */
-	public function acquireLock(string $path, int $type, string $readablePath = null) {
+	public function acquireLock(string $path, int $type, ?string $readablePath = null): void {
 		// do nothing
 	}
 
 	/**
 	 * {@inheritdoc}
 	 */
-	public function releaseLock(string $path, int $type) {
+	public function releaseLock(string $path, int $type): void {
 		// do nothing
 	}
 
 	/**1
 	 * {@inheritdoc}
 	 */
-	public function releaseAll() {
+	public function releaseAll(): void {
 		// do nothing
 	}
 
 	/**
 	 * {@inheritdoc}
 	 */
-	public function changeLock(string $path, int $targetType) {
+	public function changeLock(string $path, int $targetType): void {
 		// do nothing
 	}
 }