No OneTemporary
Actions

Size

33 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/tools/sfex.h b/tools/sfex.h
	index 9ecb528d7..3795c2953 100644
	--- a/tools/sfex.h
	+++ b/tools/sfex.h
	@@ -1,183 +1,176 @@
	/*-------------------------------------------------------------------------
	*
	* Shared Disk File EXclusiveness Control Program(SF-EX)
	*
	* sfex.h --- Primary include file for SF-EX *.c files.
	*
	* Copyright (c) 2007 NIPPON TELEGRAPH AND TELEPHONE CORPORATION
	*
	* 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., 51 Franklin Street, Fifth Floor, Boston, MA
	* 02110-1301, USA.
	*
	* $Id$
	*
	-------------------------------------------------------------------------/

	#ifndef SFEX_H
	#define SFEX_H

	#include <clplumbing/cl_log.h>
	#include <clplumbing/coredumps.h>
	#include <clplumbing/realtime.h>

	#include <stdint.h>

	/* version, revision */
	/* These numbers are integer and, max number is 999.
	If these numbers change, version numbers in the configure.ac
	(AC_INIT, AM_INIT_AUTOMAKE) must change together.
	*/
	#define SFEX_VERSION 1
	#define SFEX_REVISION 3

	#if 0
	#ifndef TRUE
	# define TRUE 1
	#endif
	#ifndef FALSE
	# define FALSE 0
	#endif
	#ifndef MIN
	# define MIN(a, b) ((a) < (b) ? (a) : (b))
	#endif
	#ifndef MAX
	# define MAX(a, b) ((a) > (b) ? (a) : (b))
	#endif
	#endif

	/* for Linux >= 2.6, the alignment should be 512
	for Linux < 2.6, the alignment should be sysconf(_SC_PAGESIZE)
	we default to _SC_PAGESIZE
	*/
	#define SFEX_ODIRECT_ALIGNMENT sysconf(_SC_PAGESIZE)

	/*
	* sfex_controldata --- control data
	*
	* This is allocated the head of sfex mata-data area.
	*
	* magic number --- 4 bytes. This is fixed in {0x01, 0x1f, 0x71, 0x7f}.
	*
	* version number --- 4 bytes. This is printable integer number and
	* range is from 0 to 999. This must be left-justify, null(0x00) padding, and
	* make a last byte null.
	*
	* revision number --- 4 bytes. This is printable integer number and
	* range is from 0 to 999. This must be left-justify, null(0x00) padding, and
	* make a last byte null.
	*
	* blocksize --- 8bytes. This is printable integer number and range is from
	* 512 to 9999999. This must be left-justify, null(0x00) padding, and make a
	* last byte null. This is a size of control data and lock data(one lock data
	* size when there are plural), and it is shown by number of bytes.
	* For avoiding partial writing, usually block size is set 512 byte etc.
	* If you use direct I/O(if you spacificate --enable-directio for configure
	* script), note that this value is used for input and output buffer alignment.
	* (In the Linux kernel 2.6, if this value is not 512 multibles, direct I/O
	* does not work)

	* number of locks --- 4 bytes. This is printable integer number and range
	* is from 1 to 999. This must be left-justify, null(0x00) padding, and make
	* a last byte null. This is the number of locks following this control data.
	*
	* padding --- The size of this member depend on blocksize. It is adjusted so
	* that the whole of the control data including this padding area becomes
	* blocksize. The contents of padding area are all 0x00.
	*/
	typedef struct sfex_controldata {
	char magic[4]; /* magic number */
	int version; /* version number */
	int revision; /* revision number */
	size_t blocksize; /* block size */
	int numlocks; /* number of locks */
	} sfex_controldata;

	typedef struct sfex_controldata_ondisk {
	uint8_t magic[4];
	uint8_t version[4];
	uint8_t revision[4];
	uint8_t blocksize[8];
	uint8_t numlocks[4];
	} sfex_controldata_ondisk;

	/*
	* sfex_lockdata --- lock data
	*
	* This data(number is sfex_controldata.numlocks) are allocated behind of
	* sfex_controldata in the sfex meta-data area. The meaning of each member
	* and the storage method to mata data area are following;
	*
	* lock status --- 1 byte. printable character. Content is either one of
	* following;
	* SFEX_STATUS_UNLOCK: It show the status that no node locks.
	* SFEX_STATUS_LOCK: It show the status that nodename node is holding lock.
	* (But there is an exception. Refer to explanation of "count" member.)
	*
	* increment counter --- 4 bytes. This is printable integer number and range
	* is from 1 to 999. This must be left-justify, null(0x00) padding, and make
	* a last byte null. The node holding a lock increments this counter
	* periodically. If this counter does not increment for a certain period of
	* time, we consider that the lock is invalid. If it overflow, return to 0.
	* Initial value is 0.
	*
	* node name --- 256bytes. This is printable string. This must be left-justify,
	* null(0x00) padding, and make a last byte null. This is node name that update
	* lock data last. The node name must be same to get uname(2). Initial values
	* are white spaces.
	*
	* padding --- The size of this member depend on blocksize. It is adjusted so
	* that the whole of the control data including this padding area becomes
	* blocksize. The contents of padding area are all 0x00.
	*/
	typedef struct sfex_lockdata {
	char status; /* status of lock */
	int count; /* increment counter */
	char nodename[256]; /* node name */
	} sfex_lockdata;

	typedef struct sfex_lockdata_ondisk {
	uint8_t status;
	uint8_t count[4];
	uint8_t nodename[256];
	} sfex_lockdata_ondisk;

	/* character for lock status. This is used in sfex_lockdata.status */
	#define SFEX_STATUS_UNLOCK 'u' /* unlock */
	#define SFEX_STATUS_LOCK 'l' /* lock */

	/* features of each member of control data and lock data */
	#define SFEX_MAGIC "SFEX"
	#define SFEX_MIN_NUMLOCKS 1
	#define SFEX_MAX_NUMLOCKS 999
	#define SFEX_MIN_COUNT 0
	#define SFEX_MAX_COUNT 999
	#define SFEX_MAX_NODENAME (sizeof(((sfex_lockdata *)0)->nodename) - 1)

	/* update macro for increment counter */
	#define SFEX_NEXT_COUNT(c) (c >= SFEX_MAX_COUNT ? c - SFEX_MAX_COUNT : c + 1)

	/* extern variables */
	extern const char *progname;
	extern char *nodename;
	extern unsigned long sector_size;

	-#define SFEX_LOG_ERR(args...) cl_log(LOG_ERR, args)
	-#define SFEX_LOG_INFO(args...) cl_log(LOG_INFO, args)
	-#if 0
	-#define SFEX_LOG_ERR(args...) do {fprintf(stderr, args);} while (0)
	-#define SFEX_LOG_INFO(args...) do {fprintf(stderr, args);} while (0)
	-#endif
	-
	#endif /* SFEX_H */
	diff --git a/tools/sfex_daemon.c b/tools/sfex_daemon.c
	index d9ad15a30..1c5609d87 100644
	--- a/tools/sfex_daemon.c
	+++ b/tools/sfex_daemon.c
	@@ -1,360 +1,372 @@
	+#include <config.h>
	#include <stdio.h>
	#include <unistd.h>
	#include <string.h>
	#include <stdlib.h>
	#include <signal.h>
	#include <limits.h>
	#include <sys/mman.h>
	#include <string.h>
	#include <errno.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <syslog.h>
	#include "sfex.h"
	#include "sfex_lib.h"

	+#if HAVE_GLUE_CONFIG_H
	+#include <glue_config.h> /* for HA_LOG_FACILITY */
	+#endif
	+
	static int sysrq_fd;
	static int lock_index = 1; /* default 1st lock */
	static time_t collision_timeout = 1; /* default 1 sec */
	static time_t lock_timeout = 60; /* default 60 sec */
	time_t unlock_timeout = 60;
	static time_t monitor_interval = 10;

	static sfex_controldata cdata;
	static sfex_lockdata ldata;
	static sfex_lockdata ldata_new;

	static const char *device;
	const char *progname;
	char *nodename;
	static const char *rsc_id = "sfex";

	static void usage(FILE *dist) {
	fprintf(dist, "usage: %s [-i <index>] [-c <collision_timeout>] [-t <lock_timeout>] <device>\n", progname);
	}

	static int lock_index_check(void)
	{
	if (read_controldata(&cdata) == -1) {
	- SFEX_LOG_ERR("%s\n", "read_controldata failed in lock_index_check");
	+ cl_log(LOG_ERR, "%s\n", "read_controldata failed in lock_index_check");
	return -1;
	}
	#ifdef SFEX_DEBUG
	- SFEX_LOG_INFO("version: %d\n", cdata.version);
	- SFEX_LOG_INFO("revision: %d\n", cdata.revision);
	- SFEX_LOG_INFO("blocksize: %d\n", cdata.blocksize);
	- SFEX_LOG_INFO("numlocks: %d\n", cdata.numlocks);
	+ cl_log(LOG_INFO, "version: %d\n", cdata.version);
	+ cl_log(LOG_INFO, "revision: %d\n", cdata.revision);
	+ cl_log(LOG_INFO, "blocksize: %d\n", cdata.blocksize);
	+ cl_log(LOG_INFO, "numlocks: %d\n", cdata.numlocks);
	#endif

	if (lock_index > cdata.numlocks) {
	- SFEX_LOG_ERR("%s: ERROR: index %d is too large. %d locks are stored.\n",
	- progname, lock_index, cdata.numlocks);
	+ cl_log(LOG_ERR, "index %d is too large. %d locks are stored.\n",
	+ lock_index, cdata.numlocks);
	return -1;
	/exit(EXIT_FAILURE);/
	}

	if (cdata.blocksize != sector_size) {
	- SFEX_LOG_ERR("%s: ERROR: sector_size is not the same as the blocksize.\n", progname);
	+ cl_log(LOG_ERR, "sector_size is not the same as the blocksize.\n");
	return -1;
	}
	return 0;
	}

	static void acquire_lock(void)
	{
	if (read_lockdata(&cdata, &ldata, lock_index) == -1) {
	- SFEX_LOG_ERR("%s\n", "read_lockdata failed in acquire_lock");
	+ cl_log(LOG_ERR, "read_lockdata failed in acquire_lock\n");
	exit(EXIT_FAILURE);
	}

	if ((ldata.status == SFEX_STATUS_LOCK) && (strncmp(nodename, (const char*)(ldata.nodename), sizeof(ldata.nodename)))) {
	unsigned int t = lock_timeout;
	while (t > 0)
	t = sleep(t);
	read_lockdata(&cdata, &ldata_new, lock_index);
	if (ldata.count != ldata_new.count) {
	- SFEX_LOG_ERR("%s", "can\'t acquire lock: the lock's already hold by some other node.\n");
	+ cl_log(LOG_ERR, "can\'t acquire lock: the lock's already hold by some other node.\n");
	exit(2);
	}
	}

	/* The lock acquisition is possible because it was not updated. */
	ldata.status = SFEX_STATUS_LOCK;
	ldata.count = SFEX_NEXT_COUNT(ldata.count);
	strncpy((char*)(ldata.nodename), nodename, sizeof(ldata.nodename));
	if (write_lockdata(&cdata, &ldata, lock_index) == -1) {
	- SFEX_LOG_ERR("%s", "write_lockdata failed\n");
	+ cl_log(LOG_ERR, "write_lockdata failed\n");
	exit(EXIT_FAILURE);
	}

	/* detect the collision of lock */
	/* The collision occurs when two or more nodes do the reservation
	processing of the lock at the same time. It waits for collision_timeout
	seconds to detect this,and whether the superscription of lock data by
	another node is done is checked. If the superscription was done by
	another node, the lock acquisition with the own node is given up.
	*/
	{
	unsigned int t = collision_timeout;
	while (t > 0)
	t = sleep(t);
	if (read_lockdata(&cdata, &ldata_new, lock_index) == -1) {
	- SFEX_LOG_ERR("%s", "read_lockdata failed\n");
	+ cl_log(LOG_ERR, "read_lockdata failed in collision detection\n");
	}
	if (strncmp((char)(ldata.nodename), (const char)(ldata_new.nodename), sizeof(ldata.nodename))) {
	- SFEX_LOG_ERR("%s", "can\'t acquire lock: collision detected in the air.\n");
	+ cl_log(LOG_ERR, "can\'t acquire lock: collision detected in the air.\n");
	exit(2);
	}
	}

	/* extension of lock */
	/* Validly time of the lock is extended. It is because of spending at
	the collision_timeout seconds to detect the collision. */
	ldata.count = SFEX_NEXT_COUNT(ldata.count);
	if (write_lockdata(&cdata, &ldata, lock_index) == -1) {
	- SFEX_LOG_ERR("%s\n", "write_lockdata failed");
	+ cl_log(LOG_ERR, "write_lockdata failed in extension of lock\n");
	exit(EXIT_FAILURE);
	}
	- SFEX_LOG_ERR("%s", "lock acquired\n");
	+ cl_log(LOG_INFO, "lock acquired\n");
	}

	static void error_todo (void)
	{
	if (fork() == 0) {
	+ cl_log(LOG_INFO, "Execute \"crm_resource -F -r %s -H %s\" command\n", rsc_id, nodename);
	execl("/usr/sbin/crm_resource", "crm_resource", "-F", "-r", rsc_id, "-H", nodename, NULL);
	} else {
	exit(EXIT_FAILURE);
	}
	}

	static void failure_todo(void)
	{
	#ifdef SFEX_TESTING
	exit(EXIT_FAILURE);
	#else
	/execl("/usr/sbin/crm_resource", "crm_resource", "-F", "-r", rsc_id, "-H", nodename, NULL); /
	int ret;
	+
	+ cl_log(LOG_INFO, "Force reboot node %s\n", nodename);
	ret = write(sysrq_fd, "b\n", 2);
	if (ret == -1) {
	- SFEX_LOG_ERR("%s\n", strerror(errno));
	+ cl_log(LOG_ERR, "%s\n", strerror(errno));
	}
	close(sysrq_fd);
	exit(EXIT_FAILURE);
	#endif
	}

	static void update_lock(void)
	{
	/* read lock data */
	if (read_lockdata(&cdata, &ldata, lock_index) == -1) {
	+ cl_log(LOG_ERR, "read_lockdata failed in update_lock\n");
	error_todo();
	exit(EXIT_FAILURE);
	}

	/* check current lock status */
	/* if own node is not locking, lock update is failed */
	if (ldata.status != SFEX_STATUS_LOCK \|\| strncmp((const char*)(ldata.nodename), nodename, sizeof(ldata.nodename))) {
	- SFEX_LOG_ERR("can't update lock.\n");
	+ cl_log(LOG_ERR, "can't update lock.\n");
	failure_todo();
	exit(EXIT_FAILURE);
	}

	/* lock update */
	ldata.count = SFEX_NEXT_COUNT(ldata.count);
	if (write_lockdata(&cdata, &ldata, lock_index) == -1) {
	+ cl_log(LOG_ERR, "write_lockdata failed in update_lock\n");
	error_todo();
	exit(EXIT_FAILURE);
	}
	}

	static void release_lock(void)
	{
	/* The only thing I care about in release_lock(), is to terminate the process */

	/* read lock data */
	if (read_lockdata(&cdata, &ldata, lock_index) == -1) {
	+ cl_log(LOG_ERR, "read_lockdata failed in release_lock\n");
	exit(EXIT_FAILURE);
	}

	/* check current lock status */
	/* if own node is not locking, we judge that lock has been released already */
	if (ldata.status != SFEX_STATUS_LOCK \|\| strncmp((const char*)(ldata.nodename), nodename, sizeof(ldata.nodename))) {
	- SFEX_LOG_ERR("lock was already released.\n");
	- exit(1);
	+ cl_log(LOG_ERR, "lock was already released.\n");
	+ exit(EXIT_FAILURE);
	}

	/* lock release */
	ldata.status = SFEX_STATUS_UNLOCK;
	if (write_lockdata(&cdata, &ldata, lock_index) == -1) {
	/FIXME: We are going to self-stop /
	+ cl_log(LOG_ERR, "write_lockdata failed in release_lock\n");
	exit(EXIT_FAILURE);
	}
	- SFEX_LOG_INFO("lock released\n");
	+ cl_log(LOG_INFO, "lock released\n");
	}

	static void quit_handler(int signo, siginfo_t info, void context)
	{
	- SFEX_LOG_INFO("quit_handler\n");
	+ cl_log(LOG_INFO, "quit_handler called. now releasing lock\n");
	release_lock();
	+ cl_log(LOG_INFO, "Shutdown sfex_daemon with EXIT_SUCCESS\n");
	exit(EXIT_SUCCESS);
	}

	int main(int argc, char *argv[])
	{

	int ret;

	progname = get_progname(argv[0]);
	nodename = get_nodename();

	-
	-#if 0
	- openlog("SFex Daemon", LOG_PID\|LOG_CONS\|LOG_NDELAY, LOG_USER);
	-#endif
	+ cl_log_set_entity(progname);
	+ cl_log_set_facility(HA_LOG_FACILITY);
	+ cl_inherit_logging_environment(0);

	/* read command line option */
	opterr = 0;
	while (1) {
	int c = getopt(argc, argv, "hi:c:t:m:n:r:");
	if (c == -1)
	break;
	switch (c) {
	case 'h': /* help*/
	usage(stdout);
	- exit(0);
	+ exit(EXIT_SUCCESS);
	case 'i': /* -i <index> */
	{
	unsigned long l = strtoul(optarg, NULL, 10);
	if (l < SFEX_MIN_NUMLOCKS \|\| l > SFEX_MAX_NUMLOCKS) {
	- SFEX_LOG_ERR(
	- "%s: ERROR: index %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
	- progname, optarg,
	+ cl_log(LOG_ERR,
	+ "index %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
	+ optarg,
	(unsigned long)SFEX_MIN_NUMLOCKS,
	(unsigned long)SFEX_MAX_NUMLOCKS);
	exit(4);
	}
	lock_index = l;
	}
	break;
	case 'c': /* -c <collision_timeout> */
	{
	unsigned long l = strtoul(optarg, NULL, 10);
	if (l < 1 \|\| l > INT_MAX) {
	- SFEX_LOG_ERR(
	- "%s: ERROR: collision_timeout %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
	- progname, optarg,
	+ cl_log(LOG_ERR,
	+ "collision_timeout %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
	+ optarg,
	(unsigned long)1,
	(unsigned long)INT_MAX);
	exit(4);
	}
	collision_timeout = l;
	}
	break;
	case 'm': /* -m <monitor_interval> */
	{
	unsigned long l = strtoul(optarg, NULL, 10);
	if (l < 1 \|\| l > INT_MAX) {
	- SFEX_LOG_ERR(
	- "%s: ERROR: monitor_interval %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
	- progname, optarg,
	+ cl_log(LOG_ERR,
	+ "monitor_interval %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
	+ optarg,
	(unsigned long)1,
	(unsigned long)INT_MAX);
	exit(4);
	}
	monitor_interval = l;
	}
	break;
	case 't': /* -t <lock_timeout> */
	{
	unsigned long l = strtoul(optarg, NULL, 10);
	if (l < 1 \|\| l > INT_MAX) {
	- SFEX_LOG_ERR(
	- "%s: ERROR: lock_timeout %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
	- progname, optarg,
	+ cl_log(LOG_ERR,
	+ "lock_timeout %s is out of range or invalid. it must be integer value between %lu and %lu.\n",
	+ optarg,
	(unsigned long)1,
	(unsigned long)INT_MAX);
	exit(4);
	}
	lock_timeout = l;
	}
	break;
	case 'n':
	{
	free(nodename);
	if (strlen(optarg) > SFEX_MAX_NODENAME) {
	- SFEX_LOG_ERR("%s: ERROR: nodename %s is too long. must be less than %d byte.\n",
	- progname, optarg,
	+ cl_log(LOG_ERR, "nodename %s is too long. must be less than %d byte.\n",
	+ optarg,
	(unsigned int)SFEX_MAX_NODENAME);
	exit(EXIT_FAILURE);
	}
	nodename = strdup(optarg);
	}
	break;
	case 'r':
	{
	rsc_id = strdup(optarg);
	}
	break;
	case '?': /* error */
	usage(stderr);
	exit(4);
	}
	}
	/* check parameter except the option */
	if (optind >= argc) {
	- SFEX_LOG_ERR("%s: ERROR: no device specified.\n", progname);
	+ cl_log(LOG_ERR, "no device specified.\n");
	usage(stderr);
	exit(EXIT_FAILURE);
	} else if (optind + 1 < argc) {
	- SFEX_LOG_ERR("%s: ERROR: too many arguments.\n", progname);
	+ cl_log(LOG_ERR, "too many arguments.\n");
	usage(stderr);
	exit(EXIT_FAILURE);
	}
	device = argv[optind];

	prepare_lock(device);
	#if !SFEX_TESTING
	sysrq_fd = open("/proc/sysrq-trigger", O_WRONLY);
	if (sysrq_fd == -1) {
	- SFEX_LOG_ERR("failed to open /proc/sysrq-trigger due to %s\n", strerror(errno));
	+ cl_log(LOG_ERR, "failed to open /proc/sysrq-trigger due to %s\n", strerror(errno));
	exit(EXIT_FAILURE);
	}
	#endif

	ret = lock_index_check();
	if (ret == -1)
	exit(EXIT_FAILURE);

	{
	struct sigaction sig_act;
	sigemptyset (&sig_act.sa_mask);
	sig_act.sa_flags = SA_SIGINFO;

	sig_act.sa_sigaction = quit_handler;
	ret = sigaction(SIGTERM, &sig_act, NULL);
	if (ret == -1) {
	- SFEX_LOG_ERR("sigaction failed\n");
	+ cl_log(LOG_ERR, "sigaction failed\n");
	exit(EXIT_FAILURE);
	}
	}

	- SFEX_LOG_INFO("Starting SFeX Daemon...\n");
	+ cl_log(LOG_INFO, "Starting SFeX Daemon...\n");

	/* acquire lock first.*/
	acquire_lock();

	if (daemon(0, 1) != 0) {
	cl_perror("%s::%d: daemon() failed.", __FUNCTION__, __LINE__);
	release_lock();
	exit(EXIT_FAILURE);
	}

	cl_make_realtime(-1, -1, 128, 128);

	- SFEX_LOG_INFO("SFeX Daemon started.\n");
	+ cl_log(LOG_INFO, "SFeX Daemon started.\n");
	while (1) {
	sleep (monitor_interval);
	update_lock();
	}
	}
	diff --git a/tools/sfex_lib.c b/tools/sfex_lib.c
	index 920975622..59948f34e 100644
	--- a/tools/sfex_lib.c
	+++ b/tools/sfex_lib.c
	@@ -1,436 +1,434 @@
	/*-------------------------------------------------------------------------
	*
	* Shared Disk File EXclusiveness Control Program(SF-EX)
	*
	* lib.c --- Libraries for other SF-EX modules.
	*
	* 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., 51 Franklin Street, Fifth Floor, Boston, MA
	* 02110-1301, USA.
	*
	* Copyright (c) 2007 NIPPON TELEGRAPH AND TELEPHONE CORPORATION
	*
	* $Id$
	*
	-------------------------------------------------------------------------/

	#ifndef _GNU_SOURCE
	#define _GNU_SOURCE
	#endif

	#include <stdio.h>
	#include <stdlib.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <errno.h>
	#include <string.h>
	#include <unistd.h>
	#include <sys/utsname.h>
	#include <sys/ioctl.h>
	#include <syslog.h>
	#include <linux/fs.h>

	#include "sfex.h"
	#include "sfex_lib.h"

	static void *locked_mem;
	static int dev_fd;
	unsigned long sector_size = 0;

	int
	prepare_lock (const char *device)
	{
	do {
	dev_fd = open (device, O_RDWR \| O_DIRECT \| O_SYNC);
	if (dev_fd == -1) {
	if (errno == EINTR \|\| errno == EAGAIN)
	continue;
	- SFEX_LOG_ERR ("%s: ERROR: can't open device %s: %s\n",
	- progname, device, strerror (errno));
	+ cl_log(LOG_ERR, "can't open device %s: %s\n",
	+ device, strerror (errno));
	exit (3);
	}
	break;
	}
	while (1);

	ioctl(dev_fd, BLKSSZGET, &sector_size);
	if (sector_size == 0) {
	- SFEX_LOG_ERR("Get sector size failed: %s\n", strerror(errno));
	+ cl_log(LOG_ERR, "Get sector size failed: %s\n", strerror(errno));
	exit(EXIT_FAILURE);
	}

	if (posix_memalign
	((void **) (&locked_mem), SFEX_ODIRECT_ALIGNMENT,
	sector_size) != 0) {
	- SFEX_LOG_ERR ("Failed to allocate aligned memory\n");
	+ cl_log(LOG_ERR, "Failed to allocate aligned memory\n");
	exit (3);
	}
	memset (locked_mem, 0, sector_size);

	return 0;
	}

	/*
	* get_progname --- a program name
	*
	* We get program name from directory path. It does not include delimiter
	* characters. Return value is pointer that point string of program name.
	* We assume delimiter is '/'.
	*/
	const char *
	get_progname (const char *argv0)
	{
	char *p;

	p = strrchr (argv0, '/');
	if (p)
	return p + 1;
	else
	return argv0;
	}

	/*
	* get_nodename --- get a node name(hostname)
	*
	* We get a node name by using uname(2) and return pointer of it.
	* The error checks are done in this function. The caller does not have
	* to check return value.
	*/
	char *
	get_nodename (void)
	{
	struct utsname u;
	char *n;

	if (uname (&u)) {
	- SFEX_LOG_ERR ("%s: ERROR: %s\n", progname, strerror (errno));
	+ cl_log(LOG_ERR, "%s\n", strerror (errno));
	exit (3);
	}
	if (strlen (u.nodename) > SFEX_MAX_NODENAME) {
	- SFEX_LOG_ERR
	- ("%s: ERROR: nodename %s is too long. must be less than %lu byte.\n",
	- progname, u.nodename, (unsigned long)SFEX_MAX_NODENAME);
	+ cl_log(LOG_ERR,
	+ "nodename %s is too long. must be less than %lu byte.\n",
	+ u.nodename, (unsigned long)SFEX_MAX_NODENAME);
	exit (3);
	}
	n = strdup (&u.nodename[0]);
	if (!n) {
	- SFEX_LOG_ERR ("%s: ERROR: %s\n", progname, strerror (errno));
	+ cl_log(LOG_ERR, "%s\n", strerror (errno));
	exit (3);
	}
	return n;
	}

	/*
	* init_controldata --- initialize control data
	*
	* We initialize each member of sfex_controldata structure.
	*/
	void
	init_controldata (sfex_controldata * cdata, size_t blocksize, int numlocks)
	{
	memcpy (cdata->magic, SFEX_MAGIC, sizeof (cdata->magic));
	cdata->version = SFEX_VERSION;
	cdata->revision = SFEX_REVISION;
	cdata->blocksize = blocksize;
	cdata->numlocks = numlocks;
	}

	/*
	* init_lockdata --- initialize lock data
	*
	* We initialize each member of sfex_lockdata structure.
	*/
	void
	init_lockdata (sfex_lockdata * ldata)
	{
	ldata->status = SFEX_STATUS_UNLOCK;
	ldata->count = 0;
	ldata->nodename[0] = 0;
	}

	/*
	* write_controldata --- write control data into file
	*
	* We write sfex_controldata struct into file. We open a file with
	* synchronization mode and write out control data.
	*
	* cdata --- pointer of control data
	*
	* device --- name of target file.
	*/
	void
	write_controldata (const sfex_controldata * cdata)
	{
	sfex_controldata_ondisk *block;
	int fd;

	block = (sfex_controldata_ondisk *) (locked_mem);

	/* We write control data into the buffer with given format. */
	/* We write the offset value of each field of the control data directly.
	* Because a point using this value is limited to two places, we do not
	* use macro. If you change the following offset values, you must change
	* values in the read_controldata() function.
	*/
	memset (block, 0, cdata->blocksize);
	memcpy (block->magic, cdata->magic, sizeof (block->magic));
	snprintf ((char *) (block->version), sizeof (block->version), "%d",
	cdata->version);
	snprintf ((char *) (block->revision), sizeof (block->revision), "%d",
	cdata->revision);
	snprintf ((char *) (block->blocksize), sizeof (block->blocksize), "%u",
	(unsigned)cdata->blocksize);
	snprintf ((char *) (block->numlocks), sizeof (block->numlocks), "%d",
	cdata->numlocks);

	fd = dev_fd;
	if (lseek (fd, 0, SEEK_SET) == -1) {
	- SFEX_LOG_ERR ("%s: ERROR: can't seek file pointer: %s\n", progname,
	+ cl_log(LOG_ERR, "can't seek file pointer: %s\n",
	strerror (errno));
	exit (3);
	}

	/* write buffer into a file */
	do {
	ssize_t s = write (fd, block, cdata->blocksize);
	if (s == -1) {
	if (errno == EINTR \|\| errno == EAGAIN)
	continue;
	- SFEX_LOG_ERR ("%s: ERROR: can't write meta-data: %s\n",
	- progname, strerror (errno));
	+ cl_log(LOG_ERR, "can't write meta-data: %s\n",
	+ strerror (errno));
	exit (3);
	}
	else
	break;
	}
	while (1);
	}

	/*
	* write_lockdata --- write lock data into file
	*
	* We write sfex_lockdata into file and seek file pointer to the given
	* position of lock data.
	*
	* cdata --- pointer for control data
	*
	* ldata --- pointer for lock data
	*
	* device --- file name for write
	*
	* index --- index number for lock data. 1 origine.
	*/
	int
	write_lockdata (const sfex_controldata * cdata, const sfex_lockdata * ldata,
	int index)
	{
	sfex_lockdata_ondisk *block;
	int fd;

	block = (sfex_lockdata_ondisk *) locked_mem;
	/* We write lock data into buffer with given format */
	/* We write the offset value of each field of the control data directly.
	* Because a point using this value is limited to two places, we do not
	* use macro. If you chage the following offset values, you must change
	* values in the read_lockdata() function.
	*/
	memset (block, 0, cdata->blocksize);
	block->status = ldata->status;
	snprintf ((char *) (block->count), sizeof (block->count), "%d",
	ldata->count);
	snprintf ((char *) (block->nodename), sizeof (block->nodename), "%s",
	ldata->nodename);

	fd = dev_fd;

	/* seek a file pointer to given position */
	if (lseek (fd, cdata->blocksize * index, SEEK_SET) == -1) {
	- SFEX_LOG_ERR ("%s: ERROR: can't seek file pointer: %s\n", progname,
	+ cl_log(LOG_ERR, "can't seek file pointer: %s\n",
	strerror (errno));
	return -1;
	}

	/* write buffer into file */
	do {
	ssize_t s = write (fd, block, cdata->blocksize);
	if (s == -1) {
	if (errno == EINTR \|\| errno == EAGAIN)
	continue;
	- SFEX_LOG_ERR ("%s: ERROR: can't write meta-data: %s\n",
	- progname, strerror (errno));
	+ cl_log(LOG_ERR, "can't write meta-data: %s\n",
	+ strerror (errno));
	return -1;
	}
	else if (s != cdata->blocksize) {
	/* if writing atomically failed, this process is error */
	- SFEX_LOG_ERR ("%s: ERROR: can't write meta-data atomically.\n",
	- progname);
	+ cl_log(LOG_ERR, "can't write meta-data atomically.\n");
	return -1;
	}
	break;
	}
	while (1);
	return 0;
	}

	/*
	* read_controldata --- read control data from file
	*
	* read sfex_controldata structure from file.
	*
	* cdata --- pointer for control data.
	*
	* device --- file name for reading
	*/
	int
	read_controldata (sfex_controldata * cdata)
	{
	sfex_controldata_ondisk *block;

	block = (sfex_controldata_ondisk *) (locked_mem);

	if (lseek (dev_fd, 0, SEEK_SET) == -1) {
	- SFEX_LOG_ERR ("%s: ERROR: can't seek file pointer: %s\n", progname,
	+ cl_log(LOG_ERR, "can't seek file pointer: %s\n",
	strerror (errno));
	return -1;
	}

	/* read data from file */
	do {
	ssize_t s = read (dev_fd, block, sector_size);
	if (s == -1) {
	if (errno == EINTR \|\| errno == EAGAIN)
	continue;
	- SFEX_LOG_ERR
	- ("%s: ERROR: can't read controldata meta-data: %s\n",
	- progname, strerror (errno));
	+ cl_log(LOG_ERR,
	+ "can't read controldata meta-data: %s\n",
	+ strerror (errno));
	return -1;
	}
	else
	break;
	} while (1);

	/* read control data from buffer */
	/* 1. check the magic number. 2. check null terminator of each field
	3. check the version number. 4. Unmuch of revision number is allowed */
	/* We write the offset value of each field of the control data directly.
	* Because a point using this value is limited to two places, we do not
	* use macro. If you chage the following offset values, you must change
	* values in the write_controldata() function.
	*/
	memcpy (cdata->magic, block->magic, 4);
	if (memcmp (cdata->magic, SFEX_MAGIC, sizeof (cdata->magic))) {
	- SFEX_LOG_ERR ("%s: ERROR: magic number mismatched. %c%c%c%c <-> %s\n", progname, block->magic[0], block->magic[1], block->magic[2], block->magic[3], SFEX_MAGIC);
	+ cl_log(LOG_ERR, "magic number mismatched. %c%c%c%c <-> %s\n", block->magic[0], block->magic[1], block->magic[2], block->magic[3], SFEX_MAGIC);
	return -1;
	}
	if (block->version[sizeof (block->version)-1]
	\|\| block->revision[sizeof (block->revision)-1]
	\|\| block->blocksize[sizeof (block->blocksize)-1]
	\|\| block->numlocks[sizeof (block->numlocks)-1]) {
	- SFEX_LOG_ERR ("%s: ERROR: control data format error.\n", progname);
	+ cl_log(LOG_ERR, "control data format error.\n");
	return -1;
	}
	cdata->version = atoi ((char *) (block->version));
	if (cdata->version != SFEX_VERSION) {
	- SFEX_LOG_ERR
	- ("%s: ERROR: version number mismatched. program is %d, data is %d.\n",
	- progname, SFEX_VERSION, cdata->version);
	+ cl_log(LOG_ERR,
	+ "version number mismatched. program is %d, data is %d.\n",
	+ SFEX_VERSION, cdata->version);
	return -1;
	}
	cdata->revision = atoi ((char *) (block->revision));
	cdata->blocksize = atoi ((char *) (block->blocksize));
	cdata->numlocks = atoi ((char *) (block->numlocks));

	return 0;
	}

	/*
	* read_lockdata --- read lock data from file
	*
	* read sfex_lockdata from file and seek file pointer to head position of the
	* file.
	*
	* cdata --- pointer for control data
	*
	* ldata --- pointer for lock data. Read lock data are stored into this
	* pointed area.
	*
	* device --- file name of source file
	*
	* index --- index number. 1 origin.
	*/
	int
	read_lockdata (const sfex_controldata * cdata, sfex_lockdata * ldata,
	int index)
	{
	sfex_lockdata_ondisk *block;
	int fd;

	block = (sfex_lockdata_ondisk *) (locked_mem);

	fd = dev_fd;

	/* seek a file pointer to given position */
	if (lseek (fd, cdata->blocksize * index, SEEK_SET) == -1) {
	- SFEX_LOG_ERR ("%s: ERROR: can't seek file pointer: %s\n", progname,
	+ cl_log(LOG_ERR, "can't seek file pointer: %s\n",
	strerror (errno));
	return -1;
	}

	/* read from file */
	do {
	ssize_t s = read (fd, block, cdata->blocksize);
	if (s == -1) {
	if (errno == EINTR \|\| errno == EAGAIN)
	continue;
	- SFEX_LOG_ERR ("%s: ERROR: can't read lockdata meta-data: %s\n",
	- progname, strerror (errno));
	+ cl_log(LOG_ERR, "can't read lockdata meta-data: %s\n",
	+ strerror (errno));
	return -1;
	}
	else if (s != cdata->blocksize) {
	- SFEX_LOG_ERR ("%s: ERROR: can't read meta-data atomically.\n",
	- progname);
	+ cl_log(LOG_ERR, "can't read meta-data atomically.\n");
	return -1;
	}
	break;
	}
	while (1);

	/* read control data form buffer */
	/* 1. check null terminator of each field 2. check the status */
	/* We write the offset value of each field of the control data directly.
	* Because a point using this value is limited to two places, we do not
	* use macro. If you chage the following offset values, you must change
	* values in the write_lockdata() function.
	*/
	if (block->count[sizeof(block->count)-1] \|\| block->nodename[sizeof(block->nodename)-1]) {
	- SFEX_LOG_ERR ("%s: ERROR: lock data format error.\n", progname);
	+ cl_log(LOG_ERR, "lock data format error.\n");
	return -1;
	}
	ldata->status = block->status;
	if (ldata->status != SFEX_STATUS_UNLOCK
	&& ldata->status != SFEX_STATUS_LOCK) {
	- SFEX_LOG_ERR ("%s: ERROR: lock data format error.\n", progname);
	+ cl_log(LOG_ERR, "lock data format error.\n");
	return -1;
	}
	ldata->count = atoi ((char *) (block->count));
	strncpy ((char ) (ldata->nodename), (const char ) (block->nodename), sizeof(block->nodename));

	#ifdef SFEX_DEBUG
	- SFEX_LOG_INFO ("status: %c\n", ldata->status);
	- SFEX_LOG_INFO ("count: %d\n", ldata->count);
	- SFEX_LOG_INFO ("nodename: %s\n", ldata->nodename);
	+ cl_log(LOG_INFO, "status: %c\n", ldata->status);
	+ cl_log(LOG_INFO, "count: %d\n", ldata->count);
	+ cl_log(LOG_INFO, "nodename: %s\n", ldata->nodename);
	#endif
	return 0;
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jul 8, 5:33 PM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2002373
Default Alt Text: (33 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions