/* *   Copyright (c) International Business Machines Corp., 2000-2002 * *   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 02111-1307 USA */#include <config.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <time.h>#include <errno.h>#include "jfs_endian.h"#include "jfs_types.h"#include "jfs_filsys.h"#include "jfs_superblock.h"#include "libjufs.h"#include "devices.h"#include "jfs_dmap.h"#include "utilsubs.h"/* * NAME: inrange * * FUNCTION: Checks to see that <num> is a power-of-2 multiple of <low> that is *      less than or equal to <high>. * * PRE CONDITIONS: * * POST CONDITIONS: * * PARAMETERS: * * NOTES: * * DATA STRUCTURES: * * RETURNS: If it is, it returns 1, else 0 */int inrange(uint32_t num, uint32_t low, uint32_t high){	if (low) {		for (; low <= high; low <<= 1) {			if (low == num) {				return 1;			}		}	}	return 0;}/* * NAME: validate_sizes * * FUNCTION: Ensure that all configurable sizes fall within their respective *      version specific limits. * * PRE CONDITIONS: * * POST CONDITIONS: * * PARAMETERS: *      sb      - superblock to check sizes * * NOTES: * * RECOVERY OPERATION: * * DATA STRUCTURES: * * RETURNS: *      success: 0 *      failure:  any other value */static int validate_sizes(struct superblock *sb){	/*	 * Make sure AG size is at least 32M	 */	if (sb->s_agsize >= (1 << L2BPERDMAP)) {		return 0;	}	return EINVAL;}/* * NAME: ujfs_validate_super * * FUNCTION: Check if superblock is valid * * PRE CONDITIONS: * * POST CONDITIONS: * * PARAMETERS: *      sb      - superblock to validate * * NOTES: * * RECOVERY OPERATION: * * DATA STRUCTURES: * * RETURNS: *      success: 0 *      failure: LIBFS_CORRUPTSUPER, LIBFS_BADVERSION, LIBFS_BADMAGIC */int ujfs_validate_super(struct superblock *sb){	if (memcmp(sb->s_magic, JFS_MAGIC, sizeof (sb->s_magic)) == 0) {		if (sb->s_version > JFS_VERSION)			return LIBFS_BADVERSION;		if (validate_sizes(sb) == EINVAL)			return LIBFS_CORRUPTSUPER;	} else {		return LIBFS_BADMAGIC;	}	return 0;}/* * NAME: ujfs_put_superblk * * FUNCTION: Write primary or secondary aggregate superblock * * PRE CONDITIONS: * * POST CONDITIONS: * * PARAMETERS: *      fp              - open port for device to write superblock to *      sb              - pointer to struct superblock to be written *      is_primary      - 0 value means we are putting the secondary superblock; *                        non-zero value means we are putting the primary *                        superblock. * * NOTES: The sizeof(struct superblock) is less than the amount of disk space *      being allowed for the superblock (SIZE_OF_SUPER).  This function will *      write 0's to the space following the actual superblock structure to fill *      the entire allocated disk space. * * RECOVERY OPERATION: * * DATA STRUCTURES: * * RETURNS: *      success: 0 *      failure: any other value */int ujfs_put_superblk(FILE *fp, struct superblock *sb, int16_t is_primary){	char buf[SIZE_OF_SUPER];	int rc;	memset(buf, 0, SIZE_OF_SUPER);	memcpy(buf, sb, sizeof (*sb));	/* swap if on big endian machine */	ujfs_swap_superblock((struct superblock *) buf);	rc = ujfs_rw_diskblocks(fp, (is_primary ? SUPER1_OFF : SUPER2_OFF),				SIZE_OF_SUPER, buf, PUT);	return rc;}/* * NAME: ujfs_get_superblk * * FUNCTION: read either the primary or secondary superblock from the specified *      device * * PRE CONDITIONS: * * POST CONDITIONS: * * PARAMETERS: *      fp              - open port for device to read superblock from *      sb              - pointer to struct superblock to be filled in on return *      is_primary      - 0 indicates to retrieve secondary superblock, *                        otherwise retrieve primary superblock * * NOTES: * * RECOVERY OPERATION: * * DATA STRUCTURES: * * RETURNS: *      success: 0 *      failure: any other value */int ujfs_get_superblk(FILE *fp, struct superblock *sb, int32_t is_primary){	int rc;	char buf[SIZE_OF_SUPER];	struct superblock *sblk = (struct superblock *) buf;	rc = ujfs_rw_diskblocks(fp, (is_primary ? SUPER1_OFF : SUPER2_OFF),				SIZE_OF_SUPER, sblk, GET);	ujfs_swap_superblock(sblk);	if (rc != 0)		return rc;	memcpy(sb, sblk, sizeof (*sb));	return 0;}/* * NAME: ujfs_validate_logsuper * * FUNCTION: Check if log superblock is valid * * PRE CONDITIONS: * * POST CONDITIONS: * * PARAMETERS: *      logsup - log superblock to validate * * NOTES: * * RECOVERY OPERATION: * * DATA STRUCTURES: * * RETURNS: *      success: 0 *      failure: LIBFS_BADVERSION, LIBFS_BADMAGIC */int ujfs_validate_logsuper(struct logsuper *logsup){	/* see if superblock is JFS log superblock */	if (logsup->magic == LOGMAGIC) {		if (logsup->version != LOGVERSION) {			return LIBFS_BADVERSION;		}	} else {		return LIBFS_BADMAGIC;	}	return 0;}/* * NAME: ujfs_put_logsuper * * FUNCTION: Write log superblock to disk * * PRE CONDITIONS: * * POST CONDITIONS: * * PARAMETERS: *      fp      - open port for device to write superblock to *      logsup  - pointer to log superblock to be written * * NOTES: * * RECOVERY OPERATION: * * DATA STRUCTURES: * * RETURNS: *      success: 0 *      failure: any other value */int ujfs_put_logsuper(FILE *fp, struct logsuper *logsup){	char buf[sizeof (struct logsuper)];	int rc = 0;	memcpy(buf, logsup, sizeof (struct logsuper));	/* swap if on big endian machine */	ujfs_swap_logsuper((struct logsuper *) buf);	rc = ujfs_rw_diskblocks(fp, LOGPSIZE, sizeof (struct logsuper), buf, PUT);	return rc;}/* * NAME: ujfs_get_logsuper * * FUNCTION: read the log superblock from the specified device * * PRE CONDITIONS: * * POST CONDITIONS: * * PARAMETERS: *      fp      - open port for device to read superblock from *      logsup  - pointer to log superblock to be filled in on return * * NOTES: * * RECOVERY OPERATION: * * DATA STRUCTURES: * * RETURNS: *      success: 0 *      failure: any other value */int ujfs_get_logsuper(FILE *fp, struct logsuper *logsup){	int rc = 0;	char buf[sizeof (struct logsuper)];	struct logsuper *logsup_buf = (struct logsuper *) buf;	rc = ujfs_rw_diskblocks(fp, LOGPSIZE, sizeof (struct logsuper), logsup_buf, GET);	if (!rc) {		ujfs_swap_logsuper(logsup_buf);		memcpy(logsup, logsup_buf, sizeof (struct logsuper));	}	return rc;}