ad_lock.c File Reference

#include <errno.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <atalk/adouble.h>
#include <atalk/compat.h>
#include <atalk/errchk.h>
#include <atalk/logger.h>
#include <atalk/util.h>
#include "ad_lock.h"

Macros
#define	ARRAY_BLOCK_SIZE   10
#define	ARRAY_FREE_DELTA   100
#define	LTYPE2STRBUFSIZ   128

Functions
static const char *	shmdstrfromoff (off_t off)
static int	set_lock (int fd, int cmd, struct flock *lock)
static int	XLATE_FCNTL_LOCK (int type)
static int	OVERLAP (off_t a, off_t alen, off_t b, off_t blen)
static void	adf_freelock (struct ad_fd *ad, const int i)
static void	adf_unlock (struct adouble *ad, struct ad_fd *adf, const int fork, int unlckbrl)
static void	adf_relockrange (struct ad_fd *ad, int fd, off_t off, off_t len)
static int	adf_findlock (struct ad_fd *ad, const int fork, const int type, const off_t off, const off_t len)
static int	adf_findxlock (struct ad_fd *ad, const int fork, const int type, const off_t off, const off_t len)
static off_t	rf2off (off_t off)
static int	testlock (const struct ad_fd *adf, off_t off, off_t len)
	Test a lock.
static const char *	locktypetostr (int type)
int	ad_lock (struct adouble *ad, uint32_t eid, int locktype, off_t off, off_t len, int fork)
int	ad_tmplock (struct adouble *ad, uint32_t eid, int locktype, off_t off, off_t len, int fork)
void	ad_unlock (struct adouble *ad, const int fork, int unlckbrl)
int	ad_testlock (struct adouble *ad, int eid, const off_t off)
	Test for a share mode lock.
uint16_t	ad_openforks (struct adouble *ad, uint16_t attrbits)
	Return if a file is open by another process.

Macro Definition Documentation

ARRAY_BLOCK_SIZE

#define ARRAY_BLOCK_SIZE   10

ARRAY_FREE_DELTA

#define ARRAY_FREE_DELTA   100

LTYPE2STRBUFSIZ

#define LTYPE2STRBUFSIZ   128

Function Documentation

ad_lock()

int ad_lock	(	struct adouble *	ad,
		uint32_t	eid,
		int	locktype,
		off_t	off,
		off_t	len,
		int	fork )

ad_openforks()

uint16_t ad_openforks	(	struct adouble *	ad,
		uint16_t	attrbits )

Return if a file is open by another process.

Optimized for the common case:

• there's no locks held by another process (clients)
• or we already know the answer and don't need to test (attrbits)

Parameters

[in,out]	ad	handle
[in]	attrbits	forks opened by us

Returns

bitflags ATTRBIT_DOPEN | ATTRBIT_ROPEN if other process has fork of file opened

ad_testlock()

int ad_testlock	(	struct adouble *	ad,
		int	eid,
		const off_t	off )

Test for a share mode lock.

Parameters

[in,out]	ad	handle
[in]	eid	datafork or resource fork
[in]	off	sharemode lock to test

Returns

1 if there's an existing lock, 0 if there's no lock, -1 in case any error occured

ad_tmplock()

int ad_tmplock	(	struct adouble *	ad,
		uint32_t	eid,
		int	locktype,
		off_t	off,
		off_t	len,
		int	fork )

ad_unlock()

void ad_unlock	(	struct adouble *	ad,
		const int	fork,
		int	unlckbrl )

adf_findlock()

int adf_findlock ( struct ad_fd * ad, const int fork, const int type, const off_t off, const off_t len )

static

find a byte lock that overlaps off/len for a particular open fork

adf_findxlock()

int adf_findxlock ( struct ad_fd * ad, const int fork, const int type, const off_t off, const off_t len )

static

search other fork lock lists

adf_freelock()

void adf_freelock ( struct ad_fd * ad, const int i )

static

remove a lock and compact space if necessary

adf_relockrange()

void adf_relockrange ( struct ad_fd * ad, int fd, off_t off, off_t len )

static

relock any byte lock that overlaps off/len. unlock everything else.

adf_unlock()

void adf_unlock ( struct adouble * ad, struct ad_fd * adf, const int fork, int unlckbrl )

static

locktypetostr()

const char * locktypetostr ( int type )

static

OVERLAP()

int OVERLAP ( off_t a, off_t alen, off_t b, off_t blen )

static

rf2off()

off_t rf2off ( off_t off )

static

translate a resource fork lock to an offset

set_lock()

int set_lock ( int fd, int cmd, struct flock * lock )

static

shmdstrfromoff()

const char * shmdstrfromoff ( off_t off )

static

testlock()

int testlock ( const struct ad_fd * adf, off_t off, off_t len )

static

Test a lock.

1. Test against our own locks array
2. Test fcntl lock, locks from other processes

Parameters

[in]	adf	handle
[in]	off	offset
[in]	len	length

Returns

1 if there's an existing lock, 0 if there's no lock, -1 in case any error occured

XLATE_FCNTL_LOCK()

int XLATE_FCNTL_LOCK ( int type )

static