mirror of
https://github.com/containers/podman.git
synced 2025-10-30 17:38:27 +08:00
111 lines
2.5 KiB
Go
111 lines
2.5 KiB
Go
package lock
|
|
|
|
import (
|
|
"github.com/containers/podman/v2/libpod/lock/file"
|
|
)
|
|
|
|
// FileLockManager manages shared memory locks.
|
|
type FileLockManager struct {
|
|
locks *file.FileLocks
|
|
}
|
|
|
|
// NewFileLockManager makes a new FileLockManager at the specified directory.
|
|
func NewFileLockManager(lockPath string) (Manager, error) {
|
|
locks, err := file.CreateFileLock(lockPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
manager := new(FileLockManager)
|
|
manager.locks = locks
|
|
|
|
return manager, nil
|
|
}
|
|
|
|
// OpenFileLockManager opens an existing FileLockManager at the specified directory.
|
|
func OpenFileLockManager(path string) (Manager, error) {
|
|
locks, err := file.OpenFileLock(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
manager := new(FileLockManager)
|
|
manager.locks = locks
|
|
|
|
return manager, nil
|
|
}
|
|
|
|
// AllocateLock allocates a new lock from the manager.
|
|
func (m *FileLockManager) AllocateLock() (Locker, error) {
|
|
semIndex, err := m.locks.AllocateLock()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
lock := new(FileLock)
|
|
lock.lockID = semIndex
|
|
lock.manager = m
|
|
|
|
return lock, nil
|
|
}
|
|
|
|
// AllocateAndRetrieveLock allocates the lock with the given ID and returns it.
|
|
// If the lock is already allocated, error.
|
|
func (m *FileLockManager) AllocateAndRetrieveLock(id uint32) (Locker, error) {
|
|
lock := new(FileLock)
|
|
lock.lockID = id
|
|
lock.manager = m
|
|
|
|
if err := m.locks.AllocateGivenLock(id); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return lock, nil
|
|
}
|
|
|
|
// RetrieveLock retrieves a lock from the manager given its ID.
|
|
func (m *FileLockManager) RetrieveLock(id uint32) (Locker, error) {
|
|
lock := new(FileLock)
|
|
lock.lockID = id
|
|
lock.manager = m
|
|
|
|
return lock, nil
|
|
}
|
|
|
|
// FreeAllLocks frees all locks in the manager.
|
|
// This function is DANGEROUS. Please read the full comment in locks.go before
|
|
// trying to use it.
|
|
func (m *FileLockManager) FreeAllLocks() error {
|
|
return m.locks.DeallocateAllLocks()
|
|
}
|
|
|
|
// FileLock is an individual shared memory lock.
|
|
type FileLock struct {
|
|
lockID uint32
|
|
manager *FileLockManager
|
|
}
|
|
|
|
// ID returns the ID of the lock.
|
|
func (l *FileLock) ID() uint32 {
|
|
return l.lockID
|
|
}
|
|
|
|
// Lock acquires the lock.
|
|
func (l *FileLock) Lock() {
|
|
if err := l.manager.locks.LockFileLock(l.lockID); err != nil {
|
|
panic(err.Error())
|
|
}
|
|
}
|
|
|
|
// Unlock releases the lock.
|
|
func (l *FileLock) Unlock() {
|
|
if err := l.manager.locks.UnlockFileLock(l.lockID); err != nil {
|
|
panic(err.Error())
|
|
}
|
|
}
|
|
|
|
// Free releases the lock, allowing it to be reused.
|
|
func (l *FileLock) Free() error {
|
|
return l.manager.locks.DeallocateLock(l.lockID)
|
|
}
|