/* -*- mode: c; c-basic-offset: 8; -*- * vim: noexpandtab sw=8 ts=8 sts=0: * * journal.h * * Defines journalling api and structures. * * Copyright (C) 2003, 2005 Oracle.  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 to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 021110-1307, USA. */#ifndef OCFS2_JOURNAL_H#define OCFS2_JOURNAL_H#include <linux/fs.h>#include <linux/jbd.h>enum ocfs2_journal_state {	OCFS2_JOURNAL_FREE = 0,	OCFS2_JOURNAL_LOADED,	OCFS2_JOURNAL_IN_SHUTDOWN,};struct ocfs2_super;struct ocfs2_dinode;struct ocfs2_journal_handle;struct ocfs2_journal {	enum ocfs2_journal_state   j_state;    /* Journals current state   */	journal_t                 *j_journal; /* The kernels journal type */	struct inode              *j_inode;   /* Kernel inode pointing to					       * this journal             */	struct ocfs2_super        *j_osb;     /* pointer to the super					       * block for the node					       * we're currently					       * running on -- not					       * necessarily the super					       * block from the node					       * which we usually run					       * from (recovery,					       * etc)                     */	struct buffer_head        *j_bh;      /* Journal disk inode block */	atomic_t                  j_num_trans; /* Number of transactions					        * currently in the system. */	unsigned long             j_trans_id;	struct rw_semaphore       j_trans_barrier;	wait_queue_head_t         j_checkpointed;	spinlock_t                j_lock;	struct list_head          j_la_cleanups;	struct work_struct        j_recovery_work;};extern spinlock_t trans_inc_lock;/* wrap j_trans_id so we never have it equal to zero. */static inline unsigned long ocfs2_inc_trans_id(struct ocfs2_journal *j){	unsigned long old_id;	spin_lock(&trans_inc_lock);	old_id = j->j_trans_id++;	if (unlikely(!j->j_trans_id))		j->j_trans_id = 1;	spin_unlock(&trans_inc_lock);	return old_id;}static inline void ocfs2_set_inode_lock_trans(struct ocfs2_journal *journal,					      struct inode *inode){	spin_lock(&trans_inc_lock);	OCFS2_I(inode)->ip_last_trans = journal->j_trans_id;	spin_unlock(&trans_inc_lock);}/* Used to figure out whether it's safe to drop a metadata lock on an * inode. Returns true if all the inodes changes have been * checkpointed to disk. You should be holding the spinlock on the * metadata lock while calling this to be sure that nobody can take * the lock and put it on another transaction. */static inline int ocfs2_inode_fully_checkpointed(struct inode *inode){	int ret;	struct ocfs2_journal *journal = OCFS2_SB(inode->i_sb)->journal;	spin_lock(&trans_inc_lock);	ret = time_after(journal->j_trans_id, OCFS2_I(inode)->ip_last_trans);	spin_unlock(&trans_inc_lock);	return ret;}/* convenience function to check if an inode is still new (has never * hit disk) Will do you a favor and set created_trans = 0 when you've * been checkpointed.  returns '1' if the inode is still new. */static inline int ocfs2_inode_is_new(struct inode *inode){	int ret;	/* System files are never "new" as they're written out by	 * mkfs. This helps us early during mount, before we have the	 * journal open and j_trans_id could be junk. */	if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)		return 0;	spin_lock(&trans_inc_lock);	ret = !(time_after(OCFS2_SB(inode->i_sb)->journal->j_trans_id,			   OCFS2_I(inode)->ip_created_trans));	if (!ret)		OCFS2_I(inode)->ip_created_trans = 0;	spin_unlock(&trans_inc_lock);	return ret;}static inline void ocfs2_inode_set_new(struct ocfs2_super *osb,				      struct inode *inode){	spin_lock(&trans_inc_lock);	OCFS2_I(inode)->ip_created_trans = osb->journal->j_trans_id;	spin_unlock(&trans_inc_lock);}extern kmem_cache_t *ocfs2_lock_cache;struct ocfs2_journal_lock {	struct inode     *jl_inode;	struct list_head  jl_lock_list;};struct ocfs2_journal_handle {	handle_t            *k_handle; /* kernel handle.                */	struct ocfs2_journal        *journal;	u32                 flags;     /* see flags below.              */	int                 max_buffs; /* Buffs reserved by this handle */	/* The following two fields are for ocfs2_handle_add_lock */	int                 num_locks;	struct list_head    locks;     /* A bunch of locks to					* release on commit. This					* should be a list_head */	struct list_head     inode_list;};#define OCFS2_HANDLE_STARTED			1/* should we sync-commit this handle? */#define OCFS2_HANDLE_SYNC			2static inline int ocfs2_handle_started(struct ocfs2_journal_handle *handle){	return handle->flags & OCFS2_HANDLE_STARTED;}static inline void ocfs2_handle_set_sync(struct ocfs2_journal_handle *handle, int sync){	if (sync)		handle->flags |= OCFS2_HANDLE_SYNC;	else		handle->flags &= ~OCFS2_HANDLE_SYNC;}/* Exported only for the journal struct init code in super.c. Do not call. */void ocfs2_complete_recovery(void *data);/* *  Journal Control: *  Initialize, Load, Shutdown, Wipe a journal. * *  ocfs2_journal_init     - Initialize journal structures in the OSB. *  ocfs2_journal_load     - Load the given journal off disk. Replay it if *                          there's transactions still in there. *  ocfs2_journal_shutdown - Shutdown a journal, this will flush all *                          uncommitted, uncheckpointed transactions. *  ocfs2_journal_wipe     - Wipe transactions from a journal. Optionally *                          zero out each block. *  ocfs2_recovery_thread  - Perform recovery on a node. osb is our own osb. *  ocfs2_mark_dead_nodes - Start recovery on nodes we won't get a heartbeat *                          event on. *  ocfs2_start_checkpoint - Kick the commit thread to do a checkpoint. */void   ocfs2_set_journal_params(struct ocfs2_super *osb);int    ocfs2_journal_init(struct ocfs2_journal *journal,			  int *dirty);void   ocfs2_journal_shutdown(struct ocfs2_super *osb);int    ocfs2_journal_wipe(struct ocfs2_journal *journal,			  int full);int    ocfs2_journal_load(struct ocfs2_journal *journal, int local);int    ocfs2_check_journals_nolocks(struct ocfs2_super *osb);void   ocfs2_recovery_thread(struct ocfs2_super *osb,			     int node_num);int    ocfs2_mark_dead_nodes(struct ocfs2_super *osb);void   ocfs2_complete_mount_recovery(struct ocfs2_super *osb);static inline void ocfs2_start_checkpoint(struct ocfs2_super *osb){	atomic_set(&osb->needs_checkpoint, 1);	wake_up(&osb->checkpoint_event);}static inline void ocfs2_checkpoint_inode(struct inode *inode){	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);	if (ocfs2_mount_local(osb))		return;	if (!ocfs2_inode_fully_checkpointed(inode)) {		/* WARNING: This only kicks off a single		 * checkpoint. If someone races you and adds more		 * metadata to the journal, you won't know, and will		 * wind up waiting *alot* longer than necessary. Right		 * now we only use this in clear_inode so that's		 * OK. */		ocfs2_start_checkpoint(osb);		wait_event(osb->journal->j_checkpointed,