Return to xfs_log.h CVS log

Up to [Development] / xfs-linux

The LSN compare code was still wrong. The lsn's need
to be signed since the comparison against XFS_LSN_CMP can be
>, <, or == 0.
The ail was getting out of order. I have no clue how things
can be working as well as they are without this fix. go figure.

/*
 * Copyright (C) 1999 Silicon Graphics, Inc.  All Rights Reserved.
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 * 
 * 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
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
 */
#ifndef	_XFS_LOG_H
#define _XFS_LOG_H

#ident	"$Revision: 1.42 $"

#ifdef __LITTLE_ENDIAN
/* Since the lsn comes out with the cycle number in the least significant
 * part of the lsn as a 64 bit quantity we need to do the comparison
 * of cycle and block numbers explicitly. On 32 bit machines this is
 * less code than a 64 bit compare anyway.
 */

/*
 * We need the signed in stuff here since we are trying to return
 * negative values.
 */

#define CMP_CYCLE_LSN(lsn)          (((__int32_t *)&(lsn))[0])
#define CMP_BLOCK_LSN(lsn)          (((__int32_t *)&(lsn))[1])

static inline xfs_lsn_t	_lsn_cmp(xfs_lsn_t lsn1, xfs_lsn_t lsn2)
{
	if (CMP_CYCLE_LSN(lsn1) != CMP_CYCLE_LSN(lsn2)) {
		return (CMP_CYCLE_LSN(lsn1) - CMP_CYCLE_LSN(lsn2));
	}

	return (CMP_BLOCK_LSN(lsn1) - CMP_BLOCK_LSN(lsn2));
}

#define	XFS_LSN_CMP(x,y)	_lsn_cmp(x, y)
#define	XFS_LSN_DIFF(x,y)	_lsn_cmp(x, y)
#else
#define	XFS_LSN_CMP(x,y)	((x) - (y))
#define	XFS_LSN_DIFF(x,y)	((x) - (y))
#endif

/*
 * Macros, structures, prototypes for interface to the log manager.
 */

/*
 * Flags to xfs_log_mount
 */
#define XFS_LOG_RECOVER		0x1

/*
 * Flags to xfs_log_done()
 */
#define XFS_LOG_REL_PERM_RESERV	0x1


/*
 * Flags to xfs_log_reserve()
 *
 *	XFS_LOG_SLEEP:	 If space is not available, sleep (default)
 *	XFS_LOG_NOSLEEP: If space is not available, return error
 *	XFS_LOG_PERM_RESERV: Permanent reservation.  When writes are
 *		performed against this type of reservation, the reservation
 *		is not decreased.  Long running transactions should use this.
 */
#define XFS_LOG_SLEEP		0x0
#define XFS_LOG_NOSLEEP		0x1
#define XFS_LOG_PERM_RESERV	0x2
#define XFS_LOG_RESV_ALL	(XFS_LOG_NOSLEEP|XFS_LOG_PERM_RESERV)


/*
 * Flags to xfs_log_force()
 *
 *	XFS_LOG_SYNC:	Synchronous force in-core log to disk
 *	XFS_LOG_FORCE:	Start in-core log write now.
 *	XFS_LOG_URGE:	Start write within some window of time.
 *
 * Note: Either XFS_LOG_FORCE or XFS_LOG_URGE must be set.
 */
#define XFS_LOG_SYNC		0x1
#define XFS_LOG_FORCE		0x2
#define XFS_LOG_URGE		0x4


/*
 * Flags to xfs_log_print()
 *
 */
#define XFS_LOG_PRINT_EXIT	0x1
#define XFS_LOG_PRINT_NO_DATA	0x2
#define XFS_LOG_PRINT_NO_PRINT	0x4


/* Log Clients */
#define XFS_TRANSACTION		0x69
#define XFS_VOLUME		0x2
#define XFS_LOG			0xaa

typedef struct xfs_log_iovec {
	caddr_t		i_addr;		/* beginning address of region */
	int		i_len;		/* length in bytes of region */
} xfs_log_iovec_t;

typedef void* xfs_log_ticket_t;

/*
 * Structure used to pass callback function and the function's argument
 * to the log manager.
 */
typedef struct xfs_log_callback {
	struct xfs_log_callback	*cb_next;
	void			(*cb_func)(void *, int);
	void 			*cb_arg;
} xfs_log_callback_t;


/* Log manager interfaces */
struct xfs_mount;
xfs_lsn_t xfs_log_done(struct xfs_mount *mp,
		       xfs_log_ticket_t ticket,
		       uint		flags);
int	  xfs_log_force(struct xfs_mount *mp,
			xfs_lsn_t	 lsn,
			uint		 flags);
int	  xfs_log_init(void);
int	  xfs_log_mount(struct xfs_mount *mp,
			dev_t		 log_dev,
			daddr_t		 start_block,
			int		 num_bblocks);
int	  xfs_log_mount_finish(struct xfs_mount *mp, int);
void	  xfs_log_move_tail(struct xfs_mount	*mp,
			    xfs_lsn_t		tail_lsn);
void	  xfs_log_notify(struct xfs_mount	*mp,
			 xfs_lsn_t		lsn,
			 xfs_log_callback_t	*callback_entry);
int	  xfs_log_reserve(struct xfs_mount *mp,
			  int		   length,
			  int		   count,
			  xfs_log_ticket_t *ticket,
			  char		   clientid,
			  uint		   flags);
int	  xfs_log_write(struct xfs_mount *mp,
			xfs_log_iovec_t  region[],
			int		 nentries,
			xfs_log_ticket_t ticket,
			xfs_lsn_t	 *start_lsn);
int	  xfs_log_unmount(struct xfs_mount *mp);
int	  xfs_log_unmount_write(struct xfs_mount *mp);
void      xfs_log_unmount_dealloc(struct xfs_mount *mp);
int	  xfs_log_force_umount(struct xfs_mount *mp, int logerror);

/* Log manager utility interfaces */
void xfs_log_print(struct xfs_mount *mp,
		   dev_t	    log_dev,
		   daddr_t	    start_block,
		   int		    num_bblocks,
		   int		    start_print_block,
		   uint		    flags);


extern int xlog_debug;		/* set to 1 to enable real log */

extern int xfs_log_need_covered(struct xfs_mount *mp);

#endif	/* _XFS_LOG_H */